ReflexOS

Demo

About

ReflexOS is the software layer for neural reflexes: tiny, deterministic brain circuits that machines and software can compose, run locally, publish under an ENS name, and prove. Digitized brains have left the lab. Fly connectomes now drive agents in Minecraft and Doom, and walk robots. These circuits are small (hundreds of neurons, not billions of parameters), fast (a decision within one control tick), deterministic (the same input always gives the same output) and light (they run on a CPU, with no GPU or cloud). That makes them a fit for a problem large models handle badly. Most systems don't need a giant model; they need a reflex: a car braking before a crash, a drone dodging an obstacle, an agent reacting to a critical event. Today these circuits can't be packaged, composed, shipped or verified the way software can. ReflexOS fills that gap. A Block is a neural circuit with a typed interface, locked by digest. LoomGuard, for example, is a collision reflex built from 780 real FlyWire neurons. In NeuroLab, Blocks are wired to sensors, control and actuators to form a Stack, either on a canvas or by describing it in plain words to an assistant, which asks a few questions and builds a graph the compiler has checked. Each Stack compiles to one canonical .reflex file containing the graph, the runtime plan and the exact model bytes, and it runs on a deterministic fixed-point runtime that behaves the same in the browser, in Node and in our npm package. A game or robot adds a reflex in two lines: npm install @reflexos/runtime, then EmergencyBrake.attach(car). ENS turns the library into something open and checkable. We registered reflexos.eth on ENSv2 with its own registry and resolver, plus branches for stacks, blocks, fleet and agents. Anyone can claim a namespace such as yourproject.reflexos.eth for free: their wallet signs a message and ends up owning the name, its registry and its resolver, while our server only holds a revocable publisher role with no admin rights. When a Stack is published, it gets its own subname, its SHA-256 goes into a text record, its file goes to IPFS through the contenthash record, and the owner's signature over the name and digest is stored on the name. Anyone can type the name, fetch the file from any IPFS gateway, and verify without trusting anyone that the bytes match the on-chain digest, that the owner signed them, and that recorded decisions replay to identical outputs. The Discover page lists every published Stack straight from registry events, with no database. Receipts make every critical decision accountable: they record what the reflex saw and why it acted, and anyone can replay them. The reflex path itself stays fully local; the chain is used only for publishing and proof, never between a sensor and a brake.

How it's made

ReflexOS is a TypeScript and Rust monorepo. The core is a deterministic spiking-neuron virtual machine: leaky integrate-and-fire neurons in Q16.16 fixed-point, with saturating integer arithmetic and weights in CSR sparse format. It exists twice with identical semantics, once in Rust (reflexos-core, with a Merkle crate for commitments and a CLI for run, replay and bench) and once in TypeScript for the browser and Node. Floating point never enters the tick loop, so a decision computed on a laptop, in a browser or on a companion computer is bit-for-bit identical, and that is what makes replay meaningful. Blocks are packaged by a Python compiler that turns circuit data into block.json: the CSR topology and weights, named input channels and output populations. LoomGuard, our collision reflex, is 780 neurons and 7,538 synapses from FlyWire FAFB v783 (LC4, LPLC2 and giant-fiber populations). A Stack is a typed graph of sensors, adapters, neural blocks, control nodes and actuators. The compiler checks port types, cycles, sample rates and the critical-path budget, locks every model by SHA-256, and emits one canonical JSON package with sorted keys and no floats. Its digest is the package's identity. The runtime schedules nodes on a 1 kHz clock and, on critical actuator changes, writes a receipt: an input commitment, state roots before and after, the actions taken, and a hash chained to the previous receipt, so a fresh runtime can replay the exact tick. The same runtime is bundled with esbuild into a dependency-free ES module and shipped as the npm package @reflexos/runtime, which our Three.js car game uses to brake with two lines of code. NeuroLab is Next.js 15 and React 19, with viem for everything on-chain. The Compose assistant is deliberately not an LLM wiring graphs. Free text, read either by a vocabulary extractor or by an optional model, fills a typed build spec. The dialogue asks only the questions that change the graph, and a deterministic planner builds the graph and runs it through the real compiler before anything reaches the canvas. There was no olfactory model to build the smell-tracking Stack from, so we engineered one: an 88-neuron circuit laid out like the fly's pathway, with bilateral receptors, antennal-lobe projection neurons, and interneurons that inhibit the receptor terminals so a dense plume doesn't saturate both sides. We tuned it by simulating it on the real VM until it steered the right way on every tick we measured. ENSv2 on Sepolia is the backbone of publishing, and it is our partner technology. We registered reflexos.eth through the ETHRegistrar's commit-reveal flow, paying in the testnet MockUSDC, and deployed our own UserRegistry and PermissionedResolver proxies through the VerifiableFactory with CREATE2 salts, one registry per branch (stacks, blocks, fleet, agents). ENSv2's hierarchy is the whole point: anyone can claim theirname.reflexos.eth, and it comes with its own registry and resolver owned by their wallet. Our operator holds only non-admin publisher roles, which the user can revoke. Publishing registers the Stack's subname, uploads the file to IPFS through Pinata, and in a single multicall writes the digest text record, the contenthash, and the owner's EIP-191 signature over the name and digest. Claiming and publishing are gasless for users: they sign messages in MetaMask, the server verifies each signature against the name's on-chain owner before spending any gas, and it rejects stale signatures so an old one can't roll a name back. Verification goes through the UniversalResolverV2, so anyone can check a Stack with nothing but its name. The hacky parts. The deployed ENSv2 contracts differed from the repository head: the resolver's initialize, setText and role layout had all changed, so we checked every function selector we call against the deployed bytecode and pulled ABIs from the exact deployment commit. On the deployed resolver, write permissions are scoped per record key, not per name, so a shared resolver would let any user overwrite anyone else's digest; that is why every user gets their own resolver. Registration normally cannot be simulated past the commit step, so before sending anything we rehearse the entire sequence with eth_simulateV1: deploy the contracts, mint, approve, commit, then jump the block timestamp past the commitment age, register, link parents, register the branches, and resolve the name back through the Universal Resolver, all on a fork. To list community builds without a database, we recovered the registries' event signature, LabelRegistered, by hashing candidate signatures until one matched the topics in real logs. Discover now scans those events and checks every entry live. Pinata stores small files as a single raw IPFS block, so a Stack's CID contains the very SHA-256 we publish as its digest, and the name's two records are two views of one fingerprint. Finally, the shared VM decoder injects loom signals into its danger population, which would have flattened the smell circuit's intensity. We route intensity through a different output population, and smooth the sparse per-tick spikes with an integer-only leaky integrator (ema += (x - ema) >> 3) that is stored in replayable state, so smell-tracking receipts still replay bit-exactly.