DEV Community

Sui Gn
Sui Gn

Posted on

We Have a Live Semantic App Mesh

#programming #ai #datascience #llm

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
Enter fullscreen mode Exit fullscreen mode

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

local.netget/apps/fulltrailer
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

This model starts differently:

.me
Enter fullscreen mode Exit fullscreen mode

The app begins with semantic space:

apps.fulltrailer.tractos.records
apps.fulltrailer.settings
apps.fulltrailer.events[]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

But:

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

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

FullTrailer was the first real proof.

The next step is making this repeatable.

Top comments (0)