FlyWire (FAFB v783)

flybench

brandoncho369

A reflex benchmark that asks the question the demo wave mostly skips: does the simulated fly still do the things a real fly is known to do? It ships a suite of behavioural tasks with literature citations, a reference leaky integrate-and-fire simulator and a scoring harness, so any set of model parameters gets a comparable number. The framing is direct about why it exists, that every Minecraft or Doom demo had to guess at synaptic weight, global gain and inhibition and then hand-tune until something looked alive.

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.

Eon fly-brain

Eon Systems PBC

Eon Systems' open re-implementation of the Shiu et al. (Nature 2024) leaky integrate-and-fire whole-brain model, covering roughly 138,000 FlyWire v783 neurons and 5 million synapses and runnable on Brian2 (CPU/CUDA), PyTorch, NEST GPU and GeNN backends so users can stimulate or silence any population and watch activity propagate. In a March 10, 2026 update the company reported coupling this brain to a NeuroMechFly v2 body in MuJoCo, describing grooming, feeding and foraging behaviours emerging from the closed sensorimotor loop, which it calls the first embodied fly upload.

navis-org/navis docs (GPL-3.0)

NAVis

navis-org (Fly Connectomics group, Cambridge)

A general-purpose Python library for handling neuron skeletons, meshes, dotprops and image volumes, with 2D/3D plotting, morphometrics, NBLAST similarity and template-brain transforms built in. Developed in the Cambridge fly connectomics community as the Python counterpart of the R natverse, it plugs into neuPrint and, through the fafbseg extension, FlyWire/FAFB. Performance-critical pieces have been moved to Rust via navis-fastcore.

Fly Brain Tetris

alexeygrigorev (@alexeygrigorev)

A Brick Game handheld in the browser where a fly works the buttons, with a second panel showing responses of a simplified linear model derived from the FAFB v783 connectome. Only a 32-channel readout learns, fitted by cross-entropy optimisation over 24 generations with 64 candidates, four games each and ten elites; the compiled 32x6 transform stays fixed. That transform, its pseudoinverse, the neuron IDs and the graph provenance are committed as JSON and pinned by SHA-256. The overview ends by saying what it is not: an artificial policy over engineered board features.

Fly Garden

carsonshicks2016-beep (@carsonshicks2016-beep)

A local 3D arena for one fly that persists between sessions, its brain the full FlyWire v783 import (138,639 neurons, 54,492,922 represented synapses, no threshold and no reduced substitute) run in Brian2 on a NeuroMechFly 2.1 body at a 100 microsecond physics step. The boundaries section is why to read it: odour-guided action selection is not established, the gait generator and escape reflex are engineered, and learning is explicitly not demonstrated. A staged report records 60 full-brain trials against 40 physical controls where the away-directed criterion failed and DNp09 stayed silent.

Fly Poker

EvanGruhlkey (@EvanGruhlkey)

Heads-up no-limit Hold em against a fly in a full-screen casino: both sides start at 100 big blinds, blinds are 0.5 and 1, stacks carry between hands and the button alternates. The opponent is a network derived from the checksum-pinned FlyWire graph, trained on a rented L4 by first copying an equity teacher and then by self-play, running locally in a browser worker. Raw connectome tables and weights are kept out of git, the FlyWire terms (CC BY-NC 4.0) are stated as separate from the MIT reference code, and the MaleCNS manifest is flagged as carrying an unresolved checksum.

FlyBrainLab (Agentic Scientific Discovery)

JonasMayerDev (@JonasMayerDev)

A hackathon entry for the Databricks "Agentic Scientific Discovery" challenge (Munich, October 2026) that hands an LLM agent team the experiment loop: plan a test on the DNg02 descending neurons, run sham, stimulation and disconnection arms over seeds 42 to 44 on the full FAFB FlyWire v783 graph (138,639 neurons, 15,091,983 processed connection rows) with pinned Shiu et al. code in Brian2, then pick the next test from the outcome. Parameters and targets were sealed beforehand, and the README states that an existing RL policy holds the body up in the 200 ms window tested.

Synaptera

omeruk (@omeruk)

A whole-brain leaky integrate-and-fire model of the FlyWire v783 connectome (138,639 neurons, 54,492,922 synapses, Brian2) flown in closed loop on a NeuroMechFly/FlyGym MuJoCo body, against criteria committed before the runs they decide. The conclusion stays narrow: the only behavioural decision coming from the connectome is feeding, read out as MN9 above 10 Hz, and its trigger is a hand-made shortcut because the leg sugar neurons chosen by connectivity leave MN9 at 0 Hz. DNp15 failed its own validation, DNg02 never spiked, and no brain-only run landed.

brainlab

@githabideri

A repository that examines other people's connectome projects instead of adding another one. It keeps a written evaluation method, an index of circuit files with their provenance, and dated frozen reports. The first report audits FlyBridge, a third party's trained connectome agent built on a 1,536-neuron, 42,921-connection olfactory pathway of FAFB v783, grading each claim as real, assisted or untested from the transcript, the key frames and above all the repository, and noting where the video and the repository disagree.

Fly Abstraction Lab

@maggogerka

A bench for one question: does connectome topology change how a reservoir transfers numeric abstractions, compared with matched graph controls and ordinary networks. Four controls sit beside the real FAFB v783 graph, degree-preserving, weight-shuffled, direction-shuffled and Erdos-Renyi, each keeping the same input and output node mappings, and the baselines are a random-graph reservoir, a GRU and an MLP. Splits are deterministic manifests with hashes, the pilot dataset is a 768-row UCI table, and the README says plainly that a model difference would not establish animal cognition.

flybrain (Go + WebGPU)

@dsbaha

A leaky integrate-and-fire simulator of the FlyWire wiring, 138,639 neurons and 54.5 M synapses, written in Go against WebGPU on Vulkan, with a pure-Go CPU backend whose arithmetic is bit-identical and a self-test that checks it. It reports its replication rather than claiming it: the reference sugar experiment gives 0.12 Hz and 457 active neurons in Brian2 and 0.13 Hz with 369 active here, at a 1 ms step instead of 0.1 ms. A brain server speaks a small TCP protocol so a separate 3D arena can run up to four embodied flies in one odour world.

Let It Flyppen

Giuseppe Bellamacina (@GiuseppeBellamacina)

Five copies of the FlyWire v783 brain, one per instrument, rehearse a song on a 3D stage in the browser. Each gets the bar and beat position as spikes into 1,055 Johnston's organ neurons; a startup probe finds the roughly 1,700 neurons the input can actually drive and simulates only those, at about 80 ms of compute per sixteenth note. The connectome stays frozen and only a linear readout over 616 output neurons is fitted online by recursive least squares, which takes the drum part from 0.47 F1 on the first rehearsal to 1.00 on the second.

NeuroPest

@IrohAmca

A desktop fly whose behaviour comes out of a leaky integrate-and-fire run of the FlyWire v783 wiring, with a 146-neuron toy circuit as the lightweight fallback. The cursor becomes three sensory streams: approach speed drives backward walking through MDN or escape through the giant fibre DNp01, bearing drives the DNa02 turns, and hunger feeds tonic current into DNp09. What sets it apart from other desktop flies is an optional vision mode sampling real screen pixels through ommatidia and medulla columns, and screen-edge collisions that punish via PPL1 so the mushroom body learns the edges.

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.

Drosophila melanogaster (auditory VST)

Lazirko Records (@Maksym-Lazirko)

A JUCE VST3 effect and standalone app in which incoming audio drives a FlyWire v783 auditory subgraph of 731 neurons, 7,056 directed pairs and 38,765 detected synapses, embedded with no runtime download. Audio enters through Johnston's organ JO-A and JO-B, and downstream AMMC and central auditory rates control a filter while an OpenGL view shows the same spikes. The data notes are strict: only released detected synapses are used and never membrane contacts, JO transmitters are not forced cholinergic, and seven central cells with no detected JO path get no invented drive.

fly-brain-honeypot

S4MU3LN3 (@S4MU3LN3)

Wires a Cowrie SSH honeypot to a Brian2 simulation of the FlyWire connectome. Each attacker command stimulates the looming detectors LC4 and LPLC2, the signal propagates through the measured wiring to the Giant Fiber, and that neuron's firing rate becomes a panic level between 0 and 1 that decides when to raise an alert and when the fake filesystem swaps in more convincing bait. The README separates Cowrie, which has existed for over a decade, from the three parts added here, and states that the comparison against a plain rule table has not been run, so no effectiveness claim is made.

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.

FlyBrain Tic-Tac-Toe

Grzegorz Oleksy (@GrzegorzOle)

A web page where each visitor teaches their own fly to play tic-tac-toe from no memories at all. The learning centre is all 2,597 Kenyon cells of the right mushroom body taken from the FlyWire wiring diagram, with their real input synapses, output neurons and dopamine compartments. For each candidate move the fly imagines the resulting board, a sparse set of Kenyon cells fires and recalls how good it was, and after PAM reward or PPL1 punishment dopamine the prediction error decides which synapses move. An exam of 100 games with learning switched off measures what stuck.

FLYNN reproduction + BC comparison

aymen-000 (@aymen-000)

A reproduction of the FLYNN paper (arXiv:2607.00025), which steers a two-camera wheeled robot in MuJoCo with a leaky RNN whose recurrent weights are the FlyWire FAFB v783 connectome, extended with a comparison the paper does not run: DAgger against plain behaviour cloning on the same agent, each scored in-distribution, with the left camera only, the right only and both off, and out of distribution on obstacle density, arena size and an unseen texture. Model, environment and analytic planner come from the authors' fly-gym release; the repository reports no numbers of its own yet.

