flyOS is a living fly camera. Open the app and you're looking at your room through the rear camera with a fly standing in it: on your desk, your wall, the back of a chair. The fly is not an animation: its nervous system is a real connectome running on the phone, so when your hand comes at it, the fly actually sees the threat and jumps to escape. Everything on screen is either measured from the circuits actually running, or a stated model, and the app says which.
That's the pitch. Below is everything else: the actual neuron counts, the equations the engine integrates, the four circuits we built and chose not to turn on, and every source we built it from. It gets technical fast. That's on purpose.
flyOS's fly is not a rigged animation reacting to hand-tuned triggers. Its nervous system is built out of MaleCNS v1.0, the complete, synapse-resolution connectome of the adult male Drosophila melanogaster central nervous system: roughly 166,000 real, traced neurons and their real synaptic connections, released by the FlyEM project at HHMI Janelia in collaboration with the University of Cambridge, the MRC Laboratory of Molecular Biology, and Google Research[1]. It ships as a set of flat connectome tables: per-neuron annotations (type, instance, soma side, consensus neurotransmitter prediction) and per-pair synaptic weights at a minimum confidence of 0.5. We downloaded them directly from Janelia's own distribution[2], not through any intermediary.
We take real, induced subgraphs of that connectome: a named list of cell types plus every real positive synapse between them, nothing added, nothing fitted. We then simulate them as populations of spiking neurons on the phone. No connection weight is invented and no contact count is adjusted to make a demo work; the only editorial choices are which cells to include and, in the larger assets, a minimum-contact threshold that exists purely to keep an asset under an 8 MB bundle budget, never to shape the result.
The raw source tables are about 1.1 GB total and never ship in the app. They're a development-only cache, re-downloaded on demand by our extraction scripts. What actually ships is the derived output: eleven small JSON circuit assets, on the order of tens of kilobytes to a few megabytes each, totaling well under the size of a single photo. The data is released under a Creative Commons Attribution 4.0 International license[3]; our derived assets remain CC BY 4.0 and we impose no further restriction on them. The Janelia FlyEM team, the University of Cambridge, MRC LMB, and Google Research do not endorse flyOS.
The connectome has roughly 166,000 neurons. flyOS runs five real, induced subgraphs of it, totaling 4,895 distinct neurons, as event-driven leaky-integrate-and-fire populations, in real time, on the phone's CPU. Each one is wired to a real sensory input and a real behavioral output: nothing is simulated in isolation just to produce a number.
| Circuit | Neurons | Directed edges | Synaptic contacts | Drives |
|---|---|---|---|---|
looming | 1,307 | 68,495 | 441,250 | LC4 / LPLC2 → the giant fiber → the jump |
clock | 52 | 475 | 3,904 | The wingbeat floor and the sleep gate |
premotor | 2,083 | 135,413 | 1,244,769 | LC10 → AOTU → DNa02, which owns steering |
feeding | 77 | 1,207 | 7,898 | Tracked food → sweet cells → a sustained MN9 gate |
johnston | 1,444 | 111,924 | 743,649 | The microphone → Johnston’s organ → startle and bracing |
(Neuron counts don't sum to 4,895 exactly: 68 cells are members of more than one circuit, most often a cell type that's both a named population in one asset and a generic connectivity-derived input to another — and, in johnston's case, the giant fiber itself, which it shares with looming. Each such cell is counted once in the total. 4,895 is the figure the app itself reports.)
looming is the one you'll actually see. All 126 LC4 and all 185 LPLC2 cells from both optic lobes are bundled, whole, along with both giant fiber cells (type DNp01) and everything the connectome shows presynaptic to them at 50 or more summed contacts: 753 cells feeding LC4, 241 feeding LPLC2. Every LC4 and every LPLC2 cell in the asset synapses directly onto a giant fiber: 385 edges, 16,433 contacts, straight into the two cells that decide whether the fly jumps[4][5]. When the eye encoder detects expansion (something getting closer, fast), it drives LC4 and LPLC2 with a Poisson-like input, and if the giant fiber's mean firing rate crosses 20 Hz in a window, the fly jumps. Nothing else can trigger that reflex, and cutting the synaptic wiring (connections off, same driven input) silences the giant fiber completely. A 3 m/s human swat is escaped every time in our own testing, with a median 60 ms to spare.
clock is 52 of the fly's own real circadian pacemaker cells, wired up as coupled oscillators rather than left to run on their actual molecular clock — a gene-expression loop no synapse-level model can reach. One population reads the phone's screen brightness as a stand-in for ambient light; entrained by that and by the phone's own clock, the network settles into a subjective time of day. That phase drives two things you can actually see: it sets a floor under the wingbeat rate, so the fly never fully stops buzzing even at rest, and it gates sleep pressure, so the fly is calmest — not necessarily asleep — right around dawn and dusk, and hardest to rouse in the middle of the night.
premotor is built from every cell the connectome actually shows wired into the four neurons that drive turning and walking: DNa02 (steering), DNp09 (forward walking), MDN (backward walking), and DNg02 (wingbeat amplitude). That includes the direct visual route in — LC9, LC10, LC31, and LoVP12, where LC10 alone supplies 43–74% of the input to the relay cells that reach DNa02 — the central complex’s own steering output (PFL2, PFL3), and 742 further relay cells, each contributing at least 100 real synaptic contacts onto those outputs. Together they give DNa02 70.4% of its actual synaptic input, MDN 72.2%, and DNp09 37.7% — for each of those cells, most of what it hears comes from inside this one circuit. It isn't just wired, either: driving the visual inputs at 50 Hz brings DNa02 to 227 Hz and DNp09 to 177 Hz, and cutting the synaptic wiring while leaving the same input running drops every one of those outputs straight to zero.
One honest limit: PFL3, the central complex’s own steering output, does not drive DNa02 on its own in this model, at any input rate up to 200 Hz. Its 736 real contacts land on two cells that would need roughly 26 coincident synaptic events within a single synaptic time constant to matter, and the relay layer it feeds sits at just 2–5 Hz under that drive. The wiring from compass to legs is genuinely there in the connectome — this app just can't get a signal through it yet, and we'd rather tell you that than quietly ship a compass that does nothing.
feeding runs on real taste neurons: sweet cells, bitter cells, a couple of relay populations, and MN9, the actual motor output that fires when a real fly commits to eating. The sweet cells are driven only when the camera has genuinely tracked food nearby — no food in frame, no drive into the circuit at all, so the network can never manufacture an appetite out of nothing. Even then, that signal has to survive real synaptic integration through the relay cells before it can move MN9; food detection never touches the motor output directly. Only once MN9's average firing rate holds above 10 Hz for three straight windows does the gate open and the fly actually go for it — a sustained signal, not a single spike, which is what keeps a flicker of visual noise from reading as a meal.
johnston is the newest sense, and the fly's real one: 1,444 chordotonal neurons of Johnston’s organ, the hearing organ in the fly's antennae. The phone's microphone is what drives it. Audio is analyzed entirely on-device, in memory, purely to produce that drive — nothing is recorded, stored, or transmitted, and the fly's hearing can be switched off in the app. Two things come out of it that you can actually see. A sharp sound reaches the giant fiber — the same two DNp01 cells the looming circuit uses to decide on a jump — and startles the fly. And sustained deflection, the kind you get by blowing on the phone, puts a cap on forward drive: the fly braces instead of pressing on.
Every circuit (including the feeding subgraph above, which we also validated against a dense reference simulator running the identical wiring at fixed 0.1 ms timesteps) runs on the same engine: an event-driven leaky integrate-and-fire simulator, written from scratch in Swift, with no language model, web view, Python runtime, or network call anywhere near it. For membrane voltage v and decaying synaptic drive g, between events each neuron follows the exact closed-form solution of:
Rest and reset potential are −52 mV; the spike threshold is strictly above −45 mV. A spike resets both v and g and opens a 2.2 ms refractory period, during which incoming synaptic drive is discarded; externally driven sensory cells are the one exception and have no refractory lockout, matching the reference model we built this from. A synaptic event is delivered 1.8 ms after the presynaptic spike that caused it. Each real synaptic contact contributes 0.275 mV of drive, multiplied by the presynaptic cell's consensus-transmitter sign: acetylcholine treated as excitatory (+1); GABA, glutamate, and histamine as inhibitory (−1); the monoamines and any “unclear” prediction carry sign 0 and simply never transmit. Nothing here is fit to produce a desired behavior: these are the published reference model's stated parameters[6], reimplemented independently from the equations, not ported from the authors' own MIT-licensed Brian2 code[7].
External sensory drive is a Poisson process with exponential inter-arrival times, sampled from a seeded SplitMix64 generator (deterministic and repeatable for a given seed), which is what makes our regression tests possible at all. There is no learning, no neuromodulation, no gap-junction model, no detailed neuron morphology, and no spontaneous firing beyond what a circuit explicitly models as tonic drive. The simulator advances 100 ms of model time per update; on an iPhone 15 that takes at or under 100 ms of wall time, every window, which is what “real time” means here.
This is the part most apps wouldn't tell you. We built nine circuits from the connectome, not five. Four of them are real and fully tested — 6,254 more neurons' worth — and they ship inside the app right now, just switched off, because when we actually measured what each one produced, none of them earned its share of the phone's compute. Running all nine would cost roughly 11,140 simulated neurons for the exact same five things you actually get: escape, steering, the crepuscular clock, feeding, and hearing.
This list used to have five circuits on it. Johnston’s organ (1,444 neurons) was here, and the reason given was that nothing in the app fed it audio, so the only signal it ever saw was gravity. That reason is gone: the microphone now drives it, and it ships switched on. The other four are still off, for the reasons below.
| Circuit | Neurons | What we measured |
|---|---|---|
| central complex (the compass ring) | 434 | The E-PG ring — the neurons that are supposed to track which way the fly is facing[8] — never settles into a stable heading under this app's simplified dynamics, and even where it does fire, the pathway from it to the steering neurons carries essentially no signal (see above). There's no compass in flyOS because there's nothing for a compass reading to actually steer. |
| color / object vision (R7/R8, Dm8, LC10, LC11) | 4,134 | Its main output barely fires — close to 0 Hz — on any real scene the camera actually sees. The one thing this circuit's wiring is good for, reading a bright color's direction straight off the eye, is already covered inside premotor, which uses the same visual data for its own steering. There's nothing left for a separate vision circuit to add. |
| thermosensory (TRN / HRN, VP) | 374 | flyOS has no way to sense temperature — no thermometer, and nothing in the app asks you to enter one — so there's no reading to give this circuit at all. Not a modeling failure: just a sense the phone doesn't have. |
| descending rack (every typed descending neuron) | 1,312 | Its steering and walking outputs are redundant with premotor, which already owns those decisions outright, and its own wing-motor readout stays at 0 Hz on every scene. Worse, switching it on alongside the feeding circuit would give it its own copy of MN9, driven by the same sweet-taste cells — risking a single meal getting credited twice in the same window. Leaving it off is what keeps a meal counted exactly once. |
None of this is hidden after the fact, either. This reasoning is written directly into the app's own source code, right next to the switch that turns each circuit on or off — it's not marketing copy invented for this page.
Tap the brain icon and the drawer's Animal card shows what the fly is doing, its circadian phase, and four meters underneath — SLEEP, AROUSAL, DRIVE, MOTOR — each one a bar of twenty boxes lighting up left to right, with the figure printed beside it. The first three are internal states, and we were careful about what those numbers actually are. We do not say the fly feels anything. These are states the literature itself uses and measures[9], and here's exactly where each one comes from.
Arousal is read straight off the running network: a leaky integrator charged directly by the giant fiber's own firing rate in the looming circuit, discharging with a 120-second time constant. It only charges upward — a threat that has passed leaves the meter standing, and it comes down on its own clock, which is the actual behavioral signature of an emotion-primitive-like state rather than just a second copy of the giant fiber's instantaneous rate. One swat measures 0.451; three swats ten seconds apart measure 0.729; five measure 0.809. Cut the looming circuit's wiring and it never leaves zero, even with identical driven input.
Drive is also read straight off the network: the mean firing rate of the real DNa02 and DNp09 populations from the premotor circuit above, divided by a 60 Hz scale chosen against what those cells actually reach under saturating drive. Sleep is different: a two-process homeostat we built, gated by circadian phase read from the real 52-cell clock network, because real clock neurons keep time with intracellular transcriptional loops and neuropeptide signaling that fast synaptic connectivity alone can't reproduce. Arousal and drive are readings off the network; sleep is a model standing in for physiology this subgraph doesn't carry — worth knowing which is which, even though the meter itself just shows you the number. One consequence of the seed: the homeostat starts from what the clock says, so a fly opened late at night is already asleep and hard to wake, and the app waits for the clock network to be running before it takes that reading rather than seeding from nothing.
Motor is the fourth meter and not a state at all: the wing-motor rate the body is holding, in Hz, on a 200 Hz scale — the mean firing of the DNg02 wing-motor neurons plus the giant fiber's take-off burst, with the clock network's circadian idle tone as a floor under it, and scaled to zero while the fly is asleep. A resting fly reads a few Hz here with its wings folded, which is why the meter is called MOTOR and not WINGS: the rate is real, the beat only happens once the fly is off the ground.
367 automated tests run the real bundled assets, not mocks, including equivalence against a dense reference simulator on the feeding circuit at fixed 0.1 ms steps. Every circuit carries a causal control: run it with synaptic transmission on, then run the identical driven input again with connectionsEnabled false. Silent input must stay silent. Cutting a specific population’s output connections (MN9's, for instance) must remove exactly that motor output while leaving upstream relay activity untouched, which is how we know the effect is really flowing through the wiring we think it is, and not some other path we didn't account for. The extraction scripts themselves are deterministic and reproducible: rerunning them against the same cached source tables produces the identical asset, byte for byte.
On an iPhone 15, the running brain holds real time: our own internal brainTime metric, simulated milliseconds of neural activity per wall-clock millisecond, reads 1.00, and reports honestly below that if the phone ever falls behind. Circuits advance concurrently on separate actors so their 100 ms windows overlap across CPU cores. An optimized macOS probe running the bundled feeding graph alone measured 4–17 ms of wall-clock compute per 2 seconds of simulated time across a range of stimulus conditions. Thermal behavior and battery use over a long session remain unmeasured by us so far.
One caveat we would rather state than let you discover: that 1.00 was measured with four circuits running, before Johnston's organ was switched on. Hearing adds 1,444 neurons but roughly 112,000 synapses, taking the running brain from about 206,000 to about 318,000 — a little over half as much work again. We have re-measured the engine on a Mac at that size and it holds with room to spare, but we have not yet re-measured brainTime on an iPhone 15 with the fifth circuit running. Until we do, treat the 1.00 above as a four-circuit number. The metric in the app is live and will tell you the truth on your own phone either way.
None of this is a roadmap with dates on it — just an honest list of what the connectome and the phone's own hardware would let us try, and what we'd need that we don't have yet.
A real compass. The connectome's own path from its heading-direction ring to the steering neurons is too weak to carry a signal (see above), but the phone already knows which way it's facing, from its own world tracking. Feeding a real heading in downstream of that weak internal pathway, instead of relying on the ring to hold its own bump, would be a different design than what shipped — an open question, not a solved one.
Real temperature. The thermosensory circuit (374 neurons) is tested and waiting on a single missing number. A phone has no ambient thermometer, but a paired sensor — a smartwatch, a smart-home accessory — could supply one.
Smell never will. MaleCNS has real olfactory circuitry we haven't touched, because no iPhone has ever had a nose, and none will. Some absences are permanent, and we'd rather say so than pretend otherwise.
More than one fly. MaleCNS v1.0 is a single male nervous system. Real courtship and social behavior run through circuits that need at least two flies to mean anything — not something one connectome, or one phone, can give you yet.
To be unambiguous: this is not a reconstruction of a living fly's complete nervous system, and it has not been biologically validated against a real animal. These are selected subgraphs with deliberately simplified dynamics: uniform synaptic physiology, transmitter effects collapsed to a single sign per neurotransmitter, no receptor-specific pharmacology, no learning. The reference numerical model we built from was itself validated on an earlier connectome (FlyWire, not MaleCNS) in a different lab's published experiments; our adaptation onto MaleCNS has not been through that process. The fly's body, its flight mechanics, and the ethogram deciding what it's doing moment to moment are engineered models we designed, not measurements of anything, and the app itself labels them that way, every time, on screen.
Further citations (for the color/object pathway, the descending-neuron nomenclature, the gustatory connectome, and every individual circuit's full population breakdown) are bundled in the app itself, in its research credits.