DEV Community: Sui Gn

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");

𓆣

Hello I am .me

Building Encrypted Semantic Islands with .me

Sui Gn — Fri, 14 Aug 2026 20:55:23 +0000

Topology is independent from audience.

Based on suign.github.io.

In traditional systems, where data lives determines who can read it (the policy-custody model). Encrypted Semantic Islands separate the two:

holding bytes ≠ possessing meaning

$T$ (Topology): Where the encrypted object lives (database, CDN, cache, device).
$A$ (Audience): The set of identities capable of deriving meaning from it.

Unless a node belongs to $A$, it cannot resolve the content. Privacy isn't enforced by organizational rules—it’s enforced by failed derivation.

neurons-me (.me) · GitHub

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

github.com

Quick Formula

$$I = (\text{path}, \text{ciphertext}, T, A, C)$$

path: Semantic location
ciphertext: Encrypted payload
T: Topology / placement
A: Audience set (e.g., $A = A_1 \cap A_2$)
C: Context & derivation conditions

Access control becomes audience chemistry: a private object is private because it cannot become meaningful outside its defined derivation path.

neurons-me.github.io

Topology $\perp$ Audience

A platform can control the container, route the data, and index the outer shape, but:

$$\text{description}(x) \neq \text{resolution}(x)$$

The Shift:

Traditional: client -> platform -> policy check -> plaintext
Semantic Island: client -> topology -> ciphertext -> derivation -> meaning

The network routes, the store stores, and only the audience resolves.

sui.gn

Semantic anchor and root identity for the .me ecosystem — Algebra of Contexts, cryptographic audiences, applied robotics.

suign.github.io

neurons.me

Sovereign semantic compute. Identity, namespace, runtime — owned by you.

neurons-me.github.io

Inverted Dependency Indexing: What Makes O(k) Reactivity Possible

Sui Gn — Wed, 12 Aug 2026 20:22:08 +0000

TL;DR: Instead of scanning the whole graph O(n), keep a reverse index from source → dependents. Cost becomes O(k) where k=|affected frontier|.

The Claim

cost(mutation) = O(k), not O(n)
T(Δp) = O(|Reach_D(p)| + C_eval)

What It Makes Possible

True O(k) reactivity — only affected chain recomputes
Faithful explain() — returns {expr, inputs, dependsOn, recomputed, sourcePath} not narrative
Low overhead — 0.0122ms → 0.0189ms (+0.007ms p95) for 3000 nodes, 300 iterations
Privacy-preserving — stealth scopes mask ●●●● origin: stealth but structure stays visible
Deterministic convergence — local segments reach consistency without global sync

Why It Matters

It makes me['!'].explain() possible: handing over the computation itself, not a self-generated account of it.

Sources

Glossary explainer of work by Sui Gn (@suign).

T A: Replication Should Not Change Audience

Sui Gn — Wed, 12 Aug 2026 20:17:48 +0000

TL;DR: C=(T,A). Topology is where bytes sit. Audience is who can read. T ⊥ A means copying never expands audience — by cryptography, not policy.

The Core

C = (T, A)
meaning(node) = f(A), never f(T)
replicate(T) ↛️ change(A)
I = (path, ciphertext, T, A, C)

Mechanism

readable(state) = decrypt(state, A)
location(state) = replicate(state, T)

A = A₁ ∪ A₂ ∪ ... → any member reads
A = A₁ ∩ A₂ ∩ ... → all required, XOR-split: Sₙ = S ⊕ S₁ ⊕ ...
identityHash(K) = keccak256("this.me/identity:v1::" + K.seed)

Why It Matters

You can replicate to 100 nodes (|T|>1) while A={self} stays locked. Node stores ciphertext, not meaning.

Sources

Glossary explainer of work by Sui Gn (@suign).

n=1 f 0: Why Single AI Channels Tolerate Zero Faults

Sui Gn — Wed, 12 Aug 2026 20:05:02 +0000

n=1 ⟹ f≤0 — A Single-Controller AI Channel Tolerates Zero Byzantine Faults

TL;DR: Lamport proved n ≥ 3f+1 in 1982. Apply it to a single-provider AI channel where n=1. Math gives f ≤ 0. Zero internal Byzantine faults tolerated — by arithmetic, not by policy.

The Equation

y_t = x_t + η_policy + η_memory + η_routing + η_incentive

A centralized channel always injects 4 noises.

The Degenerate Case

Imported result (not his, Lamport's):

n ≥ 3f + 1

Original synthesis:
n = 1 ⟹ f ≤ 0

If n=1, you cannot survive even 1 liar inside the channel. Self-report tolerates zero checks — same shape.

Why It Matters

This is why me['!'].explain() doesn't generate a narrative. It returns computation's own record.

Sources

This post is a glossary explainer of work by Sui Gn (@suign).

.me Kernel

Sui Gn — Wed, 12 Aug 2026 18:55:35 +0000

This is the technical breakthrough that stands out across this work: It is a reverse (leaf → dependents) index in a reactive semantic graph/tree.

It delivers true O(k) incremental reactivity — when a value changes, only the specific dependency chain of length k is recomputed, independent of the total graph size n.

This makes large-scale reactive semantic data practical (measured constant computational effort even with thousands to tens of thousands of nodes, and negligible overhead for full derivation traces).

It directly enables the kernel’s explain() feature: returning the actual computation record (exact expression, literal inputs with origin/masking, dependsOn, recomputed, sourcePath) instead of a generated narrative. This is the structural solution to the problem of unreliable AI/self-report explanations that the original thesis discusses.

In short, Inverted Dependency Indexing is the engineering substrate that turns the philosophical/architectural claims of .me (schema-less reactive identity graphs, stealth scopes, deterministic local convergence, and verifiable “why did you say that?” answers) into a working, efficient, and checkable system.

His broader contributions include the overall .me / neurons.me stack (declarative identity, me:// Namespace Resolution Protocol, privacy-preserving semantic spaces, etc.), but the inverted dependency mechanism is the distinctive, high-leverage innovation that makes the rest scale and become auditable.

DEV Community: Sui Gn

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

Building Encrypted Semantic Islands with .me

neurons-me (.me) · GitHub

Quick Formula

Topology $\perp$ Audience

The Shift:

sui.gn

neurons.me

Inverted Dependency Indexing: What Makes O(k) Reactivity Possible

The Claim

What It Makes Possible

Why It Matters

Sources

T A: Replication Should Not Change Audience

The Core

Mechanism

Why It Matters

Sources

n=1 f 0: Why Single AI Channels Tolerate Zero Faults

n=1 ⟹ f≤0 — A Single-Controller AI Channel Tolerates Zero Byzantine Faults

The Equation

The Degenerate Case

Why It Matters

Sources

.me Kernel

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

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