NeuroWalker

Arjunsk1291 (@Arjunsk1291)

Modulates an 18-DOF MuJoCo hexapod with a 10,000-neuron spiking subgraph of FlyWire carrying 797,577 synapse pairs, benchmarked over ten seeds per cell against a tripod-gait CPG and a PPO residual policy, then with disabled legs, locked joints, reduced torque and sensor dropout. On flat and rough ground it walks slightly further than the CPG, but on a 10-degree slope it falls in 3 of 10 runs where the CPG falls in none, and both collapse from 15 degrees while PPO keeps walking. The README marks the ROS 2 nodes, Docker image and CI as written but unverified.

Fly Doctrines

Pr1nted (@Pr1nted)

Runs the whole FlyWire connectome, 138,639 neurons and 15,091,983 synapses under the Shiu et al. leaky integrate-and-fire model, as a WebAssembly mod playing one country in the strategy game Open Doctrines. Four firing rates carry the position in; 200 ms later the 1,299 descending neurons pick the move. Three measurements shaped it: pruning to sense-to-descending paths keeps 97.7% of neurons, so lossless packing was used instead; a few always-active descending neurons made the answer action 0 in all fifteen test positions until the decoder read each neuron's own baseline; a busy turn trapped.

Fly Brain Bot

Serhii (@kh-serhii-ai)

A Ukrainian-language Telegram bot that runs the whole 138,639-neuron FlyWire v783 brain per message and reports what the fly did, computed by code from three validated output neurons rather than narrated by a language model. The speed trick is exact, not approximate: a neuron whose closed-form voltage maximum stays below threshold is skipped until new input arrives, and a test checks the result is spike-for-spike identical to naive stepping. It reproduces the published sugar dose-response, bitter suppression and grooming results.

FlyBrain iOS

pr4yhk6zt6-wq

Packs the whole FlyWire FAFB v783 brain into an iPhone: 139,255 proofread neurons and 2,700,513 directed connections as a leaky integrate-and-fire network in seven Metal compute kernels, drawn as a live point cloud, with the phone camera feeding the photoreceptors. The headline finding is a measurement: the brain needs about 21 MB of GPU memory, not the gigabytes expected, so no cropping or streaming is needed. The README corrects three numbers it started from, including that FAFB is a brain volume with no nerve cord, and says CI only proves the app compiles.

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.

FlyWireGBA

LakoMoor

A Game Boy Advance ROM with a fly you can keep as a pet, and the unusual constraint is the hardware: 256 KiB of work RAM means a 128-neuron, 2,048-edge subgraph from FlyWire FAFB v783 rather than a whole brain. The extracted circuit runs sugar sensing through to MN9 and gates feeding; walking, flight and grooming are a hand-written heuristic controller, and the scope section says so. It also states that its 33.3 ms integer steps do not reproduce the calibrated timing of the model it borrows from.

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.

Flight-test the fly

aryawidjaja (@aryawidjaja)

Tests the fly's T4/T5 to HS/VS to DNa02 steering pathway as an aircraft yaw damper, the way flight-control laws are tested: frequency response, loop margins, MIL-spec Dryden turbulence and neuron loss, all against degree- and sign-preserving shuffles, the bare airframe and a classical damper. Phase 1 is in. At 1 Hz the real wiring ranks first of twenty, with coherence 0.980 against a shuffle median of 0.31 and gain 0.666 against 0.075 Hz per deg/s. The plant is JSBSim's c172x. Later phases are re-running after an outside audit; FINDINGS.md marks every line as measured, cited or unchecked.

FlyBrain · Flappy

programmingWTF (@programmingWTF)

Runs the FlyWire FAFB v783 connectome, 144,837 neurons and 15,023,799 synapses, as a frozen network with zero learnable parameters, letting its looming-escape pathway, LC4 and LPLC2 into the DNp01 giant fibers, fly a Flappy Bird clone. The ablation carries the claim: cutting that pathway or shuffling it degree-preserving gives no wing flaps at all rather than a lower score, against 100.8 points for the real wiring over 40 games. A long table logs what failed: one-ply lookahead, ceiling boosts, every gating variant. The page lags the bench only because it cannot feed the brain fast enough.

FlyWire Pong

zonzujiro (@zonzujiro)

A page where 1,230 states from chosen FlyWire FAFB v783 neurons, joined by 8,515 exported directed edges, play real Atari Pong against the game's own opponent; the emulator is the official ALE WebAssembly build, run locally in the tab. An inspector pauses on the last decision, steps through its twelve recurrent updates, searches neurons by FlyWire ID and compares trained with pre-PPO weights. The README draws the lines: the checkpoint won 43 of 60 Python games, which it says does not establish a causal advantage of fly topology, and the encoder, dynamics and decoder are engineering choices.

Drosophila-Lang

Universidad Camilo José Cela (@UniversidadCamiloJoseCela)

An esoteric, Turing-complete programming language whose runtime is a fly brain: FlyWire v783, 138,639 neurons and 2,700,513 connections of five synapses or more. There is no RAM and no clock. Each program state is assigned to a real identified neuron (an antennal-lobe projection neuron for a named glomerulus, Kenyon cells, MBONs, PAM and PPL1 dopamine cells, DNa02, the proboscis motor neuron MN9), each variable is the strength of a Kenyon-cell-to-MBON synapse, and the program ends when the giant fibre DNp01 fires. Anatomy sets the limits: 16 variables, because there are only 16 PPL1 neurons.

Fly Brain Lab

roanbrasil (@roanbrasil)

A controlled experiment, reported as a null result, on whether the fly's real escape wiring helps a simulated fly dodge a flip-flop swat. Five brains share one body and one training budget: a plain MLP, the escape circuit cut from FlyWire v783, the same wiring shuffled while keeping each neuron's degrees, and frozen-synapse versions of both. Five seeds each, 1.97 M steps, then 1,024 identical swats per seed. The trained brains tie within the seed spread (63.8% MLP, 62.2% fly, 59.7% shuffled), and with synapses frozen at the connectome's counts neither wiring solves the task (25.6%, 27.2%).

Fly Reflex

murilopinho (@murilopinho)

A fly plays Friday Night Funkin' on a real Linux desktop, with its brain drawn live over the game. The screen is captured through a Wayland portal, the falling notes become visual stimulation, a 668-neuron FlyWire circuit with 18,968 real synapses runs as a spiking network at 1 kHz, and the motor side presses the actual arrow keys. Circuit, brain point cloud and sprite are reused from DesktopFly at a pinned commit and credited. The author keeps the limits in front: the project is labelled shelved, and at difficulty 5 the brain still goes into uncontrolled activity.

Systolic Neural Accelerator on FPGA

duydat291007 (@duydat291007)

Runs a 256-neuron subcircuit of the FlyWire FAFB v783 connectome on a Basys 3 board, closing the loop around a virtual fly that eats when sugar neurons reach the proboscis motor neurons and jumps when looming detectors reach the giant fibre. Weights are sign of transmitter times min(127, twice the synapse count) over 2,265 synapses, with no per-synapse tuning. Post-route at 100 MHz the 4x4 systolic array takes 28,937 cycles per update against 65,800 for a serial baseline. The ablation arm: over 40 trials the circuit eats 35 and escapes 39; removing all synapses gives 0 and 29.

Fly Xenotype

whydew (@whydew)

A RimWorld 1.6 mod whose Fly colonists sleep on a circuit pulled from the FlyWire v783 connectome instead of a hard-coded bedtime. A build script extracts the circadian-to-sleep-homeostat pathway (36 cell types, 260 neurons, 192 connections, about 29,000 synapses: s-LNv/LNd/DN1p/DN1a clock cells, anterior-bulb TuBu, the ER5 ring homeostat, ExR1 helicon cells, ExR3, the dorsal fan-shaped body) into C#. The README says the wiring is measured but the game's couplings into it are modelling choices, and that neuropeptides and learning are not modelled.

Grey Leno Fly Brain

SpikeCalls (@SpikeCalls)

A whole-brain fly model puppeteers a late-night talk-show host in the browser. The brain is all 138,639 FlyWire v783 neurons and 15.1 M signed connections, run as leaky integrate-and-fire cells with a 1.8 ms synaptic delay in a Web Worker in plain JavaScript; the body is a physics ragdoll on a three.js stage. Throw tomatoes, roses or sugar and each event becomes Poisson spikes on identified sensory cells. Nothing at the motor level is scripted: the host walks because P9 fired, backs off a heckler because MDN fired, and flinches when the giant fibre DNp01 crosses threshold.

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.

MelanoGraph

Akasha Corporation (@AkashaCorporation)

A whole-brain simulation substrate built around preregistration and provenance, asking what circuit organisation adds to social learning. It loads the FlyWire-derived connectivity published with the Shiu et al. model, runs leaky integrate-and-fire dynamics, and pairs every experiment with a degree-preserving rewiring control. Each step was sealed by SHA-256 before it ran. The reproduction check is reported as partial, not rounded up: a whole-brain sugar run lands within 7% of the upstream output on active neurons and MN9-right but 21% high on MN9-left.

NeuroFly

spicypunch (@spicypunch)

A macOS desktop pet that is unusually willing to be checked. A fly floats over the desktop, you drop food or cast a shadow from the menu bar, and a status window shows the sensory input, neuron activity and body output of that moment. Behind it 139,255 FlyWire v783 neurons and 15,091,983 directed connections are computed with Metal, from a pinned data version verified by SHA-256. The validation section is dated and specific: 29 core tests, PN firing 875.08 Hz when hungry against roughly 0.000037 Hz after satiety, and three sensory-blocked control arms matching the no-food run exactly.

