Everything people built with the digital fly

The community’s most-starred project: a fly crawls over your macOS desktop, with 23,210 of its neurons in a side window.

The most detailed fly body: walks and flies with RL-trained controllers. A test bench for a future connectome brain.

The Shiu model on six engines — Brian2, CUDA, PyTorch, NEST GPU, GeNN — with benchmarks and parity checks.

The fly trades bitcoin; profit and loss hit its dopamine cells. $100 balance, $10 per trade, 24 trades a day.

Paper trading by default; no profitable learning shown.

MaleCNS access from R, with morphology tools.

The fly body in MuJoCo: 87 joints, compound eyes, smell, sticky feet. The most popular body for connectome experiments.

MaleCNS plays Doom: the frame feeds ~4,000 visual inputs, damage hits the mushroom bodies with dopamine. 6,385 attempts, never beaten.

Inputs and outputs mapped by hand; the author says learning is unproven.

A curated list of fly connectome projects — a starting point for this catalog.

The whole-brain leaky integrate-and-fire model from FlyWire; it predicted feeding and grooming circuits later confirmed in live flies.

A connectome-constrained model of fly motion vision: 64 cell types, predictions matched 26 experiments.

A fly in Minecraft on 166,700 neurons and 25.6M connections. The video went viral.

Code not released yet; readouts trigger scripted body programs.

Neuron morphology analysis and visualisation in Python.

The fly watches insect Shorts on a virtual phone. “Born to fly. Forced to scroll.”

Fabric mod: every fly mob runs its own filtered MaleCNS graph, with a live HUD of its neurons.

The main explorer: five fly connectomes, search, 3D, paths between neurons, downloads.

The whole of FlyWire (139k neurons) in the browser: feed it, touch it, light it, warm it.

A platform for building and running executable brain circuits.

Reads printed letters and digits from PDF pixels through a frozen MaleCNS circuit and rebuilds simple tables, on a Mac.

A 266k-parameter decoder is trained on 1,024 neurons' activity; brain weights stay frozen.

The fly turns a steering wheel in the CARLA driving simulator — with simulated legs.

Doesn’t look at the road yet.

A frozen language model with a MaleCNS readout adapter.

The language comes from the LLM, not the fly.

The Python client for neuPrint.

Annotations of every FlyWire neuron — the neuron cloud on this site is built from them.

FlyWire v783 in a NeuroMechFly body with Hebbian plasticity.

Zenodo preprint, not peer-reviewed.

Workshop materials: how to download and open every big fly connectome.

3D browser game: a selected MaleCNS circuit in Rust/WASM tries to escape.

MaleCNS drives Mario in Super Mario 64. Bring your own ROM.

Client for the versioning and annotation engine behind FlyWire and BANC.

Frozen MaleCNS as a general 'fly reservoir': tasks plug into named input and output neurons, e.g. a bot in SSH Fighter.

No training inside the brain; tasks decode outputs by hand or train a linear readout.

A library for who influences whom, and in how many steps.

Anatomical videos in Blender from a text description.

A React/Three.js starter for your own fly project.

Silences modelled mAL output and watches what happens to courtship circuits.

An artwork: a FlyWire fly in a terrarium with endless sugar.

Wing and foot motion use supplied patterns.

“Chat with 138,000 neurons”: FlyWire LIF with a natural-language interface and dopamine learning.

MaleCNS run as a recurrent net steers a car from a 64x32 pixel view; it finishes 58 of 60 unseen streets with no collisions.

Per-synapse gains and neuron leaks are trained (25.7M params); wiring fixed, pixel map and readout random.

A MaleCNS/FlyWire agent playing Half-Life.

The fly paper-trades an intraday NIFTY straddle through OpenAlgo.

An interactive FlyWire v783 simulation with a stimulus control panel.

The public demo is down.

Runs the whole traced MaleCNS graph (165,122 neurons, 25.6M edges) in a NeuroMechFly body in closed loop; 12 flies on one GPU.

Vision is analytic (object positions are given), not optical; README lists what is and isn't claimed.

MaleCNS as a sparse reservoir for experiments.

Real-time Muse EEG is promised but still planned.

The larval connectome as a frozen reservoir reads handwritten digits at 94%.

A Rust LIF runtime to stimulate, cut and measure FlyWire-derived graphs.

Hologram flies on Snap Spectacles, each run by its own full MaleCNS LIF brain on a Mac GPU and fed by the glasses' sensors.

Sense channels and motor mappings are designed by the author; a Gemini model inventories the room.

Data, figures and notebooks for BANC, the female brain-and-nerve-cord connectome (Bates et al., Nature 2026).

FlyWire v783 in real time on a consumer NVIDIA GPU.

3D atlas of 80 male brain regions built from MaleCNS geometry, with exploded view and 1,712 traced neurons.

