MaleCNS v1.0

NeuroCraft Fly

Evan Sinclair Smith (@evnsnclr), Georgia Institute of Technology

A Minecraft fly driven by the full retained MaleCNS graph: 166,700 neurons and 25,582,938 directed edges, with six declared in-game inputs (player approach, nearby mobs, brushing, attack attempts, food, light) feeding the model and hand-chosen readouts selecting scripted body programs. The repository is currently a landing page and roadmap: the recorded demo exists, but the Fabric mod and companion source have not been published yet. The README is explicit that this shows a visible, testable mapping, not recovered fly physiology.

DenisSergeevitch/desktop-fly README (MIT)

DesktopFly

DenisSergeevitch

A 3D fruit fly living on the macOS desktop (Electron port for Windows), driven by a 1 kHz leaky integrate-and-fire simulation of two real circuits: a 668-neuron FlyWire subset for sensing, escape and decisions, and a 1,045-neuron MaleCNS descending-to-leg pathway ending in 220 motor neurons. Window edges act as terrain, window moves as threats and clicks as vibrations, and a separate window shows 23,210 neuron positions spiking live. The README is upfront that muscle mechanics are modeled rather than biologically calibrated; code is MIT, FlyWire data CC BY-NC 4.0 and MaleCNS CC BY 4.0.

DOOMFLY

nftechie (Alex Wormuth)

A MaleCNS v1.0 spiking simulation wired to a live Doom arena: each frame stimulates visual input neurons, activity propagates through 166,700 neurons, and motor output is decoded into movement and firing. The README is candid that learned survival has not been demonstrated yet.

blendi-remade/fly-brain-minecraft README screenshot (MIT)

Fly Brain Minecraft

blendi-remade

A Fabric mod for Minecraft 1.21.1 that runs the full neuPrint male-cns v1.0 connectome (about 176k neurons, 6.29M connections at 5+ synapses) as leaky integrate-and-fire units inside a fly mob, one thread per fly. In-game visual, smell, taste and touch stimuli feed sensory neurons, and decoded motor channels drive feeding, grooming, escape jumps, walking and flight. Includes a live brain-activity view, a HUD of population firing rates, and 56 JUnit tests; code is MIT, connectome data CC BY 4.0.

duth-x-stepmania

@abstractionthief

The looming-escape circuit of the MaleCNS connectome, exported as a 766-neuron model, stands in as StepMania's second player: each arrow becomes a threat from one direction and a fixed readout of descending neurons picks the key. On the sample charts the circuit took 100% of the notes on the three easiest and 97% on a 152-note chart, while three rewired copies of the same circuit managed 35 to 47%. The README is blunt that this is not a fly playing the game: the arrow-to-threat mapping is hand-made, there is no vision, and model time is not biological time.

Flappy Fly

@CROmartin

A Flappy-style game whose flap decision is read out of a frozen MaleCNS simulation of 166,700 neurons and 25,582,938 connections: hand-designed channels drive the looming and position cells, 1,314 descending traces go through PCA and logistic regression, and only that readout learns. The measured table is the point. Over 30 unseen seeds the fly readout cleared 0.07 pipes on average against 0.23 for random and 6.70 for the scripted oracle, and one DAgger round took both the fly and a three-input logistic baseline to 0.00.

fly-ears

@arpanguria68-ui

Feeds a video or a song into the MaleCNS connectome, 166,700 neurons and 25.6 M connections, frame by frame: light reaches 6,006 photoreceptors at their own eye columns and the soundtrack reaches 138 Johnston's organ neurons, with nothing after the receptors trained. On a test clip the looming cells rose to 2.92 spikes per neuron per second for an approaching disc against 0.53 while still. The music test, with its four questions fixed before running, checks the brain against its own ear input and against a degree-preserving rewired copy.

WireType

Jamie Wilson (@JamieWilson0209)

Research code for a preprint that asks whether wiring alone identifies a neuron well enough to guess its transmitter, and whether that carries from one fly volume to another. Each neuron becomes 31 connectivity numbers (degree, weights, random-walk return, trophic level, local motifs), the neuron and its 64 strongest partners become 65 tokens, and a four-block attention encoder is trained on one volume's labels then applied frozen to the other. It runs FlyWire v783 and MaleCNS v1.0 in both directions and keeps two control arms: the encoder at initialisation, and a probe on the training target.

CNSKit

OpenUploading (@OpenUploading)

A Python workflow for training task-specific models on a MaleCNS graph and running them in an application: bind observations to chosen body IDs, train a readout, input and output adapters or bounded per-neuron gains, evaluate held-out episodes, and export a pickle-free checkpoint that carries the graph fingerprint, ordered channels and provenance. Matched recurrent, zero-edge and ridge baselines are included. The README declines the usual claims, saying anatomical connectivity is only an experimental prior and that the most useful next result would be a well-controlled study of when it helps.

fly-brain (bike)

victory-c (@victory-c)

Re-implements the Shiu et al. whole-brain leaky integrate-and-fire model in PyTorch on MaleCNS v1.0, with a test that builds one random network in Brian2 and one in this engine and demands identical spikes at identical steps. It then replays the paper's taste and antennal stimulation sets on 166,700 neurons and puts the network in charge of a road bike learning to ride through side gusts. The synaptic scale is recalibrated for the denser male wiring, and the README reports that the male CNS cannot both match the published feeding gain and stay stable: at that scale bitter drive runs away.

Fly-Car

Nobuhiro Kuroiwa (@hamling-ling)

Extraction scripts that cut two circuits out of MaleCNS v1.0 for an Arduino Uno Q robot car: the Giant Fiber looming escape, 327 cells covering LC4 and LPLC2 inputs, DNp01, and the TTMn, PSI and DLMn motor side, and separately the left and right DNa02 steering pair. Both are written out as neuron and edge tables with transmitter signs. The notes are careful about the gap: the GF-to-TTMn and GF-to-PSI links that actually drive escape are electrical synapses and absent from the data, so the first simulation reads DNp01 spikes instead. A desk-run chemotaxis notebook needs no hardware.

Fly Colony

TZY114514 (@TZY114514)

Windows desktop flies that breed. Each adult runs a 668-neuron FlyWire leaky integrate-and-fire network, and an inspected or nearby fly also gets a 1,045-neuron MaleCNS leg circuit driving articulated legs; swatting is a race against its LC4 and LPLC2 looming input to the giant fiber. New here is the genetics layer: nine real genes at their map positions, crosses scored against predicted ratios with a chi-squared test, EMS mutagenesis screens, and quantitative traits that set looming gain and giant-fiber coupling, so breeding changes the circuit. Built on DesktopFly, credited in UPSTREAM.md.

Fly-Racer

supat-roong (@supat-roong)

Builds a PPO policy for Gymnasium CarRacing-v3 out of a 3,350-neuron MaleCNS v1.0 steering subgraph with 164,773 connections, keeping each presynaptic neuron's transmitter sign and learning only strengths, time constants, biases and the visual projection. Three controls share the pipeline: a degree-preserving shuffle of the same graph, real wiring with shuffled excitatory and inhibitory labels, and a plain MLP. Over 100 held-out tracks the real wiring scores 903.2 and never drops below 796, the only core to clear the 900 solved threshold, though medians are close and each core had one seed.

Fly RL

hsilvosa (@hsilvosa)

Puts a virtual fly in procedurally generated rooms and runs the annotated MaleCNS v1.0 graph (167,184 neurons, 25,583,622 directed edges) as a fixed recurrent model between simulated sensors and flight commands. Two controller families are compared: PPO policies and an explicit observed-map planner. Much of the README is a record of failure. Learned policies reach 61/64 goals through one wide gate but 0/64 in the 48 x 48 room with five narrow passages, where only the hand-written planner works (13/16 frozen). It states that navigation success does not establish an advantage from fly wiring.

Connectome ping pong

Warpfield (@castor639)

Two copies of the MaleCNS v1.0 network, 163,903 neurons and 6,235,682 connections at the usual five-synapse cutoff, rally a ball across a scaled tennis court with nothing trained. Each fly reads the ball's bearing from four small-object medulla cell types compared against a twin network that never sees the ball, then walks. In one 40-second match the released wiring lands 54 hits, the same synapses connected at random land 10, and a fly parked at centre lands 14, so the shuffled control does worse than not moving. The swing and return placement are scripted.

flydrive

ORI-Muchim (@ORI-Muchim)

Trains a hand-built Drosophila visual pathway to drive a car from 1728 ommatidia alone, then swaps in the whole MaleCNS graph (162,432 neurons, 24,380,527 edges) as the policy, learning only per-neuron dynamics and the input and output maps. Untrained T4 and T5 motion detectors reach direction-selectivity 0.98 and 0.89 straight from the wiring. At a matched 740k steps the frozen connectome drives crash-free where the hand-built pathway does not, but with six times the budget the hand-built model holds the lane at 0.70 m against 1.6 m, fine-tuning the brain hurt, and it costs 25x more per step.

MaleCNS Nav-Lite

Vlet0 (@Vlet0)

Cuts a navigation-only sub-connectome out of MaleCNS v1.0. Olfactory, gustatory and reproductive neurons are excluded first, then a bidirectional three-hop breadth-first search from visual, central-complex, descending, wing, leg, haltere and neck seeds leaves roughly 28,000 of about 166,000 neurons in a file that loads in seconds. Both the hop count and the three-synapse traversal threshold are argued for, with the neuron count each hop setting yields and a reason for dropping single-synapse edges. A CLI downloads, builds, inspects and queries the result.

microfly

fogfish (@fogfish)

Cuts small spiking brains out of MaleCNS v1.0 and runs each fly in its own Web Worker in a browser arcade world, from an 11-neuron circuit up to a forager of about 3,400 neurons and 205K connections. The world reports odour at each antenna plus taste and never steers: walking, turning and feeding come only from output spike rates. Weights are signed synapse counts divided by each target's total input, and hunger scales sensory gain. Three optional mechanisms cure the lockstep firing a large subgraph shows. A change is kept only if it beats a random walk and a size-matched random graph.

ReproFly-AI

brvnw2d5tk-ctrl (@brvnw2d5tk-ctrl)

A blinded, tool-mediated benchmark that asks whether an autonomous-scientist agent can find targets in the male Drosophila CNS connectome through an oracle it cannot see past; the agent evaluated here was GLM-5.3. The release ships the benchmark, blinding and scoring library, frozen paper-level results, figure sources and four offline reproduction scripts that make no model API calls. It is explicit about what is withheld: the private-state test suite and member-level ground truth stay controlled, and the supplementary wrappers are not a complete independently runnable reconstruction.

Flomb

Felipe (@FelipeJackFox), LEIA

A mushroom body taken from the MaleCNS connectome - 4,064 Kenyon cells, 97 output neurons, PAM and PPL1 dopamine - learns Minesweeper from two signals only: heat on a mine, sugar on a safe tile. It wins 78.4 percent of 9x9 boards with 12 mines over 2,000 unseen boards, and the write-up notes that a hand-written single-point rule wins 81.8 percent on the same boards. Two findings are stated as negatives: the advantage is sample efficiency over a plain table that ties given unlimited play, and shuffling the real wiring changes nothing.

FLYBRAIN · NES

arpanguria68-ui

Wires a frozen MaleCNS v1.0 nervous system - 166,700 neurons, 25.6M connections - to an NES emulator: twenty times a second the game picture enters the fly's own motion and object detectors, and its descending neurons press the controller, with a small learner paid in score and punished by lost lives. It ships the control experiment, not just the demo. Real against scrambled wiring on Super Mario Bros., five runs each, covered 3,214 against 563 pixels of new ground; holding right with no brain covered none.

Fly VNC Walking Simulation

Sadiq Khan (@sadiqkhzn)

Drives a NeuroMechFly body in MuJoCo from the male ventral nerve cord alone: 24,115 neurons and 1.77M edges pulled from male-cns:v1.0 over neuPrint, split by neurotransmitter into 1,026,234 excitatory and 693,369 inhibitory edges. Only a thin command interface is learned; the wiring is never touched. The validation table reports what fails: a moonwalker drive raises the motor pool 349-fold, but DNp09 suppresses walking by only 16 percent and tripod anti-phase never appears, which the author puts down to the missing proprioceptive loop.

Flypet

Adelya Leleytner (@AdeliyaLeleytner)

A handoff release of a research platform that keeps a Brian2 fly simulation running and wires it to a language model through a learned writer and a neural-token reader, so instructions go in as stimulation and the model answers from neural state. A sensory garden runs from one Docker command with no account or key. What makes it worth reading is the bookkeeping: failed, partial and superseded runs are kept rather than pruned, the reader is reported as not passing its own gate, and earlier experiments are marked as leaky.

Buzzkill

GhostInTheBus (@GhostInTheBus)

Wraps DesktopFly's connectome-driven desktop fly in a game: crumbs you drop, flies that gather while you are away and scatter when you move, and a squish that is fair only because a fast cursor trips the real looming-to-giant-fiber reflex first. The brain and body are Denis Shiryaev's; new here are the world around them and a second extract of the same circuit from MaleCNS v1.0 (CC BY 4.0), 665 neurons against the FlyWire build's 668, with the differences written down: a sharper escape threshold, and a giant fiber that keeps firing through a sustained loom.

Drosophila Cadet

SEKY443 (@SEKY443)

The flippers of 3D Pinball Space Cadet, compiled to WebAssembly in a fake Windows XP desktop, are pressed by the fly's own looming-escape circuit from MaleCNS v1.0: 373 neurons, LC4 and LPLC2 into the two giant fibers, with real synapse counts and signs, nothing trained. Each looming cell watches its own spot along a flipper; a giant fiber that fires presses it. The untrained circuit plays about as well as a trained 444-neuron brain from the same data, and unlike that one it beats six degree-preserving shuffles over 96 paired lives each. Both stay a little below a hand-written reflex.

FlyAim

0Sakura721 (@0Sakura721)

Drives a closed-loop aiming task from MaleCNS v1.0, 166,700 neurons and 25,582,938 edges, against a degree-preserving shuffle, a PID ceiling and a random floor on matched seeds and frame budgets. The pre-registered verdict is that the wiring makes no causal contribution, and the result is stronger: both network arms end up significantly further from the target than random, 412.5 and 430.9 pixels against 251.7. Making the connectome weights learnable under a three-factor rule failed all three gates too. The README insists what is refuted is this LIF model with static weights, not the fly.

FlyGateDemo

Robert Troska (@ProfTAlent)

Puts the fly's olfactory circuit from MaleCNS v1.0 on a real blog's gate, in C# on .NET 10: 2,635 receptor neurons, 686 projection neurons, 2,044 Kenyon cells, 49 output neurons and APL, with each request turned into an odour. 142,770 anonymized requests from the author's own site ship with the repo, so a run needs no download. The honest headline: the fly is not a better gatekeeper than plain cosine similarity, which catches 62-98% of probes where the fly catches 23-88%. Six punishments block almost all probes but two thirds of readers too, and three rewards bring readers back to 1.3%.

spacefly

cknisaac (@cknisaac)

Asks whether a small circuit chosen from MaleCNS v1.0, 32 Kenyon cells onto the output neuron MBON05 taught by anatomy-selected dopamine neurons, changes its response after a teaching signal, and reports a frozen failure. Teaching at the wrong region produced a first action at position 0.20 that persisted once teaching and learning were switched off, while teaching at the intended target near 0.70 produced none at all, so the declared behavioural test failed even though the plasticity mechanism itself ran. The repo calls that mechanistic success with behavioural robustness incomplete.

Fly Brain Dungeon

jasonfye2015 (@jasonfye2015)

A retro dungeon crawler where the monster hunting you has no scripted AI: its decisions come from 4,501 real mushroom-body neurons extracted from the MaleCNS v1.0 connectome, and it learns from dopamine while it hunts. Senses excite 4,064 Kenyon cells through random claws with only the top 5% firing, and those drive 97 MBONs through their real connectome synapses, each voting approach or avoid. The README is explicit that this direction is not programmed but falls out of the wiring. Dopamine updates only recently active KC-to-MBON synapses through a fading eligibility tag.

fly-muaythai

klasinlapaprechar (@klasinlapaprechar)

Two simulated flies spar in a ring, and the fighter's brain is a 6,170-neuron circuit cut from the male CNS connectome via neuPrint: LC10 opponent trackers, LPLC2 and LC4 for incoming strikes, bristle and leg touch, Johnston's-organ balance, the pC1 aggression cluster, PAM reward cells and all 1,314 descending neurons. The wiring never changes; recurrent PPO learns 14,910 parameters of gains and a descending readout on a flybody fly in MuJoCo. By update 2,000 it netted +9.1 points per bout with 65% of strikes landing, after losing to the scripted veteran at updates 1,000 and 1,500.

flybrain-play

victory-c (@victory-c)

