InfiniteMass

CRDTs: here, here is a picture of you when you were younger:)

Oblivious Compute: every picture of me is when I was younger...

A thought experiment: was the computation what we were doing when the picture was snapped, or the picture itself?

Kernel defines the proposed computational object. Halt gives you the minimal executable illustration with several conceptual images. There's five executable programs on the repo. And it's certainly not a CRDT.

Oblivious compute proposes that computation can reside in the relation between independent observers.

The interesting question isn't whether the nodes converge, the question is what type of computation are we even looking at?

is this just a video, what is this about?

What you’re seeing isn’t a client talking to a server.

Each node broadcasts state and converges locally. There’s no server, no central authority, and no history to sync.

The board you see is the system.

If you try it, run two terminals locally or connect a couple machines on the same network. It becomes clear pretty quickly how it behaves.

Happy to answer questions.

A quick note to orient readers: this demo is intentionally small and exploratory.

The core idea is not to hide network messiness, but to make it visible early. The system does not rely on logs, replay, or historical coordination for correctness; instead, candidate states compete briefly and one survives via selection and erasure.

I’ve enabled GitHub Discussions in the repo for longer technical follow-ups if that’s useful.

This is a small experimental demo exploring stateless convergence in distributed systems.

Instead of relying on logs, replay, or historical coordination, nodes exchange full state and correctness emerges through selection and erasure. Multiple candidate states may exist briefly; one survives, the rest are discarded.

The demo runs five independent nodes over UDP. A node can be severed mid-run and later rejoin without replaying history. The repository includes a short screen capture showing the system running live.

This is not production-ready and intentionally surfaces failure modes like packet loss and jitter rather than hiding them behind retries or buffering.

I’m posting this as an exploration of a primitive, not a finished system. Happy to answer technical questions or hear critiques.

(For longer technical follow-ups, I’ve enabled GitHub Discussions in the repo.)