Mushroom-body activity decides when to skip to the next video.

A desktop fly for Linux/Hyprland on a 668-neuron subset.

Chrome’s dino game run by a fixed 80-neuron MaleCNS circuit.

Only the 243-parameter readout is trained.

FlyWire activity in a closed loop with a NeuroMechFly body.

Simulated fly motor circuits play music in Ableton Live.

A game boss controlled by MaleCNS: Rust engine, Three.js viewer.

FlyWire brain + MANC nerve cord + flybody body, all in the browser on WebGPU.

Brain-to-body motor mapping is approximate.

A Windows port of DesktopFly in C# and Direct3D 11.

MaleCNS in MuJoCo with explicit engineered controllers.

The author: “not a physiologically validated digital fly”.

MaleCNS in a room with colour vision, smell, taste and wind.

JAX simulations of the MANC nerve cord that identify a central pattern generator circuit for walking (Pugliese et al., bioRxiv).

FlyWire + Shiu + flygym in one package. Sugar drives the “eat” neuron from 0 to 92 Hz, bitter cuts it by 93%.

FlyWire LIF simulation linked to a persistent 3D body.

A 1,373-neuron larval circuit drives a MuJoCo body; stimuli are given in words.

Compound eye → optic lobe → MaleCNS descending neurons → a flying body, in the browser.

A Python/GTK port for GNOME.

A fair comparison: the fly brain vs rewired graphs and ordinary neural networks on VizDoom tasks.

Pong on a MaleCNS subgraph; the author publishes the negative learning results too.

“I Have No Wings and I Must Fly” — a NeoForge Minecraft mod with a trimmed FlyWire subset and dopamine learning.

Curated list of fly-connectome apps: demos, games, trading loops, art and RL experiments on MaleCNS and FlyWire.

MaleCNS fights in the FightingICE fighting game.

Browser arena: a 165k-neuron MaleCNS LIF brain in WASM inside a MuJoCo flybody, sorting behaviours the wiring makes from added ones.

The compound eye is a trained component.

Fast GPU LIF simulator for MaleCNS, checked against FlyWire results, plus an honest record of what adding neurons couldn't show.

README also in Russian.

Godot horror game where a fly with a MaleCNS-derived brain hunts you.

A Brian2 bridge from Eon’s fly-brain to MuJoCo.

A PyTorch MPS simulator for Apple Silicon.

Official MaleCNS website: release history, downloads and a Dimorphism Explorer comparing male and female cell types.

A 3D lab with a 51-body giant-fiber microcircuit; reports a negative topology-control result.

People Playground mod: a fly brain controls a human ragdoll.

Arcade: swat a fly whose 6,000-neuron escape circuit you can watch firing.

MaleCNS as a sparse trainable layer for NumPy, PyTorch and TensorFlow.

Haiku written by mushroom-body reinforcement learning, as a “fly font”.

Chess on FlyWire with a Rust/WASM simulation in the browser.

The move readout is hand-built and untrained.

The connectome in the Craftax survival environment.

The descending-neuron readout is trained with PPO.

A benchmark: does the simulated fly still do what a real fly does? Sugar → proboscis, shadow → giant fiber.

An arcade control panel for injecting current into named MaleCNS populations.

Tic-tac-toe against a full MaleCNS LIF simulation; a readout on descending and VNC neurons is trained by self-play REINFORCE.

Wiring never modified; only the linear readout is trained. Self-hosted, no public demo.

MaleCNS spike vectors art-direct a six-shirt drop.

A 30,000-neuron flight circuit cut from MaleCNS flies an FPV drone in the Liftoff simulator via a virtual Xbox controller.

Connectome-constrained network; training tunes weights and a small linear readout to the sticks.

Compiles named MaleCNS circuits into int8 freestanding C99 for microcontrollers, bit-identical to the reference; no training.

A MaleCNS fly in a doppi cooks Uzbek plov in the browser; its neural output sets portion sizes and pauses.

Recipe order, body animation and dialogue are scripted; the network has not learned to cook.

A cross-platform DesktopFly on Electron.

A FlyWire fly learns to blow the shofar for Rosh Hashanah 5787 via dopamine-gated plasticity of mouth motor neurons.

Turns FlyWire v783 plus a compound-eye model into a trainable PyTorch Geometric vision model with a Kenyon-cell readout.

Wiring fixed; only per-synapse gains, thresholds and a linear readout are trained.

The “Bad Apple!!” video played on fly brain activity. 11.5M views.

A wee fly date between two connectomes — from the FlyWire artist.

The clip that got ~22M views in two days: a fly brain “playing” Beat Saber.

The author admits the motor system replays a trained sequence.

How does a fly feel about your logo?