Takes the Fly Bar whole-CNS spiking simulator (sstamou03/fly_brain, vendored unmodified as this repo's first commit and credited as such) and asks it to ride a road bike. The interesting part is what did not work: the walking command neurons from the literature do not track the bike's lean, with MDN firing 5-19 Hz regardless, so steering had to come from flight-stabilisation descending neurons (DNp20, DNg46, DNp22) instead. A 71-parameter decoder fitted to a PD teacher at R-squared 0.75 keeps 16 riders up a mean 14.1 s of 15 s, 9 never falling. The connectome is never changed.

MaleCNS embodied fly

Ryans-sS (@Ryans-sS)

A declared fork of the Codex connectome explorer that adds MaleCNS v1.0 beside FlyWire FAFB 783 in one local app, then wires the male dataset up as a living animal. Its 166,700-neuron network runs as a leaky integrate-and-fire brain with a metabolism (energy, water, sodium, damage, cell death) in an arena where it must press pads to stay alive, on a NeuroMechFly body in MuJoCo. Every number comes from an assay with a control arm: odour on versus off gives 0.06 mm against 2.75 mm closest approach; rewarded versus sham depresses Kenyon-cell synapses by -0.4226 against 0.0000.

maleCNS fly brain → human body

neomorrison (@neomorrison)

Puts the male fly's CNS in charge of a 1.74 m, 72 kg humanoid. All 141,615 traced maleCNS brain neurons (86 M synapses) run as leaky integrate-and-fire cells and decide where to turn, when to jump and when to eat; a PPO policy over 23 joints does the walking fly motor neurons cannot. Senses enter on identified cells (LC10, LPLC2/LC4, LB3 sugar receptors) and a fixed decoder reads named descending neurons. Hunger is added by hand, being absent from the wiring. One failure is reported: odour input gave no reliable steering or walking command, so food is found by sight, not smell.

Drosophila Whole-Connectome Cognitive Tasks

Joonghui Cho, Minchan Kang, Daeshik Kim (@joonghui0926)

Paper code that fixes the MaleCNS v1.0 directed edge set and gives each retained edge one trainable scalar, then trains that recurrent graph on bounded addition and on a grounded relational language. The prepared graph has 166,700 nodes and 25,582,938 directed edges, with no threshold. A reproduce script recovers the paper's paired numbers from run records: 92.77% against 67.93% for addition, 61.59% against 44.17% for language, 71.35% for the anatomical graph in a locked graph-null, and 60.94% against 19.27% under a sensory shuffle. Degree-preserving rewires are the controls.

Fly Mind

jasonfye2015 (@jasonfye2015)

Puts a mushroom body of 5,191 MaleCNS v1.0 neurons, 686 of them projection neurons, underneath a local language model as its affective layer. What you type or show is embedded and drives the projection neurons; the real projection-neuron to Kenyon-cell wiring makes a sparse code, dopamine weakens Kenyon-cell synapses onto output neurons in its compartment, and the valence and arousal that come out are what the model speaks from. It gets no persona, only a factual description of its own mind. Memories are kept on reported salience and replayed when Kenyon-cell activity matches them.

Fly x Jev (arena and Memory Lab)

aryap1804 (@aryap1804)

A browser robot walks a road on MaleCNS v1.0 wiring: 1,771 real eye columns feed 4,664 LC and LPLC neurons through real synapses, 203 Kenyon cells per odour drive four output-neuron types, and an external decision model picks between descending neurons. The keeper is the separate Memory Lab, which runs seven classic Drosophila memory protocols on the same mushroom-body model with no API key: conditioning, an unpaired control, a forgetting curve, reversal, silencing PPL1 or PAM, and memory with output blocked, each cited to its paper. It lists effects the model cannot show.

flypoker

0909-BoB (@0909-BoB)

A 6,194-neuron MaleCNS v1.0 subgraph pulled from neuPrint runs as a fixed spiking network under a small softmax readout that plays no-limit Texas Hold'em; the web table seats you against three flies. The README is blunt that the sensory mapping is invented and that folding or bluffing comes from the trained layer, not the wiring. Its notes document two reproducible training failures: one global reward baseline taught the decoder to fold pocket aces 99.9% of the time, and longer runs saturated the softmax so one action was picked whatever the hand.

NeuroLab

NeuroLab contributors (@Echrem)

A Minecraft Forge mod that attaches a sparse leaky integrate-and-fire simulation of a male-cns v1.0 graph, 176,422 neurons and 6,287,749 retained connections stepped at 0.5 ms in 50 ms updates, to its own fly mob or, by command, to a sheep, villager or spider, pausing that mob's vanilla AI. A dashboard plots sixteen channels and telemetry is written as JSONL in the world folder. Because the neural motor channels can stay silent, a labelled hand-built fallback supplies movement, and both dashboard and log mark when it is active. No time constant or decoding was fitted.

fly-cartpole

Curt Park (@Curt-Park)

Two mushroom bodies wired from MaleCNS v1.0, one per push direction, learn to balance CartPole under a dopamine prediction error. They hold the pole for 392.5 steps on average over the last hundred episodes across 20 evaluation seeds, against 18.7 with plasticity off and 22.8 for random pushes. Shuffled wiring scores 390.3, which a permutation test puts at p = 0.48, so the layout rather than the exact synapse map is doing the work. The log of nineteen tested hypotheses is the real document: plasticity that can only weaken synapses exhausts them.

fly-chess (backprop vs dopamine)

S1MS4 (@S1MS4)

Two ways of making the MaleCNS wiring play chess, built so they can be compared. One keeps every connection's place and sign but trains its strength with backprop on Lichess positions; the other freezes the measured brain and lets only the mushroom body change under dopamine. The board enters through photoreceptors binned into an eight by eight grid of the eye, spreads for twelve steps, and is read out of the descending neurons. A sliced custom sparse gradient keeps a ten-million-connection backward pass in 8 GB. Shuffled-wiring and lesion controls are flags, but no strength is measured yet.

fly-connectome-wiring

Guan et al. (HKUST)

Fixed-weight rate models of the adult fly leg motor system, built from MaleCNS v1.0 and MANC v1.0 and compared with six families of rewired networks under criteria fixed before the runs. It also runs the motor-input reassignment, rescue, capped-reassignment and sign-perturbation experiments. The manuscript build recomputes every reported number from the data and fails on any mismatch; noise streams are seeded, so a confirmation run reproduces the archived window to within 1e-16. Neither connectome is redistributed: you supply the public flat files.

fly-cx-navigation-servo

miwamasa (@miwamasa)

A rate model of the fly central complex extracted from MaleCNS v1.0, 2,308 neurons and 187,137 signed connections in a 1 MB quantized file, with two write-ups on it. The first recovers the heading ring from connectivity alone and finds ring-attractor motifs and a shifted comparator in the kernels; quantizing the weights acts as pruning, and a 166-neuron, 932-synapse circuit still steers in closed loop. The second argues the plain wiring is a heading servo, not a travel servo, and tests the two missing multiplications as a declared circuit. What is not from the wiring is marked an assumption.

Fly Gets a Software Job

nevchr (@nevchr)

One fruit fly applies for software jobs forever, and every visitor watches the same career: the same applications, interviews, rejections and rare offers. The backend loads a MaleCNS v1.0 runtime with 166,700 neurons and 25,582,938 processed model edges, encodes the career state as sensory input and decodes descending neurons into the next action; a seeded mock backend is kept for tests and the interface says which is running. The anatomy panel draws 125,020 mapped soma positions and seven traced skeletons, and calls the spark travelling along a branch an illustrative animation.

Connectome-Powered Navigation Agent

@manas-dange

Uses a 1,243-neuron central-complex subgraph of MaleCNS v1.0 as the frozen recurrent layer of a PPO navigation agent, and compares it against three alternatives rather than presenting it alone. The connectome agent reaches 90% of peak reward in 1,200 episodes against 1,450 for an unconstrained MLP; keeping the topology but randomising the synapse values costs about 7%, and pruning the weakest half of the synapses costs about 3.5%. A Three.js page renders the subgraph and runs the agents side by side. Note that without a neuPrint token the code falls back to a synthetic central complex.

The Fly's Escape Switch

Ewan Wu (@EwanWu06)

A bilingual interactive explainer that runs the control experiment most fly-brain demos skip. It rebuilds the 364-neuron giant fiber escape circuit from MaleCNS v1.0, pre-registers the pass criteria in timestamped commits, then tests it against four published electrophysiology results and reports that only one is reproduced: firing when the looming disk spans 34 to 37 degrees. Degree-preserving rewiring down to 40.6% intact moves that threshold by 0.11 degrees. The page also flags a bug in its own criterion code, where an absent response satisfied a test trivially.

Fly Gym

@louiscreatesai

A browser page of gym scenes that is honest about a distinction most demos blur: nothing is simulated live. Specific sensory or descending neurons of a MaleCNS v1.0 LIF model were driven for one second offline, every spike was saved, and the brain panel replays one trial at 0.35x, naming which neurons were stimulated. The blackjack scene is the most interesting: the hit-or-stand rule, whether MN9 still fires above half its sugar-only rate, was fixed before any run, and the fly only hits on 4. The page says outright that this is a model of wiring, not a mind.

fly-mania

@Shirtep

A fly plays the rhythm game osu!mania on four keys, and the accounting of what learns is clear: a fixed MaleCNS subgraph of 3,418 neurons and 242,111 synapses is never modified, and a small controller of four GRUs with 352,971 parameters is what trains. Perception is causal, a retina of four lanes by 128 rows plus 40 ms of past audio, with no access to the chart or note timings. Training is imitation via DAgger from a teacher that exists only during training, with no reward. The keys are pressed through a NeuroMechFly body with 16 ms of actuator delay and jitter.

Fly x Jev

@pasangimhana

A hybrid worth looking at for how the two halves are separated. The measured MaleCNS wiring does the sensing and the memory: a compound eye laid out on 1,771 real eye columns feeds 4,664 LC and LPLC projection neurons, and odours travel real projection-neuron to Kenyon-cell to MBON paths where dopamine weakens KC-to-MBON synapses to form an association. An external language model only chooses which of a handful of descending neurons fires next. The demo conditions the robot on toxic waste and honey, then shows it avoiding and seeking them.

FlyBrain (provenance-aware platform)

@nazkari86-lab

A sparse-connectome research platform whose scope statement is the point: it verifies data contracts, imports directed sparse graphs, runs deterministic LIF dynamics, performs paired cell-type lesions, restores checkpoints and exports experiment bundles, and says it is not yet an embodied fly. Its autonomy demo is labelled accordingly, combining reflexes, potential-field control and a tabular Q-learning residual with FlyGym's own locomotion controller; the seed-7 run reached food in 12 of 12 held-out arenas. The README calls that engineering, not evidence.

flyconn

@moiz-lakkadkutta

A Python toolkit that puts MaleCNS v1.0, FlyWire v630 and v783, hemibrain, MANC and BANC behind one offline, checksummed data layer, then builds signed sparse graphs on top of it. It propagates uncertainty (path stability across weight thresholds), runs a cross-platform LIF simulator validated against published results, and drives experiments from YAML specs that emit reports with provenance and dataset citations. Controls run by default. The README calls the project pre-alpha and is explicit that neurotransmitter identities are predicted and every simulation output is a model prediction.

Flytown

@KapilSareen

A browser town whose human-looking citizens each run a pruned piece of MaleCNS v1.0 as a live spiking network: 8,000 neurons and 234,363 connections cut from the 163,903-neuron graph, one brain per citizen, nothing trained. Feeding, escape, courtship, aggression, grooming and sleep come out of the wiring; a goal layer turns those drives into going to a cafe or picking a fight, and that layer is hand-made. Female citizens are the male wiring with male-specific cells silenced, which the README states plainly. Selecting a citizen opens a live raster of their 8,000 neurons.

TypeSafe Jev vs a Fruit Fly Brain in a Roblox Maze

@SolidifiedPlayDoh

A head-to-head race rather than a solo demo: a MaleCNS v1.0 brain and a language model run the same Roblox maze to the same apple, so the two navigation strategies can be watched side by side. The connectome stays frozen; Roblox raycasts drive the fly's own feature-detector cells and a small readout turns spikes into walking and turning, with DNg100 walking, DNa02 steering, MDN reversing and DNp01 jumping. The language model never sees the screen, only a ring of distances, the apple's smell and its own trail.

drosophila_nav

bamboosalt09-bam

A fixed fly-derived steering core is dropped into bodies with different motion limits to see what the body changes. The core is checked against the source authors' own notebook first: PFL population activity is bit-identical and the steering command agrees to 3.4e-14. The headline finding is then retracted: with command noise switched on, the ideal body succeeds in all 144 baseline trials, so "body limits rescue the core" was an artifact of the deterministic protocol. What survives is the reverse - a lagging body can low-pass the neural noise - and no body axis has a main effect.

FlyBG3

WerG0D

A follower NPC in a commercial game, Baldur's Gate 3, whose decisions come from a frozen MaleCNS v1.0 network (166,700 neurons, 25,582,938 aggregated connections, 1,314 descending neurons). The Script Extender writes an observation file, a Python bridge encodes it as an abstract stimulus, and descending spikes are decoded into five actions. The status table separates what was exercised in a real save from what was not, and says plainly that the synthetic combat arena trains only an external readout and is not evidence of learned combat in the game.

flybrain-connectome-benchmark

Vichien Fugsukjit (independent researcher)

Code and pre-registrations behind a preprint that scores the Shiu et al. whole-brain leaky integrate-and-fire model against experimental data instead of celebrating it. The benchmark plans, their criteria and their time-stamped amendments are committed before the runs; a whole-brain single-neuron knockout screen of the feeding circuit runs twice (all active neurons, then ten seeds with FDR) to diagnose where knockout predictions fail, and a Male CNS v1.0 build repeats it. The NumPy/SciPy re-implementation is validated against the original Brian2 code, and no connectome data is redistributed.

flybrain (MaleCNS pong-catch)

treewalkr

A ball-catching paddle driven by 4,706 MaleCNS neurons on a sensory-to-descending path (306k edges, sign from consensus neurotransmitter). Every synapse stays frozen anatomy; only a linear readout over descending-neuron rates is trained by the cross-entropy method. Chance is 33%; reading out the connectome alone reaches 54%, and a champion-restart refinement climbs to 84.4% on held-out seeds. The README also lists what failed: dopamine/RPE plasticity, elitist CEM, cross-seed weight averaging, and subsampling the circuit below about 3k neurons.

flygo (果蝇围棋)

icybb0903-sketch

A 9x9 game of Go in the browser against a fly: the board becomes a 415-dimensional encoding, runs through a fixed MaleCNS-derived graph of 139,662 positioned nodes and 5,536,347 filtered directed connections, and a trained output layer picks a legal move. The activity panel replays the same decision rather than decorative firing, and a failed checkpoint is an error rather than a silent fall back to an expert policy. The README is direct about the limits: playing strength, endgame judging and life-and-death rulings are unfinished, and only the wiring is real.

FlyKart

ZENinjaneer

A go-kart steered by 165,122 MaleCNS neurons on the GPU, with every "this drives that" claim checked by stimulating the input and measuring the output: LC10a to same-side DNa02 at 130-185 spikes/s for chasing, LC4 and LPLC2 into the giant fiber at 250-400 spikes/s within about 10 ms for the escape jump, taste neurons into MN9 for eating. Nobody trained it, so the turns come out jerky and it slows down to turn. The caveats are stated too: the coarse excitatory/inhibitory rule leaves photoreceptors excitatory, so the eyes are driven by darkness.

FlyPet (果蝇桌宠)

BakonZHOU

A Windows desktop fly on a 16,711-neuron MaleCNS subset with 2,075,126 signed connections, roughly a tenth of the neurons, stepped as simplified LIF at 1 ms. What sets it apart from other desktop pets is that it ships the means to distrust it: a verification script recomputes SHA-256 of the official annotation download and re-checks every bodyId and connection against the compiled matrices, and ablation controls rerun the same seed and stimulus with synapses cut. The README states that hunger, health, respawn and screen collisions are ordinary program rules.

Vibe Fly Brain

zogxray

A constructor that treats one measured nervous system as a blueprint rather than a target to copy: about 142k MaleCNS somata and a sampled process cloud are imported into an editable recipe, which can then be grown, carved and mutated in a 3D shell. The stated success test is that changing the recipe yields a different network that still works, and the README is blunt about what the project is not - not a digital twin of the fly, not end-to-end training of tens of millions of synapses. Raw and derived connectome clouds stay out of git and keep their upstream licences.

Death Star v2: Drosophila SNN Flight Control

bilalefekilic34 (@bilalefekilic34)

An interactive 3D trench run flown by a spiking network wired from named MaleCNS v1.0 circuits: LC10a for small-target tracking, DNp01 for wing beat and flight steering, dopaminergic PAM cells for reward, and a target-lock and firing feedback path. Vision comes from a 750-ommatidia compound-eye model, 375 per hemisphere, giving spherical gaze vectors and retinotopic optical-flow detection, with leaky integrate-and-fire membrane dynamics and synaptic delays. A Python neural engine streams telemetry over WebSockets to a Three.js scene. English and Turkish.

doom-fly-control

gabrycina (@gabrycina)

Runs the controls the viral "fly brain plays DOOM" videos skipped. For the trained project, 100 seed-matched games per arm on five ViZDoom scenarios score the same with the real wiring, wiring rewired at random, and no wiring at all (19.1 / 19.6 / 19.3 kills on defend-the-center). For the untrained 166,700-neuron one, scrambling its 25.6M connections cuts survival from 53 s to 7 s, yet a brainless robot that just turns right, walks and shoots lasts as long (52 s, 12 kills). A positive control remains: in the Shiu model sugar drives motor neuron MN9 at 66 Hz wired, 0 Hz scrambled.

FDDD (Fly-Driven Drug Development)

AwesomeZun (@AwesomeZun)

A browser research demo in which up to 20 independent MaleCNS fly models fly among proteins and small molecules and build a preference from pre-computed AutoDock Vina docking scores. Each fly computes 167,122 selected neurons and 6,241,236 directed connections (only those with five or more synapses) in the visitor's own browser, with activity drawn on 28,195 measured soma positions; the reward enters 1,428 neurons annotated as taste. Three proteins and six molecules give eight executed combinations. The page states the scores are not measured binding affinity.

flybrain

hrodrigobaigorria (@hrodrigobaigorria)

The neural core of the author's stonkfly experiment with every market concept stripped out: hand it a 180x320 RGB frame and an optional reward or aversive pulse, and the retained MaleCNS v1.0 graph (166,700 neurons, 25.6M connections) returns a left / right / straight readout from the DNp20 steering populations plus its memory state. A conditioning assay tests whether that memory is associative using a 2x2 reversal control, and states the limits: a white frame fires only about 14 of 4,064 Kenyon cells, and the reward effect is twice the aversive one (15 reward cells against 2).

flycraft

Solomon Shalom Lijo (independent researcher)

A paper and its code, rebuilding the published whole-brain fly model on FlyWire and MaleCNS, one model neuron for each of roughly 139,000 real ones, changing two things in the smell centre and giving it a body in Minecraft, to ask what the wiring alone knows about meeting another fly. The answers are mostly negative: the fly reacts (mouthparts on sugar, ovipositor when her head is touched), but her senses send almost nothing to the neurons deciding whether to accept a male or fight, and two flies in a box never steer towards each other, they only freeze on collision.

Fruit-fly-vision-bridge

DylanZhangzzz (@DylanZhangzzz)

Feeds an ordinary webcam, or an Intel RealSense D435i with depth and IMU, into a MaleCNS whole-brain simulation by sampling RGB pixels at published left- and right-eye L2 directions. The maps resolve 847 of 886 left-eye and 847 of 893 right-eye L2 IDs, and a saved frame drove 229 left and 217 right inputs in full-model replay. The README keeps the accounting honest: the brightness-to-drive rule is an engineering approximation, not a validated response model, the field of view is an assumption rather than a calibration, and fresh binocular capture is still pending.

MaleCNS Bee

Pacsy1 (@Pacsy1)

A Minecraft Paper plugin that flies a bee with the FlyEM MaleCNS v1.0 connectome shipped inside the jar: 165,733 proofread neurons and 6,239,854 connections, run as a spiking network on its own thread. What the bee sees, smells, tastes, hears and feels enters the fly's sensory neurons, and its descending neurons steer. Commands let you become an odour source, poke 745 head bristle neurons, or drive and silence any of 11,751 cell types. Scripted experiments print rates: a rotating drum swaps left and right HS activity (145.5 against 19.3 Hz), and blinding it halves whole-CNS activity.

Lincoln traffic control experiment

salsayid (@salsayid)

Asks whether a 196-neuron, 2,966-edge MaleCNS v1.0 optic-lobe subgraph (21,984 summed synaptic contacts, ten cell types) can request sensible signal phases for a post-game traffic queue model of three junctions in Lincoln, Nebraska. It can, by supervised imitation of a queue heuristic, and that is a negative result for the wiring: the measured circuit (93.20 queue-seconds per arrival), a rewired control (92.84), a conventional network (92.82) and the heuristic itself (93.26) all perform alike. The author says the test establishes no benefit from biological wiring.

Faithful Fly (mukha)

TryDotAtwo (@TryDotAtwo)

A verification-first reimplementation of the whole-CNS fly model in Rust with C++ and CUDA kernels, built around a pinned copy of the original published model and a deterministic Brian2 fixture, reporting where it still fails. Double precision matches all 9,440 Brian2 spike events for the sugar pilot; single precision shifted the first near-threshold spike by one tick at 436.4 ms. The MaleCNS import is provenance-locked, with hashes, index bounds, row ordering and contact totals re-checked. The visual gate is still failed and the body diagnostic is not yet driven by the nervous system.

PoopFly

Chawakorn111 (@Chawakorn111)

A whole-MaleCNS spiking fly that decides for itself when to defecate. It eats, builds up gut pressure, senses that pressure through interoceptive neurons, and the action is read out of motor-population firing rates rather than compared against a threshold. Relief lowers the pressure and produces a dopamine-like homeostatic reward driving three-factor plasticity, so the fly gets quicker at relieving itself when full and settles on a preferred background song. The run shown uses a 100,000-neuron subset with 19,716,276 synapses, computed in a Web Worker in the browser.

brainfly

Joshua Bradley (@joshuabradley012)

An attempt to close the loop from the MaleCNS connectome to a walking body, labelling every layer as validated, fitted or guessed. Each rung must match real-fly data and stop working when the wiring is scrambled. Tiling a fitted optic-lobe network onto the male eye gives correct direction preferences for all 16 T4/T5 types and a giant-fibre escape spike to looming; HS cells and DNa02 follow a rotating drum and eight NeuroMechFly flies turn with it, while three random rewirings abolish the signal. The whole-brain rung has failed five times and the fifth network still fails one of its two nulls.

CNS2FPGA

@LengQingSnow

Compiles subgraphs of MaleCNS v1.0 into a time-multiplexed FPGA engine and keeps the whole numbered workflow, from subgraph extraction through CPU reference models and fixed-point compilation to measurements on an ALINX AXKU115 board at 200 MHz. Two circuits are checked against the fixed-point CPU model: a 6,279-neuron courtship-song candidate over 13 recorded conditions, and a 226-neuron LC10a to DNa02 candidate over 560 ordered spike events. The README states plainly that these are implementation-fidelity results for a chosen LIF model, not a claim about measured fly activity.

A fruit fly connectome that learns

Weverton Guedes (@owevertonguedes)

Runs the classic punished-odour experiment on the male-cns v1.0 mushroom body and adds the controls that say whether the learning is real. Across five odour pairs, 200 flies each, avoidance of the punished odour rises from about 45% to 70-80% over 15 trials; punishment with no odour stays near chance, and shuffled wiring never learns because the punishment dopamine neuron reaches 409 Kenyon cells in the real graph but only 10 after shuffling. It also reports why the whole-brain model cannot learn this: two odours light up nearly the same Kenyon cells, 99% overlap at default inhibition.

Fly Drone

@hldrnwnv

Asks whether MaleCNS wiring can pick which way a virtual quadcopter should yaw. A target angle drives left or right LC10a cells, activity propagates through the fixed graph, and a linear decoder reads the sign of the turn off the two DNa02 descending neurons; a geometric controller and three degree-preserving shuffled graphs fly the same runs. The negatives are kept: driving the four rotors straight from wing motor neurons crashed after 1.23 s with no b1/b2 spikes, and odour-only navigation reached 4 of 8 targets against 6 of 8 for direct concentrations and 0 of 8 with the sides swapped.

Kenyon

@Aur1ety

Builds the mushroom body out of MaleCNS synapse counts, adds the published dopamine rule, and reports what the wiring decides rather than what the author fitted. Memory specificity, spread to similar odours and the direction of choice come out of the anatomy; the size of the memory is one calibration and is not counted. The failures are listed beside the successes: two memories in the same compartment do not coexist, there is no pattern completion, the real APL loop does not sharpen the odour code, and the recurrent whole-brain model cannot produce a sparse Kenyon code at any threshold.

UAM 학습 시뮬레이터

@rgh112

A Korean-language browser simulator in which two urban air mobility aircraft fly in 3D and a recurrent network wired from MaleCNS v1.0 picks checkpoints and the return leg, trained by reward from the flight itself. The extract is a 350-neuron subcircuit of 13 types with 15,182 directed connections, keeping the original body IDs, edge directions and synapse counts, with the extraction conditions recorded in a manifest. The page is careful about what it shows: attitude stabilisation and rotor control are fixed, and the bundled example is one seed after 20 training rounds.

desktop-fly-android

lan450 (@lan450)

An Android rewrite of DesktopFly in plain Java, with no Gradle and no third-party dependencies, and it is interesting mainly as a check on the original. The same circuits run here: 668 neurons and 18,968 synapses of the FlyWire v783 escape and steering pathway at 1 kHz, plus 1,045 neurons of the MaleCNS v1.0 nerve cord driving six legs. A mirror of the Swift random-number stream lets it compare value by value against the original's self-test, and it reports the same numbers, including a first giant-fibre spike 4 ms after a looming stimulus. Touch is the looming threat; a swipe is an air puff.

Flappy Fly

baltap (@baltap)

The game is projected onto the fly's compound eye and travels through its own optic lobe wiring, taken from the male central nervous system connectome; 79,992 spiking neurons are simulated every millisecond in the browser with every spike drawn at its real position. Each crash or cleared pipe releases dopamine that changes synapses, so a newborn fly crashes into nearly every pipe and a few hundred lives later clears dozens in a row. Switches turn learning, exploration and the innate gap attraction off separately, which makes the claim checkable.

Fly Brain Explorer

rashmina-a (@rashmina-a)

Two pages served by one small Python server, no build step. The first draws the male central nervous system connectome in 3D, colours neurons by neurotransmitter, and lets you fire a stimulus, pull up a single neuron's skeleton and follow its real connectivity. The second drops an agent running the olfactory chain from receptor neurons through projection neurons to Kenyon cells and mushroom-body output neurons, with dopaminergic learning, into a 2D foraging world, and evolves its sensorimotor policy at hundreds of generations per second before you experiment on the trained fly.

fly-in-the-bottle

dimm0909 (@dimm0909)

A desktop widget: an anatomical fly in a glass jar you can poke, rotate and shake, in a frameless transparent window that can sit on the wallpaper beneath every other window. The behaviour is not animation. A separate C++ process simulates the MaleCNS connectome, 164,606 neurons, event-driven so it costs almost nothing at rest, and four named descending neurons decide when the fly flies, turns, walks or reacts to a poke. The body is the FlyBody model with two-segment leg inverse kinematics. The README says the widget did not start on Windows, which Linux and X11 are the tested path.

Fly Number Recognition

Alex Grossi (@alexgrossidev)

A hundred real neurons and 3,630 real connections compiled into a recurrent network in PyTorch, trained to say whether a stream of ten digits contained a 6 or a 7. Gradient descent may change a connection's strength but may never invent one that the animal does not have. It works, and the author leads with the part that deflates it: a degree-preserving rewiring of the same neurons learns the task exactly as well, so the result is about connectome-constrained learning in general and not about this fly. A viewer replays the trained activity on the real neuron positions.

flybrain-reservoir

Milan Kalajdzic (@MilanKalajdzic)

Asks one narrow question and answers it in the negative: is measured wiring a better reservoir than random wiring with matching statistics? The male CNS (166,700 neurons) becomes the recurrent layer of an echo state network fed daily market data, against rewirings that preserve each neuron's partner count. On forecasting there is no edge either way. On memory capacity the fly comes last, 8-11x behind random wiring, because its dense knots saturate before the rest of it moves. Per-region and per-neuron gains, a NARMA-10 benchmark and a replication on FlyWire all agree.

FlyDefence

david93518 (@david93518)

A local security investigation workbench with a connectome laboratory bolted on, and the value here is the result it reports against itself. A MaleCNS v1.0 subgraph of 5,269 neurons and 152,689 directed edges runs an engineering update rule, and the repo says plainly that its activity values are neither firing rates nor attack probabilities. Held-out network-intrusion data gives the real wiring 76.77% average precision against 77.20%, 77.28% and 76.06% for three degree-preserving rewirings, and 82.34% for the encoder alone. The biological topology did not help.

FlyFace

FlyFace contributors (@8S8642)

Presents photographs of human faces to a simulation built from MaleCNS v1.0 and records what the neurons do. The playful framing is an A/B preference, but the structured output keeps every measurement and marks the descending-neuron orientation readout as unvalidated. The result is a negative one and is stated as such: responses are specific to individual images, and no global ranking emerges that matches human attractiveness ratings, nor the inverse of them. The pipeline verifies checksums on about 1.1 GB of source data before building the graph.

flymsg

Gianluca Mazza (@gianlucamazza)

A whole-nervous-system spiking model of MaleCNS v1.0 that spends most of its effort checking itself rather than on demos. It runs a battery of circuits whose function is known from experiments, with controls, dose-response and latency-order checks, and reports passing all 29 with no compensating adjustment. Separately it re-runs the published brian2 model of Shiu et al. on the female FlyWire brain and agrees within noise, a comparison that turned up six places where an earlier version of this code had quietly diverged. A browser page replays the activity on real neuron surfaces.

FlyRace

Ned Cutler (@nedcut)

A browser time-trial racer that was meant to have a connectome-driven opponent and ships without one, which is the point. The project set a pre-registered gate before any training was allowed to start: could an ordinary image network, given any of ten camera and sensor arrangements, predict hard braking well enough on courses it had not seen? None of the ten passed, so the gate closed and the recorded negative result names every score and notes that none of the three budgeted training runs was spent. The fly brain panel survives only as an untrained exhibit, and no fly opponent is planned.

FlyVigilante

AwesomeZun (@AwesomeZun)

Drug-safety case triage arranged after the layers of a fly's nervous system: wide cheap intake, cheap reflex judgements, sparse memory, rare deliberation, and a narrow bottleneck to a human queue. The bottleneck it targets is measured in the repo's own warehouse: 422,459 adverse-event reports in one quarter. A MaleCNS v1.0 central-brain subgraph of 49,244 neurons and 1.05 million signed connections runs as a firing-rate model in the browser at 30 Hz, so a decision lights the matching cell population and spreads along measured wiring. The routing policy itself is deterministic engineering.

GiantFiber (GF-1)

reacherwu (@reacherwu)

A reflex layer that sits underneath a flight controller rather than inside the planning loop, built from circuit motifs lifted out of the connectome: lobula Col4 cells computing angular expansion, two named giant-fibre descending cells, wide-field tangential cells for left-right asymmetry, and a sixteen-wedge central-complex ring that puts the aircraft back on heading after a roll. It preempts PX4 over MAVLink. The figures come from hardware-in-the-loop simulation, not a flown aircraft, and the repo is clear that the topology is a prior, not a running simulation of the measured network.

A Matrix das Moscas

Zidanski (@Zidanski)

Six flies share one 3D world, three running FlyWire v783 and three running MaleCNS v1.0, both under the leaky integrate-and-fire model of Shiu et al. on an event-driven CPU engine, so one world is inhabited by two different measured nervous systems at once. The rule the project holds itself to is stated first: the world code never moves a fly. The world turns physical situations into sensory input and reacts to what the flies do; every movement is read out of simulated neurons. It runs a hundred simulated days, with a sugar-to-motor-neuron validation recorded before the world was built.

ReflexGuard

mrgrit (@mrgrit)

Collision avoidance for a powered wheelchair, where the rider drives and the system only steps in when something is closing fast. A reduced MaleCNS v1.0 circuit of 187 neurons and 185 edges runs as a leaky integrate-and-fire model on a GPU behind an authenticated interface; a rule-based mock is kept as a separate mode for comparison. The README refuses the obvious overclaim: this is not a whole brain and not a physiologically validated model, and the validation so far is in a Webots simulation of three corridors, not on a real chair.

SuperTruth Connectome Study

Jason Alan Snyder, SuperTruth Inc. (@evil-robot)

A pre-registered study that holds the MaleCNS v1.0 wiring fixed (166,700 cells, 6,242,118 connections of five or more synapses), trains only the connection strengths and the way in and out, and asks it to reproduce a health-record trust score on 20,000 synthetic records. Its headline result undercuts the headline: a scrambled copy and a size-matched random graph scored just as well, so what mattered was the kind of substrate, not the fly's anatomy. Four language models got the same 300 records for comparison. The protocol, five controls and decision rules were dated before the first run.

Drosophil-Anki

Ethan Chen (@ethanwchen)

An Anki add-on where the fly in the corner is not a mascot: it runs a slice of a real connectome as a live spiking simulation while you review. A card's note id activates olfactory neurons, a sparse set of Kenyon cells responds, Good and Easy fire the reward PAM neurons while Again fires the punishment PPL1 neurons, and the Kenyon-cell-to-MBON synapses rewire the way a real fly's do. The male fly runs MaleCNS and the female runs the FlyWire connectome. Sync replays a whole review history through the brain in seconds, and hovering names the neuron and transmitter under the cursor.

axoaxodend

fkaempf

For any pair of neuron sets in the male CNS, classifies every synapse between them by whether it lands on the target's dendrite or on its axon, and writes out a table plus a Clio-NG scene that opens without hosting anything. Two implementations disagree and the README says which to trust: the navis split by synapse flow centrality is for numbers, while the single-edge R cut can land anywhere on a weakly polarised cell. On AVLP743m body 531383 it reports a segregation index of 0.01 where navis gets 0.20, and it calls 13% of AVLP749m to PAM01/PAM02 synapses axo-axonic where navis calls none.

Drosophila Under the Hood

Piotr Abramski (@abstractionthief)

An R-to-Python-to-browser pipeline over the male CNS: neuPrint queries become a whole-connectome input/output map, a leaky-integrator dynamics demo and a static explorer showing the 140,024 traced neurons that have a recorded soma position, 84.8% of all 165,122. The export manifest records the classifier source hash and whether the recorded commit had local changes. Tests cover classification, graph metrics, pathway pruning and the browser exports, including responses arriving out of order; the README notes that they stub plotting, so visual behaviour still needs a check in a browser.

Bottlenecks of the Fly Brain

danilo-lazovic

Max-flow / min-cut analysis of the male CNS wiring, asking which neurons sit between a sense and the descending neurons that drive movement. Cutting to all 1,314 descending neurons says nothing: the cut is just the first relay layer, because the CNS is shallow, a median of two hops from any sense. Restricted to a single target it becomes informative, and the vision-to-giant-fiber cut is dominated by LPLC2 and LC4, known experimentally to drive looming escape. Removing those neurons leaves 83% of synapse flow against 99.99% for random on-path controls. The spiking ablation step is unfinished.

flybrain-eyegaze-tracking

Rick Gorman (@rickgorman)

A webcam gaze tracker feeds a MaleCNS simulation. Browser-side MediaPipe turns iris positions and head pose into a screen point, and only the normalized direction from the on-screen fly to that point leaves the page. That drives LC4 and LPLC2 on each side, 80 ms of a 162,517-neuron, 6,138,378-connection leaky integrate-and-fire run, and a linear readout of 1,310 descending neurons' membrane voltage becomes a velocity. Only the readout is trained and the wiring stays fixed. The README states plainly that the connectome does not make gaze tracking more accurate.

FlyBreak

Shriya Sai (@Shriya-sai)

A thirty-second game on a graph derived from MaleCNS v1.0: a signal starts at the LC4 cell-type group and tries to reach DNg108 while you cut or jam nodes to stop it, without destroying the structural routes to DNa13 and DNa02. The playable level is 21 cross-matched cell-type groups and 43 directed edges carrying measured male synapse totals from 19 to 11,597, committed as a reviewable JSON file. Every four seconds the fly recomputes its strongest surviving routes and reroutes, so redundancy, shared nodes and collateral damage become the thing you reason about.

flycns

Felipe Santibáñez-Leal (@fsantibanezleal)

Compiles a connectome release into a graph a simulator can run, with every array verified against its SHA-256 and a table whose hash differs refused outright. It models both compound eyes over the release's own optic-lobe columns, 879 left and 892 right, then simulates the whole CNS with published equations: the Shiu leaky integrate-and-fire model, held identical to a literal Brian2 transcription, and Lappalainen's graded visual neurons, held to flyvis itself. A Python reference and a browser engine are kept to each other by parity tests. Not a general simulator, not a claim about behaviour.

FlyLab

pinkysworld

Links typed receptor evidence to named MaleCNS circuits (MN9, DNp01, labellar gustatory neurons), simulates a compound at a given free concentration, and then asks whether the predicted effect needed the wiring at all. Predictions are compared against ladders of degraded graphs preserving size and transmitter composition, degree, the edge list with shuffled weights, or transmitter labels permuted at matched out-strength; failing to distinguish an effect from a null is reported as exactly that. The two committed cuts disagree and the README says so. No biological validation yet.

Meta-Brain

Matheus Soranço (@Matheussoranco)

Uses the male CNS connectome as a sparse recurrent substrate for reinforcement learning: game frames are encoded into sensory neurons, activity propagates through the connectome-derived network, and a policy-gradient-trained readout decodes motor activity into buttons. Two tracks are reported honestly. A 40,000-neuron, 1,199,959-edge sensorimotor subgraph on a corridor task improved from -2.08 to 7.13 reward, success rate 25%. Full-connectome Super Mario reached about x=1,800 in some training episodes but averaged x=314 in evaluation, success rate 0, all five episodes ending in death.

pianist-fly

Noir-infini

The MaleCNS graph — 166,700 neurons and 25.6 million chemical synapses, with no learning rules anywhere in it — is run as a vectorized leaky integrate-and-fire kernel at 0.1 ms steps with 1.8 ms synaptic delay queues, and drives a MuJoCo fly that hunts a spatial sugar plume and aims leg strikes at piano keys. Bilateral concentration feeds 23 antennal sugar receptor neurons, front-leg motor pool rates are published every 28.6 ms tick and turned into damped least-squares inverse-kinematics ramps, and a verified claw contact on a key top triggers the note and moves the sugar target on.

fly-games

Shantanu Goel (@shantanugoel)

Mario, Kung Fu and Doom played by the frozen MaleCNS v1.0 network, 166,700 neurons and 25,582,938 synapses, none of it ever trained. Each game adds exactly two pieces. An encoder puts structured game facts on the right visual projection neurons and the right side of the body: LPLC2 for looming, LC4 for threat, LPLC1 for small approaching objects, LC10a for a chased target. Raw pixels are never used, since here the photoreceptor signal dies at the lamina. Then a small linear readout over twelve descending command populations, the only thing fitted.

alpha-fly

turlockmike

Takes the MaleCNS wiring unchanged and trains it at chess by AlphaZero self-play. The board enters 17,937 sensory neurons, activity runs six steps through the graph, and the move and evaluation are read from 2,333 efferent and descending neurons; training adjusts only a gain per synapse, a resting level and time constant per neuron, and the linear maps. After 322,016 self-play games and 23 GPU hours it matches Stockfish at UCI Elo 1320. The failures are kept: adjudicating on material taught it that sitting on a lead was winning, and half precision erased a signal a hundredth the resting level.

Drosophila MaleCNS Perturbomics

Guillermo de Anda-Jauregui

An R pipeline that perturbs every annotated cell-type unit of the MaleCNS connectome once and summarises its downstream reach across effector channels with a linear propagation model over synapse counts normalised by input. Four hypotheses are stated before the run: whether the perturbome is low-dimensional, where types sit on a specialist-generalist axis, whether anatomically distinct types produce similar effects, and whether published descending-neuron phenotypes agree with predicted similarity. The model is deliberately unsigned because transmitter sign is not reliable for all classes.

fly-brainloss — How Much Brain Does a Fly Need?

zapret-digital

Removes 0 to 95 percent of the cells at random from a 165,122-neuron MaleCNS v1.0 model and asks which abilities fade first. Feeding halves at about 17 percent of cells gone, turning away from a side shadow at 55 percent, tracking a moving dot at 83 percent, while takeoff from a looming shadow and the head-touch response never halve at all. The order is the same on FlyWire's female brain. A FlyWire finding that deleting one or two PVLP069 cells releases shadow suppression of feeding did not reproduce here: none of 208 neurons tested singly did it, and 35 LC4/LPLC2 targets were needed.

flybrain — Fruit Fly Brain Farm

baltap

Three simulated flies share a 3D arena and communicate only through airborne odour plumes that diffuse, drift upward and decay on a 32-cubed grid. Each runs the same 24,029-neuron, 4.03-million-connection MaleCNS v1.0 subnetwork — olfactory pathway, mushroom body, central complex, T1 to T3 nerve cord and the strongest inputs to those regions — as a leaky integrate-and-fire network. Since no female connectome is published, the third fly is the same male wiring with a different parameter set. The README notes the engine's calibration does not hold without the significant-synapse table.

flykski

WKDev

Couples a male-cns v1.0 circuit — 360 leg motor neurons reached from DNg100 and DNb08 through interneurons — to the flybody MuJoCo fly and asks whether real wiring can ski. The terrain has slopes and moguls with five snow types, and the skis are seven-segment bending plates with camber, rocker and sidecut. The status table is blunt: the controller has only been trained on flat ground, a zero-action fly slides down an alpine slope standing but rolls over in moguls, and real versus shuffled versus random wiring showed no significant difference in three comparisons.

FruitFly Tetris

shushuzn

A closed loop from the Tetris board through compound-eye photoreceptors, the MaleCNS spiking network and descending neurons back to a move, published with the finding that it does not work. Over 400-piece games the connectome agent clears zero lines and always tops out, while a Dellacherie baseline clears 156 and never does. It measures why: visual input raises photoreceptor firing about 20 percent but descending-neuron firing by 0.8 percent, because the tonic current and decay put the resting potential at 0.993 against a threshold of 1.0, so about 6 percent of cells fire on noise every tick.

NeuroFly

NeuroFly (neuroflyapp)

A Windows desktop fly whose behaviour falls out of a leaky integrate-and-fire model over measured wiring: 7,270 FlyWire FAFB v783 neurons with 784,219 signed connections for escape, steering, thermosensation, taste and antennal grooming, plus 1,045 MaleCNS v1.0 nerve-cord neurons for walking. The loop runs at 120 Hz with 1 ms neural steps and every action comes with its causal chain. Populations and cell types can be silenced or activated, and ten protocols from the literature rerun from a seed. A validation file lists the benchmarks the model fails and the claims the authors withdrew.

SIFa Connectome Analysis

szac74

Reproducibility code for the connectome analyses behind a SIFamide study. The original work was done interactively in neuPrint and no single script was archived, so this repository consolidates the query logic, neuron identifiers, filtering rules and site metadata into scripts that rerun the published numbers on hemibrain v1.2.1 and male-cns v1.0. A validation script checks configured totals; the authors report all key totals reproduced exactly. The README states plainly that mesh distances were screening metrics only and are not by themselves evidence of synaptic connectivity.

Supermix Expanse

Kai Piper (kai9987kai)

A 132.6M-parameter language model, built and trained on a laptop CPU, carrying the whole male-cns v1.0 type graph — 11,751 cell types and 3,830,931 type-to-type edges — as a per-token recurrent core grafted into its residual stream beside branches distilled from other models. Held-out loss on connectome facts drops from 3.522 to 0.571 nats per token. The results do not oversell: only 1 of 32 grafted expert groups reproduces its teacher on held-out tokens, most of what transferred came from distillation, and writing new code or defining biomedical terms is called unusable after one CPU run.

BioReservoir

IG Digital Lab (igdigitallab)

A lab harness that treats each published connectome as a fixed reservoir: load the wiring, run it as a spiking network, drive it with human-world input and read the response out without training the brain. The method is the point. Every run is pre-registered with hashed questions and seeds before the outcome is known, and every brain is scored against three controls: a rewired version of the same graph, a no-brain baseline and a coin flip. It ships the loaders, the LIF core, the scoring and the tests; the first experiment pairs a male and a female fly brain and is still at design stage.

A fly brain plays cute-dino

cchouse168

A fixed circuit of 80 MaleCNS v1.0 neurons and 1,296 measured synapses plays a browser runner game; the only trained part is a 269-parameter readout evolved by the cross-entropy method. On 100 unseen tracks the deployed model finishes 82, hand-written rules finish 25, and silencing the circuit or leaving the readout untrained finishes 0 — identical to doing nothing. The README refuses the obvious overclaim twice: 82/100 is one seed out of a 46–87 range, and no shuffled-connectome control was retrained, so this does not show the fly's wiring beats random wiring.

dotFly

kkokosa

A native .NET inference engine that runs MaleCNS v1.0 and FlyWire v630/v783 as leaky integrate-and-fire networks in pure C#, with no Python and no sidecar process, fast enough to sit inside a Godot game loop. The float64 reference backend reproduces Brian2 spike for spike and the float32 SIMD backend is bit-identical across thread counts. Its stated purpose is to make the engineered layer visible: the room demo labels every number as measured, calibrated or fixed, prints the decoder's rules beside the readouts, and records what the model did not do — its own navigation circuit stays silent.

FlappyFly

merfijang

One shared MaleCNS v1.0 fly of 166,700 neurons plays Flappy Bird on a server around the clock, and the unusual part is what buys it a try: a configurable amount of a token's accumulated trading fees pays for one attempt. Each attempt is one sample of an evolution strategy over the descending-neuron readout, so the training budget is set by trading activity. The connectome weights stay frozen and only 13 numbers learn. The base project's hand-written flight rules are removed, so the flap decision reaches the game only through the neurons, and a bias-only control is kept with the experiments.

Listed for information only. No endorsement, no referral links.

Fly Brain Gladiators

Jawaad Jariwala

Two arena fighters, both driven by the same 166,700-neuron MaleCNS connectome, with nothing trained: no reinforcement learning, no reward function, no learned policy on top. The only choices made were which neurons read the arena and which swing the weapon. The browser view draws every neuron at its real soma position, so you can watch a looming stimulus cross from the LC4 and LPLC2 detectors in the optic lobes, through descending neurons, to motor neurons in the nerve cord over about 100 ms. An object's angular expansion rate sets the detector firing rate.

Fly Touhou (果蝇玩东方)

leimi (w13630039663-bit)

A MaleCNS v1.0 circuit dodges bullet-hell patterns ported from Touhou 6: eight named visual channels, a frozen reservoir of measured synapses, sixteen descending neurons and a 320-parameter readout evolved by the cross-entropy method, the only trainable part. Ablating the circuit collapses play to a motionless baseline. The negative results are the real contribution: 80 to 600 neurons bought nothing, widening vision from 8 to 32 channels cost 26.2%, Hebbian plasticity flipped sign with the seed, denser wiring hurt, and against a rewired control the gap was -12 frames, p = 0.9351.

Муха смотрит телевизор (Fly Watches TV)

georgesher

A finished art piece, published as-is and no longer maintained: a fly sits in a 1990s kitchen in front of a television carrying live broadcast channels. Frames at 160x90 and 15 fps become input to 4,146 photoreceptors mapped onto optic-lobe columns, a MaleCNS v1.0 simulation of 166,700 neurons and 6.24 million connections runs at a 0.1 ms step, and after two model seconds the fly either stays or flies to the remote and changes channel. The author is careful: the network only receives pixels, and "bored" and "startled" are their own reading of Kenyon-cell and giant-fibre activity.

FlyChain

Rodrigo Soto (SotoAlt)

A demonstration blockchain whose proof of work is a taste decision. Each block header hashes into a stimulus, real gustatory receptor neurons from the MaleCNS connectome are driven with it, and the resulting spike train is both the proof and the block contents: a transaction is included only if MN9, the motor neuron behind swallowing, fires — otherwise the fly spat it out. Eight flies in a row decide each block. Transactions are authorised by an ordinary secp256k1 signature over an EIP-712 digest, and connecting a wallet only changes which fly is cosmetically yours.

Listed for information only. No endorsement, no referral links.

Fly vs Jev: Pong

EnesYilmazcode

Puts a connectome and a language model on the same Pong court under the same rules. Neither moves continuously: while the ball approaches, each player looks four times and picks one of eleven paddle heights, and neither is told where the ball will arrive. For the fly, each candidate becomes a picture centred where its paddle would be, landing on 3,316 real R1-R6 photoreceptors; the MaleCNS connectome then runs as a spiking network for 150 ms per candidate and a readout over 2,048 L1 and L2 neurons scores it. The wiring never changes. Across 300 games the fly won 274.

MaleCNS Neural Field

Seed123-psy

Runs the whole MaleCNS connectome — 166,700 neurons and 25,582,938 fixed connections — on a CPU and lets its activity drive a two-dimensional forage-and-avoid task, with a local web page showing the arena and a 3D brain side by side. You can pause, single-step, slow down, replay, search a neuron and follow its real upstream and downstream partners. The action readout can be compared three ways: trained offline, random, or a rule-based reference, and an online Double DQN can keep training it. The page samples 4,769 real soma positions and says the glow is illustrative.

Etanol y comportamiento en una Drosophila in silico

Alvaro Rovira

A simulated fly in an arena whose behaviour comes from 20,000 MaleCNS v1.0 neurons and 1,319,744 signed connections, with nothing scripted: feeding fires when the proboscis motor neuron MN9 does, escape when the giant fibre crosses threshold, posture from leg motor neuron tone. Ethanol acts only on synaptic transmission, and hyperactivity, loss of leg tone, falls and loss of the righting reflex come out of that. A degree-preserving shuffled wiring is the control: odour-guided feeding drops from 97.5% to 0% and bitter rejection from 100% to 0%, while escape and sugar acceptance survive it.

FlyBrainFM / connectome-lab

avisharm-alt (@avisharm-alt)

Graph machine learning on the complete MaleCNS v1.0 release, sized to run on a laptop. It downloads the official annotation, neurotransmitter and 1.1 GB connection-weight files from the public bucket, builds a sparse directed graph, learns separate outgoing and incoming embeddings per neuron with randomized SVD, then probes whether those unsupervised embeddings recover annotations such as neuron class and searches for structurally similar neurons. An optional PyTorch path trains edge-discrimination embeddings. Raw data is fetched, never redistributed.

ConnectomePilot

pgq18 (@pgq18)

Wires the MaleCNS connectivity graph into a simulated mobile robot: sensor input drives neural activity and a policy readout produces corrections on top of a base navigation controller. The recipe that worked best trains internal connections and readout jointly for 65,536 steps, then freezes the connections and continues on the readout to 4,194,304. On 500 held-out maps with three seeds the mean success rate is 85.1% at about a million steps and 88.6% at four million, with 89.4% for the model picked by the pre-declared rule. Longer training did not help monotonically.

flybody-connectome

jamesbiederbeck (@jamesbiederbeck)

Closes a loop from rendered compound-eye images through the MaleCNS v1.0 graph to wingbeat frequency and steering on a MuJoCo fly, then reports that no visual information is in the loop yet. Driving the retina makes all 3,335 photoreceptors and two descending types spike, but not one of the 708 ventral nerve cord motor neurons does, so a wing command cannot be read where it anatomically belongs. A frozen-vision control reproduces the live run exactly, so the variation comes from the connectome's own left-right asymmetry. The halteres exist in the model but nothing joins them to the afferents.

Fly-brain Worldle

GeorgeCanon (@GeorgeCanon)

Puts two pieces of real fly data into one agent that guesses a country from its silhouette: flyvis, a frozen connectome-constrained optic lobe model, as the eyes, and a recurrent network wired as the MaleCNS central complex to integrate direction-and-distance feedback across guesses. Only gains, biases and time constants are trained; the graph and the excitatory or inhibitory signs stay fixed. Over all 195 countries it solves 96% within six guesses, but a shuffled central complex reaches 95% and a random stub 95%, and a raw 16x16 pixel input beats the optic lobe on the first guess.

FlyCast

Ankit Kapoor (@ankitkapooor)

Feeds an uploaded time series into the MaleCNS v1.0 graph used as a frozen reservoir, a leaky rate model over a sparse matrix, samples 4,096 internal states as virtual electrodes and fits a ridge readout for multi-horizon forecasting. The split is chronological at 70/15/15 with the scaler fitted on the training part only, and an optional control scrambles connection magnitudes while preserving topology and weight distribution, so whether the measured weights matter is testable, not assumed. When an autoregressive ridge or naive persistence wins, the interface says so instead of hiding it.

flynet

Zikithezikit (@Zikithezikit)

A Python library for building spiking networks on fly connectome wiring. Its loader fetches either a small slice around a cell type or the whole graph from neuPrint and caches it on disk, with a synthetic offline fallback so every example runs without a token. The network object settles under sensory input, calibrates a sensor-to-motor mapping, returns a steering command, and lets you query synaptic partners and strengths neuron by neuron. Also ships leaky integrate-and-fire neurons, spike-timing-dependent plasticity, reward-modulated Hebbian training and a command line.

FlyView

al0cam (@al0cam)

Draws one 3D scene twice, once the way a person sees it and once the way a fly does, where every viewing direction comes from a real Mi1 cell in MaleCNS v1.0: 886 medulla columns for the left eye and 887 for the right. The direction map ships as a 100 KB file, so the viewer needs only Python and a browser. The write-up separates what the data gives, which is the order of the columns, from what is imposed from published anatomy, such as the half-sphere field and the 150-degree divergence between the optical axes, and makes every imposed number an environment variable.

kobae

sksat (@sksat)

Runs MaleCNS v1.0 whole and unthinned, 166,700 neurons and 25,582,938 connections, as leaky integrate-and-fire neurons on Vulkan through wgpu, targeting AMD cards rather than CUDA, with a browser viewer for watching and stimulating it. Synaptic input is accumulated in fixed-point integers, so a run is bit-identical on the same GPU. A numba port of the DoomFly CPU kernel is the reference: spike sets match exactly over the first 20 ms, then diverge from rounding, which the author shows is the system's own chaos rather than an implementation gap. Sugar stimulation is bistable.

MaleCNS × PC-ALM

sjskoko (@sjskoko)

Asks whether a local learning rule can train a network wired from the MaleCNS connectome, on a small graph of 132 neurons and 1,001 retained connections, and answers that it can but without an advantage. Across 760 fits predictive coding with an augmented Lagrangian did not beat plain predictive coding: mean test error 0.01721 against 0.01091 on the nonlinear teacher, and a separate matched-learning-rate control left it 1.9-5.1% higher. Better initial gradient alignment did not become lower final error. Tasks use synthetic targets, not measured fly behaviour.

malecns-asteroids

dohun1214 (@dohun1214)

Runs all 166,700 MaleCNS neurons in real time to play Atari Asteroids, and spends most of its effort proving the named circuit is the cause. Looming cells feed descending neurons for an escape mode and a separate tracking pathway for a pursuit mode. Silencing two descending cells drops action agreement to 56.9% and flips the turn sign, while silencing 2,000 random cells changes nothing. Permuting only the looming projections, with degree, sign and weights preserved, moves the escape bearing error from 60.7 to 99.2 degrees; a size-matched shuffle elsewhere does not.

malecns-weights

kvnloo (@kvnloo)

A ledger rather than a runtime: it pins the MaleCNS v1.0 source files and the compiled sparse arrays by hash and states which parts may change. The census it records is 166,700 neurons and 25,582,938 directed edges under CC BY 4.0. The only plastic object it will store is an adapter on existing Kenyon-cell to mushroom-body-output-neuron edges, about 0.03% of the graph; gradient descent over the whole graph is refused and the command that would start it exits with an error. The README is blunt that the anatomy is an initialisation, not a faithful brain and not an upload.

MaleCNS — Music in the Body

matsuo-koya (@matsuo-koya)

A browser instrument that keeps playing until you stop it, driven by the measured MaleCNS v1.0 wiring: 163,997 endpoint bodies and 6,236,393 directed edges are stepped in a web worker and read out as harmony, motifs, grains and a body pulse while you fly through the neuron space in first person. Connections below weight 5 and self-connections are dropped, and provenance, transforms, counts and checksums are stored with the build. Real wiring, a rewired graph and a version without recurrence can be compared, and the page says plainly that only the wiring is measured.

3dfly

liudicsu

Flight in MuJoCo where the output is a map: a MaleCNS-structured network drives thrust and torque from descending neuron activity while the run accumulates a 3D point cloud of the room. Depth comes from motion parallax and optic flow, computed from consecutive frames, combined with egomotion, routed through the connectome and decoded from visual population activity into a 12 by 16 depth map, with classical StereoBM stereo kept alongside as a baseline. The README is explicit that the flow extraction and neural readout are hand-designed approximations.

Fruit Fly Connectome Emergence

chenshuai9101

Treats MaleCNS v1.0 as ground truth for what a real emergent system measures like, then uses that signature to calibrate a multi-agent emergence engine. The reported signature is anatomical modularity with Newman Q of 0.44 over 28 brain regions, a high-rank spectrum where the top mode holds only about 1 percent of variance, and a spectral radius of 3,777 raw that lands at exactly 1 after column normalisation. The payoff is an audit: those numbers exposed a scale-dependent bug in the other engine's classifier.

Drosobot

guinpereira

A robot controller taken straight from measured reflex circuits rather than a network trained from scratch. In Portuguese. Each neuron is a leaky integrate-and-fire unit and each weight a synapse count from the reconstruction, with the published whole-brain parameters rather than gains tuned by hand, leaving one free parameter: with a threshold seven millivolts above rest, a connection needs roughly 25 synapses to fire its target alone. The phase is explicit: all validated in software, no hardware bought yet, parts ordered only after a circuit works in simulation.

Flappy Flies

YuzhouCheng66

Race eight connectome-based flies through 30 courses of one to five gates, with docking tolerances tightening from 0.18 m and 30 degrees to 0.03 m and 3.5 degrees. Each fly maps 27 local sensor values into 2,048 sensory neurons and reads 512 outputs from a frozen MaleCNS-derived graph. The default campaign replays collision-audited full-model rollouts with their neural activity; a live mode runs the whole network in WebGPU in a browser worker. The README calls it a connectome-inspired rate model, and warns that curated success is not a population success rate.

fly-brain-calculus

JitheshVijay

Gives the connectome a multiple-choice calculus item and then spends the rest of the repository showing that the wiring is not why it succeeds. The fly reaches 0.795 held-out accuracy against a 0.311 control and 0.25 chance, but the control arms run the wrong way: permuting which neurons excite or inhibit beats the real graph, degree-preserving rewiring beats that, and a plain random graph with the right edge count scores 0.980. Only shuffling synapse counts hurts, which moves the network out of its operating regime. The reading offered is a random nonlinear reservoir.

Fly Brain Drone

abbosaliboev

A MuJoCo drone with a rendered camera looks for an apple in a 3D room, and is never given the apple's coordinates: only what its own simulated eye sees goes into a pipeline of MaleCNS pathways pulled live from neuPrint plus a pretrained connectome-constrained optic-lobe model. The dashboard shows the arena, the drone's compound-eye view, a 91-column hexagonal retina and 47,261 neuron positions with 27,523 visual-type neurons lit by live activity. The status section states up front that the project is unfinished and separates what currently works reproducibly from what does not.

Fly Brain Escape

ak7660

Throw a looming threat at a fly in your browser and watch 4,296 MaleCNS neurons and 149,232 synapses decide, wired as they are in the animal from looming detectors through interneurons and descending neurons to motor neurons. The comparison was set up before training, with a rule that a gap must exceed two pooled standard deviations. Real wiring reaches 90 percent in 30 iterations against 77 for a degree- and layer-matched shuffle, but it is not more accurate, since both saturate. A linear classifier on the eye neurons scores 100 percent, so the task is easy.

Муха в машине (fly-brain-explainer)

cosmiksoul

A Russian interactive explainer that separates the biology, the engineering and the meme in the viral clips. It starts with how a sliced brain becomes a graph and what the graph does not contain, moves through what the spiking simulations actually animate, and ends in a sandbox where a toy fly brain pulls a slot-machine lever and plays a guessing game against the reader. Both games carry a shuffle-the-wiring button, which the author names as the control the viral videos are missing and the thing that separates the brain having learned from the rig having been built that way.

fly-cord-robots

SakshayMahna

Drives a simulated legged robot from the fly's ventral nerve cord, its spinal-cord equivalent, instead of a hand-designed gait, first on a hexapod, then on an amputated quadruped it never evolved for. The log is the interesting part: the published circuit science was reproduced, all six leg circuits identified and confirmed, a fly body built in physics simulation, and motor-neuron output moved real joints open loop. Then a pre-registered pilot closed the loop with proprioceptive feedback and found it either negligible or enough to drive the network into a runaway, non-rhythmic state.

The Fly Hears

rahilmavani

Say a digit into your microphone and watch it travel through roughly 30,000 simulated neurons wired by 1,348,769 signed connections taken from MaleCNS. Sound is measured in 32 frequency bands, an engineered mapping turns those into stimulation, the wiring stays fixed, and only a small logistic-regression reader is trained, which the README labels reservoir computing. Across 3,000 recordings from six speakers, held out by speaker, fly wiring scores 70.0 percent clean and scrambled wiring 69.7 percent, with the order reversing under added noise. Only one scrambled graph was evaluated.

Kärbes (fly-mp)

stamkivi

A whole simulated fly brain takes the chair of the Estonian parliament, which has 101 seats, as a notional 102nd member. Real sittings are played to it from the parliament's open data: every speech arrives as a scent from the speaker's side of the hall, insults come straight at it, and when its escape reflex fires it rings the bell. The first plan failed twice over, and the author reports both failures: the brain is purely reflexive with no memory, and across 784 bills the single fact of who tabled a bill predicted the chamber's vote 94 percent of the time.

fly-pet

zhongpei

A desktop pet whose brain is neither trained nor a lookup table: desktop events are encoded as injections into sensory populations such as LC10a, LC4 with LPLC2, touch and smell, a forward pass runs the real MaleCNS weight matrix of 166,700 neurons and 25.6M synapses, and actions, continuous parameters and expressions are decoded from descending neuron firing rates including DNa02, DNp01, DNg100, MDN and pIP10. DNg100 grades walking speed and left-right asymmetry in DNa02 turns the head in real time. The four mappings the author considers exploratory sit behind a speculative flag.

FlyBrain Camera

0xtwone

A live 3D view of neural activity that is unusually careful about what it is not. All 166,700 neurons take part in the computation, but only the 140,638 with finite coordinates are drawn and the 26,062 without are left out rather than given invented positions. Connection lines are sampled from the real connectivity matrix but are straight segments between soma endpoints, not reconstructed fibres, and no unrelated pretty brain mesh is passed off as these neurons. The display buffers 25 steps at 20 ms, which the README says is not a real-time biological recording.

FlyBrain-LLM

000214075

A Chinese language model whose forward and output path is the connectome itself: 164,587 neurons and 25,563,096 synapses, with no attention, no positional encoding, no normalisation, no residual stream, no key-value cache and no transformer block, leaving sequence modelling to the recurrence of the wiring. It runs on one desktop with an AMD card. The project refuses to assume the wiring helps and builds in three comparison arms, then reports the negative result plainly: the hybrid model that keeps a transformer reaches lower perplexity than the pure connectome one.

FlyCoder

tolga-ileri

166,700 neurons trying to centre a div. A closed loop is built on an existing whole-brain runtime with the weights left frozen: a stylesheet viewport is encoded onto identified visual projection neurons, a cursor of actions is read off descending neurons, and the resulting keypress edits the stylesheet so the square moves, with a dashboard and a three-dimensional fly showing the same control signals. The README states in its own words that it does not claim the neurons understand stylesheets, and that what is new here is the interface rather than the model.

flymj

lo2003058

Uses the mushroom body's projection-to-Kenyon-to-output wiring as the fixed sparse structure of a network trained to predict Japanese mahjong discards, then runs the comparison most demos skip. Real wiring reaches 65.73 percent test accuracy, a degree-matched random rewiring 65.61 percent, and a parameter-matched dense network 65.29 percent. Both sparse arms beat the dense one clearly, while real against random is not significant. The author's reading is that the sparse expansion shape is what helps, not the fly's particular diagram. A playable app sits on top of the trained model.

FlyOhtani

gitwub5

A life-sized fly, 3.7 mm tall, stands at the plate with a bat, sees the pitch through its own two eyes as a pair of small greyscale images, and swings when a circuit taken from the connectome commands its forelegs, all inside a physics simulator with a body model from published work. The recorded hit in the README is specific: the circuit decided at 27.1 milliseconds that the ball was high in the zone, and the ball left at 808 millimetres per second at a ten degree launch angle, which scales to roughly 14 metres at human size. Playback runs 133 times slower than life. Korean and English.

flyscreen

majiangmagic

Play any video file into a fly brain and watch the body react. Frames drive a whole-brain LIF network in the style of Shiu et al., activity spreads over MaleCNS v1.0 wiring using the 141,781 neurons that have soma coordinates and 5,536,527 synapses, and the result moves a flybody MuJoCo fly of 68 rigid bodies, 103 joints and 78 actuators standing on a floor with real gravity, contact and friction. Drag a file onto the local web page and it previews the brain point cloud and the body side by side while writing an MP4 with the original audio mixed back in.

flysim mushroom-body fix

maumcrez-svg

A whole repository for one transposed index, in flycoinrh, which is also listed here. The upstream code reads a post-by-pre weight matrix in the wrong orientation, so what it classifies as dopaminergic input is actually feedback from the output neurons, and any approach or avoidance readout built on it silently gets the sign backwards. A second fact kept the bug alive: the shipped graph deletes every dopaminergic edge, so the correct read returns zeros. The fix vendors upstream unmodified, and two strict expected failures pin the defect so that quietly repairing them turns the suite red.

FlySoul

heyobi

A MaleCNS-derived circuit fights the tutorial boss of Dark Souls III through SoulsGym, and the README reports two runs as separate claims because they are. Letting the circuit's own descending pools choose actions, with three-factor dopamine plasticity on Kenyon-cell to MBON synapses, won 8 fights out of roughly 5,200, and the trend over 1,720 fights of the final circuit is flat at 0.0 plus or minus 0.4 points per 100 fights: it can win, and it does not learn to. Fitting a Double-DQN outside the brain instead won 737 of about 6,300, which the author labels plainly as not the fly's learning.

Haltere Pilot

Ameerkhanjk

A quadrotor flight controller built from a 9,235-neuron MaleCNS subnetwork: every neuron within three synapses of an input port and a wing motor neuron. Each drone sensor enters at the afferent population that carries it in a real fly, so the gyroscope reaches the brain only through 204 haltere afferents. A degree-preserving rewired control scores 23.3 fruit per minute against the real wiring 22.3, so the connectome gives no task advantage. The ablations pay off: silencing the halteres drops the score to 0.5, while silencing as many random neurons barely registers.

MaleCNS Lab

merolaagi

A locomotion circuit pulled out of MaleCNS v1.0 by anatomy rather than by result: six traced DNa01, DNa02 and DNg13 descending neurons, their strongest nerve-cord and leg-motor targets, and chordotonal or campaniform sensory cells, giving 807 neurons, 21,161 measured connections and 329,230 synapses. A sparse leaky integrate-and-fire model drives a simplified six-leg readout in a local UI that runs intact, silenced, feedback-free and shuffled conditions. The README calls it a real anatomical subset with assumed dynamics, and names the truncated feedback loops as a major limitation.

MaleCNS Pong Lab

almera-vs

Pong in the browser where the court is sampled as two overlapping crops, reduced to 64 luminance channels and fed to annotation-matched photoreceptors; sparse activity spreads over retained MaleCNS edges, and annotated tibia motor pools drive an engineered muscle and joint model that moves the paddle, with joint angle and velocity fed back as proprioception. The stated goal is inspectability, not performance: scene, neural state, muscle plant and display are kept separate so a result can be traced to the graph, a modelling assumption or a display-only feature.

BH26: MaleCNS sniffs cells

Jiandong Chen, Masao Nagasaki (Kyushu University)

A BioHackathon Japan 2026 project report asking whether a fly brain can do useful work on genomics data. The mushroom body turns an odour into a sparse code over Kenyon cells, and its alpha-prime-3 compartment behaves as a novelty detector whose output neurons are suppressed by dopamine within a few repetitions of the same odour. The project presents single-cell RNA-seq profiles to the simulated brain as odours and reads that compartment's output as a novelty score, so cells resembling ones already smelled habituate. Reported in three stages, from blood cells to a lung adenocarcinoma dataset.

pyfly-lightning

NewJerseyStyle

A pip-installable library for running experiments on connectome-derived spiking substrates without first becoming a connectomics engineer: point it at a task and it builds the substrate slice, finds a routing for the input, trains the readout and reports which null models the result beat. It is backed by MaleCNS v1.0 at 165,122 traced neurons and 25.6M directed edges and by FlyWire 783, both fetched over public HTTPS with sha256-pinned integrity checks and no API token, with any other connectome pluggable as an edge list. The plan command prints the reason behind every setting it chose.

fly（コネクトームを触る環境）

seeton

A Japanese workbench for handling three connectomes side by side, with a table comparing what each one covers: the male central nervous system with brain, optic lobes and nerve cord together, the lighter central female brain used for practice because every tool supports it, and the whole female brain kept as the comparison for sex differences. The environment comes pre-wired with the standard morphology, query and template libraries plus a physics body and a local web app, and a fetch script that pulls 78 MB by default or the full 7.7 GB on request.

Shouko（ショウコ）

Muika (@Moemu)

Imports the 166,700 neurons and 25,582,938 connections of the male central nervous system as a control network, trains it to output twelve joint targets, and hands those to a physics simulator so a humanoid avatar walks. The project is honest that a wiring list carries no brain function by itself, and it reports the ablation, not only the demo: nine of nine fresh starts stay upright for 30 seconds, a continuous two-minute walk covers 65.55 metres with 0.13 metres of lateral drift, three of three lateral pushes are recovered, and severing the brain connections drops the body in about a second.

Smells Like Alpha

rgourley

The 7,443 MaleCNS neurons that handle smell are simulated, each symbol's technical setup is turned into an odour, the circuit runs on it, and the learning cells that fire decide which one the fly likes best; when a trade closes the outcome rewires the cells that chose it. Everything is paper money on an external platform, and the command line keeps the dangerous step explicit: a rehearsal decides and prints the whole session while sending nothing, and only an added go flag lets it trade. Listed for information only, with no endorsement and no referral link.

virtual-fly

shute2004

Couples a MaleCNS snapshot of 166,700 neurons and 25,582,938 directed edges to a FlyBody MuJoCo body in closed loop, and insists on doing the learning inside the simulated nervous system: no backpropagation, no gradient descent, no external controller, only local activity, eligibility and dopaminergic modulation through released DAN populations. The canonical v1 run changed 2,163,179 stored edges over six episodes, yet frozen evaluation before and after both ended in a gate collision at control step 120, so the run establishes weight change, not improved behaviour.

AxonWeave

dhakalnirajan

A sparse-network toolkit for using MaleCNS in NumPy/SciPy, PyTorch and TensorFlow/Keras. It preserves graph connectivity while allowing edge gains to be trained, and exposes assumptions about signs and receptors as model settings. Anatomical connections supply the structure; the numerical dynamics and learning rules remain modeling choices.

cocoa

flyconnectome

A Python library for comparing and jointly clustering neurons across connectomes, including FlyWire, hemibrain, MANC and MaleCNS. It helps investigate cell-type correspondence across different reconstructions. The documented FANC and BANC integrations remain TODO items and are not counted as implemented support here.

Faiku

xyzzyapps

A mushroom-body learning experiment that traces target Japanese and English glyphs as 2D movements. The repository distinguishes a MaleCNS-based route from a simplified eight-channel fallback. Tracing provided letters or verse is a motor-learning task here; it does not demonstrate autonomous poetry composition or semantic understanding.

fly-odor-onoff

yukincom

An odor ON/OFF intervention study using the fixed MaleCNS LIF model derived from fly-brain-minecraft. It investigates persistent activity in four DM1/VA2 projection neurons and how blocking input during the OFF period changes that activity while retaining ON responses. The results concern this model and intervention, not a biological validation or repair of the entire circuit.

Fly Space Program

steph4n-gh

A simulated rocket-control experiment combining MaleCNS-derived dynamics with trained command readouts. The author reports 60 successful landings in 80 unseen-start trials across ten tasks, versus none in a vision-blocked control. Failures remain part of the report. The result does not establish completion of every planned mission or operation of the proposed physical Fly Cube.

fly-swing

JHC56

A MuJoCo rope-swinging experiment driven by an extracted visual and escape circuit, with an engineered memory system choosing movement directions. Its body is a non-rotating capsule. The full-CNS display uses a separate offline computation and does not drive the controller; neither web swinging nor the added memory is a biological fly capability.

FlyDoom

eganeganegan

A VizDoom research framework for testing sparse recurrent controllers derived from MaleCNS. It supports PPO and plasticity experiments alongside degree-preserving rewires, random graphs and conventional neural-network baselines. Fixed and trainable components are experimental choices; the framework itself is not evidence that biological wiring outperforms those controls.

FlyLab

Sudharsanselvaraj

A research prototype that turns Chromium screenshots into keyboard actions through a learned controller and simulated foreleg contacts. It includes MaleCNS activity views and execution traces. The demonstrated task is a fixed-layout, single-line HTML heading exercise; it does not establish general coding ability. The hosted showcase is static, while execution requires a local runtime.

FlyOCR

jerryjliu

An OCR experiment that passes printed characters through a fixed MaleCNS circuit and learns a small decoder for the resulting activity. It includes native computation, Python tooling and a research report with baseline comparisons. Conventional classifiers outperform the fly model in reported comparisons, so the work should not be described as proving an advantage of biological wiring.

Fruit Fly Fashion

jtc268

A fashion-art experiment using MaleCNS spike vectors to change the position, rotation and scale of existing print designs. Humans supply the source graphics and the original colors are preserved. The project explores a connectome-driven transformation of artwork, rather than a fly independently inventing garment designs from nothing.

The complete gustatory connectome of adult Drosophila

Janelia Research Campus and collaborators

A Cell study reconstructing adult male gustatory pathways across the brain and ventral nerve cord, relating taste circuits to feeding, foraging and social behavior. It examines a sensory system within the whole-CNS wiring resource. The circuit analysis is distinct from the dataset release and from a simulation demonstrating those behaviors.

MaleCNS on Apple MPS

seohyunjun

A PyTorch MPS implementation for running MaleCNS stimulation experiments on a Mac, with 3D activity reports and a small grid-navigation task using a fixed neural encoder and trained output layer. The README also records limited activity in a basic stimulation run. Success on a small fixed-goal grid should not be read as general locomotion or a validated whole-brain behavior.

404 Media: A Digital Fly Brain Has Taken Over the Internet

404 Media

Becky Ferreira's report on the wave, written from interviews rather than from the timeline. It traces the trend to the graduate student whose Minecraft fly reached millions of views in a day, sets the games alongside researchers using the same release for harder questions about learning circuits, and states plainly that a structural map without the biochemistry is not a candidate for consciousness. It also puts the release in its scientific context, as the male counterpart to the 2024 female brain and the first chance to compare the two at cellular resolution.

Awesome Fly Brain Agents

PerturbationAI

A second curated list of the September 2026 wave, narrowed to projects that put a large fly connectome into an active loop: games, robots and bodies, markets, desktop agents. Each row states the connectome and the scale the project reports, the environment, whether the loop is actually closed or only partly, and a note on what is not established. Those notes are the useful part, flagging when turns are instructed rather than learned, when motor control is still a dry run, or when a project cautions against reading its own demo as fly vision.

Boltzmann-fly

Junichiro Niimi (@jniimi)

Re-runs the author's own published energy-based world model with its coupling pattern fixed to mushroom body wiring: 343 projection neurons carry the 72 input features, 1,918 Kenyon cells with at least one projection input form the first hidden layer, and 49 output neurons the second. Only the existence of a connection is taken from the connectome; magnitudes are learned, and the directed graph is symmetrised to get an energy function. At one seed it matches the dense original on prediction and on one counterfactual parameter, and falls short on the other. The stated goal was that it runs.

Call fly

cashew-labs

A phone call with a fruit fly. A full-duplex speech model does the listening and talking in 80 ms frames, so you can interrupt it; the connectome sits beside it as a reservoir. The speech model's 4,096-number internal state is summarised into 64 fixed features, fed into the retained MaleCNS graph with its own previous activity, pooled back into 128, and passed through a fitted adapter that nudges the text-token scores by a small bounded amount. The browser draws the same reservoir state in 3D, so the visualisation is the thing actually in the loop.

DOOM-x-Fly

Aur1ety

Runs 138,968 MaleCNS neurons and 4.6 million signed synapses as a recurrent network, unchanged apart from one global scale factor, and has a 256-unit decision layer reading 1,312 descending and 9,199 visual projection neurons pick one of eight Doom buttons. Over 100 runs from unseen starts on shareware E1M1 it reaches the exit 57 percent of the time against 0 percent for random or always-forward and 6 percent for a blind replay; scrambling its own frames drops it to 0. The author states the open question plainly: an earlier, simpler test suggested random wiring carried at least as much signal.

flybench (opifor)

opifor

An independent reimplementation of the Shiu et al. leaky integrate-and-fire model, built to put a male and a female brain in the same simulator and the same world: MaleCNS, the FlyWire FAFB female and the BANC female all load from their public releases. It reproduces the published female benchmarks, and every experiment is pre-registered, with the text hashed into the record and failures reported like successes. Held so far: the male song command chain, and mated-state gating silencing pC1 and vpoDN. Not held: song entering the female ear never reaches vpoDN.

透視果蠅 Fly Explorer

klmtseng

A bilingual 3D site that explains the male CNS to schoolchildren by replaying one escape reflex: looming, giant fiber, jump and wing muscle neurons. It draws the 140,024 neurons of the connectome's 166,691 that have soma coordinates, and colour carries provenance. Green is real position and simulated spikes, magenta is what the model could not produce and the authors injected, grey is a drawn body that is not in the data, amber is the motor-to-muscle step where only the timing is real. Limits are printed, including a textbook relay that never fired in their own run.

fly-flappy（果蝇大脑玩 Flappy Bird）

ns2250225

Flappy Bird played entirely in the browser by the MaleCNS v1.0 connectome: 166,700 neurons and 25,088,107 retained connections stepped at 50 Hz in a Web Worker over a sparse CSC weight matrix, with LC4, LPLC2, LC10a and a vertical-velocity channel carrying the game state in. Three modes separate what the wiring does from what training adds: PURE BRAIN decodes raw descending activity, ONLINE TRAIN fits a logistic readout while flying, and FAST TRAIN freezes a separately trained model. Flight safety rules block runaway flapping, and a URL seed makes runs reproducible.

fly-mcp

franBec

Exposes a MaleCNS brain to any agent that speaks remote MCP. ask_fly renders your text as a 320 by 180 frame, runs it through a pinned build of an existing spiking implementation, and returns a verdict from a left-minus-right descending-neuron spike differential with a second neuron as gate, plus the raw spike statistics. reward_fly and punish_fly queue engineered pulses into 15 dopaminergic and 2 aversive cells, consumed by the next question rather than at call time. Every tool description repeats the same disclaimer, and a deterministic mock backend runs with no dataset at all.

fly_p1_sign

martialsystems

A single question asked of a parent project and answered no. Replacing that project's hand-set P1 row with MaleCNS one-hop signed contact counts onto 88 pC1 cells removes the result that HD present and cVA absent was necessary and sufficient to gate courtship song. The extracted weights explain why: LC10a dominates at plus 606, the cVA path arrives at plus 62, the HD path at minus 3, and ppk23 does not contact P1 at one hop, so P1 would only cross zero at a weight far below what the map gives. Every condition still sings, across three seeds.

FlyBoost

tls8012

A scikit-learn compatible classifier and regressor whose hidden structure is a fixed MaleCNS graph in PyTorch, usable inside Pipeline, GridSearchCV and eval_set like any other estimator. The control is built into the API: fly_mode switches between the real topology, a frozen variant where only the readout learns, and a shuffled graph that keeps the same neurons, edge count, exact in and out degrees and signed weights while destroying the real pre-to-post pairing. The roughly 122 MB connectome tensor stays out of the wheel and is fetched from a release on first fit.

FlyDrones

SpikeCalls (@SpikeCalls)

Turns a drone camera, or a hand in front of a webcam, into activity on the fly's own visual cells, runs the MaleCNS connectome as a spiking network, and reads six descending neurons out as stick commands for a real drone or a simulator. An open palm looks like sinking, so T4c to VS to DNg02 climbs; a rush at the camera fires LPLC2 and LC4 into the giant fiber DNp01 and it escapes. The browser demo runs 850 spiking neurons live. The README separates the measured wiring from the engineered parts: the camera-to-neuron bridge, the tonic flight drive and the safety governor are the authors' own.

FlyDurak

KremlevLev

The MaleCNS connectome as a recurrent policy for two-player Durak: 165,122 neurons and 10,511,038 directed edges converted into a signed, normalised sparse graph, combined with a compact decision GRU, legal-action masking, actor and critic heads, and factorised synaptic gains. It was trained by reinforcement against random, scripted, frozen-policy and determinized-search opponents, then fine-tuned with search. One command bootstraps the venv, builds the connectome and downloads a 374 MiB checkpoint. The README calls it an exploratory demo whose multi-seed GRU and LSTM comparison is unfinished.

FlyType / FlyBreak

michaelpersonal

Two tasks on one substrate: typing a target sentence, and brick breaker. Both see only a locally rendered 320 by 180 frame of the retained MaleCNS graph, 166,700 neurons and 25.6 million connections, and both act from neural activity alone. Typing stimulates 3,335 brightness and 811 colour inputs and decodes left, right or hold from a descending-neuron rate difference against a deadband; correct picks schedule a dopamine pulse into 15 identified cells. The paddle tracks the ball at 0.782 against a measured chance level of 0.5 over 6,947 scored moves.

GS FLY

rperissi

A 2.8 MHz Apple IIgs rotating real MaleCNS neurons, released for the machine's 40th anniversary. A 75,418-byte file holds 18 skeletons across 9 cell types, from the giant fiber DNp01 to a circadian clock neuron, each capped at 600 nodes by pruning the shortest terminal twigs first. The 65C816 spins them with 16-bit integer math and a 7-bit sine, depth-shaded through a 12-step ramp, while the screen mixes 320 and 640 pixel modes per scanline. With a CoGS card it opens a TLS session and streams the block down; the running benchmark projects how long all 166,700 neurons would take.

malecns-operator

hjkornn-phys

Asks whether the wiring can hold an odour in mind: the MaleCNS graph as a steady-state rate model with a 16-unit GRU bolted on outside it, 110 odorants entered as measured receptor responses, tested on odours and receptor neurons it never trained on. It scores 0.724, and then reports that the comparison which would make this a finding about the wiring is void, because the shuffled and input-only arms never learned even on their own training data. An exploratory check is kept separate: cosine similarity on lateral horn output separates same from different at 0.947 against 0.514 shuffled.

NeuroWeave

Titanium-xd

A benchmark that uses a MaleCNS subgraph of 150 neurons and 3,029 edges as an architectural mask: only anatomically real connections may carry learned weights, everything else is structurally zeroed, and the result is run against conventional models on the same tasks under the same conditions. The site carries the benchmark, a live arena and a how-it-works page. The project calls itself an engineering experiment rather than a neuroscience simulation, and reports its answer so far as task-dependent rather than a win for biological wiring.

fly-experiment

josepha-mayo

Two players under one control contract: a living Drosophila tracked by an overhead camera in an arena, and a static MaleCNS v1.0 network of 166,700 neurons and 25,582,938 edges. Both drive ViZDoom combat survival and a chess menu through one motion-to-action mapping. In nine sessions the fly logged 3,758 kills in 9,098 episodes; the connectome, held to the same bandwidth, 3,170 in 8,832; unconstrained, 6,527 in 563. The fly improved across sessions; the network could not. One chess game was completed, 186 plies. Nothing is trained; the README says a game score is not biological validation.

MaleCNS Driving Robot

AlexNoyanov

A two-wheeled acrylic robot driven by a slice of the male CNS: the right antennal lobe, about 4,057 neurons of male-cns:v1.0, run as a leaky integrate-and-fire network on a Mac M1. Camera frames and three ultrasonic ranges feed in, spikes come out as left and right motor speeds, and a Raspberry Pi 4 relays them over WebSocket to an Arduino with an L293D driver. Nothing is trained; the spike-to-wheel mapping is the author's, and the connectome is cached locally. Three watchdogs stop the motors on stale commands or dropped links. A GIF and screenshots show it moving. No licence file.

Vaxenfly

vaxenfly

A fixed reward-punishment readout for AI agents, built from the mushroom body of the male CNS: 4,064 Kenyon cells, 97 output neurons and 340 dopaminergic neurons, and 61,210 KC-to-MBON edges. Each compartment's sign comes from the ratio of PAM to PPL1 presynapses in the connectome, 8 appetitive, 7 aversive and one unsigned, and nothing is trained. The real KC-to-MBON weights give a 12.8 percent median d-prime gain over degree-preserving shuffles. Rebuilt on hemibrain, one of its own bounds fails, which the README reads as thresholds not transferring between datasets.

Brain-to-Body Switchboard

shreyansatvik (@shreyansatvik)

A browser map of the output side of the male CNS connectome: pick one of 481 descending neuron types and see which of eleven motor pools - 815 cells covering eight body areas - it reaches within three synapses, with synapse counts and input share. Excitation and inhibition come from transmitters predicted off the EM images, which the site calls predictions, not measurements, naming glutamate as the weak point. Against seven published neurons the wiring matches five; the LIF view, on a 49,448-neuron subset at 0.08 mV against Shiu's 0.275 mV, reproduces two at 75 spikes/s and five at 150.

BrainLab

@Pronexsteam

A single-GPU LIF simulator that marks every run pass or fail against an outside reference. The interesting result is negative: the sugar-to-MN9 taste experiment from Shiu et al. 2024, run on three adult connectomes, gives 76.7 Hz on FAFB v783, 68.9 Hz on MaleCNS v0.9 and 17.8 Hz on BANC v888. A control rules out edge thresholding, since FAFB at threshold 1 still reaches 70.0 Hz, pointing at the raw synapse counts instead - so the spread says more about the three datasets than about the fly. Its own FAFB figure of 111 Hz also sits above the published 93.27 Hz.

Wired Different (ConnectomeLens)

Dhruvin Sarkar (@dhruvin-sarkar)

Trains a gradient-boosted classifier on the male-only MaleCNS v1.0 cell-type graph (11,751 types, 243,439 edges) to predict Janelia's male-specific and dimorphic labels, then asks whether the real wiring beats 500 degree-preserving rewirings. All features give AUC-PR 0.759 against 0.712 for the nulls; the sharper test is topology alone, 0.489 against 0.070, at p = 0.002. The repo writes down what it may and may never assert, calls its two flagged types candidates rather than findings, and publishes a pre-specified check that failed. The site adds an atlas, a pathfinder and a guessing game.

drosophila-brain-mlx

Kisame76 (@Kisame76)

The published Shiu et al. leaky integrate-and-fire brain model rebuilt in MLX with hand-written Metal kernels. The project reports 0.29 s per biological second for FlyWire v630 (127,400 neurons, 14,687,178 edges) on an M4 Pro against 62.6 s for its Brian2 reference on the same machine; the benchmark JSON is committed. Shiu's run_exp arguments and parquet files work unchanged, MaleCNS v1.0 runs in the same engine though its spike counts are not comparable, four lanes are pinned to one spike-count SHA-256, and a degree-preserving shuffled wiring is kept as a control, where MN9 stops firing.

firefly

PixelML

A control study, not a demo. 18,318 deduplicated satellite tiles of structure wildfire damage are sampled into 99 retinal patches, injected into a frozen MaleCNS v1.0 network (166,700 neurons and 25.6M synapses by its count), read out after 48 ticks as log1p spike counts from a fixed 1,024-neuron set, and classified by a 64-unit MLP. The controls are the point: real wiring reaches ROC-AUC 0.622, a shuffled connectome 0.625, all-excitatory 0.642, random sparse wiring 0.632, and pooled pixels 0.711. On this task the measured wiring buys nothing over a scrambled one, and loses to plain pixels.

The Fly Adjudicator

CakeCrusher

Screenshots of X posts map onto 892 hexagonal ommatidial columns and run through a 140 ms leaky integrate-and-fire pass over MaleCNS v1.0, cited at 165,122 neurons and 25.5M connections, then scored on dark-edge, ON/OFF and surround activity. The author calls the verdict polarity a joke and supplies the control that kills it: a blank grey rectangle scores within five percent of a dense screenshot. What survives is the method critique - the usual descending-neuron readout saturates, and four non-spiking wide-field types, eight cells in all, separate a plausible raster from runaway activity.

fly-battery

@thechrisroberts

Six published fly behaviours written as directional predicates, sealed before any scored run, then run on the MaleCNS v1.0 graph against two nulls: a degree-preserving shuffle and a twin with randomised dynamics. Four of the six items failed; only CO2 avoidance and giant-fibre looming escape held. The seal is externally checkable: the committed battery file hashes to the sha256 registered on 1f916.ai hours before the scored rerun. The author later corrected a mis-scaled random-dynamics null: the verdicts stand and CO2 avoidance stays clean, but the looming item now reads as a wiring-only pass.

fly-drums

sykeriin

Loads the Janelia FlyEM male CNS connectome - by the project's count 165,122 traced neurons and about 10.2 million signed synapses - as a leaky integrate-and-fire network and reads six annotated motor-neuron populations (foreleg, midleg, hindleg, wing, haltere, neck) as drum voices, tuned toward human grooves from Magenta's Groove MIDI set. Only the Kenyon-cell to MBON synapse moves, by dopamine-gated depression. The LIF simulator, the mushroom-body learning circuit and the graph builder come from flycoinrh, also listed here; new are the drum mapping, the reward and the selection loop.

MaleCNS Virtual Fly (Fly.exe)

@Ibtisam-Mohammad

Runs the traced MaleCNS v1.0 graph, 165,122 neurons and all 25,563,197 edges, as a GeNN/CUDA integrate-and-fire network coupled every 15 ms to a NeuroMechFly v2 body in MuJoCo, at 0.015x real time on an RTX 3060. Twelve flies in one arena walk to an object 12 times out of 12, against 0 of 12 with the stimulus absent - but that is one seed in the third arena, after two were measured and discarded. All 66,533 photoreceptor output edges are zeroed, vision is analytic rather than rendered, the tripod gait is a published pattern generator, and the decoder cannot stop, so arriving is physics.

Fly Meijin

nyoki-mtl

A shogi policy learned on measured MaleCNS wiring. The graph stays fixed (166,700 neurons, 25,582,938 edges); the only plastic parameters are gains on existing excitatory inputs to mushroom-body output neurons, 77,364 connections from 8,374 sources onto 97 MBONs, with a variant confined to 61,210 KC-to-MBON edges. The teaching signal is a conventional shogi engine, not biology. Held-out agreement with the teacher is 26.39 percent, 1,081 of 4,096 positions, below the 30.27 percent dev-set figure used to pick the checkpoint, which came from a private corpus and several initialization stages.

Fly Neuron Atlas

mait (@mait2355n)

An evidence ledger for the motor side of MaleCNS v1.0: 815 motor-annotated neurons with 330,888 incoming edges, 2,155 shared upstream candidates (weight at least 10, reaching two or more of 42 muscle groups), full edges for 40 of them, and re-analysis tables for 23 DNa01/DNa02 voltage recordings. Verify and reproduce scripts recount the edges and exit non-zero on mismatch. The limitations file lists: 69,709 of 90,166 input bodyIds carry no annotation, dropping 44 annotation-only motor neurons cuts candidates to 1,927, and the physiology comes from female flies while the wiring is male.

Flycoding

Yuhtin (@Yuhtin)

Hands a coding agent its next instruction from a MaleCNS v1.0 network: 166,700 neurons and 25,582,938 edges are stepped at 0.1 ms across a 500 ms observation, and while DNpe017 fires the right-minus-left difference in DNp20 rate picks one of three fixed instructions, Fix above +2 Hz, Test below -2 Hz, Investigate in between. OpenCode or Codex does the actual coding. The pilot is small and reported as such: adaptive and frozen-weight networks each passed 2 of 2 attempts, and so did a uniform random chooser, using more calls. The authors state six attempts establish nothing about learning.

FlyTV

gsoloviev

A Pine Script v6 strategy that puts a slice of the male CNS connectome on a TradingView chart, then reports that it does not beat the market. Price moves enter as looming visual threat, Kenyon cells carry context, profit and loss feeds back through mushroom body synapses, and a descending-neuron readout keeps it long or flat. The Pine build is 995 neurons and 17,000 connections. On hourly BTCUSDT since 2018 it ends at 4,231 dollars against 11,904 for buy and hold. Two results survive controls: drawdown beats random in ten of twelve runs, and shuffled wiring gives 0 DNp01 spikes against 98.

Hackaday: Fly Brain Connectome Used To Trade Stocks And Play Games

Maya Posch (Hackaday)

Maya Posch's 14 September round-up, the hardware-hacker press catching up with a wave the games and science outlets covered first. It walks through what has been bolted onto the Janelia male CNS wiring diagram in under two weeks: Nftechie's Stonkfly, which reads the fly's reward circuitry as stock trades, and attempts to have the connectome play DOOM and Beat Saber, where each game frame stimulates sensory neurons and dopamine reward circuits are wired in for reinforcement learning. Posch passes on Nftechie's own admission that nobody has checked how good a fruit fly is at trading.

Haltere

Artem Skulimovskiy (@skulitom)

A flight controller wired by anatomy: 30,000 MaleCNS v1.0 neurons that sit on a sense-to-motor path of at most two synapses, plus the central complex and descending neurons, with 2.77 million connections and 37.5 million synapses. Topology and synapse sign are fixed; gains, biases, time constants, encoders and a linear readout are trained by copying a teacher MLP and backprop through a differentiable quadrotor. It then flies in Liftoff: 0.34 m hover error, a 601 m lap at 1.5 m/s with 0.67 m path error. In the simulator the plain MLP baseline reaches 10 cm where this brain gets 0.22 m.

Fault Lines

akramahmed1

A structural resilience battery on the MaleCNS v1.0 wiring graph: reachability over about 60 million sensory-to-motor pairs, a directed minimum s-t cut, and targeted-versus-random lesion curves against degree-preserving and region-constrained nulls. The headline is negative: targeted lesions disconnect more pairs than random, but no test of 24 survives FDR correction and the rewired nulls reach almost the same reachability. Wiring only, no activity. The repo calls itself preliminary and not peer reviewed, and its README and its own audit disagree on the 173,023 vs 166,700 node gap.

Ripe or Rotting

Charbel Kassab

A six-stage simulation from banana chemistry to a fly deciding to land and feed: 14 days of ripening and yeast fermentation, volatile emission, a turbulent filament plume, 59 receptors mapped onto 52 olfactory neuron types and taste classes, the 165,122-neuron MaleCNS v1.0 graph run as a spiking network in four hunger states, then surge-and-cast flight. The validation table is where to look: four of its nine checks pass and three fail outright, including attraction across 108 odorants at r = 0.06. Flight and feeding rules come from behaviour data, not from the brain.

VFB Self-Led Learning (NeuroFly 2026)

Virtual Fly Brain team

Virtual Fly Brain reopened the hands-on workshop it built for NeuroFly 2026 as seven self-led sessions anyone can work through for free, announced on the VFB news page on 6 September 2026. They run from finding a neuron, through bridging between datasets, to pulling in single-cell transcriptomics, and each can be done five ways: the vfb_connect Python client, natverse in R via reticulate, a natural-language chat, an MCP endpoint for driving it from an LLM, or the 3D browser. Material covers BANC, male CNS, MANC and the optic lobe. The footer states GPL v2.

WATT THE FLY

Watt the Fly (@flywatt-live)

Runs 38,178 neurons and 5,124,215 synapses of the Janelia FlyEM Male CNS v1.0 connectome - a visual-to-wing-motor cut of 89 cell types - as leaky integrate-and-fire units in a Web Worker, then turns the spike count in a 100 ms window into watts at 31.9 pJ per action potential to light a three.js bulb; calibrated, it draws about 6.5 uW. A table separates measured wiring from assumed synaptic sign and modelled constants, and a verify script re-checks the looming and dark-flash responses. No insect and no hardware: the bulb is a rendering. The page also carries an unfilled token-launch slot.

Listed for information only. No endorsement, no referral links.

Fruit-fly CNS - live connectome driving a body

@wjb000

A browser page where roughly 166,000 traced male CNS neurons run as leaky integrate-and-fire units with short-term depression, and the motor-neuron pools alone move the body, which goes limp when they fall quiet; the page defaults to a quadrotor, with the NeuroMechFly model behind a query parameter. What sets it apart from the other embodied demos is the perturbation kit: silence, boost, cut, swap, delay or hunger-gate any neuron from the console, run lesion sweeps, and try a cross-sex graph transplant against BANC in the repo tooling. That transplant is reported as a failure twice over.

重みは学習するのか、測るのか。ハエの脳が問い直す AI のつくり方

村本 (@1amageek)

A Japanese technical essay whose point is provenance, not scale: in a connectome model the roughly 15 million weights are counted off electron micrographs rather than fitted, with one hand-chosen constant of 0.275 mV. The often-quoted 91 percent is accuracy at predicting circuit responses, not at reproducing behaviour, and it cites Lappalainen et al. and Beiran and Litwin-Kumar to argue that wiring constrains a mechanism without determining it, since gap junctions, neuromodulation and plasticity rules are absent. It reads DOOMFLY and Fly64 as designed input-output mappings.

flybrain (annel0)

annel0

A fast GPU simulator for connectome-constrained spiking models of the Drosophila central nervous system, published together with a record of what it could not establish. It started from the question the viral wave skipped, that everyone reads the brain but nobody changes it, and ends by setting out in measured terms why that question cannot yet be answered honestly. MaleCNS v1.0 is imported to a CSR graph and FlyWire 783 exactly, so someone else's published predictions can be replicated; that replication lands at a median ratio of 1.01 and a correlation of 0.970 across thirteen neurons.

Bad Apple Fly

kevinlinxc

Plays the Bad Apple video into the MaleCNS v1.0 connectome and shows what a simulated body does in response: one pane projects neuron activity onto soma positions, the other drives a NeuroMechFly body in MuJoCo. The README opens with what it is not. The connectome is real, but the neurons are leaky integrate-and-fire units with invented parameters, not measured biophysics; the video is a spatial stimulation pattern across soma positions, not something the fly sees; there is no sensory feedback or aerodynamics; and the body mesh is the published female specimen paired with male neural data.

C3S Reflex Circuits

BruceLanLan

Takes one behaviour, looming-evoked escape gated by the giant fiber, and carries it from the MaleCNS v1.0 wiring through an explicit teacher model, then a 16-bit decision table covering all 65,536 rows, and finally a netlist of 173 NAND gates and 6 latches proved exhaustively equivalent to that table. The question is how small a deterministic machine reproduces a connectome-shaped behaviour, and how much of that machine can be proven rather than trusted. A browser bench launches a looming block at a fly and evaluates the netlist cell by cell every 5 ms, verifying its SHA-256 on load.

CyberFly (fly brains on Snap Spectacles)

PtPavloTkachenko

Hologram flies placed in a real room through Snap Spectacles (2024), each running its own copy of the MaleCNS v1.0 connectome (166,700 neurons, 25.6 million synapses) as the leaky integrate-and-fire model of Shiu et al. 2024. The brains run on a Mac behind a Metal GPU kernel; the glasses turn the room into fly senses, streaming eyes, world mesh, hands and head to the brains, while descending and motor neurons come back to move wings, legs and head. The selected fly's brain is drawn live as a 16,000-neuron point cloud, and a decisions document lists every engineered part.

fasterfly

franciscocarloserra

Event-driven Triton kernels that step the whole MaleCNS connectome, 165,000 neurons and 24.5 million synapses, at 3,455 Hz on a single RTX 3090. With a 1 ms membrane time step that is one second of fly life in 0.29 seconds of wall clock, about 3.5 times faster than real time, against 708 steps per second for a torch.sparse COO baseline. Batching sixteen or sixty-four flies trades single-fly latency for throughput and reaches 51,159 fly-steps per second. The README is explicit that the same input produces the same spikes as the torch.sparse reference.

Fly Brain Atlas

ashemag

An interactive 3D atlas of the adult male fly brain built from published MaleCNS geometry: 80 brain regions carrying 7,270,902 native source triangles, with exploded and paired-region views, plus 1,712 traced neurons at 2,180,126 segments and eight complete neuron meshes loaded on demand. Geometry is served locally and no API token is needed at runtime. Every asset carries its source URL and a SHA-256 checksum in an attribution manifest, and the page states that the cellular view is a selected collection illustrating morphology, not the whole population.

fly-connectome-template

Mert Cobanov (@cobanov)

A browser workbench for starting your own fly-connectome experiment instead of rebuilding the scaffolding each time. It opens with 124,289 classified brain soma positions from MaleCNS v1.0 rendered without stretching the axes, plus the anatomical flybody mesh, and leaves the environment and the model as replaceable parts: training and inference stay in your own stack, and outputs are mapped back by neuron ID. The licence requires attribution in both the web UI and the repository.

Fruit Fly Plays Fruit Ninja

hcsolakoglu

A reduced MaleCNS circuit, 4,386 real neurons and 468,923 measured edges representing 4,210,625 synapses, controls a Fruit Ninja-style game through an explicit pixel to activity to blade loop. What earns it a place is the control set: you can switch between measured wiring, rewired wiring with its own refitted readout, connections cut, blinded input, a random blade and a plain pixel heuristic, with a seed for reproducible launches. The README says outright that this is a fixed-connectivity rate model with engineered visual and motor interfaces, not a whole-brain emulation.

Fly Self Driving

suanmiao

Runs the measured MaleCNS wiring, 165,122 neurons and 25,563,197 synapses, as a recurrent network and trains it to steer a car from a 64 by 32 pixel windscreen. The adjacency never changes; what is learned is one gain per synapse and one leak per neuron. On held-out streets with parked cars, oncoming traffic and a slow car to overtake it completes 58 of 60 runs across three independent sets with no collisions against any car. The site replays logged state rather than re-simulating, puts the real input beside the drive, and publishes the failures too.

FlyBrain-HalfLife

Yusuftmle

An agent that plays Valve's Half-Life with no deep network, policy or reinforcement learning in the loop: every turn, jump and evasive move comes out of biophysical leaky integrate-and-fire circuits derived from MaleCNS v1.0 and FlyWire and simulated as sparse tensors. Frames are projected onto a 60x60 compound-eye retina and taking damage triggers a giant-fiber escape. The headline figure is the size of the source dataset; the graph actually stepped in the demo is a 12,260-neuron subgraph, shown beside the game with calcium-style activity and descending-neuron meters.

Fruitless

nicodunks

A paired experiment on the MaleCNS wiring graph (166,606 classified neurons, roughly 25.6 million connections) asking whether blocking the output of the inhibitory mAL pathway lets male-associated sensory input reach courtship-related P1 neurons. Both arms get identical inputs and the same firing rules; the only change is the mAL block. All 36 combinations of three input pathways, three seeds and two inhibition settings were run, and the README states plainly that the cell identities and connection effects stay modelling assumptions rather than measured properties.

NeuroHex

shakeabhishek

A physical hexapod robot whose escape behaviour comes from fly wiring rather than a hand-written state machine or an abstract neural network. Only the direct one-hop synaptic neighbourhood of the giant-fiber escape circuit is pulled out of the MaleCNS reconstruction through Virtual Fly Brain, roughly 391 neurons including LC4 and LPLC2 looming detectors and JO mechanosensors, and simulated in Brian2 on a Raspberry Pi 5. A camera and OpenCV optical flow feed the spike encoder, and a decoder drives eighteen servos through a PCA9685 controller: a connectome on real hardware, not in a simulator.

ASCII.jp: マイクラのハエに本物の脳を再現

ASCII.jp (G.Raymond)

Japanese coverage devoted to NeuroCraft Fly specifically. It reports the six input types the Minecraft fly responds to (player proximity, surrounding mobs, brushing, attacks, food and light), notes that selected readouts pick predetermined actions rather than simulating natural physiology, and states the release position clearly: the repository holds introductory materials and demo footage, with the Fabric mod source still unpublished.

AUTOMATON: ハエの脳の配線図が DOOM に使われる

AUTOMATON (Kosuke Takenaka)

A Japanese games-press account of DOOMFLY, focused on the mechanism rather than the spectacle: Doom's screen becomes signals the fly can receive, activity runs through the MaleCNS v1.0 model, and taking damage sends an aversive stimulus to dopamine cells. Its most useful line is the negative result, that after roughly 3,000 attempts no learning had been confirmed in the form of longer survival.

Closed-Loop Fly

ZeroXClem

Closes the sensorimotor loop in the browser: rendered images drive a compound eye sampled at the connectome's 1,771 column directions, the optic-lobe rate model feeds the whole MaleCNS graph, descending-neuron rates drive the wings, and the body's new pose renders the next frame. It is an explicit combination of two upstream projects joined at MaleCNS body IDs, AbijahKaj's optic-lobe front end and Xenova's whole-CNS WebGPU back end, and it ships an ablation bench that produced the published cruise figures.

Connectome Fighter

Unjuno

Connects the MaleCNS v1.0 connectome to the FightingICE fighting-game platform through a pinned implementation of the Shiu et al. leaky integrate-and-fire dynamics. Game observations become a versioned Poisson sensory interface, real output-body spike counts become versioned action groups, and a public research ledger records the runs. The repository draws an unusually sharp line between what is biological data (the anatomy), what is a published model (the dynamics) and what is a project-defined interface (the sensory and action mappings, reward and plasticity rules).

connectome_interpreter

Yijie Yin, University of Cambridge

A Python library that turns a wiring diagram into testable hypotheses about circuit function, and it runs on a laptop or in Colab even for whole-brain analyses of around 140,000 neurons. It computes polysynaptic effective connectivity between groups of neurons with or without signs, retrieves and plots the actual subcircuit between sources and targets, and exposes a differentiable connectome model. Installable from PyPI, with an accompanying preprint and Colab notebook.

Dexerto: the digital fly gets its own heaven

Dexerto (Zackerie Fairfax)

The article that gave the wave's counter-current a name. It covers Macroblock's announcement of an open-world sim where the simulated fly gets grass, trees and endless fruit instead of Beat Saber, sets it against NeuroCraft Fly and the rhythm-game clip, and notes that the Beat Saber demonstration was later clarified as incomplete, a useful correction given how often that clip's view count is cited.

FLM (Fly Language Model)

nftechie (Alex Wormuth)

Couples a frozen language model to the retained MaleCNS v1.0 graph: token embeddings drive the fixed 166,700-node network, and a 278,528-parameter adapter reads its state to adjust the next-token scores of Liquid AI's LFM2.5-1.2B-Instruct. Only the adapter trains, against a parameter-matched direct-input control. The README puts the caveat in its first paragraph, that language ability comes from the pretrained model and this does not mean a biological fly understands language.

Fly Arena

Artem X (@artem-x-meta)

Combines a NeuroMechFly body in MuJoCo with MaleCNS connectome data and explicit behavioural controllers. The hybrid mode covers walking, odour-guided food search, contact feeding through an articulated proboscis, grooming, sleep pressure and waking; a separate two-fly arena adds shared food, body collisions, pushing, foreleg fencing and retreat. The README states that the demo clips were recorded with the connectome disabled, showing the engineered controllers, and that this is an experimental model rather than a validated digital fly.

fly-craftax

Liu Zihe (@liuzihe02)

Puts a connectome simulation into Craftax, an open-ended survival environment, and trains a linear descending-neuron readout with PPO. What sets it apart from most of the wave is the harness around it: a brain-only throughput benchmark, an MN9 sugar-response check against Shiu et al., a calibration sweep over lamina bias and synapse weight, zero-shot rollouts against ablation controls, and a replay of the trained readout on a held-out key versus an open-loop baseline. A research prototype, not a result.

Fly Dino

Mert Cobanov (@cobanov)

The original Chromium Dino game played through an 80-cell measured MaleCNS circuit: eight engineered observations feed the fixed cells, 16 descending-cell activities feed a 16-12-3 readout, and only that 243-parameter readout is trained, using the cross-entropy method over 80 generations and 15,680 episodes. The published checkpoint clears 99/100 held-out 180-second courses; the same readout with the circuit silenced clears 0/100. The author states this shows learned control and dependence on circuit activity, not that biological topology is better.

Help the Fly Escape

David Zhang (@dzhng)

A 3D browser puzzle game: arrange household objects in a furnished house, release a swarm of flies, and see how many find the exit before time runs out. Each fly has its own simulated activity from a selected part of the MaleCNS connectome, running as Rust compiled to WebAssembly with a TypeScript world and interface; you can follow one fly, read its left/right color inputs and inspect its neural traces. The stated design rule is to build the game around observed behavior rather than forcing the neurons to produce a chosen strategy.

Fly / Wirehead

Matty (@mattyhempstead)

"Born to fly. Forced to scroll." A simulated fly watches an endless feed of insect Shorts on a virtual phone: the browser samples the phone image at 90x160 pixels, luminance and color stimulate 3,335 R1-R6 and 811 R8 inputs in the full MaleCNS v1.0 graph, and a compiled kernel advances 50 ms of neural time per accepted frame. The overlay charts the measured PAM11 dopamine firing rate in Hz alongside whole-network spike counts. Explicitly inspired by Stonkfly; body motion is an amplified readout, not a physics simulation.

FlyBrain Engine

Mehran (@mehrantsi)

A native Rust and Metal implementation of the published FlyWire leaky integrate-and-fire model, with Python kept as an independent Brian2/NumPy verification lane and as the offline Parquet-to-CSR compiler. It now carries a Rust embodiment layer too: MuJoCo runs an exported NeuroMechFly body behind a fixed-rate sensory bridge and a native viewer. A separate experimental integration connects MaleCNS v1.0, 166,700 neurons and 24,469,412 signed edges including the nerve cord, adding no cross-specimen wiring. A paired control run disconnects the motor readout while the neurons keep running.

FLYFEAR

Furkan Çakır (@furkancak1r)

A first-person horror prototype in Godot 4.5 where a physical fly shares the room with you: a MaleCNS v1.0 simulation (166,700 neurons, 25,582,938 directed connections) influences its flight while a separate reward-updated decision layer picks which scare events fire. The repository ships the built game, the data, a separate Python simulation, tests and measurement reports, and documents a pre-training run of 48 synthetic players over 576 rounds. The README is in Turkish.

Flyhard

Mark Unthank (@MarkUnthank)

Trains a model built from 165,122 traced MaleCNS neurons and 25,563,197 measured connections to physically operate a steering wheel through a simulated fly foreleg, then drives a car in CARLA. The reported pilot passed 100/100 held-out stationary steering targets after 600 optimizer updates and 0/100 before, with a worst hold error of 4.85 degrees against a predeclared 7.45-degree limit; removing the foot grip removes over 99 percent of the steering response. The README states that visual driving, combined wheel and pedal control, and three-seed replication remain untested.

flyverse

tel∅s (@tel-0s)

Gives the MaleCNS v1.0 connectome colour vision, smell, taste and wind sense, a body that walks, jumps and flies, and a room with a table and fruit on it. The console shows a body camera, an orbit view, both retinal mosaics, antennal inputs and simultaneous population, motor and body readouts, with switches for simulated central-complex steering, anemotaxis and escape gating. The connectome is never trained or edited; everything else rests on a documented set of physiological assumptions.

GIGAZINE: ハエの脳マッピング公開直後の DOOM / マリオ64

GIGAZINE

Japanese-language coverage of the wave, published six days after the MaleCNS release. It walks through Alex Wormuth's Doom experiment (including the PPL101 dopamine cells stimulated on damage), Jessica Paquette's Super Mario 64 controller, Evan Smith's NeuroCraft Fly in Minecraft and a Bad Apple!! visualisation, and closes on the point most of the wave elides: the connectome shows structure and connections, not a complete functional replication of the biology.

Google Research: A connectomics milestone

Google Research (Michał Januszewski, Viren Jain)

The release-day post from the Google Research side of the collaboration, describing the male central nervous system reconstruction as the largest brain map by neuron count to date: over 166,000 neurons and 125 million synaptic connections, led by HHMI Janelia with Google Research and academic collaborators, published in Cell as a study of sexual dimorphism. It points to the Janelia download page and to Neuroglancer for viewing the volume. This is the announcement the entire September 2026 demo wave grew out of.

fly-brain (embodied whole-CNS, browser)

Lulzx

An embodied whole-CNS simulation that runs in a desktop browser: a 165,122-neuron MaleCNS v1.0 brain in a MuJoCo flybody body with a flyvis-trained compound-eye front end. Four views ship together, a connectome viewer with stimulable cell types, an algorithmic-structures page (ring attractor, expansion coding, motif census), an arena where you place sugar, odour and threats and watch a fly's brain in an inset, and an anatomy viewer. An endogenous-activity module supplies the spontaneous drive the connectome model lacks, entering only as synaptic input to identified descending neurons.

MaleCNS Cell Type Explorer

Reiser Lab, HHMI Janelia Research Campus

A browsable reference for the MaleCNS v1.0 cell types, generated from the dataset itself and published by the lab: one page per cell type with connectivity, region innervation and morphology. It is the resource the demo projects should be checking their named neurons against, since almost every game demo picks out descending neurons such as DNp01 or DNg100 by name without a way to see what those cells actually connect to.

mindmeld-with-fly

Pandu Sastrowardoyo (@Decentricity)

Drives a sparse MaleCNS reservoir with a live Muse EEG headset and renders the result in the terminal through libcaca, with a human scalp and band pane next to the fly visualisation. A synthetic EEG source lets it run without a headset. The README sets its own limits clearly: the reservoir dynamics are not biophysics, and the "fly EEG bands" are the spectral content of the digital reservoir rather than insect electrophysiology.

Neural Canvas (Fruit Fly Simulation)

Xenova (Hugging Face)

A standalone Hugging Face Space where you paint neurons, stimulate the network and watch an articulated Three.js fly respond, all locally in the browser. It retains 166,700 MaleCNS entries and 25,582,938 directed connections and runs a leaky integrate-and-fire model adapted from Shiu et al. on WebGPU kernels, with a JavaScript fallback. The card is candid that the walking, turning and flight animations are crafted and illustrative, that gains and thresholds were chosen for the demo, and that body motion never feeds back into the network.

OpenFly

marketcalls

The trading branch of the wave, aimed at the Indian options market instead of crypto: the full MaleCNS v1.0 simulation is wired through OpenAlgo to one strategy, an intraday short straddle on the current-month NIFTY expiry, sized with volatility-based stop losses and flat by 15:15 daily. Prices and option chains come from the user's own OpenAlgo connection into a local DuckDB, with no mock data. Paper mode is the default, live mode needs an explicit opt-in, and the README states that no profitable edge has been demonstrated.

Swat.

hrook1

A browser arcade game where you try to swat a fly and watch its escape circuit light up before you click. It runs a simplified spiking model of 6,000 traced MaleCNS v1.0 neurons and 1,275,994 directed connections (preserving 10,659,685 original synaptic contacts), feeding simulated vision into an extracted LC16-to-MDN retreat circuit whose activity influences evasive turns and bursts. Baseline cruising, flight animation and collision rules are authored game mechanics, and the README says so plainly.

▶@_lyraaaa_ on X (video poster, 2026-09-12)

Fly Brain Plays Beat Saber

@_lyraaaa_

A short video posted on X by @_lyraaaa_ showing a simulated MaleCNS v1.0 fly brain hooked up to Beat Saber. It carries the highest view count Know Your Meme lists for the September 2026 wave, roughly 22 million views and 84,800 likes. Dexerto reports that the creator later clarified the video does not yet show the model independently playing: its motor system had been trained to reproduce a recorded sequence, while visual reactions and actual playing patterns were still being developed through reinforcement learning. Read the view count with that in mind.

▶@nftechie_ on X (video poster, 2026-09-12)

Fly Brain Trades Bitcoin with $100

@nftechie_

A video post by Alex Wormuth (@nftechie_), the creator behind the earlier Doom livestream, giving a simulated fly brain $100 and using its neural activity to trigger buy and sell orders on Coinbase, with dopamine neurons stimulated whenever it profits. Know Your Meme reports about 3.4 million views. The author published Stonkfly the same day: prices become an RGB chart stimulating 3,335 brightness and 811 R8 inputs in the MaleCNS graph, a fixed readout proposes buy, sell or hold, and profit or loss stimulates PAM11 or PPL101 cells. It paper-trades by default and shows no profitable learning.

natverse/coconatfly README (GPL-3.0-or-later)

coconatfly

Gregory Jefferis (natverse)

An R package from Greg Jefferis that puts one uniform interface over the major fly connectomes so the same partner-query or cell-type comparison can be run across hemibrain, FlyWire, MANC, FANC, BANC, the male CNS and the male optic lobe. It is flagged as experimental and its API may still change, but it is already the workhorse for hemibrain-versus-FlyWire comparisons in the natverse community.

connectome_data_prep

Yijie Yin, University of Cambridge

Yijie Yin's (Cambridge) notebooks and scripts for turning raw connectome releases into analysis-ready sparse connectivity matrices and metadata tables, with axon/dendrite splitting via flow centrality. It covers the adult male CNS, BANC, FlyWire/FAFB, hemibrain and MANC as well as the larval connectome, and includes benchmarking code for the pathfinding and effective-connectivity analyses used in the Connectome Interpreter framework. No license file is present.

sjcabs/fly_connectome_data_tutorial (MIT)

Fly Connectome Data Tutorial (SJCABS)

SJCABS winter school (Sven Dorkenwald & Alexander Bates)

Course material from the San Juan Winter School on Connectomics and Brain Simulation, written by Sven Dorkenwald and Alexander Bates, that walks students from loading data to morphology, direct and indirect connectivity analysis in both Python and R. Its most useful feature is a harmonised metadata schema and a public cloud bucket covering BANC, FAFB, the male CNS, MANC and hemibrain, so the same notebooks run across all five datasets.

flycoin

ad7584

A token experiment: a Python simulation of 165,122 neurons from the September 2026 male CNS connectome is wired to token-launch platforms on Solana and Robinhood Chain. Market signals such as momentum and liquidity are mapped onto sensory populations, and launch or abort decisions are read from command neurons with known roles (proboscis extension means launch, the giant fiber escape circuit means abort). Single-commit repo with no stated license; the same account also authored commits in flycoinrh.

Listed for information only. No endorsement, no referral links.

flycoinrh

fruitflydev

A token experiment in which a neuron-by-neuron simulation of the 165,122-neuron male connectome (data pulled from the public CC-BY cloud bucket) drives a browser: screenshots pass through 892 retinotopic columns, activity propagates across the network, and motor output moves a cursor on a launchpad on Robinhood Chain, an Arbitrum-based L2. Later commits add dopamine-gated Kenyon-cell plasticity, an autonomous browsing mode and a narrator voice. Code is MIT; 30 commits over 2026-09-10 to 09-11, several by the flycoin author ad7584.

Listed for information only. No endorsement, no referral links.

FlyWire Codex

Princeton Neuroscience Institute

A browser-based explorer developed at the Princeton Neuroscience Institute that lets anyone search, filter and visualise large connectomes entirely in the browser, with no local install or bulk download. Beyond FlyWire's own FAFB v783 (139,255 neurons) it now serves BANC v888, Janelia's MANC v1.2.1, the male optic lobe (MAOL v1.1) and the male CNS v1.0, and had passed 60,000 registered users by early 2026. The open-source code lives in the murthylab/codex repository under Apache-2.0.

Gizmodo: Fruit Fly Brain Plays Doom and Super Mario 64

Gizmodo

News piece by Bruce Gil covering the wave of hobbyist simulations that followed the September 3, 2026 release of the male fruit fly CNS connectome (MaleCNS v1.0) by Google and HHMI Janelia. It profiles Alex Wormuth's Doom-playing fly brain, Jessica Paquette's Super Mario 64 run, a Minecraft port, and posture and animation experiments. The article frames the dataset as the largest brain map by neuron count, at over 166,000 neurons.

Janelia News: Male Fruit Fly CNS Connectome

HHMI Janelia Research Campus

Janelia's own announcement, dated October 6, 2025, of the first complete wiring diagram of a male fruit fly's brain and nerve cord, covering more than 166,000 neurons. The work was done by HHMI Janelia with the MRC Laboratory of Molecular Biology, the University of Cambridge and Google Research, with Gerry Rubin and Greg Jefferis among the researchers quoted, and was posted as a bioRxiv preprint. Rubin stresses that it enables the first sex-by-sex comparison of a socially complex animal, and the data is free to researchers worldwide.

Know Your Meme: Fly Brain Simulations

Know Your Meme (Literally Media)

Know Your Meme entry documenting the viral trend of hooking the MaleCNS v1.0 fruit fly connectome, released September 3, 2026 by Janelia's FlyEM team, the Cambridge Connectomics Group and Google Research, up to games and other environments. As read on September 13 it tracks a YouTube Minecraft video from September 7 with 241,000 views, a Beat Saber clip with 22 million, a Coinbase trading video with 3.4 million and a driving-simulator clip with 1.5 million, plus a talent-manager sim, a Twitch streamer persona and a Deadlock run. Still marked as a submission under review.

natverse/malecns README (GPL-3.0)

malecns (R)

natverse / Jefferis lab with Janelia FlyEM

An R wrapper that gives natverse users convenient access to Janelia FlyEM's whole male central nervous system connectome (the public male-cns:v1.0 snapshot on neuPrint), including neuron meshes, annotation columns that cross-reference FlyWire and MANC cell types, and transforms between datasets. It grew out of the collaboration between the Janelia FlyEM team and the Cambridge Drosophila Connectomics Group and has been developed since late 2021.

▶@barrelshifter on X (video poster, 2026-09-12)

Fly64 (MaleCNS plays Super Mario 64)

ornata (Jessica Paquette, @barrelshifter)

Jessica Paquette's proof-of-concept that pipes Super Mario 64 frames (from a decompiled SM64 build) into a simulated visual system of a ~100k-neuron MaleCNS v1.0 model and reads controller inputs off named descending neurons: DNg100 for movement, a DNa02/DNg13 difference for steering, DNp01/DNp10 bursts for jumping. There is no learning or reward signal, and the README says the fly mostly walks into walls and gets stuck; the author calls it 100% vibe coded. Covered by Gizmodo on 2026-09-08.

neuPrint

Janelia FlyEM (HHMI)

Janelia's connectome analysis ecosystem: a Neo4j-backed graph database plus the neuPrintExplorer web front end and an HTTP API for querying neurons and synaptic connectivity. It is the official home of the hemibrain, MANC and male CNS datasets from the FlyEM team, and the ecosystem was described in a 2022 Frontiers in Neuroinformatics paper by Plaza et al.

neuprint-python

Janelia FlyEM (HHMI)

The official Python client for the neuPrint service, letting you pull neuron metadata, connectivity tables and skeletons from Janelia's connectome databases into pandas without writing Cypher by hand. First published on PyPI in January 2020 and still actively released (0.6.3 in July 2026), it is installable via pip, conda or pixi.

Fly Lab (Ableton Live)

Apolotary (Bektur Ryskeldiev)

An Ableton Live extension for macOS that turns the 1,045-neuron MaleCNS motor subset (borrowed from DesktopFly's data) into MIDI: simulated flies bounce around a Three.js scene and their collisions, contacts and motor values trigger notes or modulate ambient parameters across five modes, including a Dark Lab mode with a small learnable 70-weight readout. The author is careful to separate the measured circuit from the composed harmony, describing the flies as particles dressed up as flies. Written up on Sonic Field on 2026-09-10.

Wikipedia: Drosophila connectome

Wikipedia (Wikimedia Foundation)

Community-written encyclopedia article that serves as a one-stop overview of fruit fly connectomics, explaining why Drosophila is used as a model and walking through the major datasets from the 3,016-neuron larval brain to the adult hemibrain, FlyWire, the FANC and MANC nerve cords, and the 2025 whole-CNS BANC and male CNS reconstructions. It also touches on how wiring structure relates to behavior. Text is under CC BY-SA 4.0; last edited August 11, 2026.