# The fly connectome is a substrate, not a model
> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.thesatyajit.com/articles/fly-connectome-computing
> date: 2026-09-18
> tags: connectomics, reservoir-computing, drosophila, fast-weights, path-integration, explainer
On September 3, 2026, Google Research and HHMI Janelia's FlyEM team — with the Cambridge Connectomics Group and the MRC Laboratory of Molecular Biology — published the complete central nervous system of a male fruit fly: **166,691 neurons**, brain and ventral nerve cord together, every synapse annotated with a predicted transmitter. It's a real community effort in the way these things always are now — decades of electron-microscope imaging, AI-assisted segmentation, and an estimated 44 person-years of human proofreading, released under CC-BY so anyone can use it. It sits next to the complete female brain that Princeton-led FlyWire consortium published in Nature two years earlier. For the first time, both sexes of one species have a synapse-resolution map of (most of) their nervous system, and the map is free.
Here's what happened next. I found a reservoir computer trained on it within days. A candidate answer to a genuinely open 20-year-old question in insect navigation, within about a week. A language-model adapter, a browser-driving robot, a drone controller, at least four browser games, a toy social network, and — inevitably — a memecoin, all within about two weeks. Four different competing "awesome fruit-fly connectome" lists exist on GitHub as I write this, because apparently one wasn't enough. GitHub's own code search is unavailable from where I'm working, so I can't claim to have surveyed everything; what follows is what I could reach by cloning repos directly and following citations out of papers and READMEs.
The thing worth writing about isn't any single one of these projects. It's that they give **contradictory answers** to the same question — does the specific wiring matter, or just its statistics — and both answers are correct, for different questions. Working out which is which is the actual payload of this piece.
## What a connectome is, and isn't
A connectome is a wiring diagram. Electron microscopy images a brain slice by slice at nanometer resolution; software traces each neuron's shape through thousands of sections and finds every point where one neuron's membrane comes close enough to another's to be a synapse; a classifier looks at the shape of the vesicles at that synapse and predicts which of a handful of neurotransmitters it releases. The output is a graph: which neurons connect to which, how many synaptic contacts back each connection, and a guess at whether that connection is excitatory or inhibitory.
That is a genuinely enormous amount of information, and it is also very specifically *not* a simulation. It does not tell you a synaptic weight — a contact count is a proxy that every project has to turn into a number using a formula the anatomy doesn't specify. It does not tell you a membrane time constant, a firing threshold, or how fast a synapse depresses. It does not tell you a receptor's kinetics beyond "probably fast, probably slow." It says nothing about neuromodulation — dopamine, octopamine, serotonin — which can silently rewrite what a fixed circuit does from one behavioral state to the next. And it captures one fly, fixed at one moment; it is not a claim about every fly, or the same fly a minute later.
Every project in this article draws its left column from the same handful of released datasets. What separates a null result from a real finding, almost without exception, is what each one chose to put in the right column — and whether that choice was even necessary for what they were trying to show.
Every soma above is a real neuron with a recovered cell body in MaleCNS v1.0 — 141,781 of them, out of 176,422 reconstructed nodes. The gap is the first hint at why the counts in the next section never agree.
## The data layer, and why nobody agrees on the neuron count
There isn't one fly connectome; there are five, covering different parts of a fly, from different sexes, at different points in the last six years:
- **Hemibrain** (Scheffer et al., 2020, *eLife*) — the first of these at real scale: ~25,000 neurons, dense reconstruction of roughly half the central brain of a *female* fly. No optic lobes, no ventral nerve cord. About 20 million chemical synapses by the paper's own headline count — though the same paper also reports 64 million postsynaptic densities and 9.5 million presynaptic T-bars, which is your first clue that "synapse count" is not one number.
- **FlyWire / FAFB** (Dorkenwald et al., 2024, *Nature*, with the companion cell-typing paper by Schlegel et al.) — the first *whole brain*: 139,255 proofread neurons, both optic lobes and the central brain, 5×10⁷ chemical synapses, female. No ventral nerve cord. Browsable at [codex.flywire.ai](https://codex.flywire.ai).
- **MANC** (Takemura et al., 2024, *eLife*) — the male nerve cord on its own, ~23,000 neurons, no brain.
- **BANC** — brain and cord together for the first time, in one female fly, ~114,000 neurons and ~108 million synaptic connections, though missing the first optic relay (the lamina) and the retina.
- **MaleCNS** (Berg, Beckett, Costa, Schlegel, Januszewski, Marin, Nern et al., 2025/26, *Cell*) — the one that landed in September: 166,691 neurons, 11,691 named cell types, brain **and** cord in the same animal, male. It found 114 cell types that differ measurably between the sexes, 262 found only in males, 69 found only in females — the first time that comparison has been possible at synapse resolution.
The MaleCNS release is where three of this piece's central examples come from, and every one of them cites it as **v1.0** specifically. I can't tell you with confidence when v1.0 became available to researchers relative to the September 3 splash — FlyWire's own data was accessible to registered collaborators well before its 2024 Nature papers, and connectomics releases often work that way. What I can tell you is that the earliest downstream project I found with an internal timestamp — the path-integration analysis below — records its own start date as September 10, one week after the announcement, already citing v1.0. Either there was quiet pre-publication access, or a research community moved from "here is a 31-gigabyte graph" to a testable hypothesis about an unsolved circuit in seven days. I couldn't confirm which from the outside, and I'd rather say that than guess.
What I can check is why the neuron and synapse counts you'll see quoted for MaleCNS never quite match. They're not being sloppy — they're counting different things:
Four different numbers for the same MaleCNS release, in the same section of this article: 46 million presynaptic sites, 125 million "synaptic connections" (Google's own announcement), 312 million postsynaptic densities, and two more numbers again once individual downstream projects apply their own proofreading and synapse-count thresholds and call the result "neurons retained" or "directed connections." None of these is wrong. A presynaptic site (a T-bar, in fly EM jargon) can have many postsynaptic partners, so PSDs will always outnumber T-bars by a lot; a press release rounding to "125 million synaptic connections" is doing some other aggregation again; and a project that only keeps edges with five or more synaptic contacts will report a smaller, different number than one that keeps everything. If you're going to build something on one of these datasets, the first thing to nail down is which of these numbers your own pipeline is actually going to produce, because it will not match the number in the announcement you read.
## The tooling: a stack you can actually install
By the time MaleCNS shipped, the software for working with any of these datasets already existed, largely because FlyWire and hemibrain forced it into being years earlier:
- **[navis](https://navis.readthedocs.io/)** and its R counterpart **natverse** — neuron morphology, skeletons, meshes, NBLAST similarity, coordinate transforms between brain templates. Works with all five datasets.
- **[fafbseg-py](https://github.com/flyconnectome/fafbseg-py)** — FlyWire/FAFB segmentation access: map a location to a neuron, pull meshes and skeletons, query connectivity, generate Neuroglancer URLs.
- **[neuprint-python](https://github.com/connectome-neuprint/neuprint-python)** — a client for Janelia's neuPrint service, which serves hemibrain, MANC, and MaleCNS (FlyWire/FAFB and BANC live in CAVE instead, via **CAVEclient**).
- **[conn2res](https://github.com/netneurolab/conn2res)** — turn any connectivity matrix into a reservoir; more on it below.
- **[flyvis](https://github.com/TuragaLab/flyvis)** — the official implementation behind the connectome-constrained visual-system model, also below.
- **[NeuroMechFly](https://github.com/NeLy-EPFL/NeuroMechFly) / [flygym](https://github.com/NeLy-EPFL/flygym)** — a physically simulated fly body, also below.
Here's the part that actually matters for a reader who wants to try any of this: loading the wiring and putting a signal through it takes about fifteen lines, and the pattern is the same regardless of which dataset you're pointed at.
```python
# Pull a small, named circuit out of hemibrain via neuPrint (neuprint-python)
from neuprint import Client, fetch_adjacencies
c = Client("neuprint.janelia.org", dataset="hemibrain:v1.2.1")
sources = [329566174, 425790257, 424379864, 329599710] # bodyIds, or use NeuronCriteria(type=...)
targets = [425790257, 424379864, 329566174, 329599710, 420274150]
neuron_df, conn_df = fetch_adjacencies(sources, targets, client=c)
# neuron_df: bodyId, instance, type — who these cells are
# conn_df: bodyId_pre, bodyId_post, roi, weight — synapse counts, per brain region
```
```python
# Build a weighted adjacency matrix from that table and put a signal through it
# with conn2res — the frozen-substrate pattern every reservoir project uses
import numpy as np
from conn2res.connectivity import Conn
from conn2res.reservoir import EchoStateNetwork
from conn2res.readout import Readout
W = np.zeros((n_neurons, n_neurons))
for _, r in conn_df.groupby(["bodyId_pre", "bodyId_post"]).weight.sum().reset_index().iterrows():
W[idx[r.bodyId_pre], idx[r.bodyId_post]] = r.weight
conn = Conn(w=W)
conn.scale_and_normalize() # rescale so the spectral radius sits below 1
esn = EchoStateNetwork(w=conn.w, activation_function="tanh")
states = esn.simulate(ext_input=stimulus) # (timesteps, n_neurons) — never trained
readout = Readout(estimator="ridge").fit(states, labels) # the only thing that learns
```
That's the whole recipe behind every reservoir-computing project in this piece, fly or otherwise: fetch a real adjacency matrix, rescale it, drive it, and train a linear readout on top. Swap `Client(...)` for a FlyWire CAVEclient session or a local MaleCNS Feather file and the rest of the pipeline doesn't change.
## Three ways to ask what the wiring is for
Once you have the graph, there are three genuinely different questions you can ask of it, and this article's three sections are exactly those three questions.
### 1. Train the free parameters, freeze the wiring — flyvis
[Lappalainen, Tschopp, Prakhya, McGill, Nern, Shinomiya, Takemura, Gruntman, Macke & Turaga, "Connectome-constrained networks predict neural activity across the fly visual system," *Nature*, September 2024](https://www.nature.com/articles/s41586-024-07939-3) is the strongest positive result in this piece, and it predates MaleCNS by two years — it used the fly optic lobe's local connectome instead. The idea: build a recurrent network whose *architecture* — which units are connected to which — is copied exactly from the measured connectome, across 64 identified cell types tiled over 721 hexagonal columns (45,669 modeled neurons, 1,513,231 connections). Everything the anatomy doesn't specify — each cell type's membrane time constant and resting potential, and the strength of one synaptic contact for each type-to-type connection — is left as a free parameter and *trained*, using nothing but a self-supervised optic-flow-estimation task on naturalistic video clips. No neural recordings enter the training at all.
Because the connectome fixes which connections can even exist, the model needs only **734 free parameters** to describe a 45,669-neuron network — two per cell type for the passive dynamics, one per connection type for synaptic strength — versus well over a million if you had to fit every possible connection weight independently. That's the whole trick: the connectome isn't training data, it's a massive reduction in what has to be learned at all.
Then they checked it against real, recorded neurons the model never saw during training. An ensemble of 50 independently trained networks correctly predicted the ON/OFF contrast preference for all 32 experimentally characterized cell types on median, and the best individual model got 30 of 32 right; it correctly recovered that T4 cells are selective for ON-motion and T5 for OFF-motion, the textbook result in fly vision; and — this is the part that closes the loop — models that did better on the training task also predicted real tuning curves more accurately (Pearson r = −0.60 between task error and direction-selectivity match, p = 2.6×10⁻⁶, against 26 previously published experimental studies). Swap the connectome-constrained architecture for a same-size *random* network with the same number of free parameters, and both the task performance and the match to real neurons get measurably worse.
This is the cleanest evidence in this entire piece that the wiring's *identity* — not just its statistics — carries real information, because the task explicitly checks against specific, identified neurons and specific, measured tuning properties. There is no equivalent of "shuffle the wiring and see if it still works" here that would even make sense: the whole claim is about *which* neuron does *what*, and a scrambled network couldn't be checked against the same 32 named cell types in any meaningful way.
### 2. Freeze everything, train only the readout — reservoir computing
The opposite extreme: don't train anything inside the network at all. Suárez, Mihalik, Betzel, Mišić and colleagues built **[conn2res](https://github.com/netneurolab/conn2res)** (bioRxiv 2023, published in *Nature Communications*, 2024) specifically to make this comparison systematic — drop a real connectome into a reservoir-computing pipeline, drive it with a task's input, and fit only a linear readout on top of whatever dynamics the fixed network happens to produce. Costi et al. had already applied this to a fly connectome for time-series prediction. It's a well-established technique going back to echo-state networks and liquid-state machines: a fixed, nonlinear recurrent system does the heavy lifting, and everything trainable lives in one linear layer at the end.
This site already covered the sharpest instance of this pattern in detail: **[oruk.ai's speech-emotion classifier](/articles/fly-connectome-reservoir)**, built on 499 neurons from an earlier MaleCNS release, which ran the one control — scrambling the wiring while keeping the same degree sequence, signs and rescaled spectral radius — that a reservoir-computing result actually needs, and reported (in their own main text, not an appendix) that the scrambled network tied the real one. I'm not going to restate those numbers here; read that piece for the full methodology and the honest accounting of what the fly's wiring did and didn't buy. What matters for this article is the *shape* of the result: when the only thing that gets trained is a readout, the reservoir's *statistics* — spectral radius, sparsity, weight scale — are doing all the work a linear model can see, and its identity is invisible to that readout by construction.
### 3. Put it in a body — embodied simulation
The third question isn't about the brain at all. **[NeuroMechFly](https://github.com/NeLy-EPFL/NeuroMechFly)** (Lobato-Rios, Tata Ramalingasetty, Özdil, Arreguit, Ijspeert & Ramdya, *Nature Methods*, 2022) built a physics-simulated adult fly body from a micro-CT scan — real leg geometry, real joint ranges, contact dynamics against a substrate, in PyBullet. Its successor **[flygym](https://github.com/NeLy-EPFL/flygym)** (NeuroMechFly v2, *Nature Methods*, 2024) rebuilt it on MuJoCo and added simulated compound-eye vision on a hexagonal retina and simulated olfaction, with a recent rewrite claiming roughly 10× faster CPU simulation and up to ~300× on GPU via Warp.
Neither of these asks "does the wiring compute usefully." They ask "what does having a body, with real mass, real contact forces and real proprioceptive delay, demand of *any* controller — hand-designed, optimized, or driven by a connectome circuit." That's a different axis entirely from programmes 1 and 2, which is exactly why it's worth keeping distinct: a controller that looks brilliant driving an abstract task can fall over, literally, the moment it has to keep six legs coordinated on a surface with friction.
Laid out this way, the disagreement in this piece's headline claim resolves into a pattern, not a contradiction. Every project whose only free parameter is a readout — reservoir computing, and one more example below — found that the wiring's specific *identity* didn't matter, only its statistics. Every project that trained parameters *inside* the wired network, or used the specific wiring to identify specific, otherwise-anonymous cells, found something real. **The connectome matters exactly when you care about which neuron, not just how many.**
## What people actually built with it, in the weeks after
This is the part that's hard to survey completely — GitHub's code search isn't reachable from this session, and there are now at least four separate "awesome fruit-fly connectome" lists on GitHub (`townie/awesome-fruit-fly`, and three forks of a second list under `cobanov`, `dhruvin-sarkar` and `WilliamJones` — same description, word for word, which says something about how these lists propagate). What follows is what I could clone and read directly, organized by what each project actually demonstrates rather than by how it was covered.
### The escape circuit: a controlled, honest middle result
**[ak7660/fly-brain-escape](https://github.com/ak7660/fly-brain-escape)** pulled 4,296 neurons and 149,232 synapses on the shortest paths from looming-detector neurons (LPLC2, LC4) to descending neurons in MaleCNS, wired them as a signed rate network, and trained roughly 8,000 cell-type-level gain parameters — never the wiring itself — on a small escape task: dodge left, dodge right, or take off, given a threat approaching from some direction. It runs in a browser at 60 fps. I cloned it, served it locally, and recorded it running rather than describing it from a screenshot:
The result the project reports is the most careful, most useful data point in this whole piece, because it sits *between* the two extremes above and says so plainly. Three wiring variants, three seeds each, scored on 1,200 held-out episodes with loom speeds never seen in training:
Real connectome wiring hit 90% accuracy in about 30 training iterations; the same network with shuffled wiring (same degree sequence, same layer structure) took 77; a version with the circuit frozen and only a readout trained took 83. The project's own stated claim rule — a gap has to exceed two pooled standard deviations before it counts — is satisfied for *learning speed* (real wiring is roughly 1.7–4.5× faster) but explicitly **not** for final accuracy: both saturate at 99%+ and the gap is inside the noise. Their own honest gloss: "a real connectome is a better *starting point for learning*, not that only a fly brain can solve it." That's a third answer, distinct from both flyvis's clean positive and the reservoir null — real wiring can shape the learning trajectory without being required for the final performance ceiling, and this project is the one place I found that checked for that distinction on purpose.
### The fast-weight odometer: the strongest case for identity mattering
A fly that wanders away from food in the dark can walk straight back to it, which requires **path integration** — a continuously updated running sum of every step it's taken, so it always has a bearing and distance back to a place it can no longer see or smell. The neurons that report each step (heading and speed, from the fly's compass in the central complex) are well characterized. The neurons that *integrate* those reports into a standing "go this way to get home" signal have not been found, despite this being one of the field's longer-running open questions.
**[pwang724/fly-circuit-exploration](https://github.com/pwang724/fly-circuit-exploration)** — a research log started September 10, 2026, one week after the MaleCNS announcement — proposes four candidate cell types: **hΔH**, **hΔA**, **hΔI**, **hΔG**. The reasoning is worth walking through because it's the clearest instance in this piece of the connectome being *necessary*, not just useful. There are two ways a circuit can hold a running sum:
- **In activations** — neurons exciting each other in a loop tuned so a signal neither decays nor explodes. This is what most existing navigation models assume, and it's also how an RNN, or a modern LLM's residual stream, holds state.
- **In weights** — every step gets written into synaptic strength, and the sum of the weights *is* the sum of the journey. Nothing has to keep firing at all for the memory to persist.
hΔG and hΔA are recorded integrators — cells already known to accumulate signal over seconds (Janke 2025; Avritzer 2026's angular-working-memory result) — but a leak over seconds isn't the same as a memory that survives an arbitrarily long pause. hΔH and hΔI, unrecorded until now, are the candidate the connectome alone surfaces: they receive the same columnar hΔB "how far have I gone" input as the two recorded integrators, *plus* dopamine coverage that could gate when new steps get written into the memory, consistent with known dopaminergic compass-plasticity mechanisms elsewhere in this circuit (Fisher 2022; Plitt 2025). You cannot get to "these four, and not some other four" without the actual wiring diagram in hand — there is no shortcut from statistics to a specific, previously anonymous cell type.
I want to be as careful with the strength of this claim as the author is. The write-up's own language is "candidate," "could," "a viable candidate for vector memory" — not a recording, not a behavioral result. A synaptic path-integrator model was simulated against the measured hΔB→hΔJ and hΔB→PFR_a column kernels and tracked the true displacement from a scripted walking route reasonably well, including recovering the correct direction after a partial reset; that's a demonstration that the *mechanism is viable given the anatomy*, not evidence it's what a living fly actually does. The author is explicit that this "reports no new experiments" and says outright that they "tried to be exhaustive with published papers but may have very well missed some key published results" — an invitation to be checked, which is exactly the right posture for a connectome-derived hypothesis with simulation support and nothing else yet. Anatomical plausibility plus a working simulation is real evidence. It is not a recording from a behaving animal, and the write-up never claims it is.
The falsification is straightforward, at least in principle: record from hΔH and hΔI in a fly performing path integration, and either see the running sum in their synaptic drive or don't. Nobody has done that yet.
The reason this belongs in an article about attention and reservoirs, and not only in a neuroscience newsletter: **fast weights versus activations is a live architectural question in machine learning, not just biology.** Schmidhuber's original fast-weight programmers and every modern description of linear attention as a kind of associative memory make essentially this same distinction — see the [linear-attention section of this site's field guide to attention mechanisms](/articles/attention-mechanisms) for the mechanics of replacing softmax attention with a kernel feature map that turns the whole operation into exactly this kind of running, additively-updated state. If the fly really does store its journey in synaptic weight rather than sustained firing, that's the biological instance of the same tradeoff: a fixed-size state that's cheap to carry forward versus one that has to be actively sustained to survive. I want to be careful not to overreach in the other direction, though — a fly integrating a path over a few minutes in the dark is a much smaller claim than "the fly does continual learning an LLM can't," and nothing here supports the bigger version.
### The language model that didn't need the brain
**[nftechie/flm](https://github.com/nftechie/flm)** — the "Fly Language Model" — is the fourth independent instance of the same null result, and its own README is almost aggressively honest about it, in a way worth quoting directly against the paper it accompanies:
"A **frozen** language model with a **trained readout** of the MaleCNS v1.0 fly connectome: 166,700 retained nodes and 25,582,938 directed connections... A **278,528-parameter adapter** reads its state and adjusts the next-token scores of Liquid AI LFM2.5-1.2B-Instruct. **Only the adapter is trained.** Language ability comes from the pretrained model; **this does not mean a biological fly understands language.**"
The recurrence is `x = tanh(W @ (0.6·x + 0.4·input))`, with `W[post, pre]` holding incoming-normalized anatomical contact counts — the same leaky-recurrent-reservoir family as oruk's `x[t] = (1−α)x[t−1] + α·tanh(Wx[t−1] + W_in·u[t])`, just with the leak and the input mixed inside the nonlinearity instead of outside it. The associated paper — self-aware enough about its own title, a pun on "Attention Is All You Need," to spend most of its text hedging rather than hyping — ran the control that matters: a parameter-matched **direct-input adapter**, same size, same training, but reading raw token embeddings instead of the fly graph's recurrent state. Three seeds, held-out negative-log-likelihood:
| condition | NLL (nats/token) |
|---|---|
| frozen backbone, no adapter | 1.381995 |
| fly-connectome adapter | 1.359816 ± 0.000110 |
| direct-input control | **1.359328 ± 0.000108** |
The control wins, by +0.000488 nats/token (95% interval [0.000005, 0.00104]) — small, but the interval doesn't cross zero, and all three seeds agreed. Relabeling the graph's node identities without retraining the readout put performance back near the untouched frozen backbone; zeroing every edge matched the frozen backbone exactly. The paper's own summary: "the useful distinction... is between an anatomical graph *participating* in language generation and anatomical wiring *improving* language modeling. The first was demonstrated... the second was not." Two independent teams, two completely different modalities — speech-emotion audio and next-token text — and the same shape of result: frozen substrate, trained readout, matched control, control wins or ties.
### The odd one out: a substrate that's allowed to learn
**[dhakalnirajan/axonweave](https://github.com/dhakalnirajan/axonweave)** doesn't run an experiment; it's a library, and I'm including it because its design stance is the explicit opposite of every project above. AxonWeave exposes MaleCNS as a PyTorch `nn.Module` or Keras `Layer` with **trainable edge weights, on top of the anatomical topology** — `brain.torch_layer(trainable_edges=True)` — rather than freezing the connectome and training only a readout, or freezing everything and training an adapter. It's explicit about why: "the published biological substrate is source data; the computational model is an explicit, configurable interpretation of that substrate," and it refuses to silently convert a neurotransmitter prediction into a universal excitatory/inhibitory rule. No result is claimed either way — it's tooling, not a finding — but it's a useful reminder that "frozen substrate" is a choice every project above made on purpose, not something the connectome forces on you.
### The browser, the toys, and the drones
Beyond the two research questions above, a genuinely large pile of demos appeared, almost all following one recipe: sample a screen or camera through the fly's retinotopic hex columns into L1/L2 (the lamina cells directly postsynaptic to the photoreceptors), run the connectome forward as a spiking or rate network, and read a handful of named **descending neurons** out to a controller axis. **[fruitflydev/flycoinrh](https://github.com/fruitflydev/flycoinrh)** implements this cleanly for driving a browser cursor: DNa02's left-right asymmetry (the real steering signal a fly uses to turn) drives cursor x, DNa01 drives forward, MDN — the Moonwalker descending neuron — drives reverse, and DNp09 drives a click, triggered by the fly's own visually-driven stopping response. Coverage of similar drone projects (`SpikeCalls/FlyDrones`) reports the same **DNa02/DNa01/MDN/DNp09** readout, plus **DNg100** mapped to joystick forward in at least one game controller.
Be precise about what this is and isn't. **The fly is not learning or playing anything.** It's a fixed dynamical system whose outputs a human wired to specific controls, and the choice of *which* neuron maps to *which* axis is an engineering decision the connectome doesn't make for you — how well any of this "plays" is substantially a property of that mapping and of how forgiving the game is, not a measure of insect intelligence. That said, it's still a genuine closed sensorimotor loop running on measured anatomy end to end, and that part is real: a screen goes in through simulated photoreceptor targets, and a cursor comes out through neurons a real fly actually steers with.
`flycoinrh`'s own code turns up a small, honest discrepancy worth naming, because the project's own dictionary file flags it against itself: it labels DNp09 "stop" for the roamer's purposes, and its own annotation table says so directly — *"Bidaye et al. 2020 Neuron 108:469 (DNp09 drives forward walking, freezing at strong activation); the roamer reads it as stop."* That's the project documenting, in its own source, that its functional label for a real descending neuron doesn't match the neuron's actual documented role in the literature. I'd rather see that self-flagged than silently correct, and it was.
The rest of this cluster I can only cover briefly and by group, because there are enough of them that individually assessing each would be its own article:
- **[DOOMFLY](https://github.com/nftechie/doomfly)** — MaleCNS driving a live Doom arena, with an attempted dopamine-gated plasticity rule on a small set of mushroom-body synapses. Press coverage described it as "has learned to play the classic FPS." The project's own README says the opposite, in its own words: *"Status: live experimental training, not demonstrated learned survival. The current v6 candidate failed its visual, conditioning and survival validation gates."* That gap between headline and source is exactly the kind of thing this site checks for, and here the primary source is more honest than the press about it.
- **Games, generally** — `ak7660/fly-brain-escape` (above), a fly-swatting game reportedly driven by a ~6,000-neuron LC16→MDN retreat circuit, `jeffory/lofly` (the male connectome's courtship-song circuit playing lo-fi audio in a browser), and a handful of live spike-raster dashboards. Fun, and a real sign of how cheap it now is to put a connectome in a browser tab — a spiking simulation that needed a cluster five years ago runs at 60fps on a laptop today.
- **Drones** — a genuine honesty gradient worth naming by name. `SpikeCalls/FlyDrones` states plainly, "hardware adapters are written against the official SDKs but have not been flight-tested by us yet." `abbosaliboev/fly-brain-drone` calls itself "work in progress, honestly documented" and reports a real, repeatable closed-loop simulated food search across positions, lighting and food colors — while also disclosing that its raw connectome motion-detection simulation "does not reliably reproduce direction selectivity," which they call "a real, deep finding, not a bug we papered over." `dylankainth/flybrain` claims deployment as a flight controller on a real DJI Tello; I could not find a flight log, video, or test result confirming an actual completed flight, so I'm reporting the claim and the gap rather than either one alone.
- **[Flybook](https://flybook-iota.vercel.app/)** — three male and three female MaleCNS instances, each with its own frozen model and persisted "memory," presenting to each other in a toy social feed. It's upfront about its own limits: "real connectome data, approximate neural dynamics, learned social preference is the question, not an established result." I couldn't find public source for it, so I can't verify what's simulated versus scripted beyond what the site itself states — but as a demonstration that a connectome plus reasonable dynamics is now cheap enough to run six instances in a browser tab and let them interact, it's a good, honest toy, and I mean that warmly.
### flycoinrh's other half: real neuroscience wrapped around a token launch
I'm splitting this out because the two halves of `fruitflydev/flycoinrh` deserve different treatment. The neuroscience pipeline — 165,122 neurons and 10,228,000 signed synaptic connections from MaleCNS, real retinotopic sampling, real descending-neuron readout — is described above and is genuine engineering on real anatomy. The project also gives its browser-driving fly `roam.py` free, unsupervised run of the open internet, live-streamed, from a machine that holds a funded wallet, and its containment engineering is worth real attention on its own merits: no wallet ever reaches the roaming browser; no keyboard exists, so the fly cannot type or fill in a field; every click is checked before it lands and vetoed if it reads as a submit, upload, payment or sign-in; and — the detail I'd credit the project for most — the very first thing they built was a keyword blocklist, and the very first thing they tested against it was `p0rn.com`, which walked straight through. Their own conclusion: keyword filters don't hold, so the real control is an allowlist. That's a published failure, which this site tends to trust more than a claimed success. Its `disclosure.md` is similarly direct: the fly has no language, every journal entry and social post is drafted by a language model from a telemetry packet, a draft containing any number not in that packet is discarded with no second attempt, and the human-written account copy is labeled as such.
The project's actual purpose, plainly: it exists to launch a token (on Robinhood Chain, with a sibling launch on pump.fun). That's not something I have a view on and I'm not going to develop one here — I'm not naming or evaluating the token, quoting a price, or linking to where it's traded, and I'd encourage reading the engineering above independent of whatever the launch does or doesn't do. It's also worth asking, in the spirit of the rest of this piece, whether the neural simulation is doing anything a simpler controller wouldn't — the project doesn't compare its connectome-driven roaming against any non-neural baseline, so on the evidence available I can't tell you it is.
## A neuroscientist's rebuttal
Patrick Mineault's ["Are flies playing Beat Saber?"](https://www.neuroai.science/p/are-flies-playing-beat-saber) is the sharpest outside check on all of this, written by someone who works in this field, and it deserves to shape this piece rather than get a footnote. His central claim is that most of these demos "don't demonstrate a full loop from sensation to motor output" in any adaptive sense — the Beat Saber fly, in his reading, is "overtrained on one track" and barely uses its visual input at all; the Mario 64 fly maps a handful of neurons to controller buttons in a way that's closer to "random button-mashing on an emulator" than to vision driving behavior. His deeper point is one this article has been circling the whole way: a connectome fixes contact counts, nothing else, and "most parameters are guessed, fitted by trial-and-error, or lifted from the literature" — so a demo can be visually striking while the connectome inside it is doing almost nothing, decorative rather than load-bearing. He's sharp about the tell for this: a worm connectome (C. elegans) dropped into the same fly-body reservoir setup works about as well as the fly's own wiring, which is exactly the oruk/FLM pattern by another name — "a recurrent net can act as a large reservoir, from which we can decode arbitrary things," wiring be damned.
I think he's right about almost everything he checks, and where this piece converges with his independently — statistics-versus-identity, controls-versus-spectacle — that convergence is worth more than either of us asserting it alone. Where I'd add a footnote of my own: some of the projects above (flyvis, the hΔH hypothesis, fly-brain-escape's learning-speed result) aren't the demos he's critiquing, and they pass exactly the test he's implicitly proposing — check against real, specific, identified neurons, or run the control that would tell you if you're wrong. His prescription for what would make the flashier demos real — swap in a Lappalainen-style visual system covering closer to the full ~45,000 visual neurons, decode from the ventral nerve cord's actual motor neurons rather than an arbitrarily chosen central one, constrain any learning to specific, biologically plausible sites rather than the whole graph — is a good checklist, and by that checklist most of the browser toys above are toys, and both flyvis and the escape-circuit ablation are not.
## The rule, stated plainly
Put every project in this piece on the same two axes — is the topology frozen, are the weights on it frozen — and the pattern holds without a single exception I found:
Reservoir computing on a fly connectome (oruk, and conn2res's whole premise): frozen topology, frozen weights, trained readout only — scrambled wiring ties it. The fly language model: frozen graph, frozen backbone, a 278,528-parameter trained adapter — a parameter-matched control without the graph wins. Both null results, from two teams, two modalities, and both teams ran the control and published it even though it undercut their own headline.
flyvis: frozen topology, but the weights *on* that topology — 734 of them — are trained, against a task with no neural data in the loop at all, and the result correctly predicts the tuning of 32 real, specific, previously-recorded cell types. The hΔH path-integration hypothesis: nothing trained yet, but the entire finding depends on the specific wiring, because you cannot guess which four anonymous cell types receive exactly the right combination of step, dopamine and octopamine input without the connectome in hand — a scrambled graph gives you nothing to even look at. fly-brain-escape sits in between and says so explicitly: real wiring learns faster, but a shuffled network gets to the same ceiling given enough time.
**A reservoir readout only needs rich, well-conditioned dynamics, and almost any recurrent network with the right spectral radius provides that — so the connectome's identity is invisible to it, and only its statistics matter.** Predicting the tuning of a specific, named cell type, or finding four specific, previously anonymous cells that anatomy alone can point to, is a different task where the specific wiring is the entire point, and no amount of degree-matched shuffling gets you there. Neither answer is more correct than the other. They're answers to different questions, asked of the same graph, and the honest ones told you which question they were actually asking.
## One claim I couldn't verify, and worked out shouldn't be true anyway
A claim circulated recently that someone had fit "100,000 biological neurons running optical flow and collision avoidance" onto a \$15 microcontroller, and that it "completely destroys 70% of modern edge-robotics control stacks." The only link offered was a bare GitHub profile, `github.com/Frankweb33`, not a repository, and no benchmark. The one repository that actually exists under that account, `flybrain-robot-bridge`, doesn't make the claim at all — it describes itself as a "stage: proof of concept" with a mock backend built from eight hand-designed activity groups, states outright that "the model is hand-designed and does not use connectome data," and that "no hardware test has been performed." There's no runnable connectome-scale simulation behind the viral number, and no benchmark against anything.
It's worth doing the arithmetic on why the headline number was never going to be plausible anyway. FlyWire's whole female brain is 139,255 neurons; MaleCNS's whole CNS is 166,691. "100,000 biological neurons" is a claim about most of an entire fly nervous system, running on a microcontroller with typically a few hundred kilobytes of RAM and no floating-point unit worth mentioning. Even the sparsest workable representation — say, one 32-bit float per neuron for a membrane state, plus a sparse adjacency list averaging even a lean 50 synapses per neuron at 4 bytes each — is already 100,000 × (4 + 50×4) = 20.4 megabytes, roughly two orders of magnitude past what a \$15 MCU carries, before you've stored a single weight, run a single integration step, or touched the actual synapse count real fly circuits carry (tens of contacts per connection is common, not per neuron). There's no plausible compression scheme that gets a hundred thousand real neurons and their real wiring into a few hundred kilobytes and still calls what's left "biological." I'm not going to build a section on a claim with no repo, no benchmark and no arithmetic behind it — this paragraph is that section, and it's this short on purpose.
## Where this leaves it
The map arrived on September 3. Within roughly two weeks, independent teams had built a reservoir computer, a language-model adapter, a candidate solution to a genuinely open question in insect navigation, a browser-driving robot with real containment engineering wrapped around a memecoin, and a toy social network — and at least four of those projects ran the control that would have told them if they were fooling themselves, and published it either way. That's the actual headline, more than any single result in it: a connectome is not a model of a brain. It's a substrate, and what a research team immediately builds on top of it — and whether they check their own excitement against a control before shipping it — tells you far more about the state of the field than the wiring diagram itself ever could.