A MaleCNS spiking network against Stockfish.

A fly brain steers a software fuzzer hunting for vulnerabilities.

The larval L1 connectome (Winding et al.) modulates a segmental VNC controller driving an 11-segment MuJoCo larva.

The browser demo uses a reduced controller; the full 2,952-node network runs locally.

A 24/7 CC0 radio inspired by MaleCNS.

FlyWire plus a NeuroMechFly body 'does' 1C:Enterprise labs: a PDF manual becomes configs that load into a real 1C base.

The fly only picks among moves the program prepares via named descending neurons; a small external decoder is trained.

The Shiu et al. brain model on Apple MLX with a Metal kernel: 1 s of brain time in 0.29 s on an M4 Pro vs 62.6 s in Brian2.

FlyWire v630, paper parameters unchanged; nothing is trained.

The Shiu model plus flyvis driving the NeuroMechFly v2 body: the fly forages, eats and grooms.

Body code not released; motor output via a few hand-picked neurons.

GPU simulator: full MaleCNS at 3,455 steps/s on one RTX 3090, or 64 flies at 51k fly-steps/s, same spikes as torch.sparse.

A directory of fly projects in English and Japanese.

All of FlyWire mapped onto 12 Intel Loihi 2 neuromorphic chips — orders of magnitude faster than numerical simulation.

84 songs are played into the ears of a full MaleCNS GPU simulation and ranked by the fly's neural response, with a 3D viewer.

FlyWire's 138,639 neurons spike in the browser, play three games and write exactly reproducible bug reports, with no LLM.

The author measures steering vs goal at zero correlation and says so up front.

FlyWire v783 on the GPU plays Vampire Survivors.

The fly plays drums.

A 50,229-neuron LIF model of FlyWire's central brain runs on an Adafruit Feather RP2350 microcontroller, poked over USB.

Dynamics, transmitter signs and stimulation are modeling choices, per the author.

The connectome graph as a policy network, trained with RL to walk a biomechanical fly — more sample-efficient than baselines.

A pet fly on your phone, offline: FlyWire's 138,584 neurons stepped as LIF cells in Rust, behaviour read from the activity.

The app shows on screen which input and output mappings are the authors' own choices.

An open world where the fly “gets to fly around forever” — the internet’s answer to the Beat Saber fly.

Announcement only so far.

A 4,386-neuron MaleCNS circuit slices fruit in a Fruit Ninja-style game through a pixel-to-activity-to-blade loop.

Reduced fixed-wiring rate model; visual and motor interfaces are engineered.

The fly assists an aircraft landing in the JSBSim flight simulator.

24 MaleCNS flies roam a Three.js world of real job listings built from your resume and surface the ones several revisit.

Likes and passes adjust learning-circuit connections; the activity decoder is learned.

Tests a frozen larval connectome as an MNIST/CIFAR reservoir against degree-preserving shuffles: +0.09 pp, p=0.51.

Negative result: the network is needed, its specific wiring is not.

Queries over the hemibrain, MANC, the optic lobe and MaleCNS.

Paint over MaleCNS neurons to stimulate them and watch walking, turning and escape drives respond; runs in WebGPU.

fruitfly.live names no author; it serves the same Neural Canvas app as Xenova's Hugging Face Space.

MaleCNS and flyvis drive a real hexapod robot through its camera.

One puff of cVA pheromone hits a male (MaleCNS) and a female (FlyWire) brain in your browser: he lunges, she pauses.

A 'what's real here' panel separates traced neurons from modeled behaviour.

A town of six flies, each a 30,000-neuron MaleCNS slice: chemotaxis, learning, courtship song. No LLM.

AU/VST3 plugin: your mix feeds the ear of a live FlyWire simulation and an animated fly reacts; audio passes through untouched.

Upload an ad and the MaleCNS retina and lamina (29,195 neurons, in-browser) score its pre-attentive visual salience.

Scores contrast salience only; the fly cannot read.

Benchmarks measured hemibrain mushroom-body wiring as a locality-sensitive hash against the random matrix used since FlyHash (2017).

Tamagotchi: keep a FlyWire fly alive for 50 days. Sugar goes to LB3, shadows to the LPLC2 → DNp01 escape path.

The anatomy atlas: 490k neurons with connectomics data, 3D viewer and CATMAID.

Full MaleCNS LIF model (165,122 neurons) drives a fly in a Godot 4 sandbox; place light, smell, heat, sound or sugar by mouse.

Controlled NeuroMechFly tests: gait needs no brain, but live FlyWire responses and real wiring beat replayed or shuffled ones.

Predicts sexually dimorphic cell types from male MaleCNS wiring alone: AUC-PR 0.759, above a degree-preserving null (p=0.002).

Unreviewed; flagged types are candidates, not findings.