Subject 783

RootVandal (@RootVandal)

A bilingual browser piece that stages the whole FlyWire v783 brain (138,639 neurons, 54.5 M synapses, the Shiu et al. leaky integrate-and-fire model computed spike by spike in a Web Worker) as a subject strapped into a chair in an underground lab you operate from a dark booth. Fifteen experiments drive named sensory cells and the model answers: 32 labellar sugar GRNs push the proboscis motor neuron MN9 to about 75 Hz, while 42 bitter GRNs leave it silent and suppress feeding to 0 Hz even with sugar present. Overload the brain and the neurons burn out unless you reset.

20fly8

dtecx (@dtecx)

A mushroom body cut from FlyWire v783, 5,177 Kenyon cells and 62,261 plastic synapses onto output neurons, smells the four boards 2048 could hand it and learns which promise sugar, live in the browser. Over 500 games per condition the trained fly scores 6,986 against 1,594 naive and 1,103 for random moves; rewire the nose and it drops to 925, below random, and shuffling its learned synapses puts it back at 1,287. Both controls are buttons on the page. It also explains why the spiking whole brain was dropped: 70-78% of Kenyon cells fired for any input, leaving no sparse code.

fly-brain-sim

kornel77777 (@kornel77777)

Download scripts, a reproducible DuckDB build, validation tests and a 3D browser viewer for the FlyWire FAFB v783 release, with a simulator on top. The tests check it against Shiu et al.: stimulating their 20 sugar-sensing neurons makes the proboscis motor neuron MN9 fire at about 100 Hz with about 380 neurons active, against their roughly 400. It also states the flaw it has not fixed: the 293,762 Kenyon cell to Kenyon cell connections are treated as excitatory, so activity entering the mushroom body saturates. A kenyon_cell_share figure is reported so this stays visible.

Fly Connectome on a GPU

XYZ-WEB3 (@XYZ-WEB3)

A FlyWire whole-brain model, 138,639 neurons and 15 million connections, rewritten as custom CUDA kernels so one second of brain time takes about 0.02-0.06 s on a laptop RTX 4070, then given senses and a NeuroMechFly body. The authors report that the original model runs away: 5 Hz into one olfactory glomerulus leaves 8,162 neurons active, which they damp with synaptic fatigue and slow adaptation. Conditioning on its 62,261 KC-to-MBON connections gives +11.4 ± 1.9 Hz in 10 of 10 flies against +0.3 Hz unpaired, but they state the memory never reaches the steering.

Fly vs Fly

Grisha Gvadzabia (@grishahq)

Two agents share one fixed 138,639-neuron FlyWire v783 spiking model and differ only in a trained output interface, then play 15x15 freestyle Gomoku; the browser replays a recorded 37-move game with the activity measured during each move. An encoder pulses 450 anatomical input neurons, the model runs 12 ms per decision, and gradients never pass through the wiring. Held-out tables report 200/200 and 199/200 immediate wins and 100/100 against a random opponent, but 100/100 versus 75/100 against a frozen heuristic. The README says this certifies the demo criteria, not expert play.

Flybrain

Dhruv Agrawat (@dhruvagrawat)

A NumPy and Numba reimplementation of the Shiu et al. whole-brain model, 138,639 neurons and 15.1 million connections, one simulated second in about 9 s on a single core, with a WebGL lab that replays experiments spike by spike and a command line taking sentences like stimulate sugar at 200 hz. Eight browser apps hand control to the fly's own neurons, each with an autopilot and a scrambled-wiring control; one is built around telling the two apart. Stimulating sugar taste activates about 430 neurons and drives the feeding motor neuron MN9 at about 115 Hz.

FlyLab

viniciosix (@viniciosix)

A static Portuguese-language lab over a deliberately hub-biased sample of FlyWire FAFB v783: 420 neurons, 5,742 directed connections and 338,945 synapses, taken as the highest weighted degrees among connections of at least five synapses. The worker steps 5 ms with weights from the log of the synapse count, and the page says what that costs: every signal is effectively excitatory, the neurotransmitter field changes nothing, no parameter was fitted to biology, and the rates shown are the model's, not measurements. The 3D view is a projection of reference coordinates, not a mesh.

PilotFly

silas1011 (@silas1011)

Flies a drone in a commercial FPV simulator by working a virtual RadioMaster TX12 that Windows sees as an ordinary controller. The picture becomes spikes in two flyvis eyes of 721 ommatidia each, then 2,384 FlyWire v783 neurons and 36,098 connections (145 lobula plate tangential cells, 825 descending neurons, 1,414 between them), then one trained layer standing in for the wing muscles. The last training stage is unfinished and the fly has never flown in the game: over 64 flights in its own simulator it takes off and never crashes, but keeps climbing and leaves the area in 28-34% of runs.

Spikecast

Padmanabhan (@padmanabhan-r)

A 138,639-neuron FlyWire spiking brain walks a road while an external typed decision model is handed ten facts five times a second and picks one of six actions. Nine come from the road and body, the tenth is one word read from the mushroom body's synapses. The driving question never names an object or mentions training, and a test checks its text. In the recording the fly walked into toxic waste once and went round it the second time, as in four test runs; with learning off it walked in four times out of four. The README calls five runs and one control a demonstration, not a statistic.

BioNose-Edge

Ali Rashidi (@Ali-Rashidi-80)

An olfactory front end for gas sensors on microcontrollers, in no-std Rust with no heap allocation, and an unusual case of a project whose headline is that the fly circuit lost. On 13,535 unseen samples from the UCI gas sensor drift set, spanning 36 months of real sensor aging, a FlyWire-derived layer of 2,048 Kenyon cells reaches 52.4 percent while the same layer with shuffled wiring reaches 53.3 and the authors' own cosine tracker reaches 67.4. Their reading is that the sparse binary code discards geometry a floating-point unit could keep, so the mushroom body stays only for ablation.

ChessFly

znatgost (@znatgost)

Takes the input wiring of a real mushroom body from FlyWire v783, 285 olfactory projection neurons, 5,177 Kenyon cells and 21,509 connections, and shows it a chessboard instead of odours. Only the Kenyon cell to output neuron synapses change, under a dopamine-like prediction error, and the fly teaches itself by self-play in a browser tab: by 5,000 games it prices a knight at 3.1 and a queen at 11.0 pawns unprompted. The headline is negative: the measured wiring rates 1690 against 1695 for the same cells with inputs shuffled, and the earlier all-random design is about 60 points stronger.

Fly Tamagotchi

ameerul-muminin (@ameerul-muminin)

A pet fly whose eating is decided by wiring rather than a rule. A phone tap is sugar, a shake is bitter, and the fly feeds only when the proboscis motor neuron MN9 passes 20 spikes per second in a re-built Shiu et al. 2024 model on FlyWire release 630. Give it both at once and it mostly refuses, which also falls out of the wiring. The authors report MN9 at 68.4 against 67.0 in the original, a shuffled-wiring brain that never eats, and a 19,698-neuron slice matching the full brain. Each state is labelled brain or game rule; hunger, light, mood and fainting are game rules.

Flyer

PixeLabs (@thepixelabs)

Asks a whole-brain FlyWire model, run with the Shiu et al. 2024 equations, what it will eat. Sugar stays on and each of 63 other tastes and smells is added in turn while the proboscis motor neuron MN9 is measured, with promising channels re-tested and confirmed under fresh noise. Six searches from different noise gave the same answer: water, low salt and one pharyngeal channel, worth about 12 to 16 extra spikes per second. No smell was ever picked; of 53 smells, 18 pushed feeding down and 35 did nothing, which the authors call a result about eating, not about what a fly likes to smell.

Doodle Fly

@dtecx

A Doodle-Jump-style game whose left and right presses are the spike-rate difference of six descending neuron types, with the whole FlyWire v783 brain simulated in the browser and no trained readout. The interesting part is that it ships its own controls: with the eyes swapped the fly falls 41 to 44 times in two minutes instead of 0 to 1, and blinded it hops in place, both switchable in the app. The target platform is picked by the game and fed to LC10a small-object detectors, which the README lists as a hand-made interface alongside the button mapping.

Fly Brain (multi-backend benchmark)

@TheOneeeeee

Answers a question most projects leave unasked: which simulator should you run a whole-brain connectome model on? It runs the same leaky integrate-and-fire model of the FlyWire brain across Brian2, Brian2CUDA, PyTorch, NEST GPU and GeNN, sweeping durations from 0.1 to 1000 seconds and 1 to 32 trials, with optogenetic-style activation and silencing as the manipulations. The README also notes a real packaging constraint, that Brian2GeNN pins an older Brian2 and so needs its own environment. A pygame foraging demo on a roughly 10,700-neuron subgraph sits on top of the same code.

Fly Brain Zero-Shot

Vibhakar Mohta (@vib2810)

Asks whether the mapped wiring copes with a body it was never tuned for. FlyVis eyes feed the Shiu et al. whole-brain model on FlyWire v783; the brain's own DNa02 turn neurons steer a NeuroMechFly body toward dark poles. Two legs are removed mid-walk and each fly is cloned at that moment, so injured and intact runs share a history. Injured flies reach as many poles as intact ones (3.14 vs 2.96 per 10 s). Scrambling the connections with neuron and edge counts held fixed drops DNa02 from about 30 Hz to 2 Hz and the fly misses. The leg rhythm, the optics and two gains are the authors' own.

Fly With Me

@izntariq

