Building Neurowire: one canonical rig, six feed formats
Neurowire treats feeds like a data-modelling job: one canonical rig every parser feeds and every serializer reads, so bolting on a format is a single serializer, choom.
The core engineering call behind Neurowire is that feeds are a data-modelling job, not a parsing or scraping brawl, choom. Every parser feeds the same canonical feed rig, and every serializer reads that one rig. The payoff is direct: bolting on a new output format is writing one serializer, not editing every parser, and backing a new input is writing one parser, not touching every output.
Neurowire kicked off from a simpler frustration: too much data to jack in. There is too much to read today, especially around AI, and following it through the usual megacorp platforms means keeping an account on someone else’s algorithm and reading whatever that corpo ICE decides to surface. Neurowire exists so any choom can easily build their own news feed from sources they trust, no gatekeeper in the middle. You can run it now at neurowire.app.
Why jack a canonical rig into the middle?
The gonk approach to a feed tool is a matrix. You have N input formats and M output formats, and if you wire them straight you end up nursing N times M conversions. RSS to Atom, RSS to JSON Feed, Atom to Markdown, and on it goes. Every new format multiplies the work and the bugs.
Neurowire collapses that matrix by jacking one canonical feed rig between the two sides. Parsers only ever target the rig. Serializers only ever read the rig. So the cost of N inputs and M outputs drops from N times M to N plus M. That single architectural call is what makes everything downstream composable, and it is the same reasoning behind the docs launch.
What does the rig serialize to?
From one canonical feed, Neurowire emits six formats. Atom and RSS 2.0 cover anything that already speaks feeds. JSON Feed 1.1 covers modern clients. Markdown gives you a readable digest you can drop into a doc or a chat. Self-contained HTML produces a page that needs nothing else to render. And NWF, the native Neurowire Feed format, is the compact representation tuned for storage and transfer.
Because the rig is the contract, none of these serializers know about each other, and none of them know which parser produced the feed they are writing. You can bolt on a seventh format tomorrow by writing one function that walks the rig and writes bytes. Preem and clean.
How do sources, meshes, and constructs slot in?
The rig sits at the centre, but Neurowire layers a few composition concepts on top so you can build real pipelines.
- Sources and taps are where content jacks in. A source is anything Neurowire can parse into the rig. A tap is a per-host recipe that turns a feed-less HTML page into a source.
- Meshes fetch several sources in parallel and merge them into one feed, handling dedupe and ordering.
- Constructs bundle multiple meshes into a single repository, grouped or flattened.
So you move from scattered sources, to a merged topic feed, to a curated bundle, and at no point do you leave the canonical rig, choom. Each layer just produces another instance of the same shape.
Where to read the code
The full documentation lives at neurowire.starside.io, and the source is on GitHub under Starside Labs. This site dogfoods the engine: its writing feeds are serialized from the same rig the docs describe. If you want the architecture in one sentence, it is this, choom: build the rig right, and every format becomes a thin layer over it. More of the open-source work sits under projects, and you can reach me through contact.