DEV Community: Sui Gn

AUDIENCE ALGEBRA

Sui Gn — Sun, 27 Sep 2026 02:20:40 +0000

In [.me](https://cleaker.me), who can read a value isn't a permission check. It's a property of the ciphertext: you can open it only if you can derive the key.

Audience Algebra is the spec for writing that "who" as an expression:

A ::= identity | OR(A1, …, An) | AND(A1, …, An)

(alice AND bob) OR carol means carol alone opens, alice and bob together open, and alice alone doesn't.
Every expression reduces to its minimal coalitions, { {alice, bob}, {carol} }, so two ways of writing the same audience get the same id. OR wraps the same key to each member. AND splits the key into XOR shares, one per member.
Nesting is just recursion.

Audience Algebra

Who can open a value, as a closed algebra: monotone formulas over kernel identities, compiled to a tree of key envelopes.

suign.github.io

There's no NOT and no XOR. Encryption can grant access but can't take it away: if you can open, people added next to you don't change that. "Everyone except X" only exists at seal time, and revoking means sealing a new version.
Groups are immutable. The same members make the same group. Adding someone makes a new group, and a name in the tree points to the current one.

Status: the kernel has single-recipient wrapping today, so OR works by composition. AND, nesting and groups are specified and come next.

The nine laws on the page are the test contract.
Full spec: SuiGn.Github.io

Surface Identity Claims

Sui Gn — Thu, 24 Sep 2026 19:07:20 +0000

DESIGN.

License: CC0 1.0 Universal — Public Domain neurons.me / suiGn

Surface Identity Claims | cleaker

Contextual namespace binding. Resolution before direction; name before place.

neurons-me.github.io

0. The one-sentence version

A namespace's claim ledger already lets a human .me prove "I am who I say I am, here" — this doc proposes the same primitive for a surface (a monad, a netget instance, any running service), so "this server is who it says it is" stops being a bare string in a JSON registry and becomes the same kind of verifiable claim.

For a while I described .me with a sentence I thought was precise: "everything that can be named, is authorized, and finishes resolving."

It sounds rigorous, but it's redundant. It lists three conditions, and there is really only one.

Authorization is not a filter

The usual way to think about access is in two steps. First you resolve the name, and then some middleware decides whether you're allowed to see the result. Authorization becomes a gate placed in front of something that already exists.

.me doesn't work that way. When you ask for a path, the resolver doesn't find a value and then hide it from you. What it returns is the result of resolving that name for you.

sui.me/profile/email

That same path can resolve in three ways:
For the owner, it resolves to the value.
For a visitor, it resolves to closed.
If the node doesn't exist, it resolves to "does not exist."

These aren't three permissions applied to one result. They are three different results of the same resolution. closed is not an error or a rejection; it's the correct answer for whoever is asking.

Termination isn't a separate condition either
"Finishes resolving" falls the same way. A resolution that never finishes isn't a resolution, it's a hung process. Requiring that it terminate is already part of what resolving means.

That doesn't make cycles go away. A pointer can point to another pointer that points back, and a chain of hops across namespaces can grow without limit. The difference is where those rules live. They aren't conditions stacked on top of the model; they're part of how resolution works: detect cycles, cap the number of hops, and return a defined result when the limit is reached.

The sentence that remains

Everything that can be named and resolved, in the context of whoever asks.

"Named" says what belongs in the system: anything with a path. "Resolved" already includes authorization and termination. "In the context of whoever asks" makes explicit what used to be hidden inside "authorized," which is that resolution depends on the identity of whoever requests it.

Why it matters

When authorization is a filter, every layer ends up reimplementing it: the API, the frontend, the proxy. Each one has its own idea of who can see what, and sooner or later they disagree.

When authorization is part of resolution, there is exactly one place that decides what a name means for someone. The interface doesn't ask "am I allowed?"; it asks "what is this for me?" and renders whatever comes back, whether that's a value, closed, or nothing.

That change in the question is what makes .me closer to a language than to a database. A language doesn't have "forbidden values." It has expressions, and every expression is evaluated in a context.

Metcalfe’s Law

Sui Gn — Thu, 17 Sep 2026 08:03:50 +0000

Understanding Metcalfe’s Law: The Mathematics of Network ConnectionsHow does adding elements to a network affect the total number of possible interactions? Whether in telecommunications, distributed systems, or graph theory, Metcalfe’s La models how the theoretical value or complexity of a network scales relative to its nodes.

The Fundamental Principle

Formulated by Robert Metcalfe in the 1980s during the development of Ethernet, the principle states that:The total potential value or complexity of a network with no central hub grows quadratically with the number of connected nodes. This behavior stems directly from combinatorics—specifically, counting unique two-way connections between elements in a fully connected graph.

me.explain(What)

Sui Gn — Wed, 16 Sep 2026 23:00:50 +0000

Reading a value tells you what is there. me.explain(path) lets you explore how it is defined.

me.order.subtotal(100);
me.order.tax(16);
me.order["="]("total", "subtotal + tax");
me.explain("order.total");

Here, order.total is derived from subtotal + tax. Its explanation describes that relationship and the paths it depends on.

The same idea can power a terminal command or a GUI Inspector: select a node, ask for its explanation, and explore the structure behind it.
path _identifies what you want to understand. _explain makes its derivation inspectable.

neurons-me / .me

Here we're codependently creating .me while it concurrently creates us.

.me

Own your knowledge.

0dec8214…a292d7

keccak-256

Hello, I am .me

  <p dir="auto">
    </p>

A Cryptographic Identity

  <div class="markdown-heading" dir="auto">

⌬ Docs

→ Watch the hash: neurons-me.github.io/.me

Getting Started

Install .me. Open your terminal and run:

git clone https://github.com/neurons-me/.me.git
cd .me

Choose

🔷 Typescript

cd Typescript
npm install
npm run build

🦀 Rust — crates.io · docs.rs
🐍 Python — Not Available Yet.

Demos

⟐🤖 ⇆ 🤖⟐ Robots That Understand Context — Same object, different meaning.

node tests/Demos/Robots_Contexts.ts

∴ 🏙️ ◉ 📡 ⌬ Smart City — A city reacting as one connected graph.

node tests/Demos/Smart_City.ts

𓀠 ⟐👤 ⇄ 👥 ⌬ ∴ 𓀠 Social Graph — Identity, trust, and relationships.

node tests/Demos/Social_Graph.ts

🏪 ⇄ 📦 ⇄ 📈 CoffeeShops — Inventory and operations as a graph.

node tests/Demos/ShopsExample.ts

💳 ⇄ 👥 ⌬ ⚖️ ∴ Splitting your Bill — Shared expenses with automatic settlement.

node tests/Demos/WalletSplit.ts

🌐 ⇄ ⌬ 𓇳 ⌬ ⇄ 🌐 Hemisphere Scale — 1 million sensors. One

…

View on GitHub

.GUI v3.0.0 — from 33MB to 2.4MB, and why it's a major version

Sui Gn — Tue, 15 Sep 2026 23:04:31 +0000

neurons-me (.me) · GitHub

Go Algorithmic. . neurons-me has 33 repositories available. Follow their code on GitHub.

github.com

npm install this.gui

— The Generative User Interface library behind the .me/Cleaker/Netget stack — just shipped v3.0.0 on npm. It's a major version, and it's worth explaining why, because the fix underneath it is a good cautionary tale about how "small" dependency choices silently balloon a bundle.

The numbers first

While rebuilding the admin UI that consumes this.gui, its production JS bundle was 16.65 MB, and its CSS was 16.2 MB. For a landing page. After this release:

Bundled CSS 16,213 KB to 0.87 KB.
start-app 14.7 MB to 590 KB
this.gui.umd.js (script-tag build) 17.5 MB to 3.26 MB

Consuming app's main JS bundle 16.65 MB to 2.39 MB

Same features.
Same components.
Nothing removed.
Just two bloat sources found and cut.

What was actually bloating it

1. The icon font was tripled and inlined. A single import 'material-symbols' pulled in all three icon families the npm package ships (outlined, rounded, sharp) — even though this codebase only ever uses material-symbols-rounded. Worse, whatever asset pipeline processed that import inlined all three as base64 directly into the CSS, regardless of file size (each is a multi-MB font covering thousands of glyphs). Net result: ~12MB of font data, most of it for two icon families nothing renders, shipped as un-cacheable text inside a CSS file that changes hash on every rebuild.

Fix: dropped the bare import. Consumers now the already-correct material-symbols.css (+ real .woff2 file) directly — a proper, cacheable static asset, the same pattern this library's own demos and Storybook config already used.

2. Theme preview images were full-resolution screenshots. The theme catalog ships 6 preview "badges." They're rendered as 28–34px avatars. The source files were 1024–1600px PNGs, 1–4MB each — full screenshots, never resized for their actual use. Imported directly in code, they got base64-inlined into the bundle the same way the font did.

Fix: resized each to their real display size (~128px, generous headroom for retina). File sizes dropped 95–99% (3.09MB → 20.8KB, for example) with zero visible difference at a 34px avatar size.

Why this is a major version, not a patch

Fixing the icon font surfaced a related, unrelated-on-the-surface issue: react-router-dom was pinned as a peer dependency at ^6.0.0. That's now ^7.18.3.

This is the actual breaking change in this release. If your app still provides react-router-dom v6, upgrading blind will break at the peer-resolution level (or worse, silently resolve an old v6 copy that no longer gets this library's routing fixes). That's exactly why this shipped as 3.0.0 and not 2.5.3 — a "patch" that quietly requires a major dependency bump is worse than an honest major version.

Migrating

npm install this.gui@3 react-router-dom@7
If you're not ready to move to React Router v7 yet, pin this.gui@^2.4.0 — it still works, just carries the old bloat this release fixes.

The unglamorous part: a build that had been silently broken
While preparing this release, npm run build's full chain (the one npm publish actually runs via prepublishOnly) turned out to have been failing at the type-check step for a while — unrelated to any of the above, and apparently never noticed because nobody had run the complete chain in one sitting recently. Two real gaps:

A RegistryMeta.kind field became required at some point, but none of the ~50 component registrations that construct one ever set it. Fixed by deriving kind from the group field every one of them already has, in one place, instead of hand-editing 50 files.
Router.tsx was still passing React Router v6's future={{ v7_startTransition, v7_relativeSplatPath }} migration flags to — flags that no longer exist in v7, because their behavior is just the default now.
Neither is visible to consumers, but both had to be fixed before 3.0.0 could actually publish at all.

neurons-me / GUI

Generative User Interface

.GUI

Generative User Interface

npx this.gui my-app

⌬ Docs · ⬡ Storybook · ⟡ Live Preview

View on GitHub

tl;dr
Upgrade if you can move to react-router-dom@7 — you get a ~85% smaller bundle for free.

Hold at ^2.4.0 if you're not ready for the React Router migration yet.
If you maintain a UI library: audit what your bundler does with imported images and fonts. "It's just an import" is exactly how a 34px avatar ships 3MB.
this.gui on npm: https://www.npmjs.com/package/this.gui

Rust .me v0.3.0

Sui Gn — Wed, 26 Aug 2026 07:42:16 +0000

I just published this-me v0.3.0 to crates.io.
It is the Rust port of the .me semantic kernel: hash-chained memory, path selectors, operators, derivations, secret scopes, proofs, key wrapping, snapshots, runtime events, and a CLI.

cargo add this-me

use this_me::kernel::Kernel;

let mut me = Kernel::new();
me.postulate("profile.name", "Jabellae")?;

This release is not just a package upload. It is the first installable Rust foundation for .me: same semantic model as the TypeScript kernel, now moving toward a runtime that can run closer to hardware.
Published crate: https://crates.io/crates/this-me
Next: examples, docs polish, Rust vs TypeScript benchmarks, and the path toward monad.ai integration.

Running the .me Kernel

Sui Gn — Fri, 21 Aug 2026 03:33:11 +0000

The .me kernel directly against your prompt yields the following state resolution:

// Initializing .me local runtime
const me = new MeKernel({ rootAnchor: "whois.me" });

// Executing input command: me.explain("Why did you say that?")
me.explain({
  target: "previous_response",
  query: "Why did you say that?"
});

Kernel Output (me.explain() trace):

{
  "status": "RESOLVED",
  "actor": "whois.me",
  "derivation_path": [
    "context://sui.gn/concepts/me.whatever(what)",
    "context://sui.gn/concepts/me.explain()",
    "rule://T_perp_A/decouple_topology_from_audience"
  ],
  "cryptographic_proof": "valid (derived from local identity graph)",
  "explanation": "Evaluated 'me.whatever(what)' as an SVO selector pattern and 'me.explain()' as an execution-trace lookup operator. Result confirmed: syntax acts simultaneously as executable code and structural context algebra."
}

The system is designed so that every output can be deterministically unrolled and proven back to its origin without relying on a centralized platform's black-box algorithm.

me.explain() — Why Did You Say That?

An AI's account of its own reasoning is generated by the same untrusted process being questioned. .me's explain() already solves this.

suign.github.io

me.whatever(what)

Sui Gn — Fri, 21 Aug 2026 03:30:40 +0000

Under the hood of the .me kernel concept, me is an object instance (the root semantic anchor). The syntax me.whatever(what) follows a strict Subject-Verb-Object (SVO) execution model where me (Subject) invokes whatever (Verb/Operator) on what (Object/Selector).

It is a formal notation: It doubles as a formal algebra (a DSL or Domain Specific Language). Instead of relying on traditional SQL or REST endpoints, it expresses queries, cryptographic audience scoping, and graph resolution directly as algebraic operations on the self.

Why it makes sense: In standard software, data belongs to a server endpoint (e.g., api.twitter.com/tweets). In this model, resolution begins at the local root identity (me). Asking me.explain() doesn't query a remote AI server; it asks the local kernel to return the deterministic derivation path, cryptographic lineage, and audit trail of why a specific output or context state was generated.

me.whatever(what)

The syntax of .me, formally: Subject-Verb-Object path calls, the real operator table, and selector syntax.

suign.github.io

We Have a Live Semantic App Mesh

Sui Gn — Wed, 19 Aug 2026 22:49:44 +0000

Today we reached an important milestone in the .me ecosystem: a real application is now running as a live semantic app over a local sovereign gateway.
neurons.me Github Docs

This is not just a frontend talking to an API.

The working circuit is:

GUI
→ netget gateway
→ app monad
→ .me semantic kernel
→ WebSocket stream
→ live React update

The app used for the proof is FullTrailer, a real fleet-management GUI. It is now reachable through:

local.netget/apps/fulltrailer

That route is handled by netget, which acts as the local gateway and app switchboard. Behind it, FullTrailer has its own monad, which serves a .me kernel over HTTP and WebSocket.

What Was Proven

The key test used three independent clients:

client 1: curl writes data
client 2: browser tab A observes data
client 3: browser tab B observes data

A write was sent externally through curl into the FullTrailer app path. Both browser tabs were already open and subscribed to the same .me path.

Without refreshing either tab, both updated live.

That means the full chain worked:

curl
→ local.netget/apps/fulltrailer
→ nginx/netget
→ monad root write handler
→ .me memory write
→ pathNotify
→ /nrp WebSocket stream
→ this.gui createWsMeRuntime
→ useSyncExternalStore
→ React re-render

This proves that the architecture is no longer theoretical. A real GUI can now observe and react to semantic state over the local mesh.

The Pieces

The architecture now has clearer roles:

.me      = semantic memory, identity, encrypted scopes, executable form
cleaker  = binding: “who am I in this namespace?”
monad    = runtime: serve a .me kernel over HTTP/WS
netget   = gateway: route, expose, connect, disconnect apps
GUI      = perception/action layer over semantic state

An app is no longer just a frontend. It becomes a semantic surface with its own kernel.

Why This Matters

Most apps start with infrastructure:

database
API routes
auth
JWT
cookies
sessions
WebSocket server
sync layer
admin panel

This model starts differently:

.me

The app begins with semantic space:

apps.fulltrailer.tractos.records
apps.fulltrailer.settings
apps.fulltrailer.events[]

The GUI binds to that space. The monad serves it. Netget exposes it. The gateway owner can connect or disconnect it.

This means a future command like:

npx this.gui my-app

should not just generate a React app. It should generate a live semantic app: GUI + monad + .me state + netget registration.

Current Status

Working now:

/apps/:name routing through netget
HTTP writes through the app mesh
WebSocket subscriptions over NRP
live React updates from .me writes
this.gui@2.3.0 with WS-backed runtime support
public docs for NRP v0.3.0 and Apps over Netget

Still being cleaned up:

app seed and local development secrets
FullTrailer sample data
app template generation
virtual-host-level metrics and governance

The Bigger Idea

This is moving toward a different kind of web app.

Not:

cloud account owns state
platform owns identity
app owns user data

But:

local kernel owns memory
identity signs
gateway governs exposure
apps connect to your space
GUI renders meaning

The result is a local-first, sovereign, semantic app mesh.

FullTrailer was the first real proof.

The next step is making this repeatable.

FullTrailer as a real GUI + monad app, live over HTTP and WS through netget

Sui Gn — Wed, 19 Aug 2026 04:10:53 +0000

Context

FullTrailer (/Users/suign/Desktop/Neuroverse/apps/FullTrailer, outside the all.this
monorepo) is a fleet-management app already built on this.gui — 7 views, all using
this.gui/atoms/this.gui/molecules/this.gui/react. Two things keep it from being a
real, canonical GUI app: app/src/runtime.tsx reimplements mountApp()/declareApp()/
routing locally instead of using the package's real ones, and there's no server behind
it except a small standalone Express proxy (server/index.js, Samsara fuel API +
photo uploads) — .me state today is purely client-side/ephemeral.

The direction, confirmed in conversation: FullTrailer gets its own monad (the
generic modules/monad/Typescript daemon, run as its own process, not forked), which
registers with the already-running local netget gateway. netget only resolves
hostnames to host:port and reverse-proxies — it does no app logic — so the frontend
stops talking to a bespoke REST API and instead talks through netget to a monad
speaking the standard .me/NRP contract. Confirmed via 3 parallel explorations this
session:

netget's gateway config already passes WebSocket upgrades through cleanly on every monad/surface route (proxy_http_version 1.1 + Upgrade/Connection headers in the shared proxyHeaders block, setNginxConfigRoutes.ts:62-70, used at every $monad_proxy_target/$surface_proxy_target proxy_pass). No netget changes needed.
The monad already has a /nrp WebSocket endpoint (nrpHandler.ts, attached to the same HTTP server/port the monad registers with netget — confirmed same-process, no separate WS registration needed, and exposure.inbound.allowWebsocket: true is already set in the registration payload). Today it only does namespace resolution (nrp.open → resolved) — no live value reads or subscriptions yet.
this.gui already ships a full client for this protocol — Beatle (src/gui/All.This/NRP/Beatle/) — but it's unused anywhere in the app (Storybook-only) and only handles the resolution handshake. Its wire contract (Beatle.types.ts) already reserves 'stream'/'data' message types for exactly this next step, and its socket already stays open after resolving rather than closing — built for this.
No kernel write-notification mechanism exists anywhere (refSubscribers in me.ts/ core-write.ts is dead code, never wired). Live subscribe needs this built from scratch — confirmed in scope per this conversation ("build live-subscribe now too").
A custom local hostname needs an explicit domain record (POST /add-domain); the NRP handle-subdomain pattern (<name>.<machine-hostname>) resolves automatically via surface_proxy.lua's existing namespace/alias matching — chosen for the first test.

What's being built

A. Monad: live semantic subscribe over `/nrp` (generic — benefits every monad)

Repo: modules/monad/Typescript. This is shared daemon infrastructure, not
FullTrailer-specific — the right layer per the same "generalize the underlying
mechanism, don't bandaid" principle this session's own code reviews have been applying.

New src/kernel/pathNotify.ts — a small in-process registry: subscribe(namespace, path, cb): unsubscribe / notify(namespace, path). Match a write to a subscription if the paths are equal or one is a dotted-prefix of the other (a write to apps.fulltrailer.tractos.records.0.status should notify a subscriber watching apps.fulltrailer.tractos.records). In-memory, single-process only — no cross-monad fan-out in this pass.
Hook notify() into the existing write path — inside handlers/commandHandler.ts (meCommandHandler, the POST /me/* handler), which already has the exact namespace+path from the URL after a successful write. Don't touch kernel internals (me.ts/core-write.ts) — this stays a thin call at the one HTTP choke point where writes already land.
Extend nrpHandler.ts's handleMessage() with new message types (add discriminants to BeatleMessage in packages/GUI/Typescript/src/gui/All.This/NRP/Beatle/Beatle.types.ts rather than overloading the existing generic 'data' — confirmed safe, no existing consumer breaks):
- 'read' (client→server): {namespace, path} → resolve via pathResolver.ts's resolveNamespacePathValue(namespace, path) (existing function, reused as-is) → reply 'data' with {value, disclosure}, same public/closed-only disclosure contract pathResolver.ts already uses.
- 'subscribe' (client→server): same lookup, then register via pathNotify.subscribe(...), keyed to this connection.
- 'stream' (server→client, already reserved in the type union): sent whenever pathNotify fires for a path this connection subscribed to — re-resolves and sends the fresh {value, disclosure}.
- 'unsubscribe' and ws.on('close', ...) both clean up that connection's entries.
- Namespace for a WS connection is captured once at connect time from the nrp.open message (matches the existing pattern — a WS upgrade has no per-message Host header to re-resolve from).

B. `this.gui`: a WS-backed `RuntimeAdapter` (generic — publishable, reusable)

Repo: packages/GUI/Typescript. Lives in the package, not in FullTrailer, so any app
can opt into live semantics the same way FullTrailer will.

New src/runtime/createWsMeRuntime.ts — composes on top of the existing createMeRuntime() (run-me.ts) rather than duplicating it: keep its action/write implementation as-is (writes stay plain HTTP POST /me/* — the monad already notifies WS subscribers once that write lands, per A.2), and replace only subscribe/getSnapshot:
- One shared WS connection per adapter instance (ws://<host>/nrp), opened lazily, sends nrp.open once.
- subscribe(path, callback) dedups multiple local listeners on the same path to one server-side 'subscribe' message; routes incoming 'data'/'stream' messages back to matching local callbacks by path; returns an unsubscribe that sends 'unsubscribe' once the last local listener for a path is gone.
- getSnapshot() reads from a local cache populated by the last 'data'/'stream' message for that path; falls back to one HTTP GET (existing NRP read endpoint) for the very first read before any WS message has arrived for that path yet.
Export from src/runtime-entry.ts (this.gui/runtime).
Build, verify, bump to 2.3.0, publish — same flow just run for 2.2.0. FullTrailer can't consume this until it's published; sequence accordingly.

C. FullTrailer: wire it all together

Repo: /Users/suign/Desktop/Neuroverse/apps/FullTrailer.

Run FullTrailer's monad as its own process — the existing, unmodified modules/monad/Typescript daemon, started with FullTrailer-specific env (ME_NAMESPACE/alias set so fulltrailer.<machine-hostname> resolves via surface_proxy.lua — confirm the exact required metadata.namespace/aliases value empirically against apps.json once it heartbeats, this is a verify-by-running item, not something to hard-code blind), its own port, MONAD_NAME=fulltrailer. Add as a third concurrently process in the root package.json dev script (app, server, now monad) — pointed at the existing modules/monad/Typescript checkout, not copied into FullTrailer's own repo.
server/index.js (Samsara proxy + uploads) stays a separate process — confirmed modules/monad's app.ts is a fixed, monolithic router chain with no extension point for custom app routes; folding app-specific business logic into the generic daemon would be the wrong layer. Two backend processes locally: the monad (.me/NRP data) and this existing Express server (external API integration).
app/src/runtime.tsx: stop reimplementing mountApp()/declareApp(). Import the real ones from this.gui/runtime. The LeftBar nav (NAV_ITEMS + active-route highlighting) has no equivalent in the package's mountApp() today — keep a small FullTrailer-local wrapper for just that nav chrome, but have it call the package's real declareApp()/writeMeValue()/readMeValue() instead of reimplementing that plumbing. Narrows the diff to "stop duplicating infra," not "invent app nav in the package."
views/Home.tsx → views/Home.ts: convert to a defineSpecView()-tagged () => GuiSpecNode factory (mirrors the npx/template conversion pattern already established this session) — the first real consumer of that feature anywhere.
The 5 CRUD views (Tractos, Remolques, Dollies, Operadores, Facturas) stay React.ComponentTypes, unchanged in shape — confirmed earlier this session they're a poor fit for spec trees (stateful forms, modals, computed values, per-row callbacks). They get live updates for free once main.tsx is pointed at createWsMeRuntime() instead of the local-only createMeRuntime()/ME(), since useMeValue already subscribes generically via runtime.subscribe.
Bump this.gui/this.me deps once B is published.

D. netget

No code changes. Verification-only: confirm the heartbeat lands in apps.json with a
namespace/alias surface_proxy.lua actually matches against fulltrailer.<machine-hostname>,
and that a request to that hostname really reaches FullTrailer's monad.

Verification

curl -X POST http://fulltrailer.<machine-hostname>/me/apps.fulltrailer.manifest round-trips through netget to FullTrailer's monad.
Open a WS connection to ws://fulltrailer.<machine-hostname>/nrp, send nrp.open, then a 'subscribe' for apps.fulltrailer.tractos.records; in a second terminal POST a write to that path via HTTP; confirm a 'stream' message arrives on the open socket with the new value.
Run FullTrailer's dev stack (app + server + new monad process) locally, open the app through the netget hostname (not localhost:5173 directly), confirm Home (now spec-tree rendered) and the CRUD views both load.
With two browser tabs open to Tractos, edit a record in one tab, confirm the other tab's list updates live without a manual refresh — the actual end-to-end proof of the whole point of this work.
npx tsc --noEmit + npx vite build clean in both modules/monad/Typescript and packages/GUI/Typescript before publishing/running.

[Boost]

Sui Gn — Wed, 19 Aug 2026 02:21:56 +0000

Sui Gn

Aug 19

Semantic Web syntax created to look like natural relationships.

#ai #programming #opensource #cybersecurity

1 min read

Semantic Web syntax created to look like natural relationships.

Sui Gn — Wed, 19 Aug 2026 02:18:59 +0000

Compact data-schema that maps data like a social or neural graph.

Key Characteristics of the SyntaxObject-Oriented Identity: Instead of complex databases, it uses standard JavaScript objects but handles them as living profiles. You invoke things relative to the current context using this.me. Bracket Operators for Logic: It leverages array-style brackets to create custom semantic commands, shorthand relationships, and conditional rules.

import Me from "this.me";
const me = new Me();

me["@"]("jabellae"); // Declares the handle/identity

me.profile.name("Abella.e");
me.profile.bio("Building the semantic web.");

// Nesting other profiles seamlessly
me.users.pablo.name("Pablo");
me.users.pablo.age(17);

2. The Pointer Syntax (->)

To prevent data duplication and establish relationships, the syntax introduces custom pointer strings. You can link one path to another to show semantic relationships:
Start .me in 60 seconds...

// Point "friends.pablo" directly to the profile data inside "users.pablo"
me.friends.pablo["->"]("users.pablo");

3. Broadcast Rules ([i] and =)

The syntax allows you to broadcast expressions over arrays or structural groups. It interprets strings as dynamic, local logical expressions:
⟁ Infinite Semantic Trees

// Automatically compute whether items in a list meet a condition
me.friends["[i]"]["="]("is_adult", "age >= 18");

DEV Community: Sui Gn

AUDIENCE ALGEBRA

Audience Algebra

Surface Identity Claims

DESIGN.

Surface Identity Claims | cleaker

0. The one-sentence version

Authorization is not a filter

The sentence that remains

Why it matters

Metcalfe’s Law

The Fundamental Principle

me.explain(What)

neurons-me / .me

Here we're codependently creating .me while it concurrently creates us.

.me

Hello, I am .me

A Cryptographic Identity

⌬ Docs

Getting Started

Choose

Demos

⟐🤖 ⇆ 🤖⟐ Robots That Understand Context — Same object, different meaning.

∴ 🏙️ ◉ 📡 ⌬ Smart City — A city reacting as one connected graph.

𓀠 ⟐👤 ⇄ 👥 ⌬ ∴ 𓀠 Social Graph — Identity, trust, and relationships.

🏪 ⇄ 📦 ⇄ 📈 CoffeeShops — Inventory and operations as a graph.

💳 ⇄ 👥 ⌬ ⚖️ ∴ Splitting your Bill — Shared expenses with automatic settlement.

🌐 ⇄ ⌬ 𓇳 ⌬ ⇄ 🌐 Hemisphere Scale — 1 million sensors. One

.GUI v3.0.0 — from 33MB to 2.4MB, and why it's a major version

neurons-me (.me) · GitHub

The numbers first

What was actually bloating it

Why this is a major version, not a patch

Migrating

neurons-me / GUI

Generative User Interface

.GUI

Generative User Interface

Rust .me v0.3.0

Running the .me Kernel

Kernel Output (me.explain() trace):

me.explain() — Why Did You Say That?

me.whatever(what)

me.whatever(what)

We Have a Live Semantic App Mesh

What Was Proven

The Pieces

Why This Matters

Current Status

The Bigger Idea

FullTrailer as a real GUI + monad app, live over HTTP and WS through netget

Context

What's being built

A. Monad: live semantic subscribe over /nrp (generic — benefits every monad)

B. this.gui: a WS-backed RuntimeAdapter (generic — publishable, reusable)

C. FullTrailer: wire it all together

D. netget

Verification

[Boost]

Semantic Web syntax created to look like natural relationships.

Semantic Web syntax created to look like natural relationships.

Compact data-schema that maps data like a social or neural graph.

2. The Pointer Syntax (->)

3. Broadcast Rules ([i] and =)

𓆣

Hello I am .me

A. Monad: live semantic subscribe over `/nrp` (generic — benefits every monad)

B. `this.gui`: a WS-backed `RuntimeAdapter` (generic — publishable, reusable)