Sound is an input the fly actually has, and this project uses it: audio from two decks is split into bands and fed to 12 subtypes of Johnston's organ, the fly's hearing organ, on the left and right. The full FlyWire v783 brain then runs as a spiking network and its 1,409 descending and motor neurons work a DJ mixer, with the crossfader following the left-right descending imbalance, the giant fibre DNp01 triggering a beat roll and bitter-driven neurons including the moonwalker MDN triggering a backspin. A bundled script checks the simulator against the published Shiu et al. model.

FLY67

Ruben Znatgost (@znatgost)

A from-scratch JavaScript rewrite of the Shiu et al. leaky integrate-and-fire model that runs all 138,639 FlyWire neurons in a Web Worker, faster than real time, with every spike drawn in 3D. What sets it apart is the validation table: against the authors' own Brian2 code on the same sugar stimulus it reaches r = 0.9996 over all neurons, and the README documents the Brian2 subtlety that silently discards synaptic input during the refractory period, which inflates downstream rates by about 50% if missed. The 6-7 animation is labelled as scripted, not a connectome output.

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.

prettyFlyfora

@zeebie-the-zebra

An ethogram simulator on FlyWire FAFB v783 that is unusually candid about the hardest part of these projects: deciding what each descending neuron should do. It does not map one neuron to one muscle. In the small network, 18 motor cells get hand-curated roles (thrust, steer, brake, arousal) with prefix heuristics as a fallback; for the full brain's roughly 1,301 motor neurons across 471 types, roles were assigned offline by driving each sensory modality and recording every motor type's response, and the resulting atlas ships as a CSV. The published package is a runtime only.

Uzum Fly

@d3xr

Product search as an application domain for the olfactory circuit, and unusual in using measured wiring rather than the random projection the FlyHash literature assumes. A product's name and category become a 384-dimensional text embedding, PCA reduces it to 51 components, each assigned to one glomerulus, and the measured FlyWire v783 projection-neuron to Kenyon-cell matrix produces activity in 4,678 Kenyon cells of which the top 5%, 234 cells, form a sparse code. The page is explicit that the product odour is invented and that the model is not trained on real clicks.

cerebro (cerebro-mosca)

Allan Matheus Silva Santos

An audit of the published whole-brain fly model, not another demo. A numba rewrite reproduces Brian2 spike for spike (rate correlation 0.999) about 1000x faster, which makes the checks affordable: one mislabelled neuron, the left il3LN6, turns an inhibitory cell excitatory and inflates the sugar response from 377 to 8,323 neurons, and an odour lights 66% of Kenyon cells where the fly uses 5-10%. FlyWire and BANC agree only up to rho 0.32 across flies, and BANC's own neurotransmitter consensus contradicts its neurons in 68 cell types. All three were reported upstream.

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.

Flippy la Mosca

ArchelKrozt

A Spanish-language pixel-art arena where FlyWire v783 (138,639 neurons, 15 million connections) runs neuron by neuron at roughly real time on an 8 GB M1 laptop in about 1.5 GB of RAM. Food, bitter, CO2, heat, wind and light are placed by hand and enter the sensory neurons; floating panels expose vision, memory, live firing and motor commands, and one panel silences neurons. A 20-second selftest checks nine known results, and assisted navigation can be switched off to watch behaviour come from the brain alone.

fly-brain-research (framework benchmark)

MoisesIbarraMejia

Runs the same FlyWire v783 whole-brain LIF model on six simulator backends - Brian2 CPU, Brian2CUDA, PyTorch, NEST GPU, GeNN and Brian2GeNN - and times them on a shared grid of durations and trial counts, keeping setup cost separate from simulation cost so compilation does not hide in the numbers. Brian2 CPU is the accuracy reference: comparison scripts report active-neuron Jaccard overlap, per-neuron firing-rate correlation and spike-count ratios between backends. Spike exports are written outside the timed section, with a manifest and checksums.

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.

Flying

CauchyRiemannEquations

Sequential recall studied in models that keep real Drosophila connectome structure, with digits of pi as a trained-sequence benchmark and an opening disclaimer that this is not evidence a living fly memorised anything. Recurrent connectivity is frozen and only an external readout is trained, and the writeup insists on separating representation, decoding and internal learning. The latest diagnostic raises frozen-head transfer from 25-27% to 49-53% and still reports failure: the registered access and retention gates are not met and aligned regression R2 stays negative.

Predicting Neuron Cell Types from Whole-Brain Connectivity

kostas52675

Asks how much of a neuron's identity is recoverable from wiring alone: 139,246 FlyWire v783 neurons are classified into their super-class from 171 features - partner and synapse counts, cell size, the neurotransmitter mix of the outputs, and the fraction of input and output synapses in each of 79 neuropils. The split is stratified 70/15/15, every model choice is made on the validation set, and the test set is read once at the end. The very skewed class balance is published up front, with optic at 55.9% and endocrine at 0.06%.

AIfa-BioBench

Maksim Galatin (CODE Eternal / AIfa Works)

Benchmark results for fly-inspired algorithms, published together with the cases where ordinary methods win. In vector retrieval the sparse fly-style projection reaches 39.55% Recall@10 against exact FAISS at 100%, and is slower (43.9 ms vs 8.8 ms). In the binary duel it uses 85x fewer non-zero weights than Sign-LSH but scores 18.9% against 80.5%. A sweep over the claw count finds the fly's d=6 is not the optimum here, and in the agent benchmark the gain comes from remembering visited links, not the bio-inspired modules. The engine code stays closed; only the numbers are here.

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.

FLIEGE

IT-EXPRESS Bayern

German open research on the steps between a wiring diagram and behaviour, publishing its counter-findings alongside its results. It ships connectome audits (neuron and synapse counts, differences between synapse detectors, prioritised candidates to re-check), cell identities mapped to senses and body targets with sources and versions, a recomputation of a published central-pattern-generator model under eight control conditions, and browser labs for the body, leg joints, neuron skeletons and a wing roll rig. One closes a foreleg joint loop through a selected BANC subgraph.

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.

FlyDesk

leath0r (@leath0r)

A Windows desktop colony in which every fly carries its own spiking brain built from the FlyWire v783 connectome, 138,639 neurons and 15 million synapses, integrated as leaky integrate-and-fire units with parameters from the published whole-brain model. The reactions come out of the circuit, not a timer: a cursor rushing at a fly lights up the looming cells LC4 and LPLC2 into the giant fibre DNp01 and it takes off, and tasting sugar drives the proboscis motor neuron MN9. Up to ten brains run in parallel. The flies age, die and pass on mutations by Mendelian rules.

Anatomi Lalat Buah 3D

@sofanaja44

An Indonesian-language 3D anatomy viewer for Drosophila melanogaster with 123 annotated parts, all geometry generated procedurally in Three.js with no external mesh or texture files. The brain layer can switch from a schematic placeholder to 43 real FlyWire neuropil meshes, taken from the surface archive bundled in the fafbseg Python package so no FlyWire account is needed, plus neuron skeletons converted from Codex SWC files. Photoreceptor axons are drawn from the actual positions of about 780 modelled ommatidia per eye.

flyspeare

@owenautosport

A mushroom body built from FlyWire v783 synapse counts (168 projection neurons, 2,456 Kenyon cells, 29 MBON types) learns to type Shakespeare from dopamine alone, over about a week of compute per fly. Memory phases follow the lobes: the gamma lobe forgets within an hour, alpha-beta holds for days, and the fly replays rewarded moments into long-term memory while it sleeps. The README is explicit that a fly cannot type: the 26 keys are invented action channels, the senses are simplified, the typing animation is not physics, and the fly's words about how it feels are rules over measurements.

fruitfly-blackjack

@rmz-24

Cards are presented to the FlyWire v783 brain as odours on projection neurons, a dopamine-like error signal reshapes Kenyon-cell to output-neuron synapses, and the learned weights are written back into the connectome so the spiking brain plays hands on its own. The mushroom-body readout agrees with basic strategy 97.5% of the time against 91.4% for a control that reads the projection neurons directly, which is the measured value of the Kenyon expansion. It also reports that driving projection neurons naively ignites the whole antennal lobe until a clamp is added.

Ragdoll playground + fly brain

@kenprosi

A browser ragdoll sandbox in which a body can be given the whole FlyWire v783 brain, 139,255 neurons and about 2.7 million connections, running in a Web Worker. Bodies are particle lattices that dent, break and heal; the brain senses pain, smell, taste, looming and being lifted, and dopamine at PPL1 and PAM weakens mushroom-body synapses so it avoids a smell it was hit while sensing. A separate section lists what is rules rather than neurons: there is no nerve cord in the data, so reflexes, walking and the choice of direction are code.

Creature Lab

RathaTart (@RathaTart)

Three experiments sharing one interface. The first replays recorded physics on NeuroMechFly body geometry and lets you build terrain. The second is the one worth the visit: measured FlyWire connectivity with simulated spikes and a trained motor readout runs ten mazes, and you can cut connections or silence the descending output and compare against the recorded outcome. The third trains a policy in a maze with four pursuers. The public page is explicit that it plays saved recordings and starts no training; live runs need the local install.

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.

Fly Admin

Valery Petrov (@valerypetrov)

The whole FlyWire v783 brain, 139,255 neurons and 54.5 million synapses, runs as a spiking simulation and looks after a throwaway local database server. Trouble in the database arrives as tastes, touches and looming shadows; the fly acts through its own motor neurons and a fix earns a burst of dopamine. What lifts it above the gag is the list of known limits: Kenyon cells never fire because nothing here smells, walking is never chosen, reward credit spills between actions, weights never decay, and the brain runs slower than real time.

Fly Brain LeetCode

Pragyaan Gaur (@pragyaangaur)

