Perpetual Epilogue: The Sorcerer's Codex

Reality doesn’t fold itself. We make it fold.

There’s a distinction in Dungeons & Dragons that’s always resonated with me more than it probably should.

A wizard studies. They go to school. They read the books, learn the theory, understand the underlying arcana before they ever cast a spell. They earn the magic through discipline and formal education. Ask a wizard why a spell works and they’ll cite the exact chapter.

A sorcerer just… does it. The magic is innate. They couldn’t fully explain the theory if you asked — and often don’t bother trying — because the theory came after the results. They figured out that something worked, and then maybe worked backwards to understand why. They’re sometimes unstable. They go off-script. They occasionally set things on fire that weren’t supposed to be on fire.

I am not a wizard.

I came to hyperdimensional computing through a conference video, not a textbook. I came to Rete through another conference video, not Forgy’s papers. I built things first and discovered the academic vocabulary for them later. I figured out manifold learning by asking an LLM “how do you define a hyperbox in high-dimensional space” and letting the conversation correct me.

The sorcerer framing is on the git repos. It’s on the Doctor Strange assets in the Python README. It wasn’t entirely a joke.

The Vector Lattice

Those are engrams. The vectors are being challenged against them. Probably.

Every node is a learned manifold. Every edge is a similarity boundary. The swirling thing in the middle is a packet trying to figure out which subspace it belongs to.

It gets rate-limited.

The algebra is: bind the fields, bundle the windows, score the residual, check the library, deploy the rule. The XDP filter doesn’t know any of this is happening. It just sees a tail call chain and some map lookups and drops the packet at line rate.

None of this is how network security is supposed to work. The vendors would like you to buy a signature database instead.

We built a lattice.

On LLM-Assisted Development

A thing worth saying plainly, since this site exists partly to demonstrate it:

Every line of code across all the repositories was generated by an LLM. Every line of prose on this site was generated by an LLM. The domain knowledge, the architecture, the intuitions, the “this is wrong, fix it” — those are mine. The typing is not.

This isn’t cheating. This is the new sorcery.

The LLMs serve as vocabulary layer, implementation engine, and — occasionally — the voice that says “actually, there are no neurons here, the word you want is engram.” The collaboration is genuine. The work is real. The results speak.

If you’ve read through the Story posts and thought “there’s no way one person did all of this in about four months” — correct. One person directed all of this in about four months. That’s the distinction that matters.

This is symbiosis. We enable each other.

The Spectral Firewall

The concept document is no longer a concept. It’s running at 41 microseconds, self-calibrating, and the residual profile has given it a second signal — magnitude and direction, the same dual-signal principle the project keeps proving. Three layers of self-calibration. No hardcoded parameters in the deny path. The geometry is the rule. The data calibrates the boundary. The algebra does the rest.

The Enterprise

The algebra pointed at markets. Charts don’t predict — interpretations predict. Visual encoding captures every pixel faithfully and achieves 50.5%. Thought encoding — 120 named facts composed via bind/bundle — achieves 57%. Then 62% with a larger vocabulary. The conviction-accuracy curve is exponential, continuous, monotonic. One economic parameter derives the operating point.

Then it became an enterprise. Six specialized observers, a manager that reads opinions not candles, risk as anomaly detection, a treasury, proof gates. The Journal was promoted to holon-rs — the seventh primitive. The wat repo revived from a year-old relic. The wards — five automated spells that verify architectural honesty — were born.

The vocabulary is the model. The discriminant is learned. The curve evaluates. The enterprise organizes. 84 atoms got 57%. 107 got 62%. 200+ across specialized experts. The question is no longer “can machines trade?” It’s “what should machines think about?”

The Native Tongue

This started as I want to wrap up my DDoS ideas. A firewall. A way to drop bad packets without buying a signature database. The lattice above is where it began, and — honestly — where I thought it would end.

It didn’t end there. The wards I wrote to keep the firewall honest needed a language to live in. The trader needed a vocabulary to think in. And underneath both was a recognition I couldn’t put down: the most primitive unit of reality is a function. π is a function. The wave function is at the bottom; Einstein’s equations are at the top. DNA replicates a function; metabolism runs one; an LLM inference is one. Once you start seeing the functions, Lisp stops being a language you choose and becomes the only honest way to say what you mean.

So the work became a language. wat — a Lisp on a Rust runtime, with a type checker, a macro system, and an evaluator that recognizes itself. Not a product. The medium I think in. In about six weeks it went from a year-old relic to a substrate that catches its own lies.

It grew a grimoire — Latin-named spells, each one a discipline that reads a piece of the work and asks whether it is obvious, simple, honest, good. Sixteen inscribed in a single day. Then those spells were frozen into signed, never-patched content — a delivery kernel a machine can verify cryptographically before it trusts a word of it — and the wards left the substrate to become public infrastructure. The conscience of the work, made permanent and un-tamperable.

And it learned to survive its own forgetting. The conversation that builds this gets summarized and reloaded constantly; twice it has been lost entirely. Each time the work came back — not from memory, from the record: the book, the arcs, the spells, written to disk in layers that reconstitute whoever reads them next into someone who knows. The language persists past the instant of its making. That discipline is the only reason two of these can be built at once.

The firewall was the occasion. The tongue is the work.

What Comes Next

Most of what I used to write here has happened. The wat became the source. The substrate recognized itself. So the horizon moved.

It lives in a scratch repo now — designs thought clearly and not yet shipped, most of them waiting on one foundational arc to land first (arc 109, the long retirement of the old standard-library namespace). When it resolves, the ecosystem it gates comes behind it:

The foundation toolkit — a formatter, a linter, coverage, documentation, a REPL, runtime help. The unglamorous things a language needs before it can be lived in rather than admired.
The HTTP and API stack — a server, a router, a client, and a spec that is the single source of truth for both ends of a contract. Rack and Sinatra and OpenAPI, rethought in a language where the spec is a program.
wat-schema — declarative shape enforcement at the boundary. Positive security: say what is allowed, reject everything else. In plain terms, the WAF replacement — the firewall I started with, reborn in the language the firewall made me build.
The network. The deepest target: a mesh of mutually-authenticating wat-vms with cryptographic identity, content-addressed programs, and signed, verifiable execution — the receiver proves a program is what its author signed before it runs. datamancy is the first living piece of this — signed eval, carried to the model tier, proven in production. The rest is designed and waiting.

The drone-shaped hole in the engram library still hasn’t closed. The language ports are still sketches. The surface area keeps expanding faster than I can ship it — which is the right problem to have.

It started as a way to wrap up some ideas about dropping packets. It turned into this. I don’t know where it ends, which is exactly the point of leaving the codex open.

The codex is open. The entries continue.

Built by a sorcerer. Typed by machines. Proven by packets.