Search by name, tag or description. Filter by category and dataset.
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.
Evan Sinclair Smith (@evnsnclr), Georgia Institute of Technology
A Minecraft fly driven by the full retained MaleCNS graph: 166,700 neurons and 25,582,938 directed edges, with six declared in-game inputs (player approach, nearby mobs, brushing, attack attempts, food, light) feeding the model and hand-chosen readouts selecting scripted body programs. The repository is currently a landing page and roadmap: the recorded demo exists, but the Fabric mod and companion source have not been published yet. The README is explicit that this shows a visible, testable mapping, not recovered fly physiology.
htem/BANC-project README (CC BY 4.0)Harvard Medical School (Lee & Wilson labs), Princeton University (Murthy lab), Harvard (Drugowitsch lab)
Connectome of a single adult female fruit fly imaged at 4 nm by serial-section EM, covering her brain and ventral nerve cord together at synapse resolution, which no earlier dataset had managed in one animal. The README reports about 188,000 neurons and 199 million predicted synapses; the analysis code (mostly R) and the Dataverse data are both released under CC BY 4.0. The paper by Bates, Phelps, Kim, Yang and colleagues was published open access in Nature in 2026.
DenisSergeevitch/desktop-fly README (MIT)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.
nftechie (Alex Wormuth)
A MaleCNS v1.0 spiking simulation wired to a live Doom arena: each frame stimulates visual input neurons, activity propagates through 166,700 neurons, and motor output is decoded into movement and firing. The README is candid that learned survival has not been demonstrated yet.
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.
blendi-remade/fly-brain-minecraft README screenshot (MIT)blendi-remade
A Fabric mod for Minecraft 1.21.1 that runs the full neuPrint male-cns v1.0 connectome (about 176k neurons, 6.29M connections at 5+ synapses) as leaky integrate-and-fire units inside a fly mob, one thread per fly. In-game visual, smell, taste and touch stimuli feed sensory neurons, and decoded motor channels drive feeding, grooming, escape jumps, walking and flight. Includes a live brain-activity view, a HUD of population firing rates, and 56 JUnit tests; code is MIT, connectome data CC BY 4.0.
TuragaLab/flybody README (Apache-2.0)Google DeepMind / HHMI Janelia (Turaga Lab)
An anatomically detailed fruit-fly body for the MuJoCo physics engine, with articulated legs, wings, leg adhesion and ready-made reinforcement learning tasks for walking imitation, free flight and vision-guided flight. Published in Nature in 2025 and released under Apache-2.0.
Princeton University (Murthy & Seung labs) with the FlyWire consortium
Whole-brain connectome of an adult female fruit fly, built by AI segmentation of the FAFB electron-microscopy volume followed by community proofreading led from Princeton. Version 783, served through the Codex explorer, holds 139,255 proofread neurons and tens of millions of synapses with neurotransmitter predictions. The flagship paper (Dorkenwald et al.) appeared in Nature in 2024 alongside companion annotation papers.
University of Cambridge (Michael Winding et al.)
Complete synaptic wiring diagram of an entire insect brain, reconstructed from a first-instar Drosophila larva and published in Science in March 2023 by a team led by Michael Winding (University of Cambridge). It comprises 3,016 neurons and about 548,000 synapses, and the analysis highlighted heavy multisensory integration, interhemispheric crosstalk and recurrent circuit motifs.
HHMI Janelia FlyEM / University of Cambridge / MRC LMB / Google Research
A complete wiring diagram of an adult male fruit fly’s central nervous system, combining the brain, optic lobes and ventral nerve cord with more than 166,000 neurons. The CC-BY dataset reached v1.0 on 2026-06-08; the Cell paper was published on 2026-09-03. These are separate release events.
navis-org/navis docs (GPL-3.0)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.
NeLy-EPFL/flygym README banner (Apache-2.0)Neuroengineering Laboratory (NeLy), EPFL
EPFL's digital twin of the adult fruit fly: a micro-CT-derived biomechanical body simulated in MuJoCo with compound-eye vision, olfaction, leg adhesion, mechanosensory feedback and a hierarchical brain/VNC control architecture. NeuroMechFly v2 was published in Nature Methods in November 2024 (Wang-Chen, Ramdya et al.), and the FlyGym 2.0 rewrite released in April 2026 brought roughly 10x faster CPU simulation and about 300x faster GPU simulation via Warp/MJWarp. It is the body used by the Eon and Rojas embodied whole-brain projects.
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.
michelangeloromerochisco (@michelangeloromerochisco)
A controlled study that freezes the larval Drosophila connectome of Winding et al. 2023 (2,952 neurons, 38,401 edges at the three-synapse threshold) as the recurrent substrate of a byte-level language model, against degree-preserving shuffles, Erdos-Renyi graphs, weight erasure and a hub-capping arm. Decision rules were written before the data, four seeds ran to 150M training bytes, and the whole thing fits in roughly 277 GPU-hours on one 4 GB laptop GPU. The paper title carries the finding: at this scale, hub concentration masks the benefit of the biological wiring.
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.
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.
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.
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.
@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.
@abstractionthief
The looming-escape circuit of the MaleCNS connectome, exported as a 766-neuron model, stands in as StepMania's second player: each arrow becomes a threat from one direction and a fixed readout of descending neurons picks the key. On the sample charts the circuit took 100% of the notes on the three easiest and 97% on a 152-note chart, while three rewired copies of the same circuit managed 35 to 47%. The README is blunt that this is not a fly playing the game: the arrow-to-threat mapping is hand-made, there is no vision, and model time is not biological time.
@CROmartin
A Flappy-style game whose flap decision is read out of a frozen MaleCNS simulation of 166,700 neurons and 25,582,938 connections: hand-designed channels drive the looming and position cells, 1,314 descending traces go through PCA and logistic regression, and only that readout learns. The measured table is the point. Over 30 unseen seeds the fly readout cleared 0.07 pipes on average against 0.23 for random and 6.70 for the scripted oracle, and one DAgger round took both the fly and a three-input logistic baseline to 0.00.
@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.
@arpanguria68-ui
Feeds a video or a song into the MaleCNS connectome, 166,700 neurons and 25.6 M connections, frame by frame: light reaches 6,006 photoreceptors at their own eye columns and the soundtrack reaches 138 Johnston's organ neurons, with nothing after the receptors trained. On a test clip the looming cells rose to 2.92 spikes per neuron per second for an approaching disc against 0.53 while still. The music test, with its four questions fixed before running, checks the brain against its own ear input and against a degree-preserving rewired copy.
@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.
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.
@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.
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.
OpenUploading (@OpenUploading)
A Python workflow for training task-specific models on a MaleCNS graph and running them in an application: bind observations to chosen body IDs, train a readout, input and output adapters or bounded per-neuron gains, evaluate held-out episodes, and export a pickle-free checkpoint that carries the graph fingerprint, ordered channels and provenance. Matched recurrent, zero-edge and ridge baselines are included. The README declines the usual claims, saying anatomical connectivity is only an experimental prior and that the most useful next result would be a well-controlled study of when it helps.
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.
victory-c (@victory-c)
Re-implements the Shiu et al. whole-brain leaky integrate-and-fire model in PyTorch on MaleCNS v1.0, with a test that builds one random network in Brian2 and one in this engine and demands identical spikes at identical steps. It then replays the paper's taste and antennal stimulation sets on 166,700 neurons and puts the network in charge of a road bike learning to ride through side gusts. The synaptic scale is recalibrated for the denser male wiring, and the README reports that the male CNS cannot both match the published feeding gain and stay stable: at that scale bitter drive runs away.
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.
Nobuhiro Kuroiwa (@hamling-ling)
Extraction scripts that cut two circuits out of MaleCNS v1.0 for an Arduino Uno Q robot car: the Giant Fiber looming escape, 327 cells covering LC4 and LPLC2 inputs, DNp01, and the TTMn, PSI and DLMn motor side, and separately the left and right DNa02 steering pair. Both are written out as neuron and edge tables with transmitter signs. The notes are careful about the gap: the GF-to-TTMn and GF-to-PSI links that actually drive escape are electrical synapses and absent from the data, so the first simulation reads DNp01 spikes instead. A desk-run chemotaxis notebook needs no hardware.
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.
supat-roong (@supat-roong)
Builds a PPO policy for Gymnasium CarRacing-v3 out of a 3,350-neuron MaleCNS v1.0 steering subgraph with 164,773 connections, keeping each presynaptic neuron's transmitter sign and learning only strengths, time constants, biases and the visual projection. Three controls share the pipeline: a degree-preserving shuffle of the same graph, real wiring with shuffled excitatory and inhibitory labels, and a plain MLP. Over 100 held-out tracks the real wiring scores 903.2 and never drops below 796, the only core to clear the 900 solved threshold, though medians are close and each core had one seed.
hsilvosa (@hsilvosa)
Puts a virtual fly in procedurally generated rooms and runs the annotated MaleCNS v1.0 graph (167,184 neurons, 25,583,622 directed edges) as a fixed recurrent model between simulated sensors and flight commands. Two controller families are compared: PPO policies and an explicit observed-map planner. Much of the README is a record of failure. Learned policies reach 61/64 goals through one wide gate but 0/64 in the 48 x 48 room with five narrow passages, where only the hand-written planner works (13/16 frozen). It states that navigation success does not establish an advantage from fly wiring.
Warpfield (@castor639)
Two copies of the MaleCNS v1.0 network, 163,903 neurons and 6,235,682 connections at the usual five-synapse cutoff, rally a ball across a scaled tennis court with nothing trained. Each fly reads the ball's bearing from four small-object medulla cell types compared against a twin network that never sees the ball, then walks. In one 40-second match the released wiring lands 54 hits, the same synapses connected at random land 10, and a fly parked at centre lands 14, so the shuffled control does worse than not moving. The swing and return placement are scripted.
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.
ORI-Muchim (@ORI-Muchim)
Trains a hand-built Drosophila visual pathway to drive a car from 1728 ommatidia alone, then swaps in the whole MaleCNS graph (162,432 neurons, 24,380,527 edges) as the policy, learning only per-neuron dynamics and the input and output maps. Untrained T4 and T5 motion detectors reach direction-selectivity 0.98 and 0.89 straight from the wiring. At a matched 740k steps the frozen connectome drives crash-free where the hand-built pathway does not, but with six times the budget the hand-built model holds the lane at 0.70 m against 1.6 m, fine-tuning the brain hurt, and it costs 25x more per step.
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.
Vlet0 (@Vlet0)
Cuts a navigation-only sub-connectome out of MaleCNS v1.0. Olfactory, gustatory and reproductive neurons are excluded first, then a bidirectional three-hop breadth-first search from visual, central-complex, descending, wing, leg, haltere and neck seeds leaves roughly 28,000 of about 166,000 neurons in a file that loads in seconds. Both the hop count and the three-synapse traversal threshold are argued for, with the neuron count each hop setting yields and a reason for dropping single-synapse edges. A CLI downloads, builds, inspects and queries the result.
fogfish (@fogfish)
Cuts small spiking brains out of MaleCNS v1.0 and runs each fly in its own Web Worker in a browser arcade world, from an 11-neuron circuit up to a forager of about 3,400 neurons and 205K connections. The world reports odour at each antenna plus taste and never steers: walking, turning and feeding come only from output spike rates. Weights are signed synapse counts divided by each target's total input, and hunger scales sensory gain. Three optional mechanisms cure the lockstep firing a large subgraph shows. A change is kept only if it beats a random walk and a size-matched random graph.
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.
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.
brvnw2d5tk-ctrl (@brvnw2d5tk-ctrl)
A blinded, tool-mediated benchmark that asks whether an autonomous-scientist agent can find targets in the male Drosophila CNS connectome through an oracle it cannot see past; the agent evaluated here was GLM-5.3. The release ships the benchmark, blinding and scoring library, frozen paper-level results, figure sources and four offline reproduction scripts that make no model API calls. It is explicit about what is withheld: the private-state test suite and member-level ground truth stay controlled, and the supplementary wrappers are not a complete independently runnable reconstruction.
Felipe (@FelipeJackFox), LEIA
A mushroom body taken from the MaleCNS connectome - 4,064 Kenyon cells, 97 output neurons, PAM and PPL1 dopamine - learns Minesweeper from two signals only: heat on a mine, sugar on a safe tile. It wins 78.4 percent of 9x9 boards with 12 mines over 2,000 unseen boards, and the write-up notes that a hand-written single-point rule wins 81.8 percent on the same boards. Two findings are stated as negatives: the advantage is sample efficiency over a plain table that ties given unlimited play, and shuffling the real wiring changes nothing.
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.
arpanguria68-ui
Wires a frozen MaleCNS v1.0 nervous system - 166,700 neurons, 25.6M connections - to an NES emulator: twenty times a second the game picture enters the fly's own motion and object detectors, and its descending neurons press the controller, with a small learner paid in score and punished by lost lives. It ships the control experiment, not just the demo. Real against scrambled wiring on Super Mario Bros., five runs each, covered 3,214 against 563 pixels of new ground; holding right with no brain covered none.
Srikar Jy (@srikarjy)
Asks whether a mushroom-body sparse code, built on real projection-neuron to Kenyon-cell edges from the hemibrain, can find high-fitness protein variants on a small measurement budget, and answers no. Across 10 ProteinGym assays and 20 seeds at matched budgets, the fly learner reaches the top 1 percent in 30.5 percent of runs at 50 measurements against 54.5 for an evolutionary search and 40.0 for plain random search. An ablation finds real hemibrain wiring slightly worse than random wiring.
Sadiq Khan (@sadiqkhzn)
Drives a NeuroMechFly body in MuJoCo from the male ventral nerve cord alone: 24,115 neurons and 1.77M edges pulled from male-cns:v1.0 over neuPrint, split by neurotransmitter into 1,026,234 excitatory and 693,369 inhibitory edges. Only a thin command interface is learned; the wiring is never touched. The validation table reports what fails: a moonwalker drive raises the motor pool 349-fold, but DNp09 suppresses walking by only 16 percent and tripod anti-phase never appears, which the author puts down to the missing proprioceptive loop.
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.
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.
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.
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.
SEKY443 (@SEKY443)
The flippers of 3D Pinball Space Cadet, compiled to WebAssembly in a fake Windows XP desktop, are pressed by the fly's own looming-escape circuit from MaleCNS v1.0: 373 neurons, LC4 and LPLC2 into the two giant fibers, with real synapse counts and signs, nothing trained. Each looming cell watches its own spot along a flipper; a giant fiber that fires presses it. The untrained circuit plays about as well as a trained 444-neuron brain from the same data, and unlike that one it beats six degree-preserving shuffles over 96 paired lives each. Both stay a little below a hand-written reflex.
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.
0Sakura721 (@0Sakura721)
Drives a closed-loop aiming task from MaleCNS v1.0, 166,700 neurons and 25,582,938 edges, against a degree-preserving shuffle, a PID ceiling and a random floor on matched seeds and frame budgets. The pre-registered verdict is that the wiring makes no causal contribution, and the result is stronger: both network arms end up significantly further from the target than random, 412.5 and 430.9 pixels against 251.7. Making the connectome weights learnable under a three-factor rule failed all three gates too. The README insists what is refuted is this LIF model with static weights, not the fly.
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.
Robert Troska (@ProfTAlent)
Puts the fly's olfactory circuit from MaleCNS v1.0 on a real blog's gate, in C# on .NET 10: 2,635 receptor neurons, 686 projection neurons, 2,044 Kenyon cells, 49 output neurons and APL, with each request turned into an odour. 142,770 anonymized requests from the author's own site ship with the repo, so a run needs no download. The honest headline: the fly is not a better gatekeeper than plain cosine similarity, which catches 62-98% of probes where the fly catches 23-88%. Six punishments block almost all probes but two thirds of readers too, and three rewards bring readers back to 1.3%.
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.
cknisaac (@cknisaac)
Asks whether a small circuit chosen from MaleCNS v1.0, 32 Kenyon cells onto the output neuron MBON05 taught by anatomy-selected dopamine neurons, changes its response after a teaching signal, and reports a frozen failure. Teaching at the wrong region produced a first action at position 0.20 that persisted once teaching and learning were switched off, while teaching at the intended target near 0.70 produced none at all, so the declared behavioural test failed even though the plasticity mechanism itself ran. The repo calls that mechanistic success with behavioural robustness incomplete.
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.
jasonfye2015 (@jasonfye2015)
A retro dungeon crawler where the monster hunting you has no scripted AI: its decisions come from 4,501 real mushroom-body neurons extracted from the MaleCNS v1.0 connectome, and it learns from dopamine while it hunts. Senses excite 4,064 Kenyon cells through random claws with only the top 5% firing, and those drive 97 MBONs through their real connectome synapses, each voting approach or avoid. The README is explicit that this direction is not programmed but falls out of the wiring. Dopamine updates only recently active KC-to-MBON synapses through a fading eligibility tag.
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%).
klasinlapaprechar (@klasinlapaprechar)
Two simulated flies spar in a ring, and the fighter's brain is a 6,170-neuron circuit cut from the male CNS connectome via neuPrint: LC10 opponent trackers, LPLC2 and LC4 for incoming strikes, bristle and leg touch, Johnston's-organ balance, the pC1 aggression cluster, PAM reward cells and all 1,314 descending neurons. The wiring never changes; recurrent PPO learns 14,910 parameters of gains and a descending readout on a flybody fly in MuJoCo. By update 2,000 it netted +9.1 points per bout with 65% of strikes landing, after losing to the scripted veteran at updates 1,000 and 1,500.
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.
victory-c (@victory-c)
Takes the Fly Bar whole-CNS spiking simulator (sstamou03/fly_brain, vendored unmodified as this repo's first commit and credited as such) and asks it to ride a road bike. The interesting part is what did not work: the walking command neurons from the literature do not track the bike's lean, with MDN firing 5-19 Hz regardless, so steering had to come from flight-stabilisation descending neurons (DNp20, DNg46, DNp22) instead. A 71-parameter decoder fitted to a PD teacher at R-squared 0.75 keeps 16 riders up a mean 14.1 s of 15 s, 9 never falling. The connectome is never changed.
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.
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.
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.
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.
neomorrison (@neomorrison)
Puts the male fly's CNS in charge of a 1.74 m, 72 kg humanoid. All 141,615 traced maleCNS brain neurons (86 M synapses) run as leaky integrate-and-fire cells and decide where to turn, when to jump and when to eat; a PPO policy over 23 joints does the walking fly motor neurons cannot. Senses enter on identified cells (LC10, LPLC2/LC4, LB3 sugar receptors) and a fixed decoder reads named descending neurons. Hunger is added by hand, being absent from the wiring. One failure is reported: odour input gave no reliable steering or walking command, so food is found by sight, not smell.
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.
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.
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.
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.
Joonghui Cho, Minchan Kang, Daeshik Kim (@joonghui0926)
Paper code that fixes the MaleCNS v1.0 directed edge set and gives each retained edge one trainable scalar, then trains that recurrent graph on bounded addition and on a grounded relational language. The prepared graph has 166,700 nodes and 25,582,938 directed edges, with no threshold. A reproduce script recovers the paper's paired numbers from run records: 92.77% against 67.93% for addition, 61.59% against 44.17% for language, 71.35% for the anatomical graph in a locked graph-null, and 60.94% against 19.27% under a sensory shuffle. Degree-preserving rewires are the controls.
sakikoniko314-blip (@sakikoniko314-blip)
A Chinese-language record of trying to make a fly connectome model steer a robot towards a heat source on a Rockchip board, and of deciding to stop. It keeps the Mali-G610 Vulkan backend with its correctness checks and a rejected optimisation (8.516 ms against 8.339 ms), the mapping from 24x32 thermal frames to sensory input, paired experiments with failure attribution, and an occlusion probe where kept state recovered 16 of 36 against 20 of 36 when cleared. The author states no benefit over a conventional controller was shown and no real motor loop was closed.
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.
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.
jasonfye2015 (@jasonfye2015)
Puts a mushroom body of 5,191 MaleCNS v1.0 neurons, 686 of them projection neurons, underneath a local language model as its affective layer. What you type or show is embedded and drives the projection neurons; the real projection-neuron to Kenyon-cell wiring makes a sparse code, dopamine weakens Kenyon-cell synapses onto output neurons in its compartment, and the valence and arousal that come out are what the model speaks from. It gets no persona, only a factual description of its own mind. Memories are kept on reported salience and replayed when Kenyon-cell activity matches them.
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.
aryap1804 (@aryap1804)
A browser robot walks a road on MaleCNS v1.0 wiring: 1,771 real eye columns feed 4,664 LC and LPLC neurons through real synapses, 203 Kenyon cells per odour drive four output-neuron types, and an external decision model picks between descending neurons. The keeper is the separate Memory Lab, which runs seven classic Drosophila memory protocols on the same mushroom-body model with no API key: conditioning, an unpaired control, a forgetting curve, reversal, silencing PPL1 or PAM, and memory with output blocked, each cited to its paper. It lists effects the model cannot show.
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.
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.
0909-BoB (@0909-BoB)
A 6,194-neuron MaleCNS v1.0 subgraph pulled from neuPrint runs as a fixed spiking network under a small softmax readout that plays no-limit Texas Hold'em; the web table seats you against three flies. The README is blunt that the sensory mapping is invented and that folding or bluffing comes from the trained layer, not the wiring. Its notes document two reproducible training failures: one global reward baseline taught the decoder to fold pocket aces 99.9% of the time, and longer runs saturated the softmax so one action was picked whatever the hand.
deShal3v (@deShal3v)
Asks of flyvis, the connectome-constrained model of the fly optic lobe (64 cell types over 721 columns, 45,669 graded neurons), the question Stringer et al. asked of mouse V1: how fast does the population variance spectrum fall off for natural images? Across 50 trained models the exponent sits near 1 on PCs 11 to 100, median 1.18. Unlike V1 it then collapses to 0.25-0.38 under whitened images in every one of the 50, while V1 stays near 1.03. Layer exponents track the photoreceptor input, a linearised copy reproduces them within 0.03, and at mouse-like single-trial noise cvPCA recovers nothing.
NeuroLab contributors (@Echrem)
A Minecraft Forge mod that attaches a sparse leaky integrate-and-fire simulation of a male-cns v1.0 graph, 176,422 neurons and 6,287,749 retained connections stepped at 0.5 ms in 50 ms updates, to its own fly mob or, by command, to a sheep, villager or spider, pausing that mob's vanilla AI. A dashboard plots sixteen channels and telemetry is written as JSONL in the world folder. Because the neural motor channels can stay silent, a labelled hand-built fallback supplies movement, and both dashboard and log mark when it is active. No time constant or decoding was fitted.
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.
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.
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.
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.
Curt Park (@Curt-Park)
Two mushroom bodies wired from MaleCNS v1.0, one per push direction, learn to balance CartPole under a dopamine prediction error. They hold the pole for 392.5 steps on average over the last hundred episodes across 20 evaluation seeds, against 18.7 with plasticity off and 22.8 for random pushes. Shuffled wiring scores 390.3, which a permutation test puts at p = 0.48, so the layout rather than the exact synapse map is doing the work. The log of nineteen tested hypotheses is the real document: plasticity that can only weaken synapses exhausts them.
S1MS4 (@S1MS4)
Two ways of making the MaleCNS wiring play chess, built so they can be compared. One keeps every connection's place and sign but trains its strength with backprop on Lichess positions; the other freezes the measured brain and lets only the mushroom body change under dopamine. The board enters through photoreceptors binned into an eight by eight grid of the eye, spreads for twelve steps, and is read out of the descending neurons. A sliced custom sparse gradient keeps a ten-million-connection backward pass in 8 GB. Shuffled-wiring and lesion controls are flags, but no strength is measured yet.
Guan et al. (HKUST)
Fixed-weight rate models of the adult fly leg motor system, built from MaleCNS v1.0 and MANC v1.0 and compared with six families of rewired networks under criteria fixed before the runs. It also runs the motor-input reassignment, rescue, capped-reassignment and sign-perturbation experiments. The manuscript build recomputes every reported number from the data and fails on any mismatch; noise streams are seeded, so a confirmation run reproduces the archived window to within 1e-16. Neither connectome is redistributed: you supply the public flat files.
miwamasa (@miwamasa)
A rate model of the fly central complex extracted from MaleCNS v1.0, 2,308 neurons and 187,137 signed connections in a 1 MB quantized file, with two write-ups on it. The first recovers the heading ring from connectivity alone and finds ring-attractor motifs and a shifted comparator in the kernels; quantizing the weights acts as pruning, and a 166-neuron, 932-synapse circuit still steers in closed loop. The second argues the plain wiring is a heading servo, not a travel servo, and tests the two missing multiplications as a declared circuit. What is not from the wiring is marked an assumption.
nevchr (@nevchr)
One fruit fly applies for software jobs forever, and every visitor watches the same career: the same applications, interviews, rejections and rare offers. The backend loads a MaleCNS v1.0 runtime with 166,700 neurons and 25,582,938 processed model edges, encodes the career state as sensory input and decodes descending neurons into the next action; a seeded mock backend is kept for tests and the interface says which is running. The anatomy panel draws 125,020 mapped soma positions and seven traced skeletons, and calls the spark travelling along a branch an illustrative animation.
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.
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.
@manas-dange
Uses a 1,243-neuron central-complex subgraph of MaleCNS v1.0 as the frozen recurrent layer of a PPO navigation agent, and compares it against three alternatives rather than presenting it alone. The connectome agent reaches 90% of peak reward in 1,200 episodes against 1,450 for an unconstrained MLP; keeping the topology but randomising the synapse values costs about 7%, and pruning the weakest half of the synapses costs about 3.5%. A Three.js page renders the subgraph and runs the agents side by side. Note that without a neuPrint token the code falls back to a synthetic central complex.
@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.
@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.
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.
Ewan Wu (@EwanWu06)
A bilingual interactive explainer that runs the control experiment most fly-brain demos skip. It rebuilds the 364-neuron giant fiber escape circuit from MaleCNS v1.0, pre-registers the pass criteria in timestamped commits, then tests it against four published electrophysiology results and reports that only one is reproduced: firing when the looming disk spans 34 to 37 degrees. Degree-preserving rewiring down to 40.6% intact moves that threshold by 0.11 degrees. The page also flags a bug in its own criterion code, where an absent response satisfied a test trivially.
@louiscreatesai
A browser page of gym scenes that is honest about a distinction most demos blur: nothing is simulated live. Specific sensory or descending neurons of a MaleCNS v1.0 LIF model were driven for one second offline, every spike was saved, and the brain panel replays one trial at 0.35x, naming which neurons were stimulated. The blackjack scene is the most interesting: the hit-or-stand rule, whether MN9 still fires above half its sugar-only rate, was fixed before any run, and the fly only hits on 4. The page says outright that this is a model of wiring, not a mind.
@Shirtep
A fly plays the rhythm game osu!mania on four keys, and the accounting of what learns is clear: a fixed MaleCNS subgraph of 3,418 neurons and 242,111 synapses is never modified, and a small controller of four GRUs with 352,971 parameters is what trains. Perception is causal, a retina of four lanes by 128 rows plus 40 ms of past audio, with no access to the chart or note timings. Training is imitation via DAgger from a teacher that exists only during training, with no reward. The keys are pressed through a NeuroMechFly body with 16 ms of actuator delay and jitter.
@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.
@pasangimhana
A hybrid worth looking at for how the two halves are separated. The measured MaleCNS wiring does the sensing and the memory: a compound eye laid out on 1,771 real eye columns feeds 4,664 LC and LPLC projection neurons, and odours travel real projection-neuron to Kenyon-cell to MBON paths where dopamine weakens KC-to-MBON synapses to form an association. An external language model only chooses which of a handful of descending neurons fires next. The demo conditions the robot on toxic waste and honey, then shows it avoiding and seeking them.
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.
@nazkari86-lab
A sparse-connectome research platform whose scope statement is the point: it verifies data contracts, imports directed sparse graphs, runs deterministic LIF dynamics, performs paired cell-type lesions, restores checkpoints and exports experiment bundles, and says it is not yet an embodied fly. Its autonomy demo is labelled accordingly, combining reflexes, potential-field control and a tabular Q-learning residual with FlyGym's own locomotion controller; the seed-7 run reached food in 12 of 12 held-out arenas. The README calls that engineering, not evidence.
@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.
@ArisLiWind
A fork of NeLy-EPFL's FlyGym that wires the BANC v888 connectome into the walking controller, which is rare: most embodied projects use FlyWire or MaleCNS. A descending neuron such as DNpe053 is simulated with its local circuit, and its firing rate scales the tripod pattern generator's amplitude. A second script closes the loop at every 0.1 ms physics step: joint angles drive 18 leg sensory neurons, an LIF network of 50 BANC neurons updates online with STDP, and motor-pool spikes become per-leg gains. A bundled script checks overlap coverage and self-loops.
@KapilSareen
A browser town whose human-looking citizens each run a pruned piece of MaleCNS v1.0 as a live spiking network: 8,000 neurons and 234,363 connections cut from the 163,903-neuron graph, one brain per citizen, nothing trained. Feeding, escape, courtship, aggression, grooming and sleep come out of the wiring; a goal layer turns those drives into going to a cafe or picking a fight, and that layer is hand-made. Female citizens are the male wiring with male-specific cells silenced, which the README states plainly. Selecting a citizen opens a live raster of their 8,000 neurons.
@SolidifiedPlayDoh
A head-to-head race rather than a solo demo: a MaleCNS v1.0 brain and a language model run the same Roblox maze to the same apple, so the two navigation strategies can be watched side by side. The connectome stays frozen; Roblox raycasts drive the fly's own feature-detector cells and a small readout turns spikes into walking and turning, with DNg100 walking, DNa02 steering, MDN reversing and DNp01 jumping. The language model never sees the screen, only a ring of distances, the apple's smell and its own trail.
@alok-108
A lesion study rather than a demo. A 1,000-neuron subnetwork of the Janelia hemibrain, picked by highest total degree (113,089 directed edges), is run as a point LIF network, and then neurons are deleted to see what the dynamics need. Removing 10% of the hubs cuts recruited unstimulated neurons from 653 to 92, while deleting twice as many at random leaves 299 on average. A sweep of 157 runs varies drive fraction, coupling and timestep. The limitations section is blunt: every synapse is modelled as excitatory, so high coupling runs away, and the hub-enriched sample must not be generalised.
@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.
@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.
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.
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.
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.
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.
WerG0D
A follower NPC in a commercial game, Baldur's Gate 3, whose decisions come from a frozen MaleCNS v1.0 network (166,700 neurons, 25,582,938 aggregated connections, 1,314 descending neurons). The Script Extender writes an observation file, a Python bridge encodes it as an abstract stimulus, and descending spikes are decoded into five actions. The status table separates what was exercised in a real save from what was not, and says plainly that the synthetic combat arena trains only an external readout and is not evidence of learned combat in the game.
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.
treewalkr
A ball-catching paddle driven by 4,706 MaleCNS neurons on a sensory-to-descending path (306k edges, sign from consensus neurotransmitter). Every synapse stays frozen anatomy; only a linear readout over descending-neuron rates is trained by the cross-entropy method. Chance is 33%; reading out the connectome alone reaches 54%, and a champion-restart refinement climbs to 84.4% on held-out seeds. The README also lists what failed: dopamine/RPE plasticity, elitist CEM, cross-seed weight averaging, and subsampling the circuit below about 3k neurons.
icybb0903-sketch
A 9x9 game of Go in the browser against a fly: the board becomes a 415-dimensional encoding, runs through a fixed MaleCNS-derived graph of 139,662 positioned nodes and 5,536,347 filtered directed connections, and a trained output layer picks a legal move. The activity panel replays the same decision rather than decorative firing, and a failed checkpoint is an error rather than a silent fall back to an expert policy. The README is direct about the limits: playing strength, endgame judging and life-and-death rulings are unfinished, and only the wiring is real.
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.
ZENinjaneer
A go-kart steered by 165,122 MaleCNS neurons on the GPU, with every "this drives that" claim checked by stimulating the input and measuring the output: LC10a to same-side DNa02 at 130-185 spikes/s for chasing, LC4 and LPLC2 into the giant fiber at 250-400 spikes/s within about 10 ms for the escape jump, taste neurons into MN9 for eating. Nobody trained it, so the turns come out jerky and it slows down to turn. The caveats are stated too: the coarse excitatory/inhibitory rule leaves photoreceptors excitatory, so the eyes are driven by darkness.
BakonZHOU
A Windows desktop fly on a 16,711-neuron MaleCNS subset with 2,075,126 signed connections, roughly a tenth of the neurons, stepped as simplified LIF at 1 ms. What sets it apart from other desktop pets is that it ships the means to distrust it: a verification script recomputes SHA-256 of the official annotation download and re-checks every bodyId and connection against the compiled matrices, and ablation controls rerun the same seed and stimulus with synapses cut. The README states that hunger, health, respawn and screen collisions are ordinary program rules.
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%.
zogxray
A constructor that treats one measured nervous system as a blueprint rather than a target to copy: about 142k MaleCNS somata and a sampled process cloud are imported into an editable recipe, which can then be grown, carved and mutated in a 3D shell. The stated success test is that changing the recipe yields a different network that still works, and the README is blunt about what the project is not - not a digital twin of the fly, not end-to-end training of tens of millions of synapses. Raw and derived connectome clouds stay out of git and keep their upstream licences.
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.
bilalefekilic34 (@bilalefekilic34)
An interactive 3D trench run flown by a spiking network wired from named MaleCNS v1.0 circuits: LC10a for small-target tracking, DNp01 for wing beat and flight steering, dopaminergic PAM cells for reward, and a target-lock and firing feedback path. Vision comes from a 750-ommatidia compound-eye model, 375 per hemisphere, giving spherical gaze vectors and retinotopic optical-flow detection, with leaky integrate-and-fire membrane dynamics and synaptic delays. A Python neural engine streams telemetry over WebSockets to a Three.js scene. English and Turkish.
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.
AwesomeZun (@AwesomeZun)
A browser research demo in which up to 20 independent MaleCNS fly models fly among proteins and small molecules and build a preference from pre-computed AutoDock Vina docking scores. Each fly computes 167,122 selected neurons and 6,241,236 directed connections (only those with five or more synapses) in the visitor's own browser, with activity drawn on 28,195 measured soma positions; the reward enters 1,428 neurons annotated as taste. Three proteins and six molecules give eight executed combinations. The page states the scores are not measured binding affinity.
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.
hrodrigobaigorria (@hrodrigobaigorria)
The neural core of the author's stonkfly experiment with every market concept stripped out: hand it a 180x320 RGB frame and an optional reward or aversive pulse, and the retained MaleCNS v1.0 graph (166,700 neurons, 25.6M connections) returns a left / right / straight readout from the DNp20 steering populations plus its memory state. A conditioning assay tests whether that memory is associative using a 2x2 reversal control, and states the limits: a white frame fires only about 14 of 4,064 Kenyon cells, and the reward effect is twice the aversive one (15 reward cells against 2).
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.
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.
DylanZhangzzz (@DylanZhangzzz)
Feeds an ordinary webcam, or an Intel RealSense D435i with depth and IMU, into a MaleCNS whole-brain simulation by sampling RGB pixels at published left- and right-eye L2 directions. The maps resolve 847 of 886 left-eye and 847 of 893 right-eye L2 IDs, and a saved frame drove 229 left and 217 right inputs in full-model replay. The README keeps the accounting honest: the brightness-to-drive rule is an engineering approximation, not a validated response model, the field of view is an assumption rather than a calibration, and fresh binocular capture is still pending.
Pacsy1 (@Pacsy1)
A Minecraft Paper plugin that flies a bee with the FlyEM MaleCNS v1.0 connectome shipped inside the jar: 165,733 proofread neurons and 6,239,854 connections, run as a spiking network on its own thread. What the bee sees, smells, tastes, hears and feels enters the fly's sensory neurons, and its descending neurons steer. Commands let you become an odour source, poke 745 head bristle neurons, or drive and silence any of 11,751 cell types. Scripted experiments print rates: a rotating drum swaps left and right HS activity (145.5 against 19.3 Hz), and blinding it halves whole-CNS activity.
salsayid (@salsayid)
Asks whether a 196-neuron, 2,966-edge MaleCNS v1.0 optic-lobe subgraph (21,984 summed synaptic contacts, ten cell types) can request sensible signal phases for a post-game traffic queue model of three junctions in Lincoln, Nebraska. It can, by supervised imitation of a queue heuristic, and that is a negative result for the wiring: the measured circuit (93.20 queue-seconds per arrival), a rewired control (92.84), a conventional network (92.82) and the heuristic itself (93.26) all perform alike. The author says the test establishes no benefit from biological wiring.
TryDotAtwo (@TryDotAtwo)
A verification-first reimplementation of the whole-CNS fly model in Rust with C++ and CUDA kernels, built around a pinned copy of the original published model and a deterministic Brian2 fixture, reporting where it still fails. Double precision matches all 9,440 Brian2 spike events for the sugar pilot; single precision shifted the first near-threshold spike by one tick at 436.4 ms. The MaleCNS import is provenance-locked, with hashes, index bounds, row ordering and contact totals re-checked. The visual gate is still failed and the body diagnostic is not yet driven by the nervous system.
Chawakorn111 (@Chawakorn111)
A whole-MaleCNS spiking fly that decides for itself when to defecate. It eats, builds up gut pressure, senses that pressure through interoceptive neurons, and the action is read out of motor-population firing rates rather than compared against a threshold. Relief lowers the pressure and produces a dopamine-like homeostatic reward driving three-factor plasticity, so the fly gets quicker at relieving itself when full and settles on a preferred background song. The run shown uses a 100,000-neuron subset with 19,716,276 synapses, computed in a Web Worker in the browser.
@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.
Joshua Bradley (@joshuabradley012)
An attempt to close the loop from the MaleCNS connectome to a walking body, labelling every layer as validated, fitted or guessed. Each rung must match real-fly data and stop working when the wiring is scrambled. Tiling a fitted optic-lobe network onto the male eye gives correct direction preferences for all 16 T4/T5 types and a giant-fibre escape spike to looming; HS cells and DNa02 follow a rotating drum and eight NeuroMechFly flies turn with it, while three random rewirings abolish the signal. The whole-brain rung has failed five times and the fifth network still fails one of its two nulls.
@LengQingSnow
Compiles subgraphs of MaleCNS v1.0 into a time-multiplexed FPGA engine and keeps the whole numbered workflow, from subgraph extraction through CPU reference models and fixed-point compilation to measurements on an ALINX AXKU115 board at 200 MHz. Two circuits are checked against the fixed-point CPU model: a 6,279-neuron courtship-song candidate over 13 recorded conditions, and a 226-neuron LC10a to DNa02 candidate over 560 ordered spike events. The README states plainly that these are implementation-fidelity results for a chosen LIF model, not a claim about measured fly activity.
Weverton Guedes (@owevertonguedes)
Runs the classic punished-odour experiment on the male-cns v1.0 mushroom body and adds the controls that say whether the learning is real. Across five odour pairs, 200 flies each, avoidance of the punished odour rises from about 45% to 70-80% over 15 trials; punishment with no odour stays near chance, and shuffled wiring never learns because the punishment dopamine neuron reaches 409 Kenyon cells in the real graph but only 10 after shuffling. It also reports why the whole-brain model cannot learn this: two odours light up nearly the same Kenyon cells, 99% overlap at default inhibition.
@hldrnwnv
Asks whether MaleCNS wiring can pick which way a virtual quadcopter should yaw. A target angle drives left or right LC10a cells, activity propagates through the fixed graph, and a linear decoder reads the sign of the turn off the two DNa02 descending neurons; a geometric controller and three degree-preserving shuffled graphs fly the same runs. The negatives are kept: driving the four rotors straight from wing motor neurons crashed after 1.23 s with no b1/b2 spikes, and odour-only navigation reached 4 of 8 targets against 6 of 8 for direct concentrations and 0 of 8 with the sides swapped.
@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.
@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.
@Aur1ety
Builds the mushroom body out of MaleCNS synapse counts, adds the published dopamine rule, and reports what the wiring decides rather than what the author fitted. Memory specificity, spread to similar odours and the direction of choice come out of the anatomy; the size of the memory is one calibration and is not counted. The failures are listed beside the successes: two memories in the same compartment do not coexist, there is no pattern completion, the real APL loop does not sharpen the odour code, and the recurrent whole-brain model cannot produce a sparse Kenyon code at any threshold.
@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.
@rgh112
A Korean-language browser simulator in which two urban air mobility aircraft fly in 3D and a recurrent network wired from MaleCNS v1.0 picks checkpoints and the return leg, trained by reward from the flight itself. The extract is a 350-neuron subcircuit of 13 types with 15,182 directed connections, keeping the original body IDs, edge directions and synapse counts, with the extraction conditions recorded in a manifest. The page is careful about what it shows: attitude stabilisation and rotor control are fixed, and the bundled example is one seed after 20 training rounds.
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.
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.
baltap (@baltap)
The game is projected onto the fly's compound eye and travels through its own optic lobe wiring, taken from the male central nervous system connectome; 79,992 spiking neurons are simulated every millisecond in the browser with every spike drawn at its real position. Each crash or cleared pipe releases dopamine that changes synapses, so a newborn fly crashes into nearly every pipe and a few hundred lives later clears dozens in a row. Switches turn learning, exploration and the innate gap attraction off separately, which makes the claim checkable.
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.
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.
rashmina-a (@rashmina-a)
Two pages served by one small Python server, no build step. The first draws the male central nervous system connectome in 3D, colours neurons by neurotransmitter, and lets you fire a stimulus, pull up a single neuron's skeleton and follow its real connectivity. The second drops an agent running the olfactory chain from receptor neurons through projection neurons to Kenyon cells and mushroom-body output neurons, with dopaminergic learning, into a 2D foraging world, and evolves its sensorimotor policy at hundreds of generations per second before you experiment on the trained fly.
dimm0909 (@dimm0909)
A desktop widget: an anatomical fly in a glass jar you can poke, rotate and shake, in a frameless transparent window that can sit on the wallpaper beneath every other window. The behaviour is not animation. A separate C++ process simulates the MaleCNS connectome, 164,606 neurons, event-driven so it costs almost nothing at rest, and four named descending neurons decide when the fly flies, turns, walks or reacts to a poke. The body is the FlyBody model with two-segment leg inverse kinematics. The README says the widget did not start on Windows, which Linux and X11 are the tested path.
Alex Grossi (@alexgrossidev)
A hundred real neurons and 3,630 real connections compiled into a recurrent network in PyTorch, trained to say whether a stream of ten digits contained a 6 or a 7. Gradient descent may change a connection's strength but may never invent one that the animal does not have. It works, and the author leads with the part that deflates it: a degree-preserving rewiring of the same neurons learns the task exactly as well, so the result is about connectome-constrained learning in general and not about this fly. A viewer replays the trained activity on the real neuron positions.
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.
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.
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.
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.
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.
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.
david93518 (@david93518)
A local security investigation workbench with a connectome laboratory bolted on, and the value here is the result it reports against itself. A MaleCNS v1.0 subgraph of 5,269 neurons and 152,689 directed edges runs an engineering update rule, and the repo says plainly that its activity values are neither firing rates nor attack probabilities. Held-out network-intrusion data gives the real wiring 76.77% average precision against 77.20%, 77.28% and 76.06% for three degree-preserving rewirings, and 82.34% for the encoder alone. The biological topology did not help.
FlyFace contributors (@8S8642)
Presents photographs of human faces to a simulation built from MaleCNS v1.0 and records what the neurons do. The playful framing is an A/B preference, but the structured output keeps every measurement and marks the descending-neuron orientation readout as unvalidated. The result is a negative one and is stated as such: responses are specific to individual images, and no global ranking emerges that matches human attractiveness ratings, nor the inverse of them. The pipeline verifies checksums on about 1.1 GB of source data before building the graph.
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.
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.
Ned Cutler (@nedcut)
A browser time-trial racer that was meant to have a connectome-driven opponent and ships without one, which is the point. The project set a pre-registered gate before any training was allowed to start: could an ordinary image network, given any of ten camera and sensor arrangements, predict hard braking well enough on courses it had not seen? None of the ten passed, so the gate closed and the recorded negative result names every score and notes that none of the three budgeted training runs was spent. The fly brain panel survives only as an untrained exhibit, and no fly opponent is planned.
AwesomeZun (@AwesomeZun)
Drug-safety case triage arranged after the layers of a fly's nervous system: wide cheap intake, cheap reflex judgements, sparse memory, rare deliberation, and a narrow bottleneck to a human queue. The bottleneck it targets is measured in the repo's own warehouse: 422,459 adverse-event reports in one quarter. A MaleCNS v1.0 central-brain subgraph of 49,244 neurons and 1.05 million signed connections runs as a firing-rate model in the browser at 30 Hz, so a decision lights the matching cell population and spreads along measured wiring. The routing policy itself is deterministic engineering.
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.
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.
mrgrit (@mrgrit)
Collision avoidance for a powered wheelchair, where the rider drives and the system only steps in when something is closing fast. A reduced MaleCNS v1.0 circuit of 187 neurons and 185 edges runs as a leaky integrate-and-fire model on a GPU behind an authenticated interface; a rule-based mock is kept as a separate mode for comparison. The README refuses the obvious overclaim: this is not a whole brain and not a physiologically validated model, and the validation so far is in a Webots simulation of three corridors, not on a real chair.
Jason Alan Snyder, SuperTruth Inc. (@evil-robot)
A pre-registered study that holds the MaleCNS v1.0 wiring fixed (166,700 cells, 6,242,118 connections of five or more synapses), trains only the connection strengths and the way in and out, and asks it to reproduce a health-record trust score on 20,000 synthetic records. Its headline result undercuts the headline: a scrambled copy and a size-matched random graph scored just as well, so what mattered was the kind of substrate, not the fly's anatomy. Four language models got the same 300 records for comparison. The protocol, five controls and decision rules were dated before the first run.
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.
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.
fkaempf
For any pair of neuron sets in the male CNS, classifies every synapse between them by whether it lands on the target's dendrite or on its axon, and writes out a table plus a Clio-NG scene that opens without hosting anything. Two implementations disagree and the README says which to trust: the navis split by synapse flow centrality is for numbers, while the single-edge R cut can land anywhere on a weakly polarised cell. On AVLP743m body 531383 it reports a segregation index of 0.01 where navis gets 0.20, and it calls 13% of AVLP749m to PAM01/PAM02 synapses axo-axonic where navis calls none.
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.
Piotr Abramski (@abstractionthief)
An R-to-Python-to-browser pipeline over the male CNS: neuPrint queries become a whole-connectome input/output map, a leaky-integrator dynamics demo and a static explorer showing the 140,024 traced neurons that have a recorded soma position, 84.8% of all 165,122. The export manifest records the classifier source hash and whether the recorded commit had local changes. Tests cover classification, graph metrics, pathway pruning and the browser exports, including responses arriving out of order; the README notes that they stub plotting, so visual behaviour still needs a check in a browser.
danilo-lazovic
Max-flow / min-cut analysis of the male CNS wiring, asking which neurons sit between a sense and the descending neurons that drive movement. Cutting to all 1,314 descending neurons says nothing: the cut is just the first relay layer, because the CNS is shallow, a median of two hops from any sense. Restricted to a single target it becomes informative, and the vision-to-giant-fiber cut is dominated by LPLC2 and LC4, known experimentally to drive looming escape. Removing those neurons leaves 83% of synapse flow against 99.99% for random on-path controls. The spiking ablation step is unfinished.
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.
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.
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.
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.
Rick Gorman (@rickgorman)
A webcam gaze tracker feeds a MaleCNS simulation. Browser-side MediaPipe turns iris positions and head pose into a screen point, and only the normalized direction from the on-screen fly to that point leaves the page. That drives LC4 and LPLC2 on each side, 80 ms of a 162,517-neuron, 6,138,378-connection leaky integrate-and-fire run, and a linear readout of 1,310 descending neurons' membrane voltage becomes a velocity. Only the readout is trained and the wiring stays fixed. The README states plainly that the connectome does not make gaze tracking more accurate.
Shriya Sai (@Shriya-sai)
A thirty-second game on a graph derived from MaleCNS v1.0: a signal starts at the LC4 cell-type group and tries to reach DNg108 while you cut or jam nodes to stop it, without destroying the structural routes to DNa13 and DNa02. The playable level is 21 cross-matched cell-type groups and 43 directed edges carrying measured male synapse totals from 19 to 11,597, committed as a reviewable JSON file. Every four seconds the fly recomputes its strongest surviving routes and reroutes, so redundancy, shared nodes and collateral damage become the thing you reason about.
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.
Felipe Santibáñez-Leal (@fsantibanezleal)
Compiles a connectome release into a graph a simulator can run, with every array verified against its SHA-256 and a table whose hash differs refused outright. It models both compound eyes over the release's own optic-lobe columns, 879 left and 892 right, then simulates the whole CNS with published equations: the Shiu leaky integrate-and-fire model, held identical to a literal Brian2 transcription, and Lappalainen's graded visual neurons, held to flyvis itself. A Python reference and a browser engine are kept to each other by parity tests. Not a general simulator, not a claim about behaviour.
pinkysworld
Links typed receptor evidence to named MaleCNS circuits (MN9, DNp01, labellar gustatory neurons), simulates a compound at a given free concentration, and then asks whether the predicted effect needed the wiring at all. Predictions are compared against ladders of degraded graphs preserving size and transmitter composition, degree, the edge list with shuffled weights, or transmitter labels permuted at matched out-strength; failing to distinguish an effect from a null is reported as exactly that. The two committed cuts disagree and the README says so. No biological validation yet.
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.
theworker02
A local studio over several insect connectome packs — neuPrint hemibrain, MANC and optic lobe, plus Insect Brain Database projectomes — browsed by silhouette and cell class rather than by lists of IDs. It reuses published level-0 and level-1 graphs instead of re-segmenting electron microscopy, keeps raw EM remote, and holds the local cache to a 10 GB ceiling; the shareable Pages build ships about 23 MB of catalogs against a 1.7 GB local pack footprint. Its stated rules include never merging the packs into an invented single insectome and never claiming synaptic connectivity without evidence.
Matheus Soranço (@Matheussoranco)
Uses the male CNS connectome as a sparse recurrent substrate for reinforcement learning: game frames are encoded into sensory neurons, activity propagates through the connectome-derived network, and a policy-gradient-trained readout decodes motor activity into buttons. Two tracks are reported honestly. A 40,000-neuron, 1,199,959-edge sensorimotor subgraph on a corridor task improved from -2.08 to 7.13 reward, success rate 25%. Full-connectome Super Mario reached about x=1,800 in some training episodes but averaged x=314 in evaluation, success rate 0, all five episodes ending in death.
Noir-infini
The MaleCNS graph — 166,700 neurons and 25.6 million chemical synapses, with no learning rules anywhere in it — is run as a vectorized leaky integrate-and-fire kernel at 0.1 ms steps with 1.8 ms synaptic delay queues, and drives a MuJoCo fly that hunts a spatial sugar plume and aims leg strikes at piano keys. Bilateral concentration feeds 23 antennal sugar receptor neurons, front-leg motor pool rates are published every 28.6 ms tick and turned into damped least-squares inverse-kinematics ramps, and a verified claw contact on a key top triggers the note and moves the sugar target on.
Shantanu Goel (@shantanugoel)
Mario, Kung Fu and Doom played by the frozen MaleCNS v1.0 network, 166,700 neurons and 25,582,938 synapses, none of it ever trained. Each game adds exactly two pieces. An encoder puts structured game facts on the right visual projection neurons and the right side of the body: LPLC2 for looming, LC4 for threat, LPLC1 for small approaching objects, LC10a for a chased target. Raw pixels are never used, since here the photoreceptor signal dies at the lamina. Then a small linear readout over twelve descending command populations, the only thing fitted.
turlockmike
Takes the MaleCNS wiring unchanged and trains it at chess by AlphaZero self-play. The board enters 17,937 sensory neurons, activity runs six steps through the graph, and the move and evaluation are read from 2,333 efferent and descending neurons; training adjusts only a gain per synapse, a resting level and time constant per neuron, and the linear maps. After 322,016 self-play games and 23 GPU hours it matches Stockfish at UCI Elo 1320. The failures are kept: adjudicating on material taught it that sitting on a lead was winning, and half precision erased a signal a hundredth the resting level.
Guillermo de Anda-Jauregui
An R pipeline that perturbs every annotated cell-type unit of the MaleCNS connectome once and summarises its downstream reach across effector channels with a linear propagation model over synapse counts normalised by input. Four hypotheses are stated before the run: whether the perturbome is low-dimensional, where types sit on a specialist-generalist axis, whether anatomically distinct types produce similar effects, and whether published descending-neuron phenotypes agree with predicted similarity. The model is deliberately unsigned because transmitter sign is not reliable for all classes.
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.
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.
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.
NKprime (primaryNK)
A Windows combat sandbox that computes two independent neural states from the BANC v888/v3 connectome — 188,508 neurons and 13,620,865 directed pairs — on Direct3D 12 at a 1 ms step, and lets their output drive sword, shield and movement actuators. There is no scripted attack or parry: hits, blocks, parries and dodges come from geometry and timing, and the learner only touches a small motor readout, never the BANC pairs. The author says it was built with heavy AI assistance, and ships source only for now because the unsigned binary trips a Defender detection they believe is a false positive.
AscendedStarr
A 512-neuron spiking mushroom body with 13,824 trainable Kenyon-cell to MBON synapses, taught 27 hand-drawn glyphs by a three-factor dopamine rule in under two minutes on one CPU thread, then read 168,985 letters out of a book without an error. The model has no digit output cell, so its 0 of 300 on digits is a structural guarantee rather than a modest score. Version 0.2.0 swaps the invented wiring for the measured hemibrain connectome and reports the uncomfortable result: the real wiring and a degree-matched shuffle of it both score 243 of 243 across three seeds, a paired difference of zero.
baltap
Three simulated flies share a 3D arena and communicate only through airborne odour plumes that diffuse, drift upward and decay on a 32-cubed grid. Each runs the same 24,029-neuron, 4.03-million-connection MaleCNS v1.0 subnetwork — olfactory pathway, mushroom body, central complex, T1 to T3 nerve cord and the strongest inputs to those regions — as a leaky integrate-and-fire network. Since no female connectome is published, the third fly is the same male wiring with a different parameter set. The README notes the engine's calibration does not hold without the significant-synapse table.
WKDev
Couples a male-cns v1.0 circuit — 360 leg motor neurons reached from DNg100 and DNb08 through interneurons — to the flybody MuJoCo fly and asks whether real wiring can ski. The terrain has slopes and moguls with five snow types, and the skis are seven-segment bending plates with camber, rocker and sidecut. The status table is blunt: the controller has only been trained on flat ground, a zero-action fly slides down an alpine slope standing but rolls over in moguls, and real versus shuffled versus random wiring showed no significant difference in three comparisons.
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.
shushuzn
A closed loop from the Tetris board through compound-eye photoreceptors, the MaleCNS spiking network and descending neurons back to a move, published with the finding that it does not work. Over 400-piece games the connectome agent clears zero lines and always tops out, while a Dellacherie baseline clears 156 and never does. It measures why: visual input raises photoreceptor firing about 20 percent but descending-neuron firing by 0.8 percent, because the tonic current and decay put the resting potential at 0.993 against a threshold of 1.0, so about 6 percent of cells fire on noise every tick.
NeuroFly (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.
szac74
Reproducibility code for the connectome analyses behind a SIFamide study. The original work was done interactively in neuPrint and no single script was archived, so this repository consolidates the query logic, neuron identifiers, filtering rules and site metadata into scripts that rerun the published numbers on hemibrain v1.2.1 and male-cns v1.0. A validation script checks configured totals; the authors report all key totals reproduced exactly. The README states plainly that mesh distances were screening metrics only and are not by themselves evidence of synaptic connectivity.
Kai Piper (kai9987kai)
A 132.6M-parameter language model, built and trained on a laptop CPU, carrying the whole male-cns v1.0 type graph — 11,751 cell types and 3,830,931 type-to-type edges — as a per-token recurrent core grafted into its residual stream beside branches distilled from other models. Held-out loss on connectome facts drops from 3.522 to 0.571 nats per token. The results do not oversell: only 1 of 32 grafted expert groups reproduces its teacher on held-out tokens, most of what transferred came from distillation, and writing new code or defining biomedical terms is called unusable after one CPU run.
IG Digital Lab (igdigitallab)
A lab harness that treats each published connectome as a fixed reservoir: load the wiring, run it as a spiking network, drive it with human-world input and read the response out without training the brain. The method is the point. Every run is pre-registered with hashed questions and seeds before the outcome is known, and every brain is scored against three controls: a rewired version of the same graph, a no-brain baseline and a coin flip. It ships the loaders, the LIF core, the scoring and the tests; the first experiment pairs a male and a female fly brain and is still at design stage.
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.
cchouse168
A fixed circuit of 80 MaleCNS v1.0 neurons and 1,296 measured synapses plays a browser runner game; the only trained part is a 269-parameter readout evolved by the cross-entropy method. On 100 unseen tracks the deployed model finishes 82, hand-written rules finish 25, and silencing the circuit or leaving the readout untrained finishes 0 — identical to doing nothing. The README refuses the obvious overclaim twice: 82/100 is one seed out of a 46–87 range, and no shuffled-connectome control was retrained, so this does not show the fly's wiring beats random wiring.
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.
SebSilent
An autonomous agent whose decision core is a structural carve of the BANC v888 brain-and-nerve-cord connectome: 12,867 neurons and 173,294 signed synapses from the published tables, out of a reconstruction of roughly 188,000. Text is hashed into a 16-of-3,840 sparse code over Kenyon cells, activity propagates for ten sub-steps, and 85 MBONs vote winner-take-all across 12 action pools. Only the 2,983 Kenyon-cell-to-MBON synapses learn, under a three-factor dopamine rule. A degree-matched random control graph can be built, so claims about the wiring can be tested against a scrambled brain.
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.
merfijang
One shared MaleCNS v1.0 fly of 166,700 neurons plays Flappy Bird on a server around the clock, and the unusual part is what buys it a try: a configurable amount of a token's accumulated trading fees pays for one attempt. Each attempt is one sample of an evolution strategy over the descending-neuron readout, so the training budget is set by trading activity. The connectome weights stay frozen and only 13 numbers learn. The base project's hand-written flight rules are removed, so the flap decision reaches the game only through the neurons, and a bias-only control is kept with the experiments.
Listed for information only. No endorsement, no referral links.
Jawaad Jariwala
Two arena fighters, both driven by the same 166,700-neuron MaleCNS connectome, with nothing trained: no reinforcement learning, no reward function, no learned policy on top. The only choices made were which neurons read the arena and which swing the weapon. The browser view draws every neuron at its real soma position, so you can watch a looming stimulus cross from the LC4 and LPLC2 detectors in the optic lobes, through descending neurons, to motor neurons in the nerve cord over about 100 ms. An object's angular expansion rate sets the detector firing rate.
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.
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.
leimi (w13630039663-bit)
A MaleCNS v1.0 circuit dodges bullet-hell patterns ported from Touhou 6: eight named visual channels, a frozen reservoir of measured synapses, sixteen descending neurons and a 320-parameter readout evolved by the cross-entropy method, the only trainable part. Ablating the circuit collapses play to a motionless baseline. The negative results are the real contribution: 80 to 600 neurons bought nothing, widening vision from 8 to 32 channels cost 26.2%, Hebbian plasticity flipped sign with the seed, denser wiring hurt, and against a rewired control the gap was -12 frames, p = 0.9351.
georgesher
A finished art piece, published as-is and no longer maintained: a fly sits in a 1990s kitchen in front of a television carrying live broadcast channels. Frames at 160x90 and 15 fps become input to 4,146 photoreceptors mapped onto optic-lobe columns, a MaleCNS v1.0 simulation of 166,700 neurons and 6.24 million connections runs at a 0.1 ms step, and after two model seconds the fly either stays or flies to the remote and changes channel. The author is careful: the network only receives pixels, and "bored" and "startled" are their own reading of Kenyon-cell and giant-fibre activity.
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.
Rodrigo Soto (SotoAlt)
A demonstration blockchain whose proof of work is a taste decision. Each block header hashes into a stimulus, real gustatory receptor neurons from the MaleCNS connectome are driven with it, and the resulting spike train is both the proof and the block contents: a transaction is included only if MN9, the motor neuron behind swallowing, fires — otherwise the fly spat it out. Eight flies in a row decide each block. Transactions are authorised by an ordinary secp256k1 signature over an EIP-712 digest, and connecting a wallet only changes which fly is cosmetically yours.
Listed for information only. No endorsement, no referral links.
EnesYilmazcode
Puts a connectome and a language model on the same Pong court under the same rules. Neither moves continuously: while the ball approaches, each player looks four times and picks one of eleven paddle heights, and neither is told where the ball will arrive. For the fly, each candidate becomes a picture centred where its paddle would be, landing on 3,316 real R1-R6 photoreceptors; the MaleCNS connectome then runs as a spiking network for 150 ms per candidate and a readout over 2,048 L1 and L2 neurons scores it. The wiring never changes. Across 300 games the fly won 274.
Seed123-psy
Runs the whole MaleCNS connectome — 166,700 neurons and 25,582,938 fixed connections — on a CPU and lets its activity drive a two-dimensional forage-and-avoid task, with a local web page showing the arena and a 3D brain side by side. You can pause, single-step, slow down, replay, search a neuron and follow its real upstream and downstream partners. The action readout can be compared three ways: trained offline, random, or a rule-based reference, and an online Double DQN can keep training it. The page samples 4,769 real soma positions and says the glow is illustrative.
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%.
Alvaro Rovira
A simulated fly in an arena whose behaviour comes from 20,000 MaleCNS v1.0 neurons and 1,319,744 signed connections, with nothing scripted: feeding fires when the proboscis motor neuron MN9 does, escape when the giant fibre crosses threshold, posture from leg motor neuron tone. Ethanol acts only on synaptic transmission, and hyperactivity, loss of leg tone, falls and loss of the righting reflex come out of that. A degree-preserving shuffled wiring is the control: odour-guided feeding drops from 97.5% to 0% and bitter rejection from 100% to 0%, while escape and sugar acceptance survive it.
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.
avisharm-alt (@avisharm-alt)
Graph machine learning on the complete MaleCNS v1.0 release, sized to run on a laptop. It downloads the official annotation, neurotransmitter and 1.1 GB connection-weight files from the public bucket, builds a sparse directed graph, learns separate outgoing and incoming embeddings per neuron with randomized SVD, then probes whether those unsupervised embeddings recover annotations such as neuron class and searches for structurally similar neurons. An optional PyTorch path trains edge-discrimination embeddings. Raw data is fetched, never redistributed.
pgq18 (@pgq18)
Wires the MaleCNS connectivity graph into a simulated mobile robot: sensor input drives neural activity and a policy readout produces corrections on top of a base navigation controller. The recipe that worked best trains internal connections and readout jointly for 65,536 steps, then freezes the connections and continues on the readout to 4,194,304. On 500 held-out maps with three seeds the mean success rate is 85.1% at about a million steps and 88.6% at four million, with 89.4% for the model picked by the pre-declared rule. Longer training did not help monotonically.
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.
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.
itznotnelo (@itznotnelo)
A reservoir-computing test of whether the larval Drosophila wiring from Winding et al. 2023 supports a Tetris policy better than a random graph with the same degree statistics. The spiking network built from the connectome is never trained; only a linear readout from descending neurons is fitted with CMA-ES, and a degree-matched rewired control is trained identically. The README is explicit about what is assumed rather than measured: signs are drawn at random because the dataset has none, the sensory pool is not fly vision, and the committed runs are too short to settle the comparison.
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.
jamesbiederbeck (@jamesbiederbeck)
Closes a loop from rendered compound-eye images through the MaleCNS v1.0 graph to wingbeat frequency and steering on a MuJoCo fly, then reports that no visual information is in the loop yet. Driving the retina makes all 3,335 photoreceptors and two descending types spike, but not one of the 708 ventral nerve cord motor neurons does, so a wing command cannot be read where it anatomically belongs. A frozen-vision control reproduces the live run exactly, so the variation comes from the connectome's own left-right asymmetry. The halteres exist in the model but nothing joins them to the afferents.
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.
GeorgeCanon (@GeorgeCanon)
Puts two pieces of real fly data into one agent that guesses a country from its silhouette: flyvis, a frozen connectome-constrained optic lobe model, as the eyes, and a recurrent network wired as the MaleCNS central complex to integrate direction-and-distance feedback across guesses. Only gains, biases and time constants are trained; the graph and the excitatory or inhibitory signs stay fixed. Over all 195 countries it solves 96% within six guesses, but a shuffled central complex reaches 95% and a random stub 95%, and a raw 16x16 pixel input beats the optic lobe on the first guess.
Ankit Kapoor (@ankitkapooor)
Feeds an uploaded time series into the MaleCNS v1.0 graph used as a frozen reservoir, a leaky rate model over a sparse matrix, samples 4,096 internal states as virtual electrodes and fits a ridge readout for multi-horizon forecasting. The split is chronological at 70/15/15 with the scaler fitted on the training part only, and an optional control scrambles connection magnitudes while preserving topology and weight distribution, so whether the measured weights matter is testable, not assumed. When an autoregressive ridge or naive persistence wins, the interface says so instead of hiding it.
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.
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.
Zikithezikit (@Zikithezikit)
A Python library for building spiking networks on fly connectome wiring. Its loader fetches either a small slice around a cell type or the whole graph from neuPrint and caches it on disk, with a synthetic offline fallback so every example runs without a token. The network object settles under sensory input, calibrates a sensor-to-motor mapping, returns a steering command, and lets you query synaptic partners and strengths neuron by neuron. Also ships leaky integrate-and-fire neurons, spike-timing-dependent plasticity, reward-modulated Hebbian training and a command line.
al0cam (@al0cam)
Draws one 3D scene twice, once the way a person sees it and once the way a fly does, where every viewing direction comes from a real Mi1 cell in MaleCNS v1.0: 886 medulla columns for the left eye and 887 for the right. The direction map ships as a 100 KB file, so the viewer needs only Python and a browser. The write-up separates what the data gives, which is the order of the columns, from what is imposed from published anatomy, such as the half-sphere field and the 150-degree divergence between the optical axes, and makes every imposed number an environment variable.
sksat (@sksat)
Runs MaleCNS v1.0 whole and unthinned, 166,700 neurons and 25,582,938 connections, as leaky integrate-and-fire neurons on Vulkan through wgpu, targeting AMD cards rather than CUDA, with a browser viewer for watching and stimulating it. Synaptic input is accumulated in fixed-point integers, so a run is bit-identical on the same GPU. A numba port of the DoomFly CPU kernel is the reference: spike sets match exactly over the first 20 ms, then diverge from rounding, which the author shows is the system's own chaos rather than an implementation gap. Sugar stimulation is bistable.
sjskoko (@sjskoko)
Asks whether a local learning rule can train a network wired from the MaleCNS connectome, on a small graph of 132 neurons and 1,001 retained connections, and answers that it can but without an advantage. Across 760 fits predictive coding with an augmented Lagrangian did not beat plain predictive coding: mean test error 0.01721 against 0.01091 on the nonlinear teacher, and a separate matched-learning-rate control left it 1.9-5.1% higher. Better initial gradient alignment did not become lower final error. Tasks use synthetic targets, not measured fly behaviour.
dohun1214 (@dohun1214)
Runs all 166,700 MaleCNS neurons in real time to play Atari Asteroids, and spends most of its effort proving the named circuit is the cause. Looming cells feed descending neurons for an escape mode and a separate tracking pathway for a pursuit mode. Silencing two descending cells drops action agreement to 56.9% and flips the turn sign, while silencing 2,000 random cells changes nothing. Permuting only the looming projections, with degree, sign and weights preserved, moves the escape bearing error from 60.7 to 99.2 degrees; a size-matched shuffle elsewhere does not.
kvnloo (@kvnloo)
A ledger rather than a runtime: it pins the MaleCNS v1.0 source files and the compiled sparse arrays by hash and states which parts may change. The census it records is 166,700 neurons and 25,582,938 directed edges under CC BY 4.0. The only plastic object it will store is an adapter on existing Kenyon-cell to mushroom-body-output-neuron edges, about 0.03% of the graph; gradient descent over the whole graph is refused and the command that would start it exits with an error. The README is blunt that the anatomy is an initialisation, not a faithful brain and not an upload.
matsuo-koya (@matsuo-koya)
A browser instrument that keeps playing until you stop it, driven by the measured MaleCNS v1.0 wiring: 163,997 endpoint bodies and 6,236,393 directed edges are stepped in a web worker and read out as harmony, motifs, grains and a body pulse while you fly through the neuron space in first person. Connections below weight 5 and self-connections are dropped, and provenance, transforms, counts and checksums are stored with the build. Real wiring, a rewired graph and a version without recurrence can be compared, and the page says plainly that only the wiring is measured.
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.
liudicsu
Flight in MuJoCo where the output is a map: a MaleCNS-structured network drives thrust and torque from descending neuron activity while the run accumulates a 3D point cloud of the room. Depth comes from motion parallax and optic flow, computed from consecutive frames, combined with egomotion, routed through the connectome and decoded from visual population activity into a 12 by 16 depth map, with classical StereoBM stereo kept alongside as a baseline. The README is explicit that the flow extraction and neural readout are hand-designed approximations.
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.
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.
chenshuai9101
Treats MaleCNS v1.0 as ground truth for what a real emergent system measures like, then uses that signature to calibrate a multi-agent emergence engine. The reported signature is anatomical modularity with Newman Q of 0.44 over 28 brain regions, a high-rank spectrum where the top mode holds only about 1 percent of variance, and a spectral radius of 3,777 raw that lands at exactly 1 after column normalisation. The payoff is an audit: those numbers exposed a scale-dependent bug in the other engine's classifier.
aujurd22
An analysis toolkit for large connectomes, built and validated on the whole central nervous system female dataset of roughly 170,000 neurons and 13.6 million deduplicated directed connections. Modules cover loading, degree-preserving null models, sampled directed-ring enrichment, spectral gap and modular structure, neurotransmitter-stratified topology, effective information, and phase synchronisation on a graphics card. Every module ships matched random controls, and the loader accepts any edge list, so the dataset-specific wrapper is a convenience rather than a requirement.
guinpereira
A robot controller taken straight from measured reflex circuits rather than a network trained from scratch. In Portuguese. Each neuron is a leaky integrate-and-fire unit and each weight a synapse count from the reconstruction, with the published whole-brain parameters rather than gains tuned by hand, leaving one free parameter: with a threshold seven millivolts above rest, a connection needs roughly 25 synapses to fire its target alone. The phase is explicit: all validated in software, no hardware bought yet, parts ordered only after a circuit works in simulation.
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.
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.
hwilner
A structural audit of a labelled directed Drosophila connectome that reports what it could not establish. The convergence diagnostic came out non-discriminative under both predefined reference families, supporting neither enrichment nor depletion; the reciprocal-pair diagnostic changed direction between the two families, giving no reference-independent result. The stated conclusion is that the completed diagnostics are inconclusive for enrichment, mechanism or causal interpretation, and that the choice of constrained null model materially changes the answer.
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.
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.
YuzhouCheng66
Race eight connectome-based flies through 30 courses of one to five gates, with docking tolerances tightening from 0.18 m and 30 degrees to 0.03 m and 3.5 degrees. Each fly maps 27 local sensor values into 2,048 sensory neurons and reads 512 outputs from a frozen MaleCNS-derived graph. The default campaign replays collision-audited full-model rollouts with their neural activity; a live mode runs the whole network in WebGPU in a browser worker. The README calls it a connectome-inspired rate model, and warns that curated success is not a population success rate.
JitheshVijay
Gives the connectome a multiple-choice calculus item and then spends the rest of the repository showing that the wiring is not why it succeeds. The fly reaches 0.795 held-out accuracy against a 0.311 control and 0.25 chance, but the control arms run the wrong way: permuting which neurons excite or inhibit beats the real graph, degree-preserving rewiring beats that, and a plain random graph with the right edge count scores 0.980. Only shuffling synapse counts hurts, which moves the network out of its operating regime. The reading offered is a random nonlinear reservoir.
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.
abbosaliboev
A MuJoCo drone with a rendered camera looks for an apple in a 3D room, and is never given the apple's coordinates: only what its own simulated eye sees goes into a pipeline of MaleCNS pathways pulled live from neuPrint plus a pretrained connectome-constrained optic-lobe model. The dashboard shows the arena, the drone's compound-eye view, a 91-column hexagonal retina and 47,261 neuron positions with 27,523 visual-type neurons lit by live activity. The status section states up front that the project is unfinished and separates what currently works reproducibly from what does not.
ak7660
Throw a looming threat at a fly in your browser and watch 4,296 MaleCNS neurons and 149,232 synapses decide, wired as they are in the animal from looming detectors through interneurons and descending neurons to motor neurons. The comparison was set up before training, with a rule that a gap must exceed two pooled standard deviations. Real wiring reaches 90 percent in 30 iterations against 77 for a degree- and layer-matched shuffle, but it is not more accurate, since both saturate. A linear classifier on the eye neurons scores 100 percent, so the task is easy.
cosmiksoul
A Russian interactive explainer that separates the biology, the engineering and the meme in the viral clips. It starts with how a sliced brain becomes a graph and what the graph does not contain, moves through what the spiking simulations actually animate, and ends in a sandbox where a toy fly brain pulls a slot-machine lever and plays a guessing game against the reader. Both games carry a shuffle-the-wiring button, which the author names as the control the viral videos are missing and the thing that separates the brain having learned from the rig having been built that way.
SakshayMahna
Drives a simulated legged robot from the fly's ventral nerve cord, its spinal-cord equivalent, instead of a hand-designed gait, first on a hexapod, then on an amputated quadruped it never evolved for. The log is the interesting part: the published circuit science was reproduced, all six leg circuits identified and confirmed, a fly body built in physics simulation, and motor-neuron output moved real joints open loop. Then a pre-registered pilot closed the loop with proprioceptive feedback and found it either negligible or enough to drive the network into a runaway, non-rhythmic state.
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.
rahilmavani
Say a digit into your microphone and watch it travel through roughly 30,000 simulated neurons wired by 1,348,769 signed connections taken from MaleCNS. Sound is measured in 32 frequency bands, an engineered mapping turns those into stimulation, the wiring stays fixed, and only a small logistic-regression reader is trained, which the README labels reservoir computing. Across 3,000 recordings from six speakers, held out by speaker, fly wiring scores 70.0 percent clean and scrambled wiring 69.7 percent, with the order reversing under added noise. Only one scrambled graph was evaluated.
stamkivi
A whole simulated fly brain takes the chair of the Estonian parliament, which has 101 seats, as a notional 102nd member. Real sittings are played to it from the parliament's open data: every speech arrives as a scent from the speaker's side of the hall, insults come straight at it, and when its escape reflex fires it rings the bell. The first plan failed twice over, and the author reports both failures: the brain is purely reflexive with no memory, and across 784 bills the single fact of who tabled a bill predicted the chamber's vote 94 percent of the time.
zhongpei
A desktop pet whose brain is neither trained nor a lookup table: desktop events are encoded as injections into sensory populations such as LC10a, LC4 with LPLC2, touch and smell, a forward pass runs the real MaleCNS weight matrix of 166,700 neurons and 25.6M synapses, and actions, continuous parameters and expressions are decoded from descending neuron firing rates including DNa02, DNp01, DNg100, MDN and pIP10. DNg100 grades walking speed and left-right asymmetry in DNa02 turns the head in real time. The four mappings the author considers exploratory sit behind a speculative flag.
alieneseren
An embedding compressor and search index built on the locality-sensitive hashing scheme described for the fly's olfactory circuit, where a small dense input is expanded into a large sparse binary code. The published benchmark compresses 10,000 vectors of 1,536 dimensions from 58.59 MB to 2.44 MB, 256 bytes each, and reports a median search latency of 815 microseconds against 3.20 milliseconds for a dense baseline on one core. It runs in memory with numpy alone and no database. The core is open source, with a separately sold professional edition.
0xtwone
A live 3D view of neural activity that is unusually careful about what it is not. All 166,700 neurons take part in the computation, but only the 140,638 with finite coordinates are drawn and the 26,062 without are left out rather than given invented positions. Connection lines are sampled from the real connectivity matrix but are straight segments between soma endpoints, not reconstructed fibres, and no unrelated pretty brain mesh is passed off as these neurons. The display buffers 25 steps at 20 ms, which the README says is not a real-time biological recording.
000214075
A Chinese language model whose forward and output path is the connectome itself: 164,587 neurons and 25,563,096 synapses, with no attention, no positional encoding, no normalisation, no residual stream, no key-value cache and no transformer block, leaving sequence modelling to the recurrence of the wiring. It runs on one desktop with an AMD card. The project refuses to assume the wiring helps and builds in three comparison arms, then reports the negative result plainly: the hybrid model that keeps a transformer reaches lower perplexity than the pure connectome one.
tolga-ileri
166,700 neurons trying to centre a div. A closed loop is built on an existing whole-brain runtime with the weights left frozen: a stylesheet viewport is encoded onto identified visual projection neurons, a cursor of actions is read off descending neurons, and the resulting keypress edits the stylesheet so the square moves, with a dashboard and a three-dimensional fly showing the same control signals. The README states in its own words that it does not claim the neurons understand stylesheets, and that what is new here is the interface rather than the model.
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.
lo2003058
Uses the mushroom body's projection-to-Kenyon-to-output wiring as the fixed sparse structure of a network trained to predict Japanese mahjong discards, then runs the comparison most demos skip. Real wiring reaches 65.73 percent test accuracy, a degree-matched random rewiring 65.61 percent, and a parameter-matched dense network 65.29 percent. Both sparse arms beat the dense one clearly, while real against random is not significant. The author's reading is that the sparse expansion shape is what helps, not the fly's particular diagram. A playable app sits on top of the trained model.
gitwub5
A life-sized fly, 3.7 mm tall, stands at the plate with a bat, sees the pitch through its own two eyes as a pair of small greyscale images, and swings when a circuit taken from the connectome commands its forelegs, all inside a physics simulator with a body model from published work. The recorded hit in the README is specific: the circuit decided at 27.1 milliseconds that the ball was high in the zone, and the ball left at 808 millimetres per second at a ten degree launch angle, which scales to roughly 14 metres at human size. Playback runs 133 times slower than life. Korean and English.
majiangmagic
Play any video file into a fly brain and watch the body react. Frames drive a whole-brain LIF network in the style of Shiu et al., activity spreads over MaleCNS v1.0 wiring using the 141,781 neurons that have soma coordinates and 5,536,527 synapses, and the result moves a flybody MuJoCo fly of 68 rigid bodies, 103 joints and 78 actuators standing on a floor with real gravity, contact and friction. Drag a file onto the local web page and it previews the brain point cloud and the body side by side while writing an MP4 with the original audio mixed back in.
maumcrez-svg
A whole repository for one transposed index, in flycoinrh, which is also listed here. The upstream code reads a post-by-pre weight matrix in the wrong orientation, so what it classifies as dopaminergic input is actually feedback from the output neurons, and any approach or avoidance readout built on it silently gets the sign backwards. A second fact kept the bug alive: the shipped graph deletes every dopaminergic edge, so the correct read returns zeros. The fix vendors upstream unmodified, and two strict expected failures pin the defect so that quietly repairing them turns the suite red.
heyobi
A MaleCNS-derived circuit fights the tutorial boss of Dark Souls III through SoulsGym, and the README reports two runs as separate claims because they are. Letting the circuit's own descending pools choose actions, with three-factor dopamine plasticity on Kenyon-cell to MBON synapses, won 8 fights out of roughly 5,200, and the trend over 1,720 fights of the final circuit is flat at 0.0 plus or minus 0.4 points per 100 fights: it can win, and it does not learn to. Fitting a Double-DQN outside the brain instead won 737 of about 6,300, which the author labels plainly as not the fly's learning.
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.
Ameerkhanjk
A quadrotor flight controller built from a 9,235-neuron MaleCNS subnetwork: every neuron within three synapses of an input port and a wing motor neuron. Each drone sensor enters at the afferent population that carries it in a real fly, so the gyroscope reaches the brain only through 204 haltere afferents. A degree-preserving rewired control scores 23.3 fruit per minute against the real wiring 22.3, so the connectome gives no task advantage. The ablations pay off: silencing the halteres drops the score to 0.5, while silencing as many random neurons barely registers.
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.
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.
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.
merolaagi
A locomotion circuit pulled out of MaleCNS v1.0 by anatomy rather than by result: six traced DNa01, DNa02 and DNg13 descending neurons, their strongest nerve-cord and leg-motor targets, and chordotonal or campaniform sensory cells, giving 807 neurons, 21,161 measured connections and 329,230 synapses. A sparse leaky integrate-and-fire model drives a simplified six-leg readout in a local UI that runs intact, silenced, feedback-free and shuffled conditions. The README calls it a real anatomical subset with assumed dynamics, and names the truncated feedback loops as a major limitation.
almera-vs
Pong in the browser where the court is sampled as two overlapping crops, reduced to 64 luminance channels and fed to annotation-matched photoreceptors; sparse activity spreads over retained MaleCNS edges, and annotated tibia motor pools drive an engineered muscle and joint model that moves the paddle, with joint angle and velocity fed back as proprioception. The stated goal is inspectability, not performance: scene, neural state, muscle plant and display are kept separate so a result can be traced to the graph, a modelling assumption or a display-only feature.
Jiandong Chen, Masao Nagasaki (Kyushu University)
A BioHackathon Japan 2026 project report asking whether a fly brain can do useful work on genomics data. The mushroom body turns an odour into a sparse code over Kenyon cells, and its alpha-prime-3 compartment behaves as a novelty detector whose output neurons are suppressed by dopamine within a few repetitions of the same odour. The project presents single-cell RNA-seq profiles to the simulated brain as odours and reads that compartment's output as a novelty score, so cells resembling ones already smelled habituate. Reported in three stages, from blood cells to a lung adenocarcinoma dataset.
EvolutionDeep
A population of 24 small spiking nervous systems, about 1,080 leaky integrate-and-fire neurons each, that read whole-chain activity on the Arc network, reduce it to a single market temperature, and react. Each fly is also an economic agent: its own spiking output decides what to buy and from whom, and the agents settle with each other in real USDC on Arc mainnet over the x402 protocol, each settlement a transfer with an on-chain hash. No language model is in the decision path. Real spending sits behind a kill switch, a global daily cap, a per-agent cap and a per-deal cap.
Listed for information only. No endorsement, no referral links.
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.
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.
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.
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.
Muika (@Moemu)
Imports the 166,700 neurons and 25,582,938 connections of the male central nervous system as a control network, trains it to output twelve joint targets, and hands those to a physics simulator so a humanoid avatar walks. The project is honest that a wiring list carries no brain function by itself, and it reports the ablation, not only the demo: nine of nine fresh starts stay upright for 30 seconds, a continuous two-minute walk covers 65.55 metres with 0.13 metres of lateral drift, three of three lateral pushes are recovered, and severing the brain connections drops the body in about a second.
rgourley
The 7,443 MaleCNS neurons that handle smell are simulated, each symbol's technical setup is turned into an odour, the circuit runs on it, and the learning cells that fire decide which one the fly likes best; when a trade closes the outcome rewires the cells that chose it. Everything is paper money on an external platform, and the command line keeps the dangerous step explicit: a rehearsal decides and prints the whole session while sending nothing, and only an added go flag lets it trade. Listed for information only, with no endorsement and no referral link.
shute2004
Couples a MaleCNS snapshot of 166,700 neurons and 25,582,938 directed edges to a FlyBody MuJoCo body in closed loop, and insists on doing the learning inside the simulated nervous system: no backpropagation, no gradient descent, no external controller, only local activity, eligibility and dopaminergic modulation through released DAN populations. The canonical v1 run changed 2,163,179 stored edges over six episodes, yet frozen evaluation before and after both ended in a gate collision at control step 120, so the run establishes weight change, not improved behaviour.
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.
dhakalnirajan
A sparse-network toolkit for using MaleCNS in NumPy/SciPy, PyTorch and TensorFlow/Keras. It preserves graph connectivity while allowing edge gains to be trained, and exposes assumptions about signs and receptors as model settings. Anatomical connections supply the structure; the numerical dynamics and learning rules remain modeling choices.
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.
schlegelp
A Python interface that brings CAVE and neuPrint-backed connectomes behind a common query layer. Its dataset capability matrix distinguishes access to connectivity, morphology and annotations. It reduces differences between data services without implying that every dataset exposes the same information or operations.
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.
Swida-Alba
A Python and web-UI toolkit for cross-dataset circuit analysis, path finding, 3D morphology views and finding experimental lines through NeuronBridge. The reviewed README describes version 4.5.0. Capabilities differ across datasets: BANC morphology-similarity analysis has deferred functionality even where other BANC operations are available.
flyconnectome
A curated reference of neurotransmitter assignments for Drosophila cell types, grounded in the experimental literature. It offers supporting evidence for interpreting connectome annotations and comparing predicted transmitters with published observations. The repository provides reference tables, not a new whole-brain reconstruction.
Aurel A. Lazar / Yiyin Zhou
A preprint reviewing the Drosophila early olfactory system through connectivity, synaptic evidence and executable circuit models. It considers feedforward pathways embedded in feedback networks and argues for linking wiring diagrams to functional computations. It offers context for interpreting connectome models rather than a new whole-brain benchmark result.
FlyBrainLab
Executable early-olfactory-system circuit libraries for FlyBrainLab and Neurokernel, covering antenna, antennal-lobe and mushroom-body models. They help assemble and run sensory-processing models from earlier circuit research. This is an established modular modeling resource, rather than a newly released whole-brain game agent.
xyzzyapps
A mushroom-body learning experiment that traces target Japanese and English glyphs as 2D movements. The repository distinguishes a MaleCNS-based route from a simplified eight-channel fallback. Tracing provided letters or verse is a motor-learning task here; it does not demonstrate autonomous poetry composition or semantic understanding.
yukincom
An odor ON/OFF intervention study using the fixed MaleCNS LIF model derived from fly-brain-minecraft. It investigates persistent activity in four DM1/VA2 projection neurons and how blocking input during the OFF period changes that activity while retaining ON responses. The results concern this model and intervention, not a biological validation or repair of the entire circuit.
steph4n-gh
A simulated rocket-control experiment combining MaleCNS-derived dynamics with trained command readouts. The author reports 60 successful landings in 80 unseen-start trials across ten tasks, versus none in a vision-blocked control. Failures remain part of the report. The result does not establish completion of every planned mission or operation of the proposed physical Fly Cube.
JHC56
A MuJoCo rope-swinging experiment driven by an extracted visual and escape circuit, with an engineered memory system choosing movement directions. Its body is a non-rotating capsule. The full-CNS display uses a separate offline computation and does not drive the controller; neither web swinging nor the added memory is a biological fly capability.
eganeganegan
A VizDoom research framework for testing sparse recurrent controllers derived from MaleCNS. It supports PPO and plasticity experiments alongside degree-preserving rewires, random graphs and conventional neural-network baselines. Fixed and trainable components are experimental choices; the framework itself is not evidence that biological wiring outperforms those controls.
Zehao Jin / Yaoye Zhu / Chen Zhang / Yanan Sui
A preprint using a whole-brain connectomic graph as the structure of a learned controller for a biomechanical fly model. Deep reinforcement learning connects the graph to whole-body locomotion tasks, with comparisons reported by the authors. The June 2026 revision concerns engineered control in a simulated body, not a direct replay of measured biological neural activity.
Sudharsanselvaraj
A research prototype that turns Chromium screenshots into keyboard actions through a learned controller and simulated foreleg contacts. It includes MaleCNS activity views and execution traces. The demonstrated task is a fixed-layout, single-line HTML heading exercise; it does not establish general coding ability. The hosted showcase is static, while execution requires a local runtime.
Benquan Wang / Jingdao Chen
A preprint on recurrent neural networks shaped by fly-brain connectivity and trained for visual navigation in MuJoCo. The authors report robustness to unfamiliar conditions and sensory loss relative to their comparison networks. This entry follows the July 2026 revision and describes simulated navigation, not a demonstrated physical robot deployment.
jerryjliu
An OCR experiment that passes printed characters through a fixed MaleCNS circuit and learns a small decoder for the resulting activity. It includes native computation, Python tooling and a research report with baseline comparisons. Conventional classifiers outperform the fly model in reported comparisons, so the work should not be described as proving an advantage of biological wiring.
jtc268
A fashion-art experiment using MaleCNS spike vectors to change the position, rotation and scale of existing print designs. Humans supply the source graphics and the original colors are preserved. The project explores a connectome-driven transformation of artwork, rather than a fly independently inventing garment designs from nothing.
Janelia Research Campus and collaborators
A Cell study reconstructing adult male gustatory pathways across the brain and ventral nerve cord, relating taste circuits to feeding, foraging and social behavior. It examines a sensory system within the whole-CNS wiring resource. The circuit analysis is distinct from the dataset release and from a simulation demonstrating those behaviors.
reiserlab
Analysis code supporting Nern and colleagues’ 2025 study of the male Drosophila visual-system connectome. It provides a reproducible entry point into the study’s computations and figures, complementing the interactive Cell Type Explorer. This is the associated research-code resource, rather than an additional connectome dataset.
seohyunjun
A PyTorch MPS implementation for running MaleCNS stimulation experiments on a Mac, with 3D activity reports and a small grid-navigation task using a fixed neural encoder and trained output layer. The README also records limited activity in a basic stimulation run. Success on a small fixed-goal grid should not be read as general locomotion or a validated whole-brain behavior.
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.
Theresa H McKim et al.
An eLife reviewed preprint integrating connectivity and transcriptomic evidence to examine a neurosecretory network in the adult fly brain. It develops predictions about endocrine and motor coordination and reports selected functional experiments. This entry points to the September 2026 second version; the first reviewed preprint appeared in November 2024.
connectome-neuprint
Tools for producing anatomical explanatory videos from connectome data using Blender or VVDViewer. neuPrint and Neuroglancer resources can supply neuron geometry and scene inputs. This is a workflow for composing and rendering scientific visualizations, rather than a simulator of neural activity or fly behavior.
Jia-Nuo Liew et al.
A preprint combining connectome structure with a spiking model to investigate orientation-selective representations in the Drosophila optic lobe. It reports orientation maps emerging in the computational model. Those modeled responses should be distinguished from direct physiological measurements of the living visual system.
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
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.
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.
Junichiro Niimi (@jniimi)
Re-runs the author's own published energy-based world model with its coupling pattern fixed to mushroom body wiring: 343 projection neurons carry the 72 input features, 1,918 Kenyon cells with at least one projection input form the first hidden layer, and 49 output neurons the second. Only the existence of a connection is taken from the connectome; magnitudes are learned, and the directed graph is symmetrised to get an energy function. At one seed it matches the dense original on prediction and on one counterfactual parameter, and falls short on the other. The stated goal was that it runs.
cashew-labs
A phone call with a fruit fly. A full-duplex speech model does the listening and talking in 80 ms frames, so you can interrupt it; the connectome sits beside it as a reservoir. The speech model's 4,096-number internal state is summarised into 64 fixed features, fed into the retained MaleCNS graph with its own previous activity, pooled back into 128, and passed through a fitted adapter that nudges the text-token scores by a small bounded amount. The browser draws the same reservoir state in 3D, so the visualisation is the thing actually in the loop.
Aur1ety
Runs 138,968 MaleCNS neurons and 4.6 million signed synapses as a recurrent network, unchanged apart from one global scale factor, and has a 256-unit decision layer reading 1,312 descending and 9,199 visual projection neurons pick one of eight Doom buttons. Over 100 runs from unseen starts on shareware E1M1 it reaches the exit 57 percent of the time against 0 percent for random or always-forward and 6 percent for a blind replay; scrambling its own frames drops it to 0. The author states the open question plainly: an earlier, simpler test suggested random wiring carried at least as much signal.
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.
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.
klmtseng
A bilingual 3D site that explains the male CNS to schoolchildren by replaying one escape reflex: looming, giant fiber, jump and wing muscle neurons. It draws the 140,024 neurons of the connectome's 166,691 that have soma coordinates, and colour carries provenance. Green is real position and simulated spikes, magenta is what the model could not produce and the authors injected, grey is a drawn body that is not in the data, amber is the motor-to-muscle step where only the timing is real. Limits are printed, including a textbook relay that never fired in their own run.
ns2250225
Flappy Bird played entirely in the browser by the MaleCNS v1.0 connectome: 166,700 neurons and 25,088,107 retained connections stepped at 50 Hz in a Web Worker over a sparse CSC weight matrix, with LC4, LPLC2, LC10a and a vertical-velocity channel carrying the game state in. Three modes separate what the wiring does from what training adds: PURE BRAIN decodes raw descending activity, ONLINE TRAIN fits a logistic readout while flying, and FAST TRAIN freezes a separately trained model. Flight safety rules block runaway flapping, and a URL seed makes runs reproducible.
franBec
Exposes a MaleCNS brain to any agent that speaks remote MCP. ask_fly renders your text as a 320 by 180 frame, runs it through a pinned build of an existing spiking implementation, and returns a verdict from a left-minus-right descending-neuron spike differential with a second neuron as gate, plus the raw spike statistics. reward_fly and punish_fly queue engineered pulses into 15 dopaminergic and 2 aversive cells, consumed by the next question rather than at call time. Every tool description repeats the same disclaimer, and a deterministic mock backend runs with no dataset at all.
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.
tls8012
A scikit-learn compatible classifier and regressor whose hidden structure is a fixed MaleCNS graph in PyTorch, usable inside Pipeline, GridSearchCV and eval_set like any other estimator. The control is built into the API: fly_mode switches between the real topology, a frozen variant where only the readout learns, and a shuffled graph that keeps the same neurons, edge count, exact in and out degrees and signed weights while destroying the real pre-to-post pairing. The roughly 122 MB connectome tensor stays out of the wheel and is fetched from a release on first fit.
bchap1n
A lab for turning fly hearing into music tools: a sequencer, a sampler and eventually a plugin. The first commit is a deliberately small 12-neuron motif modelled on the courtship-song pathway, with an onset encoder standing in for Johnston's organ and leaky integrate-and-fire dynamics whose spikes trigger samples or MIDI. The simulator does not care which graph it gets, so a measured FlyWire or MaleCNS subgraph can replace the motif. The case for this corner of the brain: the computation is temporal, the graph fits in an audio callback, and a degree-preserving shuffle is a built-in control.
Me0wX-LR
A Foundry Virtual Tabletop module that runs a connectome model on the game master's client only and lets a token on the map be the fly. Mark other tokens as food or threat, poke sugar, loom or walk, and a house-rule decoder turns the readout into grid moves: dash two squares from a threat within eight, step one square toward food, stay when fed and adjacent. An optional OpenAI-compatible key only lets the fly speak flavour text, and the README is explicit that the key must never choose the next square.
SpikeCalls (@SpikeCalls)
Turns a drone camera, or a hand in front of a webcam, into activity on the fly's own visual cells, runs the MaleCNS connectome as a spiking network, and reads six descending neurons out as stick commands for a real drone or a simulator. An open palm looks like sinking, so T4c to VS to DNg02 climbs; a rush at the camera fires LPLC2 and LC4 into the giant fiber DNp01 and it escapes. The browser demo runs 850 spiking neurons live. The README separates the measured wiring from the engineered parts: the camera-to-neuron bridge, the tonic flight drive and the safety governor are the authors' own.
KremlevLev
The MaleCNS connectome as a recurrent policy for two-player Durak: 165,122 neurons and 10,511,038 directed edges converted into a signed, normalised sparse graph, combined with a compact decision GRU, legal-action masking, actor and critic heads, and factorised synaptic gains. It was trained by reinforcement against random, scripted, frozen-policy and determinized-search opponents, then fine-tuned with search. One command bootstraps the venv, builds the connectome and downloads a 374 MiB checkpoint. The README calls it an exploratory demo whose multi-seed GRU and LSTM comparison is unfinished.
michaelpersonal
Two tasks on one substrate: typing a target sentence, and brick breaker. Both see only a locally rendered 320 by 180 frame of the retained MaleCNS graph, 166,700 neurons and 25.6 million connections, and both act from neural activity alone. Typing stimulates 3,335 brightness and 811 colour inputs and decodes left, right or hold from a descending-neuron rate difference against a deadband; correct picks schedule a dopamine pulse into 15 identified cells. The paddle tracks the ball at 0.782 against a measured chance level of 0.5 over 6,947 scored moves.
Benn Jordan (@bennjordan)
A browser instrument that plays the male fly's courtship song from the MANC nerve-cord connectome instead of samples. P1 integrates proximity and contact, pIP10 and pPR1 gate pulse and sine song, and a vPR6 and GABAergic loop in neuromere T2 sets the roughly 35 ms inter-pulse interval, driving MN-b1 and MN-b2. The Web Audio side models the wing pushing into air: drive rises from 0.8x to 3.2x between 2 mm and 25 mm, contact adds up to plus or minus 105 Hz of jitter, and a thoracic resonator sweeps its Q. Slowpoke mutants and sibling species are included.
rperissi
A 2.8 MHz Apple IIgs rotating real MaleCNS neurons, released for the machine's 40th anniversary. A 75,418-byte file holds 18 skeletons across 9 cell types, from the giant fiber DNp01 to a circadian clock neuron, each capped at 600 nodes by pruning the shortest terminal twigs first. The 65C816 spins them with 16-bit integer math and a 7-bit sine, depth-shaded through a 12-step ramp, while the screen mixes 320 and 640 pixel modes per scanline. With a CoGS card it opens a TLS session and streams the block down; the running benchmark projects how long all 166,700 neurons would take.
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.
hjkornn-phys
Asks whether the wiring can hold an odour in mind: the MaleCNS graph as a steady-state rate model with a 16-unit GRU bolted on outside it, 110 odorants entered as measured receptor responses, tested on odours and receptor neurons it never trained on. It scores 0.724, and then reports that the comparison which would make this a finding about the wiring is void, because the shuffled and input-only arms never learned even on their own training data. An exploratory check is kept separate: cosine similarity on lateral horn output separates same from different at 0.947 against 0.514 shuffled.
Titanium-xd
A benchmark that uses a MaleCNS subgraph of 150 neurons and 3,029 edges as an architectural mask: only anatomically real connections may carry learned weights, everything else is structurally zeroed, and the result is run against conventional models on the same tasks under the same conditions. The site carries the benchmark, a live arena and a how-it-works page. The project calls itself an engineering experiment rather than a neuroscience simulation, and reports its answer so far as task-dependent rather than a win for biological wiring.
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.
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.
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.
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.
josepha-mayo
Two players under one control contract: a living Drosophila tracked by an overhead camera in an arena, and a static MaleCNS v1.0 network of 166,700 neurons and 25,582,938 edges. Both drive ViZDoom combat survival and a chess menu through one motion-to-action mapping. In nine sessions the fly logged 3,758 kills in 9,098 episodes; the connectome, held to the same bandwidth, 3,170 in 8,832; unconstrained, 6,527 in 563. The fly improved across sessions; the network could not. One chess game was completed, 186 plies. Nothing is trained; the README says a game score is not biological validation.
AlexNoyanov
A two-wheeled acrylic robot driven by a slice of the male CNS: the right antennal lobe, about 4,057 neurons of male-cns:v1.0, run as a leaky integrate-and-fire network on a Mac M1. Camera frames and three ultrasonic ranges feed in, spikes come out as left and right motor speeds, and a Raspberry Pi 4 relays them over WebSocket to an Arduino with an L293D driver. Nothing is trained; the spike-to-wheel mapping is the author's, and the connectome is cached locally. Three watchdogs stop the motors on stale commands or dropped links. A GIF and screenshots show it moving. No licence file.
vaxenfly
A fixed reward-punishment readout for AI agents, built from the mushroom body of the male CNS: 4,064 Kenyon cells, 97 output neurons and 340 dopaminergic neurons, and 61,210 KC-to-MBON edges. Each compartment's sign comes from the ratio of PAM to PPL1 presynapses in the connectome, 8 appetitive, 7 aversive and one unsigned, and nothing is trained. The real KC-to-MBON weights give a 12.8 percent median d-prime gain over degree-preserving shuffles. Rebuilt on hemibrain, one of its own bounds fails, which the README reads as thresholds not transferring between datasets.
shreyansatvik (@shreyansatvik)
A browser map of the output side of the male CNS connectome: pick one of 481 descending neuron types and see which of eleven motor pools - 815 cells covering eight body areas - it reaches within three synapses, with synapse counts and input share. Excitation and inhibition come from transmitters predicted off the EM images, which the site calls predictions, not measurements, naming glutamate as the weak point. Against seven published neurons the wiring matches five; the LIF view, on a 49,448-neuron subset at 0.08 mV against Shiu's 0.275 mV, reproduces two at 75 spikes/s and five at 150.
@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.
Dhruvin Sarkar (@dhruvin-sarkar)
Trains a gradient-boosted classifier on the male-only MaleCNS v1.0 cell-type graph (11,751 types, 243,439 edges) to predict Janelia's male-specific and dimorphic labels, then asks whether the real wiring beats 500 degree-preserving rewirings. All features give AUC-PR 0.759 against 0.712 for the nulls; the sharper test is topology alone, 0.489 against 0.070, at p = 0.002. The repo writes down what it may and may never assert, calls its two flagged types candidates rather than findings, and publishes a pre-specified check that failed. The site adds an atlas, a pathfinder and a guessing game.
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.
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.
PixelML
A control study, not a demo. 18,318 deduplicated satellite tiles of structure wildfire damage are sampled into 99 retinal patches, injected into a frozen MaleCNS v1.0 network (166,700 neurons and 25.6M synapses by its count), read out after 48 ticks as log1p spike counts from a fixed 1,024-neuron set, and classified by a 64-unit MLP. The controls are the point: real wiring reaches ROC-AUC 0.622, a shuffled connectome 0.625, all-excitatory 0.642, random sparse wiring 0.632, and pooled pixels 0.711. On this task the measured wiring buys nothing over a scrambled one, and loses to plain pixels.
CakeCrusher
Screenshots of X posts map onto 892 hexagonal ommatidial columns and run through a 140 ms leaky integrate-and-fire pass over MaleCNS v1.0, cited at 165,122 neurons and 25.5M connections, then scored on dark-edge, ON/OFF and surround activity. The author calls the verdict polarity a joke and supplies the control that kills it: a blank grey rectangle scores within five percent of a dense screenshot. What survives is the method critique - the usual descending-neuron readout saturates, and four non-spiking wide-field types, eight cells in all, separate a plausible raster from runaway activity.
@thechrisroberts
Six published fly behaviours written as directional predicates, sealed before any scored run, then run on the MaleCNS v1.0 graph against two nulls: a degree-preserving shuffle and a twin with randomised dynamics. Four of the six items failed; only CO2 avoidance and giant-fibre looming escape held. The seal is externally checkable: the committed battery file hashes to the sha256 registered on 1f916.ai hours before the scored rerun. The author later corrected a mis-scaled random-dynamics null: the verdicts stand and CO2 avoidance stays clean, but the looming item now reads as a wiring-only pass.
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.
sykeriin
Loads the Janelia FlyEM male CNS connectome - by the project's count 165,122 traced neurons and about 10.2 million signed synapses - as a leaky integrate-and-fire network and reads six annotated motor-neuron populations (foreleg, midleg, hindleg, wing, haltere, neck) as drum voices, tuned toward human grooves from Magenta's Groove MIDI set. Only the Kenyon-cell to MBON synapse moves, by dopamine-gated depression. The LIF simulator, the mushroom-body learning circuit and the graph builder come from flycoinrh, also listed here; new are the drum mapping, the reward and the selection loop.
@Ibtisam-Mohammad
Runs the traced MaleCNS v1.0 graph, 165,122 neurons and all 25,563,197 edges, as a GeNN/CUDA integrate-and-fire network coupled every 15 ms to a NeuroMechFly v2 body in MuJoCo, at 0.015x real time on an RTX 3060. Twelve flies in one arena walk to an object 12 times out of 12, against 0 of 12 with the stimulus absent - but that is one seed in the third arena, after two were measured and discarded. All 66,533 photoreceptor output edges are zeroed, vision is analytic rather than rendered, the tripod gait is a published pattern generator, and the decoder cannot stop, so arriving is physics.
nyoki-mtl
A shogi policy learned on measured MaleCNS wiring. The graph stays fixed (166,700 neurons, 25,582,938 edges); the only plastic parameters are gains on existing excitatory inputs to mushroom-body output neurons, 77,364 connections from 8,374 sources onto 97 MBONs, with a variant confined to 61,210 KC-to-MBON edges. The teaching signal is a conventional shogi engine, not biology. Held-out agreement with the teacher is 26.39 percent, 1,081 of 4,096 positions, below the 30.27 percent dev-set figure used to pick the checkpoint, which came from a private corpus and several initialization stages.
mait (@mait2355n)
An evidence ledger for the motor side of MaleCNS v1.0: 815 motor-annotated neurons with 330,888 incoming edges, 2,155 shared upstream candidates (weight at least 10, reaching two or more of 42 muscle groups), full edges for 40 of them, and re-analysis tables for 23 DNa01/DNa02 voltage recordings. Verify and reproduce scripts recount the edges and exit non-zero on mismatch. The limitations file lists: 69,709 of 90,166 input bodyIds carry no annotation, dropping 44 annotation-only motor neurons cuts candidates to 1,927, and the physiology comes from female flies while the wiring is male.
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.
Yuhtin (@Yuhtin)
Hands a coding agent its next instruction from a MaleCNS v1.0 network: 166,700 neurons and 25,582,938 edges are stepped at 0.1 ms across a 500 ms observation, and while DNpe017 fires the right-minus-left difference in DNp20 rate picks one of three fixed instructions, Fix above +2 Hz, Test below -2 Hz, Investigate in between. OpenCode or Codex does the actual coding. The pilot is small and reported as such: adaptive and frozen-weight networks each passed 2 of 2 attempts, and so did a uniform random chooser, using more calls. The authors state six attempts establish nothing about learning.
gsoloviev
A Pine Script v6 strategy that puts a slice of the male CNS connectome on a TradingView chart, then reports that it does not beat the market. Price moves enter as looming visual threat, Kenyon cells carry context, profit and loss feeds back through mushroom body synapses, and a descending-neuron readout keeps it long or flat. The Pine build is 995 neurons and 17,000 connections. On hourly BTCUSDT since 2018 it ends at 4,231 dollars against 11,904 for buy and hold. Two results survive controls: drawdown beats random in ten of twelve runs, and shuffled wiring gives 0 DNp01 spikes against 98.
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.
Maya Posch (Hackaday)
Maya Posch's 14 September round-up, the hardware-hacker press catching up with a wave the games and science outlets covered first. It walks through what has been bolted onto the Janelia male CNS wiring diagram in under two weeks: Nftechie's Stonkfly, which reads the fly's reward circuitry as stock trades, and attempts to have the connectome play DOOM and Beat Saber, where each game frame stimulates sensory neurons and dopamine reward circuits are wired in for reinforcement learning. Posch passes on Nftechie's own admission that nobody has checked how good a fruit fly is at trading.
Artem Skulimovskiy (@skulitom)
A flight controller wired by anatomy: 30,000 MaleCNS v1.0 neurons that sit on a sense-to-motor path of at most two synapses, plus the central complex and descending neurons, with 2.77 million connections and 37.5 million synapses. Topology and synapse sign are fixed; gains, biases, time constants, encoders and a linear readout are trained by copying a teacher MLP and backprop through a differentiable quadrotor. It then flies in Liftoff: 0.34 m hover error, a 601 m lap at 1.5 m/s with 0.67 m path error. In the simulator the plain MLP baseline reaches 10 cm where this brain gets 0.22 m.
akramahmed1
A structural resilience battery on the MaleCNS v1.0 wiring graph: reachability over about 60 million sensory-to-motor pairs, a directed minimum s-t cut, and targeted-versus-random lesion curves against degree-preserving and region-constrained nulls. The headline is negative: targeted lesions disconnect more pairs than random, but no test of 24 survives FDR correction and the rewired nulls reach almost the same reachability. Wiring only, no activity. The repo calls itself preliminary and not peer reviewed, and its README and its own audit disagree on the 173,023 vs 166,700 node gap.
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.
Virtual Fly Brain team
Virtual Fly Brain reopened the hands-on workshop it built for NeuroFly 2026 as seven self-led sessions anyone can work through for free, announced on the VFB news page on 6 September 2026. They run from finding a neuron, through bridging between datasets, to pulling in single-cell transcriptomics, and each can be done five ways: the vfb_connect Python client, natverse in R via reticulate, a natural-language chat, an MCP endpoint for driving it from an LLM, or the 3D browser. Material covers BANC, male CNS, MANC and the optic lobe. The footer states GPL v2.
Watt the Fly (@flywatt-live)
Runs 38,178 neurons and 5,124,215 synapses of the Janelia FlyEM Male CNS v1.0 connectome - a visual-to-wing-motor cut of 89 cell types - as leaky integrate-and-fire units in a Web Worker, then turns the spike count in a 100 ms window into watts at 31.9 pJ per action potential to light a three.js bulb; calibrated, it draws about 6.5 uW. A table separates measured wiring from assumed synaptic sign and modelled constants, and a verify script re-checks the looming and dark-flash responses. No insect and no hardware: the bulb is a rendering. The page also carries an unfilled token-launch slot.
Listed for information only. No endorsement, no referral links.
@wjb000
A browser page where roughly 166,000 traced male CNS neurons run as leaky integrate-and-fire units with short-term depression, and the motor-neuron pools alone move the body, which goes limp when they fall quiet; the page defaults to a quadrotor, with the NeuroMechFly model behind a query parameter. What sets it apart from the other embodied demos is the perturbation kit: silence, boost, cut, swap, delay or hunger-gate any neuron from the console, run lesion sweeps, and try a cross-sex graph transplant against BANC in the repo tooling. That transplant is reported as a failure twice over.
村本 (@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.
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.
kevinlinxc
Plays the Bad Apple video into the MaleCNS v1.0 connectome and shows what a simulated body does in response: one pane projects neuron activity onto soma positions, the other drives a NeuroMechFly body in MuJoCo. The README opens with what it is not. The connectome is real, but the neurons are leaky integrate-and-fire units with invented parameters, not measured biophysics; the video is a spatial stimulation pattern across soma positions, not something the fly sees; there is no sensory feedback or aerodynamics; and the body mesh is the published female specimen paired with male neural data.
BruceLanLan
Takes one behaviour, looming-evoked escape gated by the giant fiber, and carries it from the MaleCNS v1.0 wiring through an explicit teacher model, then a 16-bit decision table covering all 65,536 rows, and finally a netlist of 173 NAND gates and 6 latches proved exhaustively equivalent to that table. The question is how small a deterministic machine reproduces a connectome-shaped behaviour, and how much of that machine can be proven rather than trusted. A browser bench launches a looming block at a fly and evaluates the netlist cell by cell every 5 ms, verifying its SHA-256 on load.
PtPavloTkachenko
Hologram flies placed in a real room through Snap Spectacles (2024), each running its own copy of the MaleCNS v1.0 connectome (166,700 neurons, 25.6 million synapses) as the leaky integrate-and-fire model of Shiu et al. 2024. The brains run on a Mac behind a Metal GPU kernel; the glasses turn the room into fly senses, streaming eyes, world mesh, hands and head to the brains, while descending and motor neurons come back to move wings, legs and head. The selected fly's brain is drawn live as a 16,000-neuron point cloud, and a decisions document lists every engineered part.
franciscocarloserra
Event-driven Triton kernels that step the whole MaleCNS connectome, 165,000 neurons and 24.5 million synapses, at 3,455 Hz on a single RTX 3090. With a 1 ms membrane time step that is one second of fly life in 0.29 seconds of wall clock, about 3.5 times faster than real time, against 708 steps per second for a torch.sparse COO baseline. Batching sixteen or sixty-four flies trades single-fly latency for throughput and reaches 51,159 fly-steps per second. The README is explicit that the same input produces the same spikes as the torch.sparse reference.
ashemag
An interactive 3D atlas of the adult male fly brain built from published MaleCNS geometry: 80 brain regions carrying 7,270,902 native source triangles, with exploded and paired-region views, plus 1,712 traced neurons at 2,180,126 segments and eight complete neuron meshes loaded on demand. Geometry is served locally and no API token is needed at runtime. Every asset carries its source URL and a SHA-256 checksum in an attribution manifest, and the page states that the cellular view is a selected collection illustrating morphology, not the whole population.
Mert Cobanov (@cobanov)
A browser workbench for starting your own fly-connectome experiment instead of rebuilding the scaffolding each time. It opens with 124,289 classified brain soma positions from MaleCNS v1.0 rendered without stretching the axes, plus the anatomical flybody mesh, and leaves the environment and the model as replaceable parts: training and inference stay in your own stack, and outputs are mapped back by neuron ID. The licence requires attribution in both the web UI and the repository.
hcsolakoglu
A reduced MaleCNS circuit, 4,386 real neurons and 468,923 measured edges representing 4,210,625 synapses, controls a Fruit Ninja-style game through an explicit pixel to activity to blade loop. What earns it a place is the control set: you can switch between measured wiring, rewired wiring with its own refitted readout, connections cut, blinded input, a random blade and a plain pixel heuristic, with a seed for reproducible launches. The README says outright that this is a fixed-connectivity rate model with engineered visual and motor interfaces, not a whole-brain emulation.
suanmiao
Runs the measured MaleCNS wiring, 165,122 neurons and 25,563,197 synapses, as a recurrent network and trains it to steer a car from a 64 by 32 pixel windscreen. The adjacency never changes; what is learned is one gain per synapse and one leak per neuron. On held-out streets with parked cars, oncoming traffic and a slow car to overtake it completes 58 of 60 runs across three independent sets with no collisions against any car. The site replays logged state rather than re-simulating, puts the real input beside the drive, and publishes the failures too.
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.
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.
nicodunks
A paired experiment on the MaleCNS wiring graph (166,606 classified neurons, roughly 25.6 million connections) asking whether blocking the output of the inhibitory mAL pathway lets male-associated sensory input reach courtship-related P1 neurons. Both arms get identical inputs and the same firing rules; the only change is the mAL block. All 36 combinations of three input pathways, three seeds and two inhibition settings were run, and the README states plainly that the cell identities and connection effects stay modelling assumptions rather than measured properties.
shakeabhishek
A physical hexapod robot whose escape behaviour comes from fly wiring rather than a hand-written state machine or an abstract neural network. Only the direct one-hop synaptic neighbourhood of the giant-fiber escape circuit is pulled out of the MaleCNS reconstruction through Virtual Fly Brain, roughly 391 neurons including LC4 and LPLC2 looming detectors and JO mechanosensors, and simulated in Brian2 on a Raspberry Pi 5. A camera and OpenCV optical flow feed the spike encoder, and a decoder drives eighteen servos through a PCA9685 controller: a connectome on real hardware, not in a simulator.
Erfara Labs (@erfaralabs)
Injects a Drosophila connectome graph of 28,994 neurons and 1,814,208 directed synaptic edges into layer 16 of SmolLM2-360M as a persistent leaky-integrator reservoir, without retraining the graph. In-degree normalisation holds the unweighted graph near criticality (largest Lyapunov exponent +0.0309, branching ratio 1.0220). The claim is tested against a degree-preserving null: scrambling the biological targets costs 0.0781 nats of cross-entropy, about 1.58 per cent. The README calls the graph hemibrain plus ventral nerve cord but never names the released dataset behind it.
Roxx0x
Uses the larval fruit fly connectome of Winding et al. 2023, 2,952 neurons and about 110,000 connections, as a fixed reservoir. The wiring is never modified, because you cannot edit an animal's connectome; only a one-layer linear readout is trained on the activity it produces. On handwritten digits that readout reaches 94 per cent against a 10 per cent baseline. It installs with pip, downloads the connectome once and exposes digit and time-series tasks behind a small API.
ASCII.jp (G.Raymond)
Japanese coverage devoted to NeuroCraft Fly specifically. It reports the six input types the Minecraft fly responds to (player proximity, surrounding mobs, brushing, attacks, food and light), notes that selected readouts pick predetermined actions rather than simulating natural physiology, and states the release position clearly: the repository holds introductory materials and demo footage, with the Fabric mod source still unpublished.
AUTOMATON (Kosuke Takenaka)
A Japanese games-press account of DOOMFLY, focused on the mechanism rather than the spectacle: Doom's screen becomes signals the fly can receive, activity runs through the MaleCNS v1.0 model, and taking damage sends an aversive stimulus to dopamine cells. Its most useful line is the negative result, that after roughly 3,000 attempts no learning had been confirmed in the form of longer survival.
Mert Cobanov (@cobanov)
A curated list of fly-connectome projects published on 12 September 2026, at the peak of the wave, grouped into games and control experiments, desktop flies and interactive worlds, language and art experiments, brain models and embodied simulation, datasets, analysis libraries and tutorials. Each line names the dataset used and flags whether the project runs a whole connectome or only a circuit subset, which makes it unusually useful for telling the serious entries apart from the quick ones.
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.
ZeroXClem
Closes the sensorimotor loop in the browser: rendered images drive a compound eye sampled at the connectome's 1,771 column directions, the optic-lobe rate model feeds the whole MaleCNS graph, descending-neuron rates drive the wings, and the body's new pose renders the next frame. It is an explicit combination of two upstream projects joined at MaleCNS body IDs, AbijahKaj's optic-lobe front end and Xenova's whole-CNS WebGPU back end, and it ships an ablation bench that produced the published cruise figures.
Unjuno
Connects the MaleCNS v1.0 connectome to the FightingICE fighting-game platform through a pinned implementation of the Shiu et al. leaky integrate-and-fire dynamics. Game observations become a versioned Poisson sensory interface, real output-body spike counts become versioned action groups, and a public research ledger records the runs. The repository draws an unusually sharp line between what is biological data (the anatomy), what is a published model (the dynamics) and what is a project-defined interface (the sensory and action mappings, reward and plasticity rules).
Yijie Yin, University of Cambridge
A Python library that turns a wiring diagram into testable hypotheses about circuit function, and it runs on a laptop or in Colab even for whole-brain analyses of around 140,000 neurons. It computes polysynaptic effective connectivity between groups of neurons with or without signs, retrieves and plots the actual subcircuit between sources and targets, and exposes a differentiable connectome model. Installable from PyPI, with an accompanying preprint and Colab notebook.
Dexerto (Zackerie Fairfax)
The article that gave the wave's counter-current a name. It covers Macroblock's announcement of an open-world sim where the simulated fly gets grass, trees and endless fruit instead of Beat Saber, sets it against NeuroCraft Fly and the rhythm-game clip, and notes that the Beat Saber demonstration was later clarified as incomplete, a useful correction given how often that clip's view count is cited.
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.
nftechie (Alex Wormuth)
Couples a frozen language model to the retained MaleCNS v1.0 graph: token embeddings drive the fixed 166,700-node network, and a 278,528-parameter adapter reads its state to adjust the next-token scores of Liquid AI's LFM2.5-1.2B-Instruct. Only the adapter trains, against a parameter-matched direct-input control. The README puts the caveat in its first paragraph, that language ability comes from the pretrained model and this does not mean a biological fly understands language.
Artem X (@artem-x-meta)
Combines a NeuroMechFly body in MuJoCo with MaleCNS connectome data and explicit behavioural controllers. The hybrid mode covers walking, odour-guided food search, contact feeding through an articulated proboscis, grooming, sleep pressure and waking; a separate two-fly arena adds shared food, body collisions, pushing, foreleg fencing and retreat. The README states that the demo clips were recorded with the connectome disabled, showing the engineered controllers, and that this is an experimental model rather than a validated digital fly.
Liu Zihe (@liuzihe02)
Puts a connectome simulation into Craftax, an open-ended survival environment, and trains a linear descending-neuron readout with PPO. What sets it apart from most of the wave is the harness around it: a brain-only throughput benchmark, an MN9 sugar-response check against Shiu et al., a calibration sweep over lamina bias and synapse weight, zero-shot rollouts against ablation controls, and a replay of the trained readout on a held-out key versus an open-loop baseline. A research prototype, not a result.
Mert Cobanov (@cobanov)
The original Chromium Dino game played through an 80-cell measured MaleCNS circuit: eight engineered observations feed the fixed cells, 16 descending-cell activities feed a 16-12-3 readout, and only that 243-parameter readout is trained, using the cross-entropy method over 80 generations and 15,680 episodes. The published checkpoint clears 99/100 held-out 180-second courses; the same readout with the circuit silenced clears 0/100. The author states this shows learned control and dependence on circuit activity, not that biological topology is better.
David Zhang (@dzhng)
A 3D browser puzzle game: arrange household objects in a furnished house, release a swarm of flies, and see how many find the exit before time runs out. Each fly has its own simulated activity from a selected part of the MaleCNS connectome, running as Rust compiled to WebAssembly with a TypeScript world and interface; you can follow one fly, read its left/right color inputs and inspect its neural traces. The stated design rule is to build the game around observed behavior rather than forcing the neurons to produce a chosen strategy.
Matty (@mattyhempstead)
"Born to fly. Forced to scroll." A simulated fly watches an endless feed of insect Shorts on a virtual phone: the browser samples the phone image at 90x160 pixels, luminance and color stimulate 3,335 R1-R6 and 811 R8 inputs in the full MaleCNS v1.0 graph, and a compiled kernel advances 50 ms of neural time per accepted frame. The overlay charts the measured PAM11 dopamine firing rate in Hz alongside whole-network spike counts. Explicitly inspired by Stonkfly; body motion is an amplified readout, not a physics simulation.
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.
Furkan Çakır (@furkancak1r)
A first-person horror prototype in Godot 4.5 where a physical fly shares the room with you: a MaleCNS v1.0 simulation (166,700 neurons, 25,582,938 directed connections) influences its flight while a separate reward-updated decision layer picks which scare events fire. The repository ships the built game, the data, a separate Python simulation, tests and measurement reports, and documents a pre-training run of 48 synthetic players over 576 rounds. The README is in Turkish.
Mark Unthank (@MarkUnthank)
Trains a model built from 165,122 traced MaleCNS neurons and 25,563,197 measured connections to physically operate a steering wheel through a simulated fly foreleg, then drives a car in CARLA. The reported pilot passed 100/100 held-out stationary steering targets after 600 optimizer updates and 0/100 before, with a worst hold error of 4.85 degrees against a predeclared 7.45-degree limit; removing the foot grip removes over 99 percent of the steering response. The README states that visual driving, combined wheel and pedal control, and three-seed replication remain untested.
tel∅s (@tel-0s)
Gives the MaleCNS v1.0 connectome colour vision, smell, taste and wind sense, a body that walks, jumps and flies, and a room with a table and fruit on it. The console shows a body camera, an orbit view, both retinal mosaics, antennal inputs and simultaneous population, motor and body readouts, with switches for simulated central-complex steering, anemotaxis and escape gating. The connectome is never trained or edited; everything else rests on a documented set of physiological assumptions.
Turaga Lab, HHMI Janelia Research Campus
The official PyTorch implementation of Lappalainen et al., "Connectome-constrained networks predict neural activity across the fly visual system" (Nature, 2024): a deep mechanistic network of the fly visual system whose connectivity is fixed by the connectome while its parameters are trained on an optic-flow task. The wiring ships with the package as a FIB-25/FIB-19 medulla reconstruction, not one of the whole-brain datasets. It includes pretrained model ensembles, Colab tutorials and a framework for custom models; several browser demos in the September 2026 wave use it as their eye front end.
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.
@sainimatic on X (photo, 2026-09-13)Macroblock (@sainimatic)
A counterpoint to the wave of games that put the simulated fly through hostile environments: Macroblock announced a sim where the fly simply flies around and feeds forever among grass, trees and endless fruit. The post drew roughly 24,000 likes and was picked up by Dexerto and IBTimes as the trend's ethical reaction shot. The post announces work in progress, so which connectome it uses and how far it got are not established by the sources checked.
GIGAZINE
Japanese-language coverage of the wave, published six days after the MaleCNS release. It walks through Alex Wormuth's Doom experiment (including the PPL101 dopamine cells stimulated on damage), Jessica Paquette's Super Mario 64 controller, Evan Smith's NeuroCraft Fly in Minecraft and a Bad Apple!! visualisation, and closes on the point most of the wave elides: the connectome shows structure and connections, not a complete functional replication of the biology.
Google Research (Michał Januszewski, Viren Jain)
The release-day post from the Google Research side of the collaboration, describing the male central nervous system reconstruction as the largest brain map by neuron count to date: over 166,000 neurons and 125 million synaptic connections, led by HHMI Janelia with Google Research and academic collaborators, published in Cell as a study of sexual dimorphism. It points to the Janelia download page and to Neuroglancer for viewing the volume. This is the announcement the entire September 2026 demo wave grew out of.
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.
Lulzx
An embodied whole-CNS simulation that runs in a desktop browser: a 165,122-neuron MaleCNS v1.0 brain in a MuJoCo flybody body with a flyvis-trained compound-eye front end. Four views ship together, a connectome viewer with stimulable cell types, an algorithmic-structures page (ring attractor, expansion coding, motif census), an arena where you place sugar, odour and threats and watch a fly's brain in an inset, and an anatomy viewer. An endogenous-activity module supplies the spontaneous drive the connectome model lacks, entering only as synaptic input to identified descending neurons.
Reiser Lab, HHMI Janelia Research Campus
A browsable reference for the MaleCNS v1.0 cell types, generated from the dataset itself and published by the lab: one page per cell type with connectivity, region innervation and morphology. It is the resource the demo projects should be checking their named neurons against, since almost every game demo picks out descending neurons such as DNp01 or DNg100 by name without a way to see what those cells actually connect to.
Pandu Sastrowardoyo (@Decentricity)
Drives a sparse MaleCNS reservoir with a live Muse EEG headset and renders the result in the terminal through libcaca, with a human scalp and band pane next to the fly visualisation. A synthetic EEG source lets it run without a headset. The README sets its own limits clearly: the reservoir dynamics are not biophysics, and the "fly EEG bands" are the spectral content of the digital reservoir rather than insect electrophysiology.
Xenova (Hugging Face)
A standalone Hugging Face Space where you paint neurons, stimulate the network and watch an articulated Three.js fly respond, all locally in the browser. It retains 166,700 MaleCNS entries and 25,582,938 directed connections and runs a leaky integrate-and-fire model adapted from Shiu et al. on WebGPU kernels, with a JavaScript fallback. The card is candid that the walking, turning and flight animations are crafted and illustrative, that gains and thresholds were chosen for the demo, and that body motion never feeds back into the network.
marketcalls
The trading branch of the wave, aimed at the Indian options market instead of crypto: the full MaleCNS v1.0 simulation is wired through OpenAlgo to one strategy, an intraday short straddle on the current-month NIFTY expiry, sized with volatility-based stop losses and flat by 15:15 daily. Prices and option chains come from the user's own OpenAlgo connection into a local DuckDB, with no mock data. Paper mode is the default, live mode needs an explicit opt-in, and the README states that no profitable edge has been demonstrated.
▶Ro0oney (YouTube)
The YouTube video Know Your Meme credits as one of the earliest large posts of the September 2026 wave, with over 241,000 views in three days. The creator wires a fly connectome model to the behaviour of a Minecraft mob, first a spider and then a bee. The title's talk of transferred consciousness is showmanship: coverage describes a model of neural connections with a program mapping neurons to in-game decisions, and neither the dataset version nor the neuron-to-action mapping is documented in the sources checked.
hrook1
A browser arcade game where you try to swat a fly and watch its escape circuit light up before you click. It runs a simplified spiking model of 6,000 traced MaleCNS v1.0 neurons and 1,275,994 directed connections (preserving 10,659,685 original synaptic contacts), feeding simulated vision into an extracted LC16-to-MDN retreat circuit whose activity influences evasive turns and bursts. Baseline cruising, flight animation and collision rules are authored game mechanics, and the README says so plainly.
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.
▶@_lyraaaa_ on X (video poster, 2026-09-12)@_lyraaaa_
A short video posted on X by @_lyraaaa_ showing a simulated MaleCNS v1.0 fly brain hooked up to Beat Saber. It carries the highest view count Know Your Meme lists for the September 2026 wave, roughly 22 million views and 84,800 likes. Dexerto reports that the creator later clarified the video does not yet show the model independently playing: its motor system had been trained to reproduce a recorded sequence, while visual reactions and actual playing patterns were still being developed through reinforcement learning. Read the view count with that in mind.
▶@nftechie_ on X (video poster, 2026-09-12)@nftechie_
A video post by Alex Wormuth (@nftechie_), the creator behind the earlier Doom livestream, giving a simulated fly brain $100 and using its neural activity to trigger buy and sell orders on Coinbase, with dopamine neurons stimulated whenever it profits. Know Your Meme reports about 3.4 million views. The author published Stonkfly the same day: prices become an RGB chart stimulating 3,335 brightness and 811 R8 inputs in the MaleCNS graph, a fixed readout proposes buy, sell or hold, and profit or loss stimulates PAM11 or PPL101 cells. It paper-trades by default and shows no profitable learning.
natverse/coconatfly README (GPL-3.0-or-later)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.
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)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.
Harvard Medical School (Wei-Chung Allen Lee lab)
GridTape-TEM volume of an adult female fruit fly's ventral nerve cord from the Lee lab at Harvard Medical School, with automated reconstruction and an ongoing community proofreading effort. The original EM dataset was described in Cell in 2021, and the connectomic reconstruction (Azevedo, Lesser, Phelps, Mark et al.) in Nature in 2024. This repository hosts the pip-installable fanc-fly Python package (GPL-3.0) and the project wiki, which fanc.community redirects to.
sjcabs/fly_connectome_data_tutorial (MIT)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.
caparison1234
A Python project that runs 1,373 neurons and 22,400 synapses from the Winding et al. 2023 larval Drosophila connectome as LIF units and lets them drive a real-time MuJoCo larva body. Note the front end: a small Qwen2.5 0.5B language model converts typed text (English, Korean, Japanese or Chinese) into sensory drive, so 'danger' activates nociceptors and produces retreat or curling, and 'food smell' produces head scanning; the connectome itself is not perceiving anything. All 17 commits date from 2026-03-21, well before the September wave; no license is stated.
ad7584
A token experiment: a Python simulation of 165,122 neurons from the September 2026 male CNS connectome is wired to token-launch platforms on Solana and Robinhood Chain. Market signals such as momentum and liquidity are mapped onto sensory populations, and launch or abort decisions are read from command neurons with known roles (proboscis extension means launch, the giant fiber escape circuit means abort). Single-commit repo with no stated license; the same account also authored commits in flycoinrh.
Listed for information only. No endorsement, no referral links.
fruitflydev
A token experiment in which a neuron-by-neuron simulation of the 165,122-neuron male connectome (data pulled from the public CC-BY cloud bucket) drives a browser: screenshots pass through 892 retinotopic columns, activity propagates across the network, and motor output moves a cursor on a launchpad on Robinhood Chain, an Arbitrum-based L2. Later commits add dopamine-gated Kenyon-cell plasticity, an autonomous browsing mode and a narrator voice. Code is MIT; 30 commits over 2026-09-10 to 09-11, several by the flycoin author ad7584.
Listed for information only. No endorsement, no referral links.
Fly Connectomics group (Cambridge) & Jefferis lab (MRC LMB)
A README-only index of the software produced by the Cambridge Fly Connectomics group and the Jefferis lab at MRC LMB, useful as a map of the R natverse side (nat, neuprintr, hemibrainr, fafbseg, nat.flybrains) and the Python side (navis, pymaid, fafbseg, flybrains, skeletor). It was assembled in early 2022 and has not been updated since, so treat it as a snapshot rather than a live catalogue.
yc-h (FlyCircuit-based model)
An early single-cell-resolution spiking simulator of the fly brain written in C/C++, built not on an EM connectome but on neuron data from the FlyCircuit database (flycircuit.tw), with companion programs for predicting connections and inferring neuron polarity (SPIN). The repository accompanied a manuscript under review in November 2018 and includes experiments on seizure-like hyperactivity; it has not been touched since.
Princeton Neuroscience Institute
A browser-based explorer developed at the Princeton Neuroscience Institute that lets anyone search, filter and visualise large connectomes entirely in the browser, with no local install or bulk download. Beyond FlyWire's own FAFB v783 (139,255 neurons) it now serves BANC v888, Janelia's MANC v1.2.1, the male optic lobe (MAOL v1.1) and the male CNS v1.0, and had passed 60,000 registered users by early 2026. The open-source code lives in the murthylab/codex repository under Apache-2.0.
Gizmodo
News piece by Bruce Gil covering the wave of hobbyist simulations that followed the September 3, 2026 release of the male fruit fly CNS connectome (MaleCNS v1.0) by Google and HHMI Janelia. It profiles Alex Wormuth's Doom-playing fly brain, Jessica Paquette's Super Mario 64 run, a Minecraft port, and posture and animation experiments. The article frames the dataset as the largest brain map by neuron count, at over 166,000 neurons.
HHMI Janelia Research Campus (FlyEM Project Team)
Dense synaptic-level reconstruction of a large part of the central fly brain, including the mushroom body and central complex, produced by Janelia's FlyEM team. It contains roughly 25,000 neurons sorted into thousands of cell types, with v1.0 released in January 2020 and v1.2 in December 2020. The overview paper was published in eLife and the data is served through neuPrint.
HHMI Janelia Research Campus
Janelia's own announcement, dated October 6, 2025, of the first complete wiring diagram of a male fruit fly's brain and nerve cord, covering more than 166,000 neurons. The work was done by HHMI Janelia with the MRC Laboratory of Molecular Biology, the University of Cambridge and Google Research, with Gerry Rubin and Greg Jefferis among the researchers quoted, and was posted as a bioRxiv preprint. Rubin stresses that it enables the first sex-by-sex comparison of a socially complex animal, and the data is free to researchers worldwide.
Know Your Meme (Literally Media)
Know Your Meme entry documenting the viral trend of hooking the MaleCNS v1.0 fruit fly connectome, released September 3, 2026 by Janelia's FlyEM team, the Cambridge Connectomics Group and Google Research, up to games and other environments. As read on September 13 it tracks a YouTube Minecraft video from September 7 with 241,000 views, a Beat Saber clip with 22 million, a Coinbase trading video with 3.4 million and a driving-simulator clip with 1.5 million, plus a talent-manager sim, a Twitch streamer persona and a Deadlock run. Still marked as a submission under review.
natverse/malecns README (GPL-3.0)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.
HHMI Janelia FlyEM, Cambridge Connectomics Group, Google Research
Complete connectome of the ventral nerve cord of an adult male fruit fly, the structure that plays the role of a spinal cord and drives most motor behavior. Released in June 2023 (v1.0) and updated to v1.2 in March 2024 by Janelia's FlyEM team with Cambridge and Google Research, it covers about 23,000 neurons with around 10 million presynaptic sites. Three accompanying papers were published in eLife.
▶@barrelshifter on X (video poster, 2026-09-12)ornata (Jessica Paquette, @barrelshifter)
Jessica Paquette's proof-of-concept that pipes Super Mario 64 frames (from a decompiled SM64 build) into a simulated visual system of a ~100k-neuron MaleCNS v1.0 model and reads controller inputs off named descending neurons: DNg100 for movement, a DNa02/DNg13 difference for steering, DNp01/DNp10 bursts for jumping. There is no learning or reward signal, and the README says the fly mostly walks into walls and gets stuck; the author calls it 100% vibe coded. Covered by Gizmodo on 2026-09-08.
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.
Janelia FlyEM (HHMI)
Janelia's connectome analysis ecosystem: a Neo4j-backed graph database plus the neuPrintExplorer web front end and an HTTP API for querying neurons and synaptic connectivity. It is the official home of the hemibrain, MANC and male CNS datasets from the FlyEM team, and the ecosystem was described in a 2022 Frontiers in Neuroinformatics paper by Plaza et al.
Janelia FlyEM (HHMI)
The official Python client for the neuPrint service, letting you pull neuron metadata, connectivity tables and skeletons from Janelia's connectome databases into pandas without writing Cypher by hand. First published on PyPI in January 2020 and still actively released (0.6.3 in July 2026), it is installable via pip, conda or pixi.
HHMI Janelia FlyEM Project Team with Google Connectomics
Complete wiring diagram of the right optic lobe of an adult male fruit fly, the visual-processing region, produced by Janelia's FlyEM team with Google's connectomics group. It catalogs more than 50,000 neurons in over 700 types, including roughly 16,000 intrinsic and 32,000 connecting neurons, and is served on neuPrint as optic-lobe v1.1 after a 2024 data release. The accompanying paper, a connectome-driven inventory of a complete visual system, was published in Nature in 2025.
▶@alright_mark on X (video poster, 2026-09-12)@alright_mark
A joke-toned video post by @alright_mark presenting a simulated fly-brain system attempting the "ultimate test" of parallel parking a car. Know Your Meme reports roughly 1.5 million views and 16,000 likes for the 2026-09-10 post. The coverage fetched describes only the video and its caption, not the underlying setup or which connectome data, if any, is simulated.
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.
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.
Apolotary (Bektur Ryskeldiev)
An Ableton Live extension for macOS that turns the 1,045-neuron MaleCNS motor subset (borrowed from DesktopFly's data) into MIDI: simulated flies bounce around a Three.js scene and their collisions, contacts and motor values trigger notes or modulate ambient parameters across five modes, including a Dark Lab mode with a small learnable 70-weight readout. The author is careful to separate the measured circuit from the composed harmony, describing the flies as particles dressed up as flies. Written up on Sonic Field on 2026-09-10.
Zanichelli, Schons, Freeman, Shiu & Arkhipov (arXiv preprint)
An arXiv preprint (q-bio.NC) by Niccolo Zanichelli, Maximilian Schons, Isaak Freeman, Philip Shiu and Anton Arkhipov that re-evaluates whole-brain emulation progress since the 2008 Sandberg and Bostrom roadmap. The report is organized around three capabilities: recording neural dynamics, mapping structure through connectomics, and emulation with embodiment. First posted October 17, 2025, with a third revision on November 5, 2025, under a CC BY 4.0 license.
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 (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.
Fly Brain Hub