Problems are fed one symbol at a time into the taste, touch and smell neurons of the FlyWire v783 brain (138,639 neurons, 2.7 million connections), the wiring is never changed, and answers are read off 1,303 descending neurons by a trained linear readout. It is judged on hidden tests, all-or-nothing, and is accepted on 3 of 12 easy problems. The interesting part is the control columns: a shuffled rewiring matches or beats the fly on most problems, and an order-blind lookup table on symbol counts beats both on some, which is what the readout is really leaning on.

fly-terrarium

s31fdev (@s31fdev)

A learning project that stays honest about being one. A NeuroMechFly v2 body walks a route written in a YAML file across a flat arena and writes out a video, the trajectory as a table and a plot of it. It can also walk towards what it sees and escape a looming pillar, and in that case the decision comes from a whole-brain model of 138,639 neurons rather than from the route file. The same brain runs in the browser as a terrarium page. The README gives the timings plainly: one second of model time takes about twelve seconds on the author's machine.

Fly Trading

youn-sm (@youn-sm)

A short-video project with a replication hidden inside it. Five-day price rises stimulate 21 sweet-taste receptor neurons and five-day falls stimulate 21 bitter ones; the signal spreads through 127,400 neurons and 52.79 million synapses, and a buy is called when the feeding motor neuron MN9 fires strongly. Before any of that, the repo reimplements the published whole-brain model in numpy and reproduces its numbers: sugar at 150 Hz drives MN9 to about 110 Hz, and adding bitter input drops it to about 4 Hz. It states plainly that this is a backtest with no real orders and no advice.

电子果蝇·香蕉大作战 / Digital Fruit Fly Knowledge Base

professorwang (@professorwang)

Two halves that support each other: a browser game in which a leaky integrate-and-fire network on the FlyWire connectome (139,255 neurons, 2,698,236 synapses) gates a fly's movement in a 2D sandbox, and a Chinese-language reference covering the timeline, the papers, the data platforms and the open-source stack behind the 2026 embodied whole-brain emulation story. The reference does the unglamorous work: it records the criticisms as well as the claims, fixes one neuron count that several Chinese outlets reported wrongly, and states which numbers it follows and why.

FlyBrain (Home Assistant)

aliforfaen (@aliforfaen)

Puts a house on both ends of a fly brain. The FlyWire v783 connectome, 138,639 neurons and 15,091,983 synapses, runs as a spiking network on a consumer graphics card; a room thermometer drives its thermosensory neurons, a small trained readout turns the resulting spikes into a colour, and that colour is sent to a lamp. The brain is frozen and never learns, only the readout is trained, and the README is blunt that nothing in a fly brain knows what a kitchen light is: that mapping belongs to the author, and the code says so.

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.

FlyConnectome Embodied Behavior Lab

nickliqian (@nickliqian)

Four rungs of the same ladder, each runnable offline on one machine. The first draws single-neuron morphology and a synapse network from reconstructions bundled with navis. The second is a spiking olfactory chain from receptor neurons through projection neurons and Kenyon cells, in a single HTML file. The third adds a central-complex ring attractor holding a heading while the agent closes a loop with its environment. The fourth hands control to a NeuroMechFly v2 body in MuJoCo. A separate sandbox scene exists to check neurons in 3D and to ablate parts of the olfactory chain.

FlyLeno

AgitationSkeleton (@AgitationSkeleton)

A whole-brain spiking model of FlyWire v783, 138,639 neurons and 15.1 million connections, runs in a web worker and puppeteers a ragdoll host on a talk-show stage. The unusual part is the input side: stage events such as applause, a thrown tomato or a metal pipe stimulate sensory neurons, a music playlist is fed into auditory neurons, and the audience reaction reaches dopamine neurons, which is what shapes what the model chooses next. On the output side the same neurons drive the ragdoll's muscles, a babbling lip-synced voice, and fly-like grooming and feeding.

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.

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.

Visualising Fruit Fly Neurons

Zack Maz (@zack-maz)

All 139,248 neurons of the adult brain as a point cloud, one point each, with several ways of arranging them. Anatomical places each at its anchor point inside the neuropil meshes; soma position moves them to their cell bodies and notes that 15% have none in the brain and stay put; mirrored folds the right hemisphere onto the left so matching neurons overlap. Beyond anatomy it offers dimensionality reductions of each neuron's input and output region profile and of who it connects to, and an axis giving how many steps a neuron sits from the sensory periphery.

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.

Connectome Lab

Berke Yaşar Çelik (@berkeyc)

Packs published wiring diagrams into one format and gives each a browser lab: stimulate a cell type, silence it, rewire the brain into a degree-preserving control, compare. The worm is the real thing, with nose touch driving backward crawling at -72.9 Hz against -0.8 for the rewired control, and the lab reports its misses too, since tail touch produces no forward crawling although real worms do. Read the fly parts carefully: the browser experiments use a synthetic 5,236-neuron brain with invented numbers, and FlyWire is an importer plus a local Python runner.

FLY//BRAIN

xhoxe2

A browser simulation of 127,400 neurons on the signed FlyWire 630 connectivity that ships with the Shiu whole-brain model, running continuously in a web worker with no backend. Sugar and bitterness at the mouth drive sensory neurons, the recurrent network computes spikes, and two MN9 motor neurons extend a mouth whose extension changes the next contact, so the loop closes inside the page. An approaching finger drives 104 LC4 and 210 LPLC2 cells, and giant-fiber spikes accumulate into a spring-and-ground jump. The contact model, input mappings and muscle adapter are authored.

Fly Brain Rig & Fly Swat

snuri00

One whole-brain FlyWire v783 simulation — 138,639 neurons and 54.5 million synapses — under four programs: a lab console, a swatting game, ViZDoom, and a camera fed through the fly's compound eyes with flyvis. The DOOM numbers come with lesions: 3.1 kills per episode for the intact brain, 1.3 with LC10 silenced, 0.0 with the giant fibers cut, 0.9 for random buttons. Its aim is weak and the README says so, an enemy inside 4 degrees of the crosshair on 13% of tics against 9% for random, and the leftward steering bias is left in because cancelling it made the score worse.

fly-room-demo

meatxsucks

A FlyWire v783 brain — 138,639 leaky integrate-and-fire neurons and 15,091,983 synapses — walks a NeuroMechFly body around an 80x80 mm MuJoCo room with four differently textured walls, two boxes, two pillars and a red target. The code splits into sensors, brain and actuators so the same brain can later steer a real drone: the actuator already assembles a MAVLink body-frame velocity packet and leaves it unsent. The brain is vendored unmodified from another repository, with an UPSTREAM.md saying so, and a separate control script runs the giant fiber with no visual input at all.

flybrain (dino)

seowol-dev

A whole-brain FlyWire v783 network (138,639 neurons, 15.09 million connections, 54.49 million synapses) rewritten on numpy and scipy instead of Brian2, running one second of biological time per wall-clock second, closed in a loop with a fly body in a 2D arena and with the Chrome dinosaur game. The controls are the point: over six 20-second trials the sighted fly survived 17.9 s and cleared 6.5 cacti, finishing 5 of 6, while a uniform grey or silencing the R1-6 photoreceptors both dropped it to 2.85 s, no cacti, none finished.

FlyChess Thinker

Arkazzae

Chess against the FlyWire graph: 134,181 neurons and 2.7 million connections, kept fixed after dropping connections below five synapses, with gains, biases, inputs and a readout trained over 26 million position presentations. It runs in the browser after a 51 MB download, showing the activity cloud over measured cell-body positions while it weighs candidate moves. Measured strength is about 1500 Elo against Stockfish, 95% interval 1410 to 1603, for the 64-visit search; the other two configurations are unrated. The rules and legal-move filter come from the software, not the fly.

Flywire AI

xieguigang

A whole-brain spiking simulation platform written in VB.NET on .NET 10, assembling the FlyWire FAFB v783 tables, 139,255 neurons and about 50.67 million synapses, directly into a leaky integrate-and-fire network with no training at all: topology, connection strength and excitatory/inhibitory polarity are copied from the electron-microscope reconstruction. It offers a 3D point cloud with per-timestep spike playback, whole-brain current injection with a CUDA back end checked against a CPU SIMD one, and a Snake loop feeding 5,536 afferent and reading 441 efferent neurons.

DOOM-FlyWire Neuro-Sandbox

EmirMuhammetARAN

Runs the FlyWire whole-brain graph with no downsampling — 139,248 neurons and 15,090,883 directed synapses — as a ViZDoom agent. Frames reach photoreceptors and motion detectors through a 32 by 32 ommatidia array, and 1,303 descending neurons decode into steering and fire. What sets it apart is the browser console: dopamine, octopamine, serotonin, GABA and acetylcholine gains, plus targeted ablations of an optic lobe, the T4/T5 motion detectors, the central complex, Kenyon cells or all descending neurons. Below 0.2x GABA the network tips into global hypersynchrony.

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.

Fly-Projects (Fly-Dar, Fly-Manager, By-The-Flys-Gaming)

Dtpk

Three small Python projects that feed a FlyWire connectome something other than pixels. Fly-Dar watches WiFi signal strength through nmcli and lets the fly decide what counts as normal for the room, with one slider for how long that baseline lasts, so it can flag a person moving. Fly-Manager is a pygame file browser where the fly reacts to files appearing and can clear a directory when two arrive at once. By-The-Flys-Gaming reads a game radar through X11 capture and emulates a gamepad. Without the Codex CSVs each falls back to a mock graph and says so.

FlyWire Coding Cortex

imrizwan

A pip-installable package and MCP server that lets a coding agent step a FlyWire-derived spiking circuit and read population rates back as drives: implement, stop, reverse, steer, groom. The bundled seed profile is a 668-neuron escape and steering subgraph with roughly 19,000 signed edges; larger profiles pull the public Codex dumps or the 10.6 GB Zenodo release, and the README tells agents never to fetch the largest without asking a human. The wiring and contact counts are FlyWire data; the membrane dynamics, the task-to-current encoding and the rate-to-drive map are the author's models.

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.

Computational Coupling

VIT-AP University (Ashok Raj Pasala, Snigdha Gorai)

Asks what the claim that a real connectome beats its rewiring depends on, and answers: four things besides the wiring. Varying the null ensemble, the unit model, the operating point or the readout each flips the gap's sign on identical data. Two ensembles both called degree-preserving randomisation disagree in sign on 6 of 10 cells, in significance on 3. Under an all-to-all readout, deleting the recurrent matrix costs nothing. The networks include the Drosophila central complex and antennal lobe from FlyWire v630. It also retracts an earlier version of itself, listing every withdrawn claim.

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.

FlyWire Connectome Critic & Visualizer (drozophoto)

Kidpun

Send a photograph to a Telegram bot and watch a fly react to it. The image passes through a retina, a spike wave travels across FlyWire release 783 — 138,639 identified neurons and 15,091,983 synaptic connections held as a sparse float32 matrix with the release's own cell-type, hemisphere and neurotransmitter annotations — and the motor response is streamed to both a web canvas running the connectome projection at 60 fps and back to the chat. Built on FastAPI and aiogram, tested by the author on a MacBook Air M1.

Fly-Delity (FlyWire Connectome Music Rater)

Rahul-A-2111

Upload an MP3 or WAV and a simplified Drosophila auditory circuit rates it. Audio becomes injected current, then runs through a sparse leaky integrate-and-fire network built from cached FlyWire synapse and annotation tables. The default Courtship mode favours roughly 140 BPM, a 180 Hz peak, harmonic content and stable pulse timing. The evaluator is explicit about its shortcuts: analysis is capped at the first 30 seconds, the simulation looks at three two-second clips only, and if P1 and pIP10 are unmapped or silent the mating score falls back to a BPM match.

Fly Lint

timbrinded

Reviews TypeScript and JavaScript pull requests with a hosted language model for the measurements and a local network of 1,000 FlyWire neurons and 24,492 measured connections for the choices. The compiler extracts changed symbols, their callers and related tests; the model answers batches of small contract and lint questions; the fixed connectome feeds a trained output layer that selects and scores focused checks for four lint patterns. Only that output layer is fitted. Bundled recordings of real pull requests replay without an API key.

flybrain (@flybrain/brain)

acamilo

A library rather than a demo: the connectome dataset format, the leaky integrate-and-fire kernel, the plasticity rule, the population-rate readout and the activity-map geometry, packaged as @flybrain/brain with no game, no emulator and no reward rules inside. Browser artifacts derive from FlyWire FAFB v783 via a Python builder that regenerates them from official Codex exports. A scalar reward nudges a bounded set of Kenyon-cell to MBON gains. The 76 tests take about seven seconds, and the full 139,255-neuron network runs a Game Boy readout at roughly 0.9x real time single-threaded.

OptiCompanion

vicvasper

An Unreal Engine 5.8 plugin that profiles your project while you pause, using an olfactory circuit as its decision maker. GPU pass timings and level statistics enter 51 inputs, one per real uniglomerular projection-neuron type, expanding into 2,337 Kenyon cells wired from the FlyWire FAFB v783 right calyx. Dopamine is the prediction error, so it stops retesting what it knows. On synthetic worlds it reached 83% of the best possible saving against 78% for Thompson sampling and 14% for random — and without projection-neuron adaptation it lost to Thompson sampling, 71% to 77%.

Virtual Fly Lab

williamrusya

A browser experiment in which a reduced taste circuit of 447 simulated neurons and 24,403 directed FlyWire v630 connections gates feeding at sugar contact, alongside a separate 910-neuron rate model of a FlyWire mushroom-body motif whose Kenyon-cell to MBON efficacies change under dopaminergic modulation. Version 0.6 adds A/B sugar feeders, per-cue memory bars and a test phase with shocks and plasticity switched off, so cue identity can be separated from location by swapping the feeder sides. Walking, attraction, stress and health stay illustrative rules.

数字果蝇 / digital-fly-brain

chenmzh (@chenmzh)

An independent reproduction of the Shiu et al. 2024 whole-brain model on a fixed FlyWire v630 graph of 127,400 neurons and 14,687,178 directed connections, followed by a habituation study. Three one-second trials per condition give a proboscis motor neuron rate of 0 Hz with no input, 67.67 Hz on average under sugar, and 6.67 Hz when bitter input is added; rerunning with the same seed reproduces the spike files down to their checksums. The author calls this a small qualitative reproduction and reports that repeated stimulation showed no decrement until local short-term depression was added.

זבוב משחק מלך הפלאפל (Fly Brain Falafel)

Eli-HarShefer (@Eli-HarShefer)

A browser game where a falafel stand is run by 4,798 real FlyWire neurons and 116,960 real synapses as a leaky integrate-and-fire network, with the interface tagging every action as connectome or game logic. Calibration found a push-pull pair: one tracking pathway fires hardest when the target is centred and inhibits turning, the other fires at the periphery and drives it. Enforcing Dale's law corrected an edge-level neurotransmitter prediction that would have cancelled the escape reflex. The central complex runs and spikes but was measured not to contribute here, reported as a result.

fly-voca

Injae Yun (@Injae-Yun)

Tries to read a fly's internal states off FlyWire FAFB v783 and BANC v888 wiring, along eight axes including hunger, thirst, arousal, courtship, defence, taste and steering, and records why those states do not persist in simulation. State cells return to baseline within 250 ms after the stimulus ends, which the author notes matches recordings rather than contradicting them; persistence is carried downstream, and three routes (loop gain, a whole-brain scan, a body loop) fail to produce it in this model class. Conditions are seed-matched and refutations are kept as results.

FlyBrain (TouchDesigner)

alicwyz (@alicwyz)

A TouchDesigner component that loads the FlyWire connectome from Codex and runs it as a point-operator network on the GPU. A Python pipeline pulls the public data with a Codex API token, filters it by super class or brain region, limits how many incoming connections each neuron keeps, turns predicted neurotransmitters into signed weights and writes one CSV the component reads. You can watch the point cloud or treat the graph as a black box, feeding a signal into one group of neurons and reading another group's response out, which makes the wiring usable as material for live visuals.

flyconnectome-nulls

G. Park (@gyujeongion)

Evolves foraging agents whose brain is a compressed FlyWire v783 connectome alongside populations built on randomised wiring, and shows that the choice of null model decides the answer. Column shuffles and degree-preserving swaps overtake the connectome by generation 600 in 10 of 10 seeds, but they also create direct olfactory-to-motor links the real graph almost lacks (0.012% against 10.6-10.7%). Controls that randomise only the interior erase the gap, and transplanting those shortcuts into the connectome adds 0.44 fitness. Five pre-registration protocols were frozen before the runs.

flydoom (mikeluvnugs)

mikeluvnugs (@mikeluvnugs-gif)

A leaky integrate-and-fire model over measured fly wiring plays a ViZDoom scenario, and the finding is that it plays badly. Over 20 seeds the full FlyWire brain scores 1.25 kills per episode and the hemibrain version 1.15, against 1.45 for random actions and 0.00 for doing nothing; neither beats random and the two connectomes are not distinguishable. The README lists what is not biology, including receptive fields assigned by array index and constants never retuned for the larger graph, and keeps earlier negative results such as a five-seed configuration that regressed on twenty.

NeuroWing Atlas

Ajafarnezhad (@Ajafarnezhad)

A bilingual English and Persian workbench for a locally stored FlyWire/FAFB dataset. On first run it builds a compact local index instead of loading the dataset into browser memory, then serves neuron, pathway and synapse browsing, SWC skeleton viewing and an optional whole-brain atlas that can be interrupted and resumed. Eighteen built-in experiments cover light, food, odour, wind, heat, touch, slalom and drawn paths, and custom tasks can be saved. A scope note separates dataset facts from the modelled firing dynamics, sensorimotor mappings and learning behaviour.

BeeBrain

Blamp26

A Fabric mod that hands each Minecraft bee its own state inside a pinned 139,255-neuron, 2,698,236-connection flybrain simulation, sharing one immutable topology across 100 bees at about 1,005 aggregate neural updates per second. What sets it apart from other Minecraft ports is the verification: the upstream reference is pinned to a named commit, the connectome artifact to its SHA-256, and the run is checked for reference-exact parity against upstream fixtures. The README says outright that it does not claim a fly brain understands Minecraft.

BioBrain

jovid1242

Asks whether the FlyWire wiring of 139,255 neurons can seed a sparse, event-driven, trainable spiking network that costs far fewer synaptic operations than a fair baseline, and says up front that it does not assume the answer is yes. The finished milestone is mostly a negative one. In Python and NumPy on a CPU, event-driven execution beats time-step only at extreme sparsity: up to 6.6x at 100 neurons, 1.2x at 10,000 and never at 50,000. Compiled with Numba it is still about 2x slower than compiled time-step at realistic activity.

drosophila-brain-docker

Seriouskosk

Packages the published whole-brain leaky integrate-and-fire model into self-contained container images across five Python versions, so the 127,000-neuron model runs on a processor with one command and a verification script that prints a pass in about 25 seconds. Its main value is a real incompatibility it pins down: the published model’s loose version bound resolves to a library release that dies at import because it calls an array method removed in a major numpy release, which makes the two constraints mutually exclusive and silently breaks modern environments. English and Russian.

The Drosophila Critic

Synthetic Humanities Lab

A fly listens to poetry. A poem is spoken by a fixed synthetic voice, the audio is reduced to its loudness envelope, that drives the antennal hearing input of a frozen whole-brain connectome, and the recorded spikes become a response, which an interpreter then reads without ever seeing the poem's text. The fly never receives a semantic representation of the words. The published edition replays William Blake's The Fly with its actual recorded neural response, and a deployable version accepts new poems, with a three-dimensional fly body facing a speaker while the traces replay.

firefly-brain

kris072008

Runs 139,248 neurons and about 2.7 million synaptic connections as a spiking network whose own steering neurons drive a fly around an arena looking for sugar, with nothing in the game logic saying to go towards food. A shader renders 400 of those neurons live behind a Ghostty terminal, and a browser mode plays 3D chess against the network. The integrator is checked against the closed-form response rather than trusted: with the published parameters one synapse is worth about 0.043 mV, so roughly 160 coincident synapses are needed to reach threshold.

First movement

augmentedthinker

Takes motor spikes from a verified run of the published whole-brain model and applies them as torque to an engineered mouth joint in a standard fly body; the physics simulator computes the movement and a browser replays it. Five conditions can be compared, including a disconnected brain transmission and an inactive actuator. The boundary is drawn explicitly: body geometry, masses and joint locations come from the published model, while the spike-to-torque mapping, the spring, the damping and the single-hinge simplification are the authors’ engineering and not a validated model of feeding.

Fly Brain Collector

bth0mp

Listings get a plain-text score, the score sets how hard the simulated sugar-tasting neurons are stimulated, roughly 127,000 neurons of the Shiu et al. FlyWire model run for one simulated second, and the firing rate of MN9, the proboscis motor neuron, decides how much the fly wants the item. A budget is re-solved after every judgement, and nothing is ever bought or bid on. The honest part is a labelled section: the fly has no idea what a collectible is, all the judgement lives in scoring rules a person wrote, and the connectome here is acting as a simple transfer function.

fly-ftl-extract

andrew000

A drop-in replacement for a localisation key extractor, same command, same options, byte-for-byte the same output, in which the decision of whether a string is a translation key is made by a simulated mushroom body rather than a parser: 124 projection neurons into 2,597 Kenyon cells with one inhibitory feedback cell and 48 output neurons, taken from the FlyWire right hemisphere, with a readout trained by a delta rule. The tokenizer only proposes candidates and encodes their context as an odour. A test asserts the hot path loads no syntax tree, so switching the fly off finds no keys at all.

FlyLite

aikian

Asks how sparse a fly-brain model can get before it stops working. Starting from the 127,400 neurons and 14.7 million weighted edges of the validated whole-brain model, it removes edges with six different operators at the same edge budget, keeping magnitude, wiring position or neither, including a task-aware one, and then re-runs three experimentally validated circuits in both a silent and a spontaneously active network. Hypotheses were fixed before the first phase. Everything runs on a laptop processor or a free cloud runtime, at roughly one to three minutes per simulated second.

flywire-gnn

omkar-dhakane

Packages the proofread whole-brain female connectome as a ready-to-train graph dataset: 139,255 neurons, 2,700,513 directed pairs at five or more synapses, 174 features per node built from degrees, per-neuropil profiles across 79 regions and neurotransmitter profiles, seven edge attributes, and a nine-class label covering every node. One class downloads and caches the data, deterministic stratified splits come with it, and three baselines are reproducible. The task it sets is predicting a neuron’s class from wiring structure alone, with no authentication and no data wrangling.

HouseFly

Vortitron

A fly that lives in a Home Assistant dashboard, running a rate model of 4,724 identified neurons wired by 126,108 measured synaptic connections, with household sensors delivered to the neurons that carry that kind of information in the fly. About 450 KB of connectome and a few milliseconds of numpy per tick. Its one rule: every behaviour either comes out of the measured wiring or is labelled a controller, and the failures are checks: the compass does not integrate a sustained turn, the escape pathway had no real threshold, and a directed escape is impossible from half a brain.

Flylab: digital fly and Pong

jingsong-wang

A 3D feeding arena running 127,400 neurons and all 14,687,178 weighted connection rows from the Shiu et al. FlyWire 630 model in browser Web Workers, at 0.1 ms steps with stated threshold, time constant, delay and refractory values. Food contact drives 21 sugar sensory neurons and MN9 output controls mouth extension. The care is in the wording: row count is not synapse count, walking and the spike-rate-to-uptake conversion are engineered, and the MN9 spike counts are called model sanity checks rather than biological accuracy.

Leadsfly

ul1dev

You send a message, and a fly in a 3D office puts down its newspaper, walks to the computer, sits, types and replies in the chat. The model behind the behaviour is 138,639 simulated neurons and about 15 million directed connections from FlyWire v783 as prepared for the Shiu et al. model, with a live activity view where you can click a neuron and inspect its connections. The README does not oversell it: in the public build every message returns one fixed greeting, and the text is not generated by the fly brain, only the actions and the timing are.

neurafly

emiliano-go

A terminal audio visualiser that puts whatever the machine is playing through the 138,333 proofread neurons and 2,052,622 weighted synapses of the whole-brain connectome, release v783, and draws the result as a living disk in braille characters using the terminal's own palette. It captures system audio, so anything playing anywhere drives it, and when the sound stops the disk collapses to a point. The prepared network file is committed so a plain clone works, with a script to regenerate it from the original release, and a self-test that checks the coupling invariant.

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.

FruitFlyBrain (datasets and projects)

ROHITCRAFTSYT

A workspace of eight runnable projects over two connectomes that need no login: hemibrain v1.2 at 21,739 neurons, 3.55M connections and 14.3M synapses, and FlyWire FAFB annotations covering 139,248 neurons and 8,840 cell types. The projects run graph analysis, a neurotransmitter and cell-type census, shortest-path circuit tracing, a connectome-wired simulation, NAVis 3D rendering, a cell-type classifier, neuron embeddings and synapse link prediction, each writing its own figures and tables. Several carry a sanity check against known fly neuroscience.

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.

FlyScale (VybFly)

rickenator

Asks whether you can enlarge a whole-brain wiring diagram and still have it behave like a brain. A hidden geometry is learned for the FlyWire graph, then new neurons are placed near old ones and wired by the learned rule, growing 139,255 neurons and 2,700,513 connections up to 1,392,550 and 27,842,102. Sparsity holds: connections grow as N to the 1.02. The results the authors highlight are the limits. Nothing built here handles delayed or ordered stimuli at any scale, and a mushroom-body model trained on odour-reward learns exactly as well on a shuffled graph.

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.

Connectome OS

ruvnet

An alpha Rust environment for stimulating, cutting and inspecting connectome-derived networks, with FlyWire and synthetic-network demonstrations. It is intended as an experimental debugging platform. The README separates working demonstrations from planned components, including MuJoCo body integration, so the roadmap is not a demonstration of embodied fly behavior.

Music on the Fly

Koya Matsuo

Koya Matsuo’s browser music work maps FlyWire v783 wiring through artificial dynamics and human-designed musical rules, with MIDI and video export. Its network display uses a layout rather than anatomical neuron positions. It is a generative artwork informed by a connectome, not a recording of music composed by a living fly.

train-your-fly

eudald-seeslab

A PyTorch Geometric workflow that combines FlyWire v783 wiring with a compound-eye input model for image classification. Connectivity is fixed, but synaptic gains, optional thresholds and readout parameters can be learned. It is a trainable classifier constrained by a connectome, rather than an unchanged biological brain or a readout-only learning experiment.

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.

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.

FlyBrain Learning Lab

alipyth

A local web lab for a FlyWire/FAFB dataset you already hold on disk. On first run it builds a compact DuckDB index beside the data and then serves only what a page needs, so the browser never loads the whole release. It explores neurons, synapses, neuropils and pathways, draws real SWC skeletons, can generate a whole-brain atlas in the background, and ships 15 built-in experiments including light, food, odour, wind, heat, touch, slalom and hand-drawn paths, plus an experimental imitation-learning controller. The interface and a full second README are in Persian.

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.

Immortal Fruit Fly

MidTermDev

Puts the parts a simulation usually loses on a chain. A FlyRegistry ERC-721 on BNB Smart Chain holds, per fly, the hash of the connectome it runs, the model version, the hash of its full brain state and where those bytes live on IPFS, its memory root, energy, generation, death count, parents and the body currently running it, capped at 10,000 tokens. Bodies are separate programs that speak the registry protocol, so a fly can die inside one game and be instantiated in another. The brain itself is a whole-brain FlyWire simulation with arena and Doom modes.

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

fruit-fly (desktop)

rembish

A desktop fly for Linux, macOS and Windows whose every move comes from a whole-brain FlyWire simulation of 139,255 neurons and about 34 million synapses running in real time. The screen is fed in through retinotopic eyes, 785 and 796 columns driving 6,670 mapped photoreceptors and 4,541 lamina cells, with the cursor drawn in perspective so it looms as it approaches. Dodges come from the looming detectors into the giant fiber, steering from a descending left-right rate difference, and take-offs from a 1,305-neuron descending pool rather than a random walk.

Virtual Fly (Project Genesis)

ritwikj2

A creature that keeps living in a 3D jar whether or not anyone is watching, driven by 143,921 neurons and 12.3 million synapses from the BANC connectome as spiking neurons. It receives only a 12 by 6 pixel image, two antennal odour concentrations, per-leg touch, joint angles, heat, hunger and pain, with no language model and no if-hungry-go-to-food rule anywhere. State is checkpointed every two minutes and resumes after a restart. Its log reports 55 simulated hours across 19 lives, with hazard avoidance rising from roughly half to about 80 percent of approaches.

Fly Chess Lab

tolatolatop

The whole FlyWire v783 network, 138,639 neurons, 15,091,983 connections, unthresholded, stepped as a Rust-to-WebAssembly LIF model in browser Web Workers, 0.41 s and 180 MiB a move. The board enters fixed visual neurons as 64 by 12 Poisson channels; the move is an untrained plus-or-minus-one projection of descending activity, no engine. In its own 120 ms test no descending neuron spikes; the move is read from subthreshold signal, and when that is zero, as after cutting synapses, the page refuses to move. Numerics match Brian2 to 2.6e-13 mV on a four-neuron circuit. It calls its play very weak.

flywire-fly-lab

suifei (@suifei)

The Shiu et al. LIF model of the full FlyWire brain, 138,639 neurons and 15,091,983 weighted synapses, run on a 16 GB laptop at about 2.5 s per simulated second, then 17,628 virtual knockouts across three sensory reflexes in 9.88 machine-hours. Agreement with published behaviour, as Cohen's kappa per pathway: 0.59 for sugar, 0.87 for water, 0.91 for grooming (n = 1). A browser game runs a 4,599-neuron subcircuit live. The 65,000-character Chinese report lists 28 errors the author found in their own work, and what the model cannot do: no learning, and all 307 PAM dopamine neurons sit at 0 Hz.

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.

drosophila-1c

Reaper404-wag

An agent that finishes university 1C:Enterprise labs, from the PDF brief to configuration XML and documents posted into real databases, with a FlyWire leaky integrate-and-fire simulation in the loop and a self-audit that dismantles its own premise. The README scores 113 checks per condition: the canonical descending-neuron path reaches 102.2, zeroing all 2.7 million simulated connections also reaches 102.2, and random action choice scores highest at 103.4. Only a shuffled descending graph changes anything, and for the worse, at 93.0 - a corrupted brain hurts where an absent one is neutral.

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.

Chess vs The Fly Brain

shuka0158

A Hugging Face Space that scores each legal chess move by how the fly's dopaminergic cells react to the resulting board. Squares map to fixed sensory-neuron clusters, activity runs twelve leaky integrate-and-fire steps over a FlyWire edge list shipped as a 93 MB weights.npz, and the move is picked by mean PAM rate minus mean PPL rate across 331 real dopaminergic neurons, plus material and repetition terms. The README says plainly that the squares-to-neurons map is arbitrary rather than retinotopic, and that the fly's reward circuitry is for associative learning, not chess. The Space is paused.

FlyBrain-HarmonyOS

zhuhaozoo (@zhuhaozoo)

A native HarmonyOS phone app (ArkTS + ArkGraphics 3D) that keeps the FlyWire graph on-device: a 12 MB packed edge file and FAFB v783 coordinates ship in the repo, all 139,255 neurons draw as a colour-coded cloud, and a worker steps leaky integrate-and-fire at 10 Hz. The README declares the simulation a port of snedea/flybrain (MIT), also listed here, carrying its constants; new are the platform, the on-device data packing and the 3D rendering. It reports 61-78 ms per tick on hardware and admits most motor groups never fire, so the fly on screen runs mainly on a hand-written state machine.

Fly Worker

hwkim3330

A browser QA fuzzer on the FlyWire v783 connectome: 138,639 neurons run as leaky integrate-and-fire units at about 1,321 steps/second while a raycast game renders into the lamina-to-medulla stage and descending output steers directly, with no hand-scripted correction - cutting the 40 steering channels drops separation from 0.95 to 0.00. LIMITATIONS is where the project argues against itself: goal-directed navigation fails, steering-to-light correlation is near zero across four decoder variants, the graph is pruned to 2.7M of 15.09M pairs, and the bug tally differs between the two documents.

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.

重みは学習するのか、測るのか。ハエの脳が問い直す 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.

FLYBRAIN · Bad Apple × DOOM

fazchile17

A local 3D viewer of the FlyWire FAFB v783 connectome, 139,255 neurons, 15,091,983 directed pairs and 54,492,922 contacts, that paints either the Bad Apple!! animation or the shareware episode of DOOM using nothing but neurons as pixels. After a one-off data preparation of roughly 3 GB the viewer runs entirely offline on localhost; only the outbound links to Virtual Fly Brain and FlyWire need the network. Documentation is in Spanish. One of two independent Bad Apple entries from the same week.

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.

Buzzback Brain

Buzzback (zormy111)

The neuroscience core of a token project: it simulates the complete FlyWire female brain (138,639 neurons, 15,091,983 synaptic rows) as a leaky integrate-and-fire network, stimulates the sugar-sensing gustatory receptor neurons and reads out the proboscis-extension motor neuron MN9, whose firing triggers an on-chain buyback in production. The repository publishes the model, the calibration and a demo video; the code is the interesting part, and this listing covers the code, not the token.

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

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.

FastFly

eonfathom (Michael)

A GPU simulator aiming at real-time or faster execution of the whole FlyWire brain, 139,255 neurons and 54.5 million synapses, on a single consumer NVIDIA card. The engineering is the point: leaky integrate-and-fire neurons, CSR sparse connectivity with FP16 weights, a push model that only processes synapses of neurons that actually fired, warp-ballot spike detection with bit-packed flags, and warp-per-spike load balancing. Connectivity comes from Shiu et al.'s v783 release and annotations from flywire_annotations.

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.

The Fly Wheel (blackjack dealer)

flywheel-sol

A blackjack dealer whose hit-or-stand decision on hands of 12 to 20 comes from one stimulation of a FlyWire v783 leaky integrate-and-fire simulation (138,639 neurons, 15.09 million synapses) with Shiu et al. 2024 parameters, read out at the proboscis motor neuron MN9. The repository ships the model, the measured calibration, a negative control and a script that replays any hand played on the site, so a player can verify which code decided it. Listed for the verifiable-decision machinery, not the token.

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

Infinite Sugar

William Kelly (@cnqso)

A browser artwork rather than a game: 139,255 FlyWire neurons drive an embodied fly in a terrarium whose sweet-sensing neurons receive continuous stimulation, so it feeds forever. Feeding, head and antennal motion follow neural activity, while wing movements and small foot shuffles use supplied patterns; a corner map lights up sampled FlyWire positions as neurons fire. The author credits Harris Rosenblum's Infinite Pain (2025) as the inspiration and lists flybody, MuJoCo and Shiu et al. as the body and model references.

webgpu-fly

Ahmet Barış Günaydın (@abgnydn)

Fire a real descending neuron in the FlyWire connectome and watch the spike cascade propagate through the wiring into MANC nerve-cord data; what comes out is a walking magnitude and a turn bias that modulate a hand-written tripod gait. It runs entirely in the browser on WebGPU with no install, and ships a separate science view. The README labels the motor mappings as explicit approximations, and the project predates the September 2026 wave by several months.

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.

erojasoficial-byte/fly-brain README demo GIF (MIT)

fly-brain (Rojas)

Enrique Rojas Aliaga, Universidad de San Martín de Porres

A solo project from Enrique Rojas Aliaga at Universidad de San Martín de Porres (Lima) that wires a spiking network of 138,639 FlyWire v783 neurons and 15.1 million synapses into a NeuroMechFly v2 body in MuJoCo, complete with compound eyes, legs and wings. The author reports vision-driven motion detection, olfactory chemotaxis, gustatory responses and emergent walking, flight and escape, and frames the work around how connectome plus embodied experience yields individual behavioural differences; a 2026 preprint is archived on Zenodo.

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.

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.

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.

natverse / nat

Jefferis lab, MRC LMB

A tidyverse-style family of interoperable R packages for importing, visualising, analysing and exporting 3D neuroanatomy, built around the core nat (NeuroAnatomy Toolbox) package that Greg Jefferis's group has maintained on GitHub since 2014. Satellite packages such as neuprintr and fafbseg give R users access to hemibrain and FlyWire/FAFB data. The ecosystem was described by Bates, Jefferis and colleagues in eLife in 2020.

Drosophila_brain_model (Shiu et al.)

Philip K. Shiu et al.

The reference code for Shiu et al., "A Drosophila computational brain model reveals sensorimotor processing" (Nature, October 2024), a leaky integrate-and-fire model of the whole FlyWire brain implemented in Brian 2. Users activate neurons by FlyWire ID with Poisson input or silence them to mimic optogenetics and read out spike times and rates; both the v630 and v783 connectome releases are supported and Jupyter tutorials are included. Later projects such as Eon Systems' fly-brain build directly on it.

flybrain (snedea)

snedea (GitHub user)

A browser-based simulation by GitHub user snedea that runs a leaky integrate-and-fire network of all 139,255 FlyWire FAFB v783 neurons and 2.7 million connections inside a Web Worker, letting visitors poke the fly with food, touch, wind, light and temperature and watch unscripted behaviour emerge from the wiring. It began in March 2026 as a scale-up of heyseth's 302-neuron C. elegans worm-sim and is hosted at flybrain.app.

Virtual Fly Brain

Virtual Fly Brain consortium (UK institutions incl. MRC HGU)

A long-running UK-funded web atlas that registers neuron images, gene-expression patterns and connectomics onto standard Drosophila brain templates and links them through an anatomy ontology, so anatomy, expression and connectivity can be cross-searched in one place. Supported since 2009, it now indexes over 600,000 3D images and roughly 490,000 neurons with connectivity, spanning hemibrain, FlyWire, FANC and the larval L1EM data. The v2 front end (geppetto-vfb) is an MIT-licensed customisation of the Geppetto platform.

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.