Fruit fly brain simulation projects: GitHub code, online demos and evidence grades

Project's own claim “"The real wiring of a fruit fly's learning centre, taken from the FlyWire connectome and hooked up to a chessboard ... teaches itself chess by playing itself"; and "the real FlyWire wiring learns chess exactly as well as the same cells with their inputs shuffled" (README)” source

Mechanism Wiring: FlyWire v783 PN->KC connections only (285 PNs, 5,177 KCs, 21,509 edges >= 5 synapses); binary (who connects to whom). Neuron model: other: binary threshold Kenyon cells (fire when >= 2 inputs are on) and one rate-like output neuron (tanh-squashed sum). Input: hand-made: 806 board channels (piece-square and piece-count) converge 2-3 per PN by a seeded permutation (src/brain.js). Output: hand-made: the single MBON value is the position evaluation used by an ordinary alpha-beta search (1-3 moves plus captures). Trained parts: KC->MBON weights and a board-channel shortcut, by a dopamine-like prediction-error rule from self-play results. Body: none (3-D fly carrying pieces is animation). Scripted parts: alpha-beta search and move generation are ordinary engine code; games stopped at 200 moves are scored by material.

Measured result (by the authors unless stated) Exam rating (Elo scale on which the Random bot = 400) after 10,000 self-play games, one fly per wiring, from the committed brain files: real FlyWire wiring 1680, shuffled claws 1675, the original random design 1850; all start at 660. The author's bigger exams (README): 1690, 1695 and 1755; real vs shuffled 53% to 47% head to head. The real wiring is no better than shuffled wiring and a little worse than a random design.

Grade basis (checked 3 Oct 2026)

• data/mushroom_body.json at 52276aa: source 'FlyWire connectome v783 ... as packaged by Shiu et al. 2024', minSynapses 5, 285 PN IDs and KC claw lists [direct]
• src/brain.js:9-14, 85-105: 'flywire', 'shuffled' (same claw count per KC, each claw re-drawn from the pool of real PN partners, so PN popularity is kept in expectation) and 'random' (4,000 cells, 7 random inputs straight from board channels) wirings [direct]
• brains/adult.json, adult-shuffled.json, adult-random.json: exam curves over 10,000 self-play games (seed 1 each); exam rating at 10,000 games: real 1680, shuffled 1675, random design 1850; untrained egg 660 for all [direct]
• README 'Real wiring vs random wiring': bigger 200-game exams 1690 / 1695 / 1755 and a round robin (real vs shuffled 53% to 47%); tools/compare.mjs produces them, but its output is not committed [README; numbers not in files]

Limits A clean negative result, but thin: one trained fly per wiring and one shuffle (seed 1), with exam ratings from 40-game exams per opponent, so differences of a few tens of Elo are within noise. Only the PN->KC layer is from the connectome; the Kenyon cells are binary threshold units, a single output neuron does the evaluating and an ordinary search picks moves. The shuffle keeps each Kenyon cell's claw count and draws partners from the real PN pool (PN popularity kept only in expectation).

More facts Data licence: FlyWire v783 derived data (CC BY 4.0 per FlyWire; not stated in the repository) · Peer review: none · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-30 (not an update date) · Last push, any branch: 2026-09-30

Sources

• https://github.com/znatgost/chessfly [direct]

Project's own claim “A QA fuzzer for browser games. One of its policies is a real fruit-fly connectome — and that one loses.” source

Mechanism Wiring: FlyWire v783, all 138,639 neurons, pruned to 2,700,513 connections with >=5 synapses; weights rescaled to 0.44 mV. Neuron model: LIF. Input: hand-made. Output: learned. Trained parts: No weight training. A 1.2 s start-up calibration flashes each eye, picks up to 20 left and 20 right descending neurons that respond differently, and normalises them (a fitted readout). Vision preprocessing gains are hand-set.. Body: none. Scripted parts: No scripted steering found. Steer is the normalised right-minus-left rate of the calibrated DN channels, with an adaptive baseline and smoothing. Thrust is active-DN rate clamped to 0.25-1. The game turns steer/thrust into movement or synthetic keys..

Measured result (by the authors unless stated) Steering vs light-direction correlation over 8 seeds is about 0: 0.046 ± 0.272 (ratio decoder), 0.077 (adaptive baseline), −0.042 ± 0.111 (threshold+tanh), 0.046 ± 0.272 (200 ms saccade) (LIMITATIONS.md:15-24; README.md:171 says 'correlation ... is 0 over 8 seeds'). Map-coverage benchmark (policy_bench.mjs; README.md:46-56; LIMITATIONS.md:188-221): fly 42% (35-50, 3 reps), smoothed noise 61% (57-66, 5 reps), uniform noise 50% (46-52), straight 5%. Paired test: fly+noise 53% (49-56) vs the same noise alone 56% (52-63), so the connectome adds −3 points, within run-to-run spread. Static left/right test: separation 0.947, 0.000 after cutting the 40 steering channels, 1.121 after restoring them (README.md:69-72).

Grade basis (checked 28 Sep 2026)

• tools/00_fetch.sh:6-11 downloads Connectivity_783.parquet, Completeness_783.csv and FlyWire 783 annotations [direct]
• tools/pack.py:4,18-30 packs FlyWire v783 with threshold TH=5, N=138639; docs/data/brain.bin header N=138639, M=2700513 [direct]
• docs/lif.js:10-19,80-127 uniform LIF (Shiu et al. parameters, W_SYN=0.44, Poisson drive on sensory neurons) [direct]
• docs/fly.worker.js:55-127 loads brain.bin and meta.json in a Web Worker, drives left/right LA>ME neurons from a 16x12 view grid, reports steer/thrust every 100 ms [direct]
• docs/calibrate.js:18-87 picks DN channels by flashing each eye; docs/calibrate.js:96-137 computes steer/thrust only from those channels [direct]
• policy_bench.mjs:45-95,97-123 seeded benchmark (24,000 frames): fly vs uniform noise, smoothed noise, straight-ahead, and a paired no-connectome control fed the same noise sequence as the fly+noise hybrid [direct]
• docs/policy.js:75-81 hard-codes the measured table the page shows (fly 42%, hybrid 53%, smooth 61%, uniform 50%, straight 5%) [direct]

Limits Page responds (HTTP), not played. The simulation runs on the CPU in plain JS in a Web Worker. WebGL is used only for the three.js brain view and the GTA1/Carnage3D target, and DOOM mode uses WASM. No WebGPU. Graded A as a well-controlled negative result: a seeded, reproducible benchmark with a paired no-connectome control. Limits: the controls are no-graph and random baselines, not shuffled wiring. There are only 3-5 repeats, on the author's own test game, and the metric is map coverage, not fly behaviour. The readout is fitted at start-up. No script in the repo produces the ~0 correlation numbers; they appear only in LIMITATIONS.md. The page shows hard-coded results. Visual input goes to LA>ME, not to photoreceptors. The README says MIT, but the repo has no LICENSE file.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-15 (not an update date) · Last push, any branch: 2026-09-27; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/hwkim3330/flyworker [direct]
• https://hwkim3330.github.io/flyworker/ [direct]

Project's own claim “165,122 neurons, 104 million synapses. This project runs that file as a spiking brain, inside a physics-simulated body, in a web browser” source

Mechanism Wiring: MaleCNS v1.0 (Janelia FlyEM), all 165,122 neurons; CSR graph of connections with >=3 synapses (browser run uses minSyn 6); transmitter signs. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: The flyvis optic-lobe model (a separately trained network) drives the optic-lobe input neurons from eye raycasts. The tripod stepping generator is fitted by CMA-ES to FlySuite kinematics. Nine global brain parameters were fitted by cross-entropy search to the same literature benchmark used for scoring. A reafference-cancel model is also fitted.. Body: flybody. Scripted parts: The docs openly list many 'scaffold' plugins outside the graph. These include a tripod CPG that makes all coordinated leg movement (without it the fly freezes), a bout scheduler using ethology statistics, an escape gate, a reafference gain, steering adaptation, a righting reflex, a groom pattern, courtship and female-rejection rules, flight saccades, an octopamine arousal rule and a hand-added GF gap junction. Each can be switched off with ?off=..

Measured result (by the authors unless stated) Ablation ladder (docs/31-ablation-ladder.md, public/data/ablation_ladder.json; 12 paired seeds, 17-assay benchmark built from literature summary statistics): calibrated model 0.796 +/- 0.006; weight-shuffled wiring 0.404 (change -0.392 +/- 0.013), 0.559 after refitting; all-excitatory control 0.524. respond-like-the-fly: only 1 of 5 animal rows is matched by every ensemble member, and 0 of 4 members match all rows.

Grade basis (checked 28 Sep 2026)

• scripts/prep_graph.py:7,10,32 read MaleCNS v1.0 annotation, transmitter and connectome-weight feather files [direct]
• src/wasm/lif.c:29 lif_step, the WASM SIMD conductance LIF kernel over the full graph; src/brainsetup.js:66 uses the WebGPU kernel if navigator.gpu exists, otherwise WASM [direct]
• src/arena.js:47,75 loads lif.wasm into SharedArrayBuffer memory (warns if not cross-origin isolated); src/arena.js:56 loads the flyvis vision model [direct]
• src/sim/motor.js:3,10 default 'descending' mode: DN_ROLES map named descending neurons (DNg100, MDN, DNa02, DNp01, ...) to forward, backward, turn, groom and escape commands [direct]
• src/sim/scaffold/plugins/cpg.js:6,23 the stepping generator is a CMA-ES-fitted two-harmonic tripod, on by default [direct]
• scripts/rungs.mjs:17 and scripts/calib_eval.mjs:38 w_shuffle control permutes synapse counts across retained edges [direct]
• public/data/ablation_ladder.json and ablation_refit.json (generated 2026-09-18): baseline 0.7961 vs w_shuffle 0.4041 (refit 0.5591), sign_free 0.5241, 12 paired seeds [direct]
• public/data/experiments/respond-like-the-fly.md compares ensemble members, including weight-shuffled wiring, with animal perturbation results (MDN, 13B, decapitation) [direct]

Limits Page responds (HTTP), not played. Needs WebAssembly, SharedArrayBuffer (cross-origin isolation through a service worker) and a module Web Worker per fly. WebGPU is used if present, else WASM (?gpu=0 forces WASM). The README targets desktop Chrome, Edge or Firefox. Grade A rests on the offline benchmark with shuffled-wiring and sign-free controls, not on the arena behaviour. The benchmark targets are literature summary numbers, and the same benchmark was used to fit the global parameters. Doc 31 says its table predates a later objective repair (baseline would drop to 0.697) and has not been re-run. In the arena, coordinated walking comes from the fitted CPG scaffold, not from the connectome; the author documents this openly. The 'paper' is a self-published textbook. Browser check 2026-10-03 (no GPU): the arena fetched its 14.6 MB graph and started 4-5 workers, then passed our 1.6 GB browser memory limit twice; the page also warned that it was not cross-origin isolated (no SharedArrayBuffer).

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 27 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-10 (not an update date) · Last push, any branch: 2026-09-24; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Lulzx/fly-brain [direct]
• https://lulzx.com/fly-brain/arena.html [direct]
• https://lulzx.com/fly-brain/textbook/ [paper]

Project's own claim “A whole fruit fly brain — all 138,639 neurons and 15.1 million connections of the FlyWire connectome — simulated live in your browser tab and wired to a virtual fly” source

Mechanism Wiring: Whole FlyWire v783 brain, signed synapse counts (Shiu et al. files). Neuron model: spiking: Shiu et al. LIF (JavaScript, lazy exact updates; validation/ compares with Brian2 2.9 reference runs). Input: hand-made: sugar, bitter and water GRNs, Johnston's organ, LC4/LPLC2 driven as Poisson inputs by arena events. Output: hand-made: MN9, giant fibre, aDN1, P9, DNa02, MDN rates times fixed MOTOR_GAIN values set body kinematics. Trained parts: none. Body: custom (procedural animated 3D fly, not physically simulated). Scripted parts: the '6-7' gesture every 15-25 s (labelled as scripted); gait animation.

Measured result (by the authors unless stated) README: bitter laced sugar lowers MN9 about 14x (52 to 3.7 Hz); not re-run by us and not compared with a control. 5 Oct 2026, our own test (Brian2 2.9.0, Shiu et al. model, not fly67's engine): fly67's looming rule held on both sides (left loom: giant fibre 111.5 Hz, contralateral DNa02 23.0 vs 0.0 Hz; right loom: 119.0 Hz, 44.0 vs 0.0 Hz; fly67's committed values: 114.8 Hz, 25 vs 0 and 120.3 Hz, 43 vs 0). With degree-preserving shuffles the giant fibre and DNa02 were 0 Hz (n 3). In a FlyGym body (our mapping, constant external drive) the real brain turned the fly away in 4 of 4 runs and the scrambled brains in 0 of 3 (controls ledger study byo-flygym-loom). The 'away' direction rests on our mapping's DNa02 sign and on fly67's claim; we did not verify it in real flies. A primary source (Card and Dickinson 2008) shows flies jumping away from a looming threat at takeoff, not walking flies turning.

Grade basis (checked 1 Oct 2026)

• src/engine.js:17-20,91-98 (commit 45f62fd): Shiu et al. constants (tau 5 ms, refractory 2.2 ms, w_syn 0.275 mV) and closed-form LIF updates [direct]
• src/circuits.js:5,29-45: sensors (sugar/bitter/water GRNs) and readouts (MN9 = CB0701, DNa02 left/right, ...) chosen by the author [direct]
• src/arena.js:9,34-36,94-100: MOTOR_GAIN mapping and the scripted '6-7' easter egg ('NOT produced by the connectome') [direct]
• validation/ folder: Brian2 2.9 reference files and a lazy-vs-dense equivalence check (not run by us) [direct: file list]
• GitHub API 2026-10-01: MIT; last commit 2026-09-29 [direct]

Limits A faithful browser port of the Shiu model with hand-made inputs and outputs. The body is animated from a few descending-neuron rates; there is no ventral nerve cord or physics. No scrambled-wiring control. One gesture is scripted and labelled. Browser check 2026-10-03: the brain runs in a Web Worker as recorded; the download is 33.3 MB, not the ~100 MB in our earlier record (corrected). 5 Oct 2026: our own Brian2 run of the Shiu model reproduced the looming 'turn away' rule on both sides, and degree-preserving shuffles abolished it (controls ledger study byo-flygym-loom; this is our test, not a control by the author).

More facts Data licence: FlyWire FAFB: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-29

Sources

• https://github.com/znatgost/fly67
• https://znatgost.github.io/fly67/

Project's own claim “Tonight's host: Grey Leno, piloted by Drosophila melanogaster” source

Mechanism Wiring: Whole FlyWire v783 brain from the Shiu et al. files, signed synapse counts; dopamine-gated plasticity (on by default) changes the weights of synapses onto the voice (articulator) motor neurons while the show runs. Neuron model: spiking: Shiu et al. leaky integrate-and-fire (event-driven JavaScript port in a Web Worker); optional spike-frequency adaptation, off by default. Input: hand-set: show events, thrown objects, music loudness bands and food touch stimulate chosen sensory groups (sugar GRNs, Johnston's organ, looming, taste) as Poisson inputs; stimulus neuron IDs from erojasoficial-byte/fly-brain. Output: hand-set: descending-neuron rates (P9/oDN1 forward, MDN backward, DNa01/02 turn, giant fiber startle, aDN1 groom, MN9 feed) divided by fixed saturation gains (40 Hz; 15 Hz for startle); ~1,250 other DNs pooled onto 46 ragdoll muscles; voice from song/flight DNs and mouthpart motor neurons. Trained parts: none offline; online dopamine-gated plasticity onto voice motor neurons, and an engineered action selector (softmax over values learned from the model's own dopamine) that starts spontaneous actions by stimulating descending neurons. Body: custom (Rapier physics ragdoll of Grey Leno or a giant fly, three.js). Scripted parts: Gait pattern generator ('VNC', engineered), balance 'puppet strings', saccadic turns and walking bouts, food taxis, homing (engineered input onto DNa01/02 and P9), sleep, the show director and all stage events; the README table marks each as engineered.

Measured result (by the authors unless stated) No measured result or control in the repository.

Grade basis (checked 30 Sep 2026)

• tools/build_connectome.py:3-22,41 builds data/connectome.bin.gz from philshiu Completeness_783.csv and Connectivity_783.parquet, min_syn 1 as Shiu [direct]
• js/brain-worker.js:5-14 Shiu LIF equations (dv/dt, dg/dt, v_th reset, Poisson stimulus kicks); :462 loads data/connectome.bin.gz; :42 dopamine plasticity PL.enabled true; :47 adaptation off by default [direct]
• js/motor.js:3-40 decodeMotor: rates of forward/backward/turnL-R/startle/groom/feed divided by motorGains (40 Hz, startle 15 Hz), EMA 250 ms [direct]
• js/brain-worker.js:39,205-207,253 dopamine-gated plasticity only on synapses onto the plastic readout (articulator) neurons [direct]
• js/instincts.js:1-25 neural vs engineered list (sugar GRNs -> MN9 decides eating; food taxis, homing, saccades, bouts engineered) [direct]
• js/mind.js:1-24 action selector outside the connectome: softmax(Q/T) over talk, stroll, turn, back up, fart, retch, rest; Q learned from DA = tanh((PAM - PPL1)/20 Hz); a chosen action stimulates the matching descending/motor neurons ('fictive drives') [direct]
• README.md 'What drives what' table: each behaviour marked neural or engineered [direct]
• No wiring control or no-brain baseline anywhere in the repository (grep for shuffle/scramble/rewire finds only playlist and animation code) [direct]

Limits The whole v783 brain really runs, with no offline training, and the README labels every engineered layer. But the show is built around it: gait, balance, food seeking, homing and sleep are ordinary code, spontaneous actions are chosen by an engineered selector that then stimulates descending neurons, input neurons and output gains are chosen by hand, and plasticity rewrites voice synapses during the show. Reactions (startle, eating, grooming) do come from the model's own neurons. There is no scrambled-wiring or no-brain control, so how much of Leno's behaviour needs the real wiring is not shown. Borderline B/C. The viral video is a streamer's playthrough, not the author's.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-22 (not an update date) · Last push, any branch: 2026-09-27; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/AgitationSkeleton/flyleno [direct]
• https://flyleno.viosarcade.xyz/ [direct]
• https://www.youtube.com/watch?v=BOSg6HYVX1o [video]

Project's own claim “A little house. A swarm of flies. A real connectome behind every wrong turn.” source

Mechanism Wiring: subset: 70,000 neurons / 798,715 edges of MaleCNS v1.0 (seed-touching extraction, minimum weight 5). Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none. Body: custom. Scripted parts: Readouts are fixed formulas: the mean voltage of left/right DN and MN sets gives thrust and turn, and the olfactory spike difference is scaled by a calibrated 4.0. Walking, flying and landing switch at hand-set thresholds. An authored 'exit suction' airflow near doorways helps flies out. The kinematic body has no leg gait..

Measured result (by the authors unless stated) specs/done/neural-vision/README.md: 7 prespecified directional/intensity contrasts pass with Bonferroni correction over 847 comparisons. Input silencing reproduces the dark-input trajectory. Motor and behavioural (approach/avoidance) effects were not established. None of this is a wiring control.

Grade basis (checked 28 Sep 2026)

• data/processed/brain/manifest.json: dataset 'MaleCNS v1.0', neuronCount 70000, edgeCount 798715, minimumWeight 5, synthetic false [direct]
• packages/sim-client/src/attempt-worker.ts:52 fetches /brain/graph.bin into the WASM AttemptSession [direct]
• crates/sim/src/lif.rs:21-27 LIF parameters (tau 20, threshold 1, noise 0.015); :296 membrane update with synaptic input, external current and noise [direct]
• crates/sim/src/lif.rs:351 motor_output maps DN/MN mean voltages and olfactory spike fractions to thrust, turn and flight [direct]
• crates/sim/src/body.rs:693 takeoff when flight_thrust > threshold 0.2; :733 adds authored exit_suction_velocity [direct]
• specs/done/neural-vision/README.md:23,29 controlled neural tests pass, but approach/avoidance behaviour is not established [direct]

Limits Page responds (HTTP), not played. Needs WebAssembly and WebGL (three.js); the simulation runs on the CPU. The lab view has 20 flies and retinal mode at most 16, and each fly runs its own 70k-neuron brain (about 42% of MaleCNS, not the whole CNS). The README is careful and calls the input and movement rules models. The authored doorway 'exit suction' is not mentioned in the README. The project's controls test input propagation (silencing, sham ablation), not the wiring itself. No licence file.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 49 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-06 (not an update date) · Last push, any branch: 2026-09-17; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/dzhng/fly-escape [direct]
• https://fly-escape.vercel.app/ [direct]

Project's own claim “Simulated neural activity drives crafted walking, turning, and flight animations. The movements are illustrative, not validated predictions of fly behavior.” source

Mechanism Wiring: MaleCNS v1.0: 166,700 neurons (all annotated rows with a superclass, brain + nerve cord), 25,582,938 directed edges, no synapse threshold; histamine/unknown transmitters get 0 weight (~11.6k neurons have no fast output). Neuron model: LIF (Shiu et al. 2024 parameters, event-driven, dt 0.1 ms). Input: hand-made. Output: hand-made. Trained parts: none. Body: custom. Scripted parts: Body motion is kinematic: an authored tripod gait with joint-limited IK, and a bounded flight/landing controller that starts when the DNp01 rate passes 100 Hz. The walk/turn/fly buttons stimulate chosen cells (LC9, LC4). The turn buttons also stimulate the DNa02 readout neurons directly, so turning can appear without recurrent transmission. No contact physics and no sensory feedback from body to brain..

Grade basis (checked 28 Sep 2026)

• public/model.json 'data' block: dataset 'MaleCNS v1.0', neurons 166700, directedEdges 25582938, source male-cns.janelia.org, CC BY 4.0 [direct]
• public/data/manifest.json: source feather files from storage.googleapis.com/flyem-male-cns/v1.0/... with SHA-256 hashes; zeroFastCurrentNeurons 11609 [direct]
• src/brain.js:1-12 LIF constants (dt 0.1 ms, rest -52, threshold -45 mV, tau 20/5 ms, 0.275 mV per synapse); src/brain.js:66-129 event-driven LIF over the outgoing CSR with a 1.8 ms delay queue and Poisson drive [direct]
• src/worker.js:31,41 the WebGPU path is checked against the JavaScript reference and falls back to JS on failure [direct]
• src/stimulus.js:59-66 readout groups (DNp09/DNg100/DNg97 walk, DNa02/DNa11/DNg13 turn, MDN reverse, DNp01 escape) and stimulus targets (LC9 walk, LC4 fly, plus DNa02 direct for turns) [direct]
• src/controller.js:49-66 smoothed DN rates map to ground speed (8*tanh) and yaw rate (3.8*tanh); DNp01 > 100 Hz starts the authored escape flight [direct]

Limits Page responds (HTTP), not played. WebGPU (via @huggingface/kernels) is used when available, with a JavaScript fallback. WebGL2 is required for rendering. All 166,700 neurons are integrated, so the whole CNS really runs. The README is unusually honest: it calls the movement illustrative and says Shiu's validation does not carry over to MaleCNS. The model is a female-brain model applied to a male CNS, shown on a female NeuroMechFly body. Minor internal mismatch: model.json lists 11,068 omitted fast-output neurons, but the data manifest lists 11,609. Space licence metadata: apache-2.0. LICENSE file: MIT for app code, CC BY 4.0 for MaleCNS data, Apache-2.0 for body and kernels. fruitfly.live: serves the same app with a different build. /model.json and /data/manifest.json are byte-identical to the Space. But the page replaces the paint tools with a 'live Solana trade tape': buy/sell trades arriving over a websocket (/ws on the same host) trigger the walk/fly stimulation presets. That page names no author and shows no licence or link to the original Space; it only links the MaleCNS data and the Hugging Face kernels blog. List only the Hugging Face Space as try_url. 6 Oct 2026 browser check (headless, no GPU): after 'Download & start' the page moved but fetched only 5.87 MB in 60-90 s and started no Web Worker, so its ~77 MB brain download was not seen in our check window and the simulation was not confirmed; we will re-read the code.

More facts Data licence: CC-BY-4.0 · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://huggingface.co/spaces/Xenova/fruit-fly-simulation [direct]
• https://xenova-fruit-fly-simulation.static.hf.space/index.html [direct]
• https://fruitfly.live/ [direct]
• https://fruitfly.live/model.json [direct]
• https://fruitfly.live/assets/index-DyzlLaks.js [direct]

Project's own claim “A simulated fruit-fly brain plays Open Doctrines, live in your browser.” source

Mechanism Wiring: Whole FlyWire v783 brain, Shiu weights unchanged. Neuron model: spiking: Shiu et al. LIF (Python port and a JavaScript worker, checked spike for spike against Brian2 on a scripted input, per README). Input: hand-set: land and surplus -> sugar GRNs, losses/deficit/new wars -> bitter, treasury -> water, number of wars -> Johnston's organ. Output: hand-set: 1,299 descending neurons dealt into 39 balanced groups by a committed seed; spikes per group choose actions under the game AI's per-turn budget. Trained parts: none. Body: none. Scripted parts: Game engine, action menu and per-turn budget are the game's own; the neuron-to-action assignment is arbitrary by design.

Measured result (by the authors unless stated) No completed result: a pre-registered comparison with a shuffled-connectome control (postsynaptic column permuted, same action groups) is implemented, and the author discarded 96 early control runs as invalid (PREREGISTRATION.md), but no brain-vs-control result is committed.

Grade basis (checked 30 Sep 2026)

• open_fly/brain.py:13,28-30 Shiu constants (v_th -45 mV, w_syn 0.275 mV, f_poi 250) [direct]
• open_fly/live.py:401-403 loads Completeness_783.csv and Connectivity_783.parquet; four input channels [direct]
• open_fly/encode.py:9,29-31 sugar/bitter/water/jon from land, deficit, wars and treasury [direct]
• open_fly/decode.py:1-8,33-43 descending neurons dealt into 39 groups by seed; the shuffled-connectome control uses the same groups [direct]
• notebooks/open_fly_colab.ipynb cell 5: shuffled control permutes the postsynaptic column; PREREGISTRATION.md fixes the comparison, but no completed brain-vs-shuffle result is committed [direct]

Limits The whole brain runs untrained, but the mapping from 1,299 descending neurons to 39 game actions is arbitrary by design, and game events reach the brain as four taste/hearing channels. The author pre-registered a shuffled-wiring comparison and documents invalid runs openly, but no result is in the repository yet, so there is no evidence that the real wiring plays differently from a scrambled one.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 3 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-13 (not an update date) · Last push, any branch: 2026-09-28; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Pr1nted/Open-Fly [direct]

Project's own claim “a fruit fly you keep, running on her own connectome — 138k neurons in your browser” source

Mechanism Wiring: FlyWire v783, all 138,639 neurons; only edges with >=5 synapses kept (2,700,513 of 15,091,983); sign per neuron. Neuron model: LIF (Shiu et al. 2024 parameters, event-driven active set, dt 0.1 ms). Input: hand-made. Output: hand-made. Trained parts: A linear softmax policy (5 actions x 58 descending cell-type features), trained with REINFORCE from the user's reward clicks, chooses the 'taught' action. The connectome itself has no plasticity.. Body: custom. Scripted parts: Idle wandering is sine-driven (app.js:177-181). Grooming comes from the pet's 'dirt' need, not from neurons (cues.js:47 sets groom 0). Sleep and stopping come from energy and light state. Trained actions play fixed drive patterns (cues.js:52-60). The body is procedural WebGL2 animation, not physics. Hunger, thirst and the 50-day lifespan are game timers..

Measured result (by the authors unless stated) README only: after 28 contrastive trials, buzz->proboscis 87% and puff->jump 87% (chance 20%); an untaught odour gave proboscis 65%. Subtracting the pre-cue baseline cut the cosine similarity between two cues from 0.85 to 0.007. The pruned model keeps 92.5% of responding neurons (rate correlation 0.988 vs the full model). No shuffled-wiring or no-connectome control. The scripts need tools/lif.py and data files that are not in this repo.

Grade basis (checked 28 Sep 2026)

• web/js/engine/sim.worker.js:1-10 LIF constants from Shiu et al. (V0 -52, Vth -45, tau 20/5 ms, wsyn 0.275) [direct]
• web/js/engine/sim.worker.js:48-95 spike delivery over the CSR connectome, Poisson drive on stimulated neurons, integrate and threshold [direct]
• web/data/meta.json.gz: version 'flywire-783', threshold 5, n_neurons 138639, n_edges 2700513 [direct]
• web/js/game/brain.js:28-41 the whole packed connectome is decoded and sent to the worker [direct]
• web/js/game/cues.js:10-22 inputs are annotated sensory types (LB3, BM_InOm, JO-B*, ORN_DM1/DM2, LPLC2, hygrosensory) [direct]
• web/js/game/cues.js:36-48 reflex output = mean firing rate of named DN/MN channels (DNp01, MN9/MN10, DNa02, ...) through hand-set saturation constants [direct]
• web/js/game/learn.js:13-70 5-action softmax policy with a REINFORCE update (trained readout) [direct]
• web/js/app.js:171-183 body drive comes from the policy action or instinct channels, plus scripted idle wandering and need-based grooming [direct]

Limits Page responds (HTTP), not played. The whole connectome really is simulated in a worker. Needs WebGL2, module workers and DecompressionStream; no WebGPU or WASM. The README says 'no scripted reactions', yet much of what you see is not neural: idle walking, grooming (brushing actually stops it, against the README table), sleep and the fixed trick animations. Trick-learning is a trained policy on top of the connectome, and the 87% result is compared only with chance. The repo is marked 'parked'. Licence: the LICENSE file is MIT for code and notes that the data in web/data/ (derived from FlyWire v783 and Schlegel et al. annotations) stays CC BY 4.0, which is why the metadata shows NOASSERTION.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-13 (not an update date) · Last push, any branch: 2026-09-19; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/RaphaelSR/fly-vial [direct]
• https://raphaelsr.github.io/fly-vial/ [direct]

Project's own claim “An 80-cell measured fly connectome circuit drives the original Chromium Dino through a learned neural readout.” source

Mechanism Wiring: subset: 80 neurons of MaleCNS v1.0 (32 visual input cells, 16 descending outputs, 32 bridge cells), 1,296 edges, 26,029 synaptic contacts; chosen by anatomy, not by game results. Neuron model: rate: signed, input-normalised leaky tanh units, 3 iterations per decision (ACh +1, GABA/Glu -1, others 0). Input: hand-made. Output: learned. Trained parts: Only the 243-parameter 16-12-3 MLP readout, trained with CEM (64 candidates, 8 elites). Circuit weights are fixed contact counts.. Body: none. Scripted parts: The 8 inputs are read straight from the game state, not from pixels. Which observation drives which visual cell type is an arbitrary choice. The Flybody fly and the gray 124k-cell atlas are display only (a keyboard-rig animation and anatomical context)..

Measured result (by the authors unless stated) public/benchmarks/benchmark.json, 100 held-out 180 s courses: connectome + trained readout 99/100 completed (mean 179.37 s); silenced connectome 0/100 (4.51 s); untrained readout 0/100 (4.49 s); random 0/100 (4.66 s); idle 0/100 (4.51 s); hand-written rule 0/100 (46.49 s). Replicates on the same courses: 85/100 and 100/100.

Grade basis (checked 28 Sep 2026)

• scripts/build-connectome.py:17-47 picks 4 cells for each of 8 visual types (LC4, LC11, LC9, LC15, LC16, LC17, LC21, LPLC2) by synapses onto DNs, 16 DN targets and 32 two-hop bridges, and keeps all internal edges [direct]
• public/data/connectome/manifest.json: 'FlyEM MaleCNS v1.0, min confidence 0.5', 80 nodes, 1296 edges, source SHA-256 hashes [direct]
• src/lib/connectome.ts:3-37 leaky tanh dynamics over the normalised signed graph; 'ablated' returns zeros [direct]
• src/lib/policy.ts:41-53 8 engineered observations (distance, width, height, speed, player y, ...) [direct]
• src/lib/policy.ts:54-81 16 DN activities -> 12 tanh -> 3 scores, argmax gives the key [direct]
• src/lib/training.ts:81-158 CEM neuroevolution of the readout weights only [direct]
• src/lib/benchmark.ts:18-25 controls: silenced connectome, untrained readout, rule, random, idle; no rewired/shuffled circuit and no readout fed the raw observations [direct]

Limits Page responds (HTTP), not played. Uses WebGL via three.js, and training runs in a web worker; no WebGPU or WASM. Only 80 neurons are simulated, and the count and selection method match the code. The 124k-cell brain view is static context. Graded C (small subset + trained readout): nearly all control skill sits in the trained readout. The controls only show that the readout needs some input (silencing gives zeros). They do not test whether the fly wiring beats a rewired or random circuit, and the author says so openly (docs/experiment.md:9,95). Licence: the 'Cobanov Template Attribution License 1.0' is custom and not OSI-approved. It allows free use, changes and commercial deployment. But any web interface or repository that uses substantial parts must show a visible, linked credit ('Built with fly-connectome-template by Mert Cobanov'). Rights end if a breach is not fixed within 30 days. Third-party data (MaleCNS CC BY 4.0, Flybody Apache 2.0, Chromium BSD) keeps its own licences. 5 Oct 2026: at commit e34c6614 (2026-10-03) the README adds trained direct-input controls with no connectome (10 seeds each): mean completion 92.2 for the connectome controller and 92.2 for a 243-parameter plain network (78.4 for 147 parameters); the author writes that the task does not need the connectome. There is still no rewired-circuit comparison.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 20 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-12; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/cobanov/flyjump [direct]
• https://flydino.cobanov.dev/ [direct]

Project's own claim “A browser demo of a small robot walking down a road, driven by wiring from the real MaleCNS v1.0 fruit fly connectome” source

Mechanism Wiring: MaleCNS v1.0 subsets: eye columns to 4,664 LC/LPLC neurons (direct or via one optic-lobe intermediate, signed), PN-KC-MBON-DAN mushroom-body circuit, LC/LPLC to five command-neuron pathways. Neuron model: rate (precomputed sparse weights, low-pass filtered rates); no spiking whole-brain simulation. Input: hand-made: ray-cast eye columns, synthetic odors (random 6-glomerulus draws), pain sources. Output: hand-made menu of six actions (DNp09 walk, DNa02 veer left/right, MDN back, DNp01 takeoff, Fdg feed). Trained parts: external model (TypeSafe Jev, System One API) chooses the action from a text-like state; hand-set dopamine plasticity on KC-MBON gains and visuomotor pathway gains. Body: none (2D/3D robot in a browser scene). Scripted parts: Demo sequence (arena/js/main.js:189-251); the world and pain sources.

Measured result (by the authors unless stated) None reported as numbers. The demo shows avoidance after toxic contact, seeking after honey and takeoff over a barrier after pain; the action itself is chosen by Jev.

Grade basis (checked 1 Oct 2026)

• arena/js/jev.js:29,94,108,134-141 (commit 88cd607): one 'choice' question per call to /api/decide, proxied to TypeSafe; the returned choice (or a probability-weighted exploration when stalled) sets the action [direct]
• arena/js/mb.js:7,46,88: KC-MBON gains decay with dopamine and relax with a 420 s time constant; valence label passed to Jev [direct]
• README 'How it works' (same commit): eye columns, LC/LPLC weights, Jev's six-option action menu and state fields [direct]
• GitHub API 2026-10-01: created and pushed 2026-09-29T21:00Z, 4 stars, MIT [direct]
• aryap1804/fly-x-jev (created 2026-09-30T22:37Z, not a GitHub fork) is a later copy of the same project with a 'Memory Lab' of ablation experiments (silence PPL1 / PAM); logged in exclusions.md, not linked [direct: README]

Limits The connectome supplies sensory features and a learned valence, but an external commercial model picks every action, so the behaviour shown is not driven by a fly-brain simulation. No control (no scrambled wiring, no Jev-only baseline). Requires a paid API key to run.

More facts Data licence: MaleCNS: CC-BY-4.0 · Peer review: none · GitHub stars: 6 (5 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-29

Sources

• https://github.com/pasangimhana/fly-x-jev

Project's own claim “139,255 neurons and 2.7M connections from the FlyWire FAFB v783 connectome run in real time via a leaky integrate-and-fire model” source

Mechanism Wiring: FlyWire FAFB v783, 139,255 neurons / 2,698,236 edges (syn_count x neurotransmitter sign), normalised; neurons sorted into 63 hand-made functional groups. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none in the brain; the page says a language-model agent ('Claude') reviews requests filed by a second agent that reads the fly's drive meters, and its approvals change the fly's world (food, light) (page text, 5 Oct 2026). Body: custom. Scripted parts: The data has 0 neurons in the leg and wing motor groups, so a hand-weighted 'virtual VNC' makes up the motor outputs from group activity. A threshold state machine picks the behaviour (walk, explore, feed, startle, fly, groom, rest, phototaxis). Food-seeking steers toward the food with atan2, and phototaxis steers toward the canvas centre. Hunger, fear, fatigue and curiosity are hand-coded counters. If the binary fails to load, a 59-group legacy model is used..

Grade basis (checked 28 Sep 2026)

• js/brain-worker-bridge.js:93 loads data/connectome.bin.gz into the worker [direct]
• data/neuron_meta.json: neuron_count 139255, edge_count 2698236; all MN_LEG_*, MN_WING_*, DN_WALK/FLIGHT/TURN groups have 0 neurons [direct]
• js/sim-worker.js:3,25-28,318 LIF (leak 0.95, threshold 1.0, weight scale 0.15) over CSR; groups with no recent activity are skipped (neuropil gating), 10 ticks/s [direct]
• js/brain-worker-bridge.js:252 'virtual VNC motor layer' builds leg/wing outputs from group activity with hand-set weights; :321 says steering is done by the behavioural layer, not by the network [direct]
• js/fly-logic.js:18,54 BEHAVIOR_THRESHOLDS and evaluateBehaviorEntry choose the behaviour state [direct]
• js/main.js:1045-1049 food-seeking steers by atan2 toward the food; js/main.js:1064 phototaxis steers toward the canvas centre [direct]
• js/connectome.js:175,182 drives are hand-coded increments (hunger +0.005 per tick, fear +0.3 on touch) [direct]

Limits Page responds (HTTP), not played. The whole-brain LIF does run on the CPU in a Web Worker, but only groups with recent activity are updated each tick. WebGL2 is used only for the neuron display. The README says the fly is not scripted and that behaviour 'emerges', but the code picks behaviours with thresholds and steers toward food and light with hand-written geometry. The README names data/neuron_meta.bin.gz, but the code loads data/connectome.bin.gz. The project is forked from a worm-sim demo. No control or benchmark. Browser check 2026-10-03: besides the brain worker, the page tries a chat WebSocket (wss://caretaker.flybrain.app/) and a chat-history endpoint on port 7600; both failed here. 5 Oct 2026 (plain GETs of index.html and js/caretaker-*.js): wss://caretaker.flybrain.app is a public tunnel to a caretaker server that receives the fly's drives, behaviour and position once per second; port 7600 is the same server run locally (chat and analytics, hidden on the public site). The page states that a language model ('Claude') acts as caretaker and approves or denies requests, which drops food or dims the lights. The server code is not public, so which model runs there was not verified.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 161 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-03-27 (not an update date) · Last push, any branch: 2026-08-13; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/snedea/flybrain [direct]
• https://flybrain.app [direct]

Project's own claim “A fruit fly's wiring diagram is flying this drone.” source

Mechanism Wiring: Default and browser: MiniFly, a synthetic 850-neuron / 4,928-edge network given real cell-type names (not connectome data). Optional: MaleCNS v1.0 flat tables, >=3 synapses, transmitter signs. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: Optional ridge-regression readout from DN rates to throttle/yaw (flydrones calibrate); weights fixed. Body: custom. Scripted parts: Tonic flying bias on DNg02. A giant-fibre rate above a threshold triggers a fixed 0.7 s climb/drop program. A safety governor can override the brain, and the drone's own flight controller keeps it level. The demo gestures are scripted optic-flow patterns..

Grade basis (checked 28 Sep 2026)

• docs/live/app.js:15 the browser demo fetches ./minifly.json; docs/live/minifly.json name 'minifly-synthetic', n=850, nnz=4928 [direct]
• docs/index.html:123 banner: 'MiniFly: 850-neuron synthetic stand-in with real fly cell types, running in your browser' [direct]
• src/flydrones/defaults.yaml:7 brain source defaults to 'minifly'; src/flydrones/brain/synthetic.py:1-3 says MiniFly is not real fly data [direct]
• src/flydrones/brain/connectome.py:214-219,230-329 optional MaleCNS v1.0 builder (min 3 synapses, NT signs); src/flydrones/brain/lif.py:1-40 LIF with Shiu et al. parameters [direct]
• src/flydrones/motor/decoder.py:85-99 escape threshold triggers a fixed throttle burst [direct]
• ROADMAP.md:11 'MaleCNS group presets verified against neuPrint' still unchecked [direct]

Limits CONFLICT resolved: yes, the browser demo at spikecalls.github.io/FlyDrones runs MiniFly, an 850-neuron hand-wired synthetic network, not the connectome (docs/live/app.js:15, minifly.json, docs/index.html:123). The page itself says so. The non-browser Python package can build a MaleCNS v1.0 graph and run it with Shiu-style LIF, feeding optic flow in and giving throttle/yaw out to a simulator or drone adapter. That path alone would be B-level, but it is not the default. The repo shows no MaleCNS run output: all GIFs, the swarm run and the dashboard are MiniFly, and the full-size figure is only a speed benchmark on a random graph. MaleCNS neuron-group presets are marked unverified. Hardware adapters are not flight-tested (README). There is no control or real-fly comparison. CITATION.cff names 'Claude' as author, which suggests AI-written code. Licence MIT.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 232 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-15 (not an update date) · Last push, any branch: 2026-09-16; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/SpikeCalls/FlyDrones [direct]
• https://spikecalls.github.io/FlyDrones/ [direct]

Project's own claim “"The selected checkpoint won 43 of 60 completed clean-Pong games in Python ... These results do not establish a causal advantage of fly topology and are not a measured browser win rate." (README)” source

Mechanism Wiring: FlyWire FAFB v783 subgraph of 1,230 selected neurons (visual inputs to DNp15 and DNp01); topology from FlyWire, weights trained. Neuron model: rate: 12 synchronous recurrent updates per decision with held input and reset between decisions (network.mjs). Input: hand-made: brightness and temporal encoding of the game frame on 114 mapped columns of an 11x11 grid into 355 visual neurons; placement inferred from connectivity and column annotations. Output: learned: a small action decoder on two descending readouts (DNp15, DNp01); actions are sampled. Trained parts: connection weights, biases, encoder arrays and the action decoder (supervised initialisation, then PPO, in the author's separate training project). Body: none. Scripted parts: none in the policy (no ball-following fallback, per the README); the opponent is the Atari game's own player.

Measured result (by the authors unless stated) Author's committed receipt: the selected checkpoint won 43 of 60 Python games (23/30 and 20/30). No control.

Grade basis (checked 6 Oct 2026)

• README.md at 769597a: network description, training lineage and the author's statement that results do not establish a topology advantage [direct]
• verification/python-checkpoint.json: checkpoint sha256 17c27074..., validation 23/30 wins and confirmation 20/30 wins in Python [direct]
• verification/port.json and tests/parity.mjs: browser inference matches 30 recorded Python frame pairs (README: max probability difference 0.000007871) [direct, file list and README]
• No shuffled-wiring or non-connectome baseline in the repository [direct]

Limits A small trained network that borrows FlyWire topology, not a simulation of a fly brain; the author says so. The training project and data are not in this repository, and no control compares the fly topology with random wiring. The bundled zip is the emulator's upstream source archive (by name and the README notice).

More facts Data licence: FlyWire v783 derived (neuron IDs and trained weights in model.json); no data licence stated in the repository · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/zonzujiro/flywire-pong [direct]

Project's own claim “Two real fruit fly brains. One pheromone. Opposite reactions.” source

Mechanism Wiring: subset: 615 neurons / 5,837 edges of MaleCNS v1.0 and 599 neurons / 2,171 edges of FlyWire v783 (ORN_DA1, DA1 PNs, top lateral-horn targets, pC1/mAL or pC1/vpoEN/oviIN/mAL, top 30 DNs, plus ~298 'context' neurons picked for looks). Synapse counts are stored but not used; weights are hand-set by edge class.. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none. Body: custom. Scripted parts: Fly bodies are keyframed puppets. After the first descending-neuron spike, the male body plays 'lunge' and the female body plays 'pause' (chosen by a sex flag). Verdict text is fixed for each side. Weights are hand-set (strong 'spine' edges along a chosen pathway, weak lateral edges), and delays are stretched to 0.72 s per hop. In Pong mode, input goes to context neurons binned by soma height..

Grade basis (checked 28 Sep 2026)

• src/main.js:128-146 loads data/real/{male,female}.json first, then procedural fallbacks [direct]
• data/real/male.json meta.provenance: MaleCNS v1.0 via neuPrint; data/real/female.json: FlyWire FAFB v783, Connectivity_783.parquet [direct]
• src/sim.js:38-42,148-165 edge weights come from edge class (spine/feedforward/lateral), not synapse count; src/sim.js:20 DELAY_BASE 0.72 s per hop [direct]
• src/sim.js:303-305 the first descending-neuron spike calls onVerdict [direct]
• src/body.js:248,474 the body enters (male ? 'lunge' : 'pause') from the sex flag, not from network output [direct]
• src/modes.js:28-30 VERDICT_TEXT is fixed per side [direct]

Limits Page responds (HTTP), not played. Uses WebGL through three.js; no WASM or WebGPU. About 600 neurons per sex are simulated, not whole brains. The README says 'nobody keyframed their choices' and credits the wiring for the difference, but the code hard-codes lunge versus pause by sex. The connectome subsets only decide when a descending neuron first fires. The in-app 'what's real' panel admits the dynamics are staged and the bodies are puppets. The linked Cell paper is the MaleCNS data paper, not a paper about this project. No licence file.

More facts Data licence: several (see dataset entries) · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-11 (not an update date) · Last push, any branch: 2026-09-12; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/anzal1/samesmell [direct]
• https://anzal1.github.io/samesmell/ [direct]

Project's own claim “A whole-animal Drosophila nervous system — brain, spinal cord, and body — running end-to-end in a browser tab on WebGPU” source

Mechanism Wiring: FlyWire FAFB v783 whole brain (139,255 neurons per README/build script) + MANC VNC (23,188 neurons per README), linked by DN cell-type name. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: An optional flybody RL walking policy (Vaxenburg et al.) runs on a separate path that bypasses brain and VNC. w_syn was tuned to reach Kenyon-cell sparsity.. Body: flybody. Scripted parts: A hand-written sine tripod CPG (driveLegs) is scaled by two numbers from the VNC (walk magnitude, turn bias). A kinematic assist, on by default, writes body velocity and yaw straight from that command. A pitch/roll damper is always on. If vnc.bin is missing, the code falls back to a 200-neuron hand-designed spine..

Measured result (by the authors unless stated) LIMITATIONS.md:319-330: with the assist on, the body moves 0.80-0.88 cm/sim s whatever the controller; with it off, 0.029-0.163 cm/sim s, and the CPG path mostly spins in place. README: the RL policy with the assist off covers 2.004-2.021 cm/sim s vs 0.032 with no policy (brain bypassed). The brain kernel runs at ~0.25 kHz biological time on an M2 Pro. These are body and throughput checks, not connectome controls.

Grade basis (checked 28 Sep 2026)

• tools/build_csr.py:139-140 builds brain CSR from proofread_connections_783 / root_ids_783 [direct]
• src/sim.ts:48 navigator.gpu.requestAdapter: WebGPU LIF (src/shaders/lif.wgsl) [direct]
• src/main.ts:627-646 loads MANC vnc.bin as a second FlySim, otherwise a synthetic 200-neuron fallback (src/vnc.ts:1-3) [direct]
• src/physics.ts:695-750 driveLegs: sine tripod gait scaled by walk/turn [direct]
• src/physics.ts:627-633 kinematic assist sets qvel translation and yaw from the command [direct]
• LIMITATIONS.md:319-330 assist on/off table: the assist does the locomotion whatever the controller is [direct]

Limits Page responds (HTTP), not played. Needs WebGPU (no fallback for the brain) and WASM (MuJoCo); data is served from an R2 bucket. The headline 'whole-animal nervous system' is more than the code delivers, but the README and LIMITATIONS.md say openly that the connectome only scales a hand-written gait and the assist does the moving. The brain-to-VNC link joins cell-type names across two different animals. The only dynamics check is KC sparsity, which was also the tuning target. The src/vnc.ts header comment ('MANC isn't loaded here yet') is out of date.

More facts Data licence: several (see dataset entries) · Peer review: none · GitHub stars: 9 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-05-04 (not an update date) · Last push, any branch: 2026-09-04; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/abgnydn/webgpu-fly [direct]
• https://webgpu-fly.pages.dev/ [direct]

Project's own claim “A sparse neural simulation constrained by the Winding et al. L1 connectome receives environmental sensory signals ... drives an 11-segment MuJoCo neuromechanical body” source

Mechanism Wiring: none in the browser (0 neurons simulated). Local build only: larval L1, 2,952 nodes from user-prepared data, otherwise a random 512-node scaffold. Neuron model: none. Input: none. Output: none. Trained parts: none (local build body/gait parameters calibrated against Schleyer larva tracks). Body: custom. Scripted parts: In the browser, heading turns toward the nearest food with atan2 and the crawl is a fixed 1.41 Hz sine wave. The wall response is a fixed +0.9 rad turn. 'Knockout' lowers drive by 0.035 per silenced item, whichever neuron it is. The neuron list is 12 hard-coded entries while reporting 'total: 2952', and 'active neurons' is 180*drive. In the local build, a segmental CPG sets the rhythm, and DN activity only adjusts it slightly..

Measured result (by the authors unless stated) Local build only: paired MDNa knockout (20 seeds, 5 s trials) gave identical control and knockout values on every metric (0.0% change). The author reports this as a null result showing that the controller bypasses MDNa (experiments/mdna_bilateral_knockout.md). Nothing is measured for the browser demo.

Grade basis (checked 28 Sep 2026)

• tools/build-pages.mjs:5,13-14 the Pages build injects web/demo-api.js, which replaces /api/* with in-browser code (no Python/MuJoCo server) [direct]
• web/demo-api.js:43-47 steers toward the nearest food with atan2, uses a fixed-frequency phase and a scripted bump turn, and has no neural computation [direct]
• web/demo-api.js:36 segment muscle wave from sin(phase+i*.66) [direct]
• web/demo-api.js:44,53 knockout lowers drive by 0.035 per item; 'active' = Math.round(180*drive) [direct]
• web/demo-api.js:12-25,68 hard-coded 12-neuron list reported as total: 2952 [direct]
• cyberlarva/connectome.py:54-72 (local build) loads winding_l1_connectome.npz if present, else a random 512-node scaffold; :92,99-102 random E/I signs and DN groups taken by index stride; :169-175 CPG with DN modulation, turning dominated by odor_lr*1.5 [direct]

Limits Page responds (HTTP), not played. Needs WebGL (three.js). No WebGPU or WASM, and MuJoCo does not run in the browser. The README does say the online build uses a 'reduced browser-side segmented controller', but in fact it simulates no neurons, and the page header still reads 'MuJoCo neuromechanics / connectome habitat'. Its neuron count and 'active neurons' numbers are made up. The local build would be about grade C: the connectome data is not shipped (gitignored), transmitter signs are random, DN groups are arbitrary slices, and behaviour comes mostly from the CPG and direct sensor terms. flybrain.info hosts a copy under /play/cyberlarva/.

More facts Data licence: article CC BY 4.0; no separate data licence found · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-15 (not an update date) · Last push, any branch: 2026-09-15; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/ChenYvhang/cyber-larva [direct]
• https://chenyvhang.github.io/cyber-larva/ [direct]

Project's own claim “Every flash is a spike in a run of the Shiu et al. model (Nature, 2024) on the full FlyWire v783 connectome” source

Mechanism Wiring: FlyWire v783 as stated (138,639 neurons, 15,091,983 connections) for the offline runs; the browser loads only positions, classes and types for 139,248 neurons. Neuron model: LIF (stated Shiu et al. re-implementation in numpy, offline; not run in the browser). Input: hand-made. Output: none. Trained parts: none stated. Body: none. Scripted parts: The whole Lab is playback: 8 precomputed spike files (/data/p/<id>.bin, first of 10 trials) and precomputed mean rates from /data/presets.json. No neuron integration happens in the page..

Measured result (by the authors unless stated) The site states that its numpy version of the Shiu model activates the same neurons as the Brian2 reference in the sugar experiment, with a 0.94 correlation of firing rates (https://flybrain.info/#lab). No code or data is given, so this cannot be checked.

Grade basis (checked 28 Sep 2026)

• https://flybrain.info/main.js loadPreset() fetches /data/p/${id}.bin and replays it with Replay.advance(); the hero view cycles 5 stored runs [direct]
• https://flybrain.info/brain.js Replay class (about lines 323-348) reads stored spike indices and times plus per-neuron mean rates and steps through them; there is no integration step [direct]
• https://flybrain.info/data/presets.json: 8 presets with stimulated-neuron counts, rates (40-220 Hz), trials 10, active-neuron counts and top responders [direct]
• https://flybrain.info/data/brain.json: count 139248 (positions/classes only) [direct]
• Page text states a numpy re-implementation with 0.94 firing-rate correlation vs Brian2 on the sugar experiment; no code, repository or data for this model is linked [direct]

Limits Page responds (HTTP 200); not played. Needs WebGL (three.js) only. Graded U because the model that made the runs is not published: the browser shows stored results, not a live simulation. The page itself says the 3D view replays the first of 10 runs and the list shows averages. It is open that this fly has no body and that smell stimuli had to be given at low rates, because the model 'runs away' into a shared ~10,000-neuron state. Also a competitor directory: it lists projects (/projects/) and hosts copies of cyber-larva and fly-worker under /play/. No author or licence is stated for the site or its data derivatives. Directory text was not copied.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://flybrain.info/ [direct]
• https://flybrain.info/main.js [direct]
• https://flybrain.info/data/presets.json [direct]

Project's own claim “an untrained fruit fly: the adult Drosophila connectome as a spiking simulation. Gaps ahead stimulate its looming-sensitive visual neurons and its descending neurons steer. No training, only innate wiring” source

Mechanism Wiring: Whole FlyWire v783 brain built by the authors' own create_model (Shiu et al.). Neuron model: spiking: Shiu et al. LIF in Brian2, restored per 100 ms decision window. Input: hand-made: gaps in own lane drive LPLC2 + LC4 of both eyes; side-lane gaps drive LPLC4 + LC22 (fly2, candidate M3). Output: hand-made: turn = right minus left of DNa02 + DNa01 + DNg13; jump = giant fibre; thresholds chosen on practice seeds (gain 250 Hz, falloff 2, turn 40 Hz, jump 175 Hz). Trained parts: none in the brain; 4 mapping/readout parameters grid-searched on practice seeds and frozen. Body: none (game runner). Scripted parts: game engine and bots; dodge-before-jump rule.

Measured result (by the authors unless stated) Held-out seeds 1200-1399, mean rows survived (of 150): fly2 82.3; the same mapping and rule with no brain 74.1; fly2 on shuffled wiring 27.8 (docs/calibration/FLY2_REPORT.md). The real wiring adds about 8 rows over a brainless rule; on shuffled wiring the readout neurons never fire.

Grade basis (checked 1 Oct 2026)

• bakeoff/fly/data.py:10-24 (commit 79d8039): Shiu et al. repository at 91bdd1e7 with sha256 checks of the v783 files [direct]
• bakeoff/fly/brain.py:1-10,67-83: untrained Shiu model built by create_model/default_params; shuffle_seed builds the shuffled-wiring control from bakeoff/fly/shuffle.py [direct]
• bakeoff/fly/shuffle.py:4-6,16-24: targets permuted among connections of the same sign; out-degree and in-degree by sign kept; counts travel with the presynaptic side [direct]
• docs/calibration/FLY2_REPORT.md 'Controls' and 'Floors' tables: fly2 82.34 held-out mean rows; no brain 74.05; shuffled wiring (seed 1) 27.84; fly 65.98; random 23.93 and always-jump 32.13 on practice seeds [direct]
• docs/DECISIONS.md:236-275 (decision 43): the authors' own reading ('our part is large'; 'the shuffled control is weak evidence') [direct]

Limits A careful, pre-specified comparison by the author, but small: one shuffle seed, no spread reported, held-out seeds had been used earlier in candidate research, and the brainless rule already reaches 90% of fly2. The shuffled control mainly shows that the real wiring routes the chosen eye cells to the chosen readout neurons.

More facts Data licence: FlyWire FAFB: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-19 (not an update date) · Last push, any branch: 2026-10-01

Sources

• https://github.com/zack-maz/brain-runners
• https://github.com/zack-maz/brain-runners/blob/main/docs/calibration/FLY2_REPORT.md

Project's own claim “"build it a body, give it vision, smell, pain, a sense of balance and put it all in Terraria" (video description, translated); stream: "There are no scripted commands ... the nervous system decides how to move the body."” source

Mechanism Wiring: MaleCNS v1.0 (minconf 0.5), whole CNS incl. VNC; incoming CNS edges to primary sensory neurons omitted by default. Neuron model: other: sparse spiking model with adaptation, short-term depression and delays (CPU/CUDA), 'simplified engineering models' per the author. Input: hand-made: game light, chemistry, contact, load, airflow, gravity, temperature and physiology injected into annotated MaleCNS sensory populations (approximate receptor assignment). Output: hand-made: decode_motors() reads turn/forward/backward/feeding/adhesion/grip motor-population rates (per-leg slots in MaleCNS) through fixed activation functions. Trained parts: reward-modulated plasticity on eligible synapses, reward from the body's own energy, hydration and harm. Body: custom (2-D Terraria body, tModLoader). Scripted parts: documented peripheral fall-backs: a tarsal-flexion grip reflex when no grip population exists, a fixed adhesion formula when no adhesion population exists; a diagnostic taxis controller exists but is not the experiment's controller (which mode the video used was not traced).

Measured result (by the authors unless stated) One 13.7-hour run, 176 lives: mean lifespan 278.4 s, longest 1,676.5 s, 3,353 food events; deaths thorn 88, creature 65, starvation 23 (experiments/latest/lives.csv, recomputed by us). Median lifespan of the last 44 lives 163.3 s vs 102.8 s for the first 44 (our recomputation). No plasticity-off or scrambled-wiring control.

Grade basis (checked 2 Oct 2026)

• GitLab wdf.gost/terraria-wdf-fly-brain at 9052966d (2026-09-26): README.md, docs/BRAIN.md, docs/EMBODIMENT_AUDIT.md, docs/EXPERIMENT_REPORT.md, data/malecns/PROVENANCE.md, runtime/src/flywire_brain.cpp:148-233 (motor decode) read 2026-10-02 [direct]
• experiments/latest/lives.csv (176 lives) recomputed by us: mean lifespan 278.4 s, quarter means 223.1/325.9/251.8/312.7 s match the report; quarter medians 102.8 -> 163.3 s; our one-sided permutation p = 0.037 (last vs first 44 lives, median); Spearman rho 0.11 [direct]
• Video metadata: 0nniju8lLxk (28,244 views on 2026-10-02) and bZtcBcGVnbU (stream 2026-09-25) [video]; the video is newer (2026-09-29) than the last commit

Limits Grade B, not A: no control (the author says so and recommends paired plastic vs plasticity-disabled runs). The improvement over lives comes from one uncontrolled run whose world changed as it ran. The video (2026-09-29) is newer than the last public commit (2026-09-26). GitLab, not GitHub: stars and archive state from the GitLab API (0 stars on 2026-10-02).

More facts Data licence: MaleCNS CC BY 4.0 · Peer review: YouTube video and repository docs · GitHub stars: 0 () · Repository created: 2026-09-25 (not an update date)

Sources

• https://gitlab.com/wdf.gost/terraria-wdf-fly-brain [direct]
• https://www.youtube.com/watch?v=0nniju8lLxk [video]
• https://www.youtube.com/watch?v=bZtcBcGVnbU [video]

Project's own claim “A fruit fly's entire brain plays a Doodle-Jump-style game — live, in your browser. 138,639 spiking neurons · 15.1 million connections · zero training” source

Mechanism Wiring: Whole FlyWire v783 brain, signed synapse counts. Neuron model: spiking: Shiu et al. LIF (TypeScript, event-driven closed-form updates in a Web Worker). Input: hand-made: platform offset to LC10a Poisson drive per eye. Output: hand-made: smoothed left/right steering DN rates, balanced by calibration gains, to buttons (src/control.ts:34-51). Trained parts: none; a start-up calibration sets left/right gains (src/brain/worker.ts calibrate()). Body: none (2D game sprite; a 3D fly presses arcade buttons as animation). Scripted parts: game physics and rendering.

Measured result (by the authors unless stated) README table (author's runs, not re-run by us): intact brain about 12,500 typical score and 0-1 falls in 2 min; eyes swapped 133 and 41-44 falls; blind about 280 (hops in place).

Grade basis (checked 1 Oct 2026)

• src/control.ts:11,25-29,34-51 (commit 676b4e5): LC10a input, swap-eyes and blind controls, steering readout with calibration gains [direct]
• src/brain/worker.ts:77,130,151: calibrate() at start-up (50 Hz, 600 ms) [direct]
• README 'controls' table (falls in 2 min, typical score, best of 5): intact, eyes swapped, blind; produced by scripts/play.ts (not run by us) [direct: README table; numbers not in a results file]
• GitHub API 2026-10-01: MIT; created and last commit 2026-09-29 [direct]

Limits Input and readout are hand-made and calibrated; the two controls manipulate the input (eye swap, blinding), not the wiring, so they show that the steering follows the eyes but not that this wiring is needed. No scrambled-wiring or simple-rule baseline. The control numbers are in the README only.

More facts Data licence: FlyWire FAFB: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-29

Sources

• https://github.com/dtecx/doodle-fly
• https://dtecx.github.io/doodle-fly/

Project's own claim “Game frames stimulate modeled sensory neurons; activity propagates through the retained MaleCNS v1.0 wiring, and a fixed neuron-to-button interface turns, moves and fires.” source

Mechanism Wiring: MaleCNS v1.0, whole retained graph (166,700 neurons, 25.6 M edges), no cropping. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: No trained readout. An optional experimental dopamine-gated plasticity rule acts on 4,184 existing KC->MBON11 edges; health loss triggers a 200 ms artificial pulse into 2 PPL101 cells.. Body: none. Scripted parts: none found. The readout gains are fixed joystick gains, and no game state goes into the decoder..

Measured result (by the authors unless stated) Negative. The learning candidate failed its vision, conditioning and survival gates. In the v6 survival pilot, the plastic arm averaged 3.66 s survival vs 5.83 s for frozen (n=2 test episodes each; doom-ui/public/learning-iterations.json). The first pilot had zero KC spikes and zero edge changes (docs/doom-learning-review.md). Baseline BCI: a 6 s closed-loop test gave 210 non-zero action tics and 3 kills; disconnecting all edges abolished the controls (docs/doom-status.md, outputs/doom/bci-validation.json).

Grade basis (checked 28 Sep 2026)

• doom/connectome.py:98-174 import_graph() accepts only 'malecns_v1' [direct]
• doom/engine.py:78-100 step(): each frame's luminance drives retina neurons, then the LIF kernel advance() runs over all edges [direct]
• doom/engine.py:121-125 'bci' mode: turn = DNp20 right minus left rate x 0.12, forward = DNpe017 rate x 0.4, attack = any DNpe017 spike. Hand-set gains [direct]
• outputs/doom/bci-validation.json: intact vs black pixels vs retina disconnected vs all edges disconnected. Disconnecting every edge abolishes the controls. Marked 'learning_demonstrated': false [direct]
• doom-ui/public/learning-iterations.json: v6 survival pilot with plastic, frozen and shuffled arms. Plastic mean survival 3.66 s vs frozen 5.83 s (one frozen run censored at 8 s); announcement_ready false [direct]
• docs/doom-learning-review.md: first pilot of 22 episodes; all training runs had zero Kenyon-cell spikes and zero changed memory edges, which is a negative mechanism result [direct]

Limits Grade B: the full MaleCNS v1.0 graph is simulated and drives the game, but the only controls are disconnecting all edges and an n=2 learning pilot, with no shuffled/random-wiring or no-graph baseline for the Doom behaviour. The openly reported negative learning result is recorded in measured_result. The input-output interface is engineered: the four read-out cells (DNp20, DNpe017) were picked after checking which ones respond to the screen. The author says these are not natural motor roles; the biologically motivated readout (DNa02, DNp09, MDN, MN9) produced zero actions. Photoreceptor positions and colour responses are inferred proxies, and graded visual cells are approximated as spiking. The simulation runs slower than real time (about 0.16-0.21x). The controls are small (two seeds, one reconstructed animal, 12 s episodes, some censored), and the first shuffled control failed its dose check. The author records this. Attempts: no count of learning attempts is given as a performance metric. Survival rounds restart on death, with neural state kept. The repo is a fresh snapshot with no history. The public viewer URL in the docs is a placeholder (doomfly.example).

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 404 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-06 (not an update date) · Last push, any branch: 2026-09-09; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/nftechie/DOOMFLY [direct]

Project's own claim “A Fabric mod for Minecraft 1.21.1 that runs the complete male fruit fly nervous system inside a fly mob.” source

Mechanism Wiring: MaleCNS v1.0: all 176,422 neurons, edges with >=5 synapses only (6,287,749 edges, about 72% of synapses), autapses dropped, sign from predicted transmitter. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none (global gain 0.65 and Kenyon-cell input gain 0.25 hand-tuned). Body: custom. Scripted parts: Reflex layer on by default (odour taxis, random exploration bouts, collision turns) runs when the brain gives no locomotor command. There is a hand-coded priority ladder of behaviour modes, a flight state machine and hand-set speed gains. Looming, small-object and optic-flow values are computed from the game's object list and injected into LC4/LPLC2/LC11/HS/VS rather than coming from a retina pathway..

Measured result (by the authors unless stated) Sanity benchmarks only, with no wiring control (README 'Validation', docs/VALIDATION.md). Silent brain gives 0 spikes. Sugar GRNs at 120 Hz drive MN9 to 30-90 Hz, and adding bitter suppresses MN9 to 0-10 Hz. Looming at 150 Hz drives the giant fibre to 330-380 Hz. These are compared with reference values from the Shiu et al. 2024 model, not with fly recordings.

Grade basis (checked 28 Sep 2026)

• tools/fetch_neuprint.py:148-149,164 query male-cns:v1.0 with e.weight >= 5 [direct]
• tools/build_flyb.py:123,172,175 writes src/main/resources/connectome/malecns-v1.0.flyb.gz, keeps weight >= min_weight, drops autapses, excludes no superclass by default [direct]
• docs/connectome-stats.json:2-22 male-cns:v1.0, min_weight 5, 176,422 neurons, 6,287,749 edges [direct]
• src/main/java/com/fruitfly/brain/LifConfig.java:12-39 and LifNetwork.java:326-344: LIF (tau 20 ms, threshold -45 mV, 0.275 mV/synapse) [direct]
• src/main/java/com/fruitfly/brain/SensoryEncoders.java:10-20,303-310 Poisson rates on sensory types; analytic looming injected into LC4/LPLC2 [direct]
• src/main/java/com/fruitfly/brain/MotorMap.java:83-114 and MotorDecoder.java:175-222 hand-weighted DN readouts and priority ladder with thresholds [direct]
• src/main/java/com/fruitfly/entity/FlyBody.java:44-80 and FruitFlyConfig.java:50 reflex layer on by default [direct]

Limits LICENCE: the API says NOASSERTION because LICENSE lines 23-27 add a data note (male-cns:v1.0, CC BY 4.0) after the MIT text. Code is MIT and data is CC BY 4.0. DATA: 'complete nervous system' holds for neurons, but only edges with >=5 synapses are kept, and gain is tuned to compensate. The bundled .flyb.gz blob was not opened (missing from the shallow clone); its origin and filter were checked through the build scripts and connectome-stats.json. BEHAVIOUR: the README itself marks food-seeking walking and flight as hand-built. The reflex layer is on by default, so some walking seen in play is not from the network (the HUD labels it [REFLEX]). Looming input is analytic. Female mobs use the male brain. There is one commit.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 145 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-06 (not an update date) · Last push, any branch: 2026-09-06; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/blendi-remade/fly-brain-minecraft [direct]

Project's own claim “A whole-brain Drosophila melanogaster connectome simulation that plays Five Nights at Freddy's 1.” source

Mechanism Wiring: FlyWire v783, measured weights; every weight multiplied by 3 (arousal_multiplier). Neuron model: spiking: LIF (adapted from eonsystemspbc/fly-brain run_pytorch.py), v_th -45 mV. Input: hand-set: screen-region pixel difference above an MSE threshold drives chosen eye clusters at full rate. Output: hand-set: DNp01 spike -> door, accumulated left-right eye-population potential -> which hallway, DNp09 -> tablet; fixed click positions. Trained parts: none (constants fitted to the simulated network's own measurements). Body: none (NeuroMechFly mesh for display). Scripted parts: Scene analysis is a pixel-difference threshold in ordinary code; mouse positions are fixed coordinates. Since 6 Oct 2026, when DNp09 fires on camera 1C, a hand-written memory that fades over about 10 s drives the left looming inputs (LPLC2 and LC4) directly; it replaced the look at camera 2A and keeps the giant fibre firing so the left door stays shut for about 20 s..

Measured result (by the authors unless stated) The author reports reaching 5 AM on night 3 with 9% of the power left in the best recorded run, before Foxy got in ahead of 6 AM (video R4Ogbf33Gfo on YouTube, added to the README on 6 Oct 2026); the earlier best was 4 AM on night 2 (video 4UNPlA-YJtw). No control run (for example scrambled wiring or a threshold rule without the brain).

Grade basis (checked 30 Sep 2026)

• src/config.py:9-10 FlyWire 783 parquet and completeness files; :52 mse_threshold 1500; :80 v_threshold -45.0 [direct]
• src/brain_adapter.py:31-54 FlyWire ids to model indices; spikes accumulated per step [direct]
• README.md:12-30 door via giant fiber, hallway via left-right eye potential, tablet via DNp09; arousal_multiplier x3; no training [direct]

Limits An honest, untrained whole-brain setup, but the game-relevant seeing is a pixel-difference threshold computed before the brain, and each action is read from one chosen neuron or population. The same threshold could close the door without a brain; no such baseline or wiring control is reported. Weights are scaled by 3. Re-read 2026-10-03 at adf8752d (PR #12, 2 Oct): the tablet camera feed now reaches the brain too. The image distance from a start-of-night reference bank drives LC9 and LC31a (Pirate Cove) or LPLC2, with its growth driving LC4 (west hall), and a DNp04 or DNp09 spike decides the action (ADR 0026). This is still a pixel-difference input with hand-set spans, computed before the brain, and there is still no wiring control, so grade B is unchanged.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 3 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-01 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/ArtyMend07/Fly-NAF [direct]

Project's own claim “playing mario 64 using a fly's brain” source

Mechanism Wiring: MaleCNS v1.0, all 166,700 superclass-annotated neurons; weights signed by transmitter and normalised by total input. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none. Body: none. Scripted parts: Stick smoothing, deadzone, clamping, 0.8 s jump cooldown and a 2-frame A press. No scripted gameplay found..

Grade basis (checked 28 Sep 2026)

• fly64/data.py:16-21 downloads MaleCNS v1.0 flat tables; fly64/data.py:88-98,133-135 keeps 166,700 annotated neurons, NT signs, input normalisation [direct]
• fly64/data.py:139-146 visual inputs R1-6/R7/R8; forward = DNg100; turn = DNa02/DNg13 by side; jump = DNp01/DNp10 [direct]
• fly64/model.py:124-140 LIF step (dt 20 ms, tau 100 ms) with tonic current, noise and visual drive; fly64/model.py:142-157 hand-set rate-to-stick gains and jump threshold [direct]
• scripts/validate_causality.py:1-30 live vs frozen vs vision-disconnected check that only requires outputs to differ [direct]

Limits LINK resolved: README.md line 3 links https://x.com/barrelshifter/status/2097004115826200898. The only commit author is 'Jessica Paquette', and the post's author (via api.fxtwitter.com) is Jessica Paquette (@barrelshifter), posted 2026-09-07. So flybrain.info (GitHub ornata) and Fly Brain Hub (X post) point to the same project. There is no licence file (API licence null), so by default all rights are reserved. The user must supply their own US Super Mario 64 ROM and build sm64ex. It was tested only on one M2 MacBook, and the author calls the code '100% vibe coded' and unreviewed. The LIF parameters are the author's own coarse choices (dt 20 ms), not Shiu et al. The eye-to-pixel map is partly estimated. The causality script reports no numbers, and there is no goal, benchmark or control. There is also a separate --demo-model random 4,096-cell fixture, clearly labelled.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 67 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-07 (not an update date) · Last push, any branch: 2026-09-08; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/ornata/fly [direct]
• https://x.com/barrelshifter/status/2097004115826200898 [direct]

Project's own claim “BANC v888 fruit-fly connectome simulation with real-time neural control, physics combat, and reinforcement learning.” source

Mechanism Wiring: BANC 888 (README: 188,508 neurons, 13,620,865 directed pairs; not checked, data not in repo). Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: small plastic readout (19 features -> 4 residuals on forward/turn/sword/shield) trained with reward-modulated policy gradient; connectome weights fixed. Body: custom. Scripted parts: none found for actions; hit/block/parry are classified from geometry; tuning gains and thresholds are hand-set.

Grade basis (checked 28 Sep 2026)

• tools/prepare_banc_latest.ps1:11-17 downloads banc_888 metrics, meta, edgelist_simple_v3 and NT v2 from the BANC GCS bucket [direct]
• tools/convert_banc_latest.py:184-186,384 builds the cache from banc_888 ids, materialization 888 [direct]
• src/neural/gpu_dual_brain.cpp:240-306 HLSL LIF update for two brains (leak, threshold, reset, refractory, synaptic decay) [direct]
• tools/build_banc_io_map.py:166-182 inputs = sensory afferents by side; readouts = descending and motor neurons by side [direct]
• src/sim/v065_learning_main.cpp:879-933 visual/body senses set Poisson rates on sensory groups [direct]
• src/sim/v065_learning_main.cpp:728-876 hand-made map: MN/DN mean -> forward, L-R difference -> turn, right MN -> sword, left MN -> shield [direct]
• src/learning/plastic_readout.h:47-56 and src/sim/v065_learning_main.cpp:2096-2106 learned residual added to the base control [direct]

Limits BANC 888 data is really loaded and simulated; the learner only changes a small readout (flagged as a trained part), not the connectome. The input and output maps are coarse (whole sensory/descending/motor superclasses split by side), and sword/shield are simply right/left motor-neuron rates. No control (e.g. rewired graph) or benchmark. The Windows binary was withdrawn after a Defender detection; source build only, D3D12 GPU needed. Made with GPT/Codex help (README). Licence (LICENSE file, 'FASL-1.1') is source-available, not open source: you may view, build and run it for personal, educational or non-commercial research use and share unmodified copies, but sharing modified versions, derivative projects or any commercial use needs written permission from the author.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 1 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-22 (not an update date) · Last push, any branch: 2026-09-23; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/primaryNK/FlyArena [direct]

Project's own claim “"cut and shuffled both make 0 flaps: the brain no longer commands the wings"; real wiring mean score 100.8 with 256 flaps vs 0.00 and 0 flaps for the cut and shuffled graphs over 40 games (README table, translated; measured under an earlier noise stream)” source

Mechanism Wiring: FlyWire FAFB v783 whole brain as a signed sparse graph built by the author (data/spiking_full.npz). Neuron model: LIF (author's own discrete model: 20 ms ticks, leak exp(-dt/tau) = 0.819, threshold 1.0, background noise; src/fpv/spiking_brain.py), not the Shiu et al. parameters. Input: hand-made: looming angular kinematics of the pipes mapped to LC4/LPLC2 target rates through a tuning curve (s50 30, n 3), which the author calls the one external assumption (src/fpv/looming.py). Output: hand-made: a flap when DNp01/DNp04 fire, with a 0.14 s cooldown (demo/server.py). Trained parts: none in the escape-reflex demo; an earlier controller variant with a small trained readout is still in src/fpv/spiking_controller.py. Body: none (2D Flappy Bird game). Scripted parts: game physics; projection of the pipes into a looming stimulus.

Measured result (by the authors unless stated) Not verified by us. The author's report (ESCAPE.md) gives a DNp01 threshold near 29 Hz per LC4 cell, a maximum DNp01 response of about 4.1 Hz at full drive, 11 responding descending neurons of 472 (truncated graph) or 1,301 (whole brain), no DNp01 response after cutting the 102 direct LC4 to DNp01 edges, and all 472 descending neurons silent under the shuffled graph.

Grade basis (checked 6 Oct 2026)

• scripts/build_spiking_asset.py at 7a8b601: reads fafb_783_simple_edgelist.feather and fafb_783_meta.feather, records source FlyWire FAFB v783 [direct]
• src/fpv/spiking_brain.py: discrete LIF, 20 ms tick, leak 0.81873, threshold 1.0 [direct]
• src/fpv/looming.py: LC4/LPLC2/LPLC1 sense groups, DNp01/DNp04 escape group, looming_drive tuning curve, variant() for shuffled targets (out- and in-degree kept), cut edges and blocked inhibition [direct]
• demo/server.py: loads SpikingBrain with the whole-brain asset and fpv.looming; FLAP_COOLDOWN 0.14 s [direct]
• No committed result files: the README's ablation commands write to output/, which is not in the repository; control numbers exist only in README.md and ESCAPE.md [direct]

Limits The control results (cut and shuffled pathways give zero flaps) are only in the author's documents, measured under an earlier noise stream, so they do not raise the grade. Per the author's own report, DNp01 stays far below its real firing range and does not fire when the stimulus covers a realistic part of the visual field, so the game needs strong, wide drive. Chinese-language documentation; no licence.

More facts Data licence: FlyWire v783 derived asset committed in the repository (data/spiking_full.npz, about 50 MB); no data licence stated · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/programmingWTF/FlyBrain [direct]

Project's own claim “A connectome-based fruit fly physically learning to operate a steering wheel in CARLA” source

Mechanism Wiring: MaleCNS v1.0 topology: 165,122 traced neurons, 25,563,197 edges; unsigned (transmitter predictions not used). Neuron model: rate. Input: hand-made. Output: hand-made. Trained parts: All ~25.7 M edge gains plus per-neuron leaks, trained by behaviour cloning of an offline IK teacher (600 Adam steps, one seed). Input and output maps are frozen random projections (10 state features to VNC sensory neurons; VNC motor neurons to 7 foreleg joints).. Body: FlyGym. Scripted parts: Throttle/speed and turn requests in the CARLA videos are scripted. There is an engineered forefoot grip and a passive right-leg grip. In parking and three-point turns (code not in HEAD), velocity regulation and IK are fixed..

Measured result (by the authors unless stated) Wheel steering: 100/100 held-out targets after training vs 0/100 for the untrained core (reports/2026-09-09/e03-wheel-pilot/metrics.json). Disabling the grip removes >99% of the steering response (reports/2026-09-09-carla-video/validation.json). Parallel parking: 0/50 successes for both learned and reset core, mean final error 3.71 m vs 18.31 m (apps/website/public/press/data/parking-notes.md). Three-point turn: 6/8 held-out passes vs 0/2 for the reset core.

Grade basis (checked 28 Sep 2026)

• scripts/acquire_connectome.py:2,10-14,32 downloads pinned MaleCNS v1.0 flat tables with hash checks [direct]
• src/flyhard/connectome.py:1-5,44-79 tanh rate model on fixed adjacency with trainable edge_gain and leak [direct]
• src/flyhard/motor_policy.py:8-43 frozen random sensory and motor projections [direct]
• scripts/train_wheel.py:57-98 IK teacher demonstrations and MSE behaviour cloning [direct]
• src/flyhard/cockpit.py:1,11-18 NeuroMechFly/FlyGym body with passive wheel; scripts/capture_carla_cockpit.py:38,206-215 steer = gain x wheel angle, scripted throttle [direct]
• reports/2026-09-09/e03-wheel-pilot/metrics.json initial_successes 0, trained_successes 100 [direct]

Limits The controls compare trained vs untrained gains on the same wiring. They show that training works, not that connectome wiring matters. There is no shuffled-wiring or no-graph baseline and no real-fly comparison, so the grade is B, not A. The whole network is fitted by behaviour cloning, so it is a large trained model that uses connectome topology, with random frozen I/O maps (trained parts flagged). Transmitter signs are not used, and there is one training seed. Driving has no vision: the fly controls only steering, from scripted turn requests. The famous 'parallel parking, 50 attempts' video shows 0/50 successes, and its side-panel fly is an unsynchronised replay. The parking and three-point-turn code is not in HEAD, only result files and press notes. Most of the repo is website and livery assets. Licence MIT.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 83 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-09 (not an update date) · Last push, any branch: 2026-09-15; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/MarkUnthank/flyhard [direct]

Project's own claim “A real fruit fly's brain drives a go-kart, and you can watch it think; nobody trained anything, the behaviour comes from the wiring.” source

Mechanism Wiring: Whole MaleCNS v1.0, traced neurons, signed by predicted neurotransmitter. Neuron model: spiking: leaky integrate-and-fire with the Shiu et al. equations and parameters, on GPU (PyTorch). Input: hand-set: truck azimuth computed by the game drives LC10a neurons with a sigmoid receptive field; looming channel gated by computed time to contact; taste neurons for sugar; a user 'drive' slider stimulates oDN1 (DNg97) at up to 300 Hz. Output: hand-set: steer = (DNa02+0.5 DNa01 right - left)/60 Hz; throttle from oDN1+BDN2; reverse if MDN > 5 Hz; jump on any giant-fiber spike; feed from MN9. Trained parts: none. Body: kart physics in Python (no fly body). Scripted parts: Scene analysis (truck direction, collision course) is done by game code before reaching the neurons. Forward drive is set by the user's slider stimulating oDN1. An optional autopilot blend exists (0% by default)..

Measured result (by the authors unless stated) No measured result or control in the repository.

Grade basis (checked 30 Sep 2026)

• flykart/connectome.py:28-32,111-135 downloads MaleCNS v1.0 flat-connectome feathers; keeps status 'Traced' neurons [direct]
• flykart/brain.py:1-10,41-51 Shiu LIF equations and parameters (w_syn 0.275 mV, v_th -45 mV) [direct]
• flykart/interface.py:1-17,151-169 LC10a pursuit input, looming, taste, oDN1 driven at 300 Hz * drive slider [direct]
• flykart/world.py:240-262 looming input gated by computed time to contact [direct]
• flykart/interface.py:176-190 decode: steer from DNa02/DNa01 L-R, throttle from oDN1/BDN2, reverse MDN > 5 Hz, jump on GF spike [direct]
• flykart/world.py:330-336 and flykart/server.py:42 autopilot blend 'assist' defaults to 0.0 [direct]
• Re-opened by the runner at HEAD 82d88a1 (2026-09-29T19:20): flykart/connectome.py:28-32 MaleCNS v1.0 flat-connectome feathers; flykart/brain.py:41-51 v_th -45 mV, w_syn 0.275 mV; flykart/interface.py:176-190 hand-set decode (steer from DNa02/DNa01 L-R /steer_hz, throttle (oDN1+0.5 BDN2)/180, reverse MDN > 5 Hz, jump on any GF spike); flykart/world.py:330-336 and server.py:42 assist 0.0 by default. The new commit adds a CPU kernel (brain.py, cpu_kernels.py, cpu_random.py) and does not change the mapping [direct]

Limits The whole connectome is simulated with no training, but the game does the seeing: it computes the truck's direction and collision timing and injects them into chosen cell types, and output rates are mapped to kart controls by hand-set thresholds and gains. Forward speed follows a slider that stimulates the forward-walking neuron directly. There is no control run (for example scrambled wiring), so how much of the chasing comes from connectome routing rather than the chosen input/output cells is not shown. The README's 'its eyes see the game' overstates the input side.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 0 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-28 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/ZENinjaneer/flykart [direct]

Project's own claim “A fly-connectome simulation that can operate a crypto trading account. Actual neural output, actual Coinbase integration. Profitable learning has not been demonstrated.” source

Mechanism Wiring: MaleCNS v1.0, whole retained graph. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: Experimental dopamine-gated plasticity on 7,835 existing KC->MBON07/MBON11 edges. Gain grows by 20 mV-equivalent pulses into 15 PAM11 cells (profit) or 2 PPL101 cells (loss). No trained readout.. Body: none. Scripted parts: none found. Risk limits and cooldowns can veto orders..

Grade basis (checked 28 Sep 2026)

• stonkfly/neural/controller.py:15-17,26-38 fixed decoder: DNp20 right-minus-left mean rate above a threshold, gated by DNpe017 spikes, gives BUY or SELL, else HOLD [direct]
• stonkfly/neural/kernel.cpp:4-22 LIF kernel (20 ms membrane, 5 ms synapse) over every retained edge; docs/model.md:11 gives the parameters [direct]
• docs/model.md:43-47 profit gives a PAM11 pulse, loss gives a PPL101 pulse; the rule acts on 7,835 KC->MBON edges [direct]
• docs/validation.md: 6-observation paper run gave one BUY fill and five BUY proposals vetoed; 'neither successful learning nor a profitable policy' [direct]
• stonkfly/config.py:28,53-56 default capital $100, max order $10 [direct]

Limits The default is paper trading on real public prices, and live trading needs the user's own Coinbase key. The only reported run was six observations, with no benchmark or trading control. Same-checkpoint controls only show that weights change differently with and without reward. The decoder tends to repeat BUY, which the author flags as one-sided exposure. The chart had to be switched to a light background because the dark chart gave no Kenyon-cell spikes. The input display is an engineered adapter, and the 'profit/loss dopamine' assignments are engineered choices. flybook-git/flybook is an exact copy of this repo (same commit 78ef3e05).

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 844 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-10 (not an update date) · Last push, any branch: 2026-09-10; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/nftechie/stonkfly [direct]

Project's own claim “A real fruit fly connectome (MaleCNS v1.0, 166,700 neurons) running inside Pokémon Red via PyBoy; the README says the long walk is a scripted teacher, not the fly.” source

Mechanism Wiring: Whole MaleCNS v1.0, frozen, as stated; the loader and weights live in the external alextitonis/fly.ai package, which is not in this repository. Neuron model: LIF (dt 20 ms, tau 100 ms, gain 3.0, tonic 0.14, as stated in the README; kernel code is in fly.ai). Input: hand-set from game memory: nearest sprite's screen dx (or a fixed right-side enemy in battle) drives LPLC2/LC4/LPLC1/LC10a on the left or right side by the sign of dx. The README diagram says 'screen pixels', but the code reads sprite positions from RAM.. Output: learned: logistic readout on a decaying descending-neuron trace (PCA-compressed), two classes only (left/right); A is pressed by code when no object is off-centre. Trained parts: The readout only (fit at startup on 33 synthetic offsets); connectome weights frozen. Body: none (stylised 2D fly drawing on a gamepad). Scripted parts: The whole journey shown in the video: a planner builds a walkable-tile map from memory, searches frontier northward and flees battles (render/record_journey.py). In the fly-driven mode, target selection, dead zone, A presses and move timing are code..

Measured result (by the authors unless stated) Author reports a cross-validated AUC of about 0.95 for decoding the object's side from descending-neuron activity when RAM offsets drive the visual neurons, with a shuffled-label control at chance (pokemon-red/README.md:93-98). No shuffled-wiring control for Pokémon. In the Arkanoid chapter, the real and weight-shuffled connectomes both survive over 1500 frames, while rewired or silenced wiring fails at about 204 frames. Measured by the author, not reproduced by us.

Grade basis (checked 29 Sep 2026)

• pokemon-red/README.md:14-16,83-85 'the long walk from Pallet Town to Viridian City is a scripted teacher'; 'The navigation is the teacher' [direct]
• pokemon-red/render/record_journey.py:15-22,29-37 walkable-tile planner presses buttons; the brain is stepped on screen luminance only to record the activity panel [direct]
• pokemon-red/pokesim/encoder_b.py:1-10,291-323 input is sprite positions read from RAM, not pixels [direct]
• pokemon-red/play_live.py:56-61,103-110 logistic readout trained on a synthetic dx sweep; fly chooses only left or right, code presses A when no target [direct]
• pokemon-red/pokesim/compare.py:388-392 control is a shuffled-label readout, not shuffled wiring [direct]
• retroid/retroidsim/ablate.py:1-14 and retroid/README.md:79-84,117-128 wiring ablations for the Arkanoid chapter: rewired topology loses the ball in about 204 frames against >1500 for the real connectome, but shuffled weights do as well as real [direct]

Limits In the Pokémon demo the connectome does not play. The video's walk is a scripted planner. In the fly-driven mode it gets one number from game memory (where the nearest sprite is) and a trained readout turns its descending-neuron activity into left or right. The README diagram says 'screen pixels', but the code reads RAM. The neuron model and connectome loader are in the external fly.ai package, so they were not inspected here. The Pokémon chapter has only a shuffled-label control. The Arkanoid chapter in the same repository has a real wiring ablation (rewired topology fails, shuffled weights do not), which would merit a separate assessment. blackicon-eth/fly-plays-pokemon now redirects to blackicon-eth/fly-plays-games (same commit), so one entry covers both. Not the Raspberry Pi 5 Twitch stream covered by XDA (different dataset, emulator and input neurons).

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 0 (29 Sep 2026; reused from our 29 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-19 (not an update date) · Last push, any branch: 2026-09-24; reused from our 29 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/blackicon-eth/fly-plays-games [direct]
• https://github.com/blackicon-eth/fly-plays-pokemon [direct]

Project's own claim “A simulated fruit-fly brain (FlyWire connectome) plays Game Boy games on a 24/7 stream.” source

Mechanism Wiring: Whole FAFB v783 Codex connection export as a CSR graph, with a sign per neurotransmitter (sign table is the author's modelling choice). No subsetting.. Neuron model: LIF point neurons at 1 ms: 20 ms decay, threshold 1, 2 ms refractory, weight scale 0.005, random per-neuron baseline drive and noise; TypeScript library with a bit-exact Rust service (optional CUDA kernel). Input: hand-set: each L1 column samples one screen pixel (nearest pixel after normalising the column's 2D position; left eye mirrored), drive = luminance x 0.20. Screen pixels, not game memory.. Output: hand-set: descending neurons split round-robin by index into command_0..7; normalised population rates feed a fixed decoder (D-pad as one exclusive group with 800 ms hold, hysteresis 1.05, fatigue; A/B pulses; Start/Select rare pulses with a boot variant). Trained parts: No trained readout. Reward-modulated STDP on a bounded set of Kenyon-cell-to-MBON gains (clamped to 0.9-1.1). Decoder constants were tuned by hand from measured room-escape runs.. Body: none (Game Boy player). Scripted parts: Reward detectors read game memory (story flags, new maps, exploration tiles, badges, catches, talks, items) and pay a scalar reward. The game layer reports blocked directions from position, which forces fatigue on that direction. Boot mode relaxes Start/Select throttling on title screens. Optional macro mode (default off) maps channels onto scripted actions (A* walks to exits/people/items, best-move attacks, menu handling)..

Measured result (by the authors unless stated) Author reports decoder tuning runs: with the blocked-direction rule at hysteresis 1.05, 14 of 15 runs left the starting house against 13 without it (gameboy.ts:43-54, from infra/docs/room-escape.md). Throughput about 20 emulator fps in the browser prototype. No comparison against shuffled wiring or a random agent for the connectome itself; learning not shown to help. Measured by the author, not reproduced by us.

Grade basis (checked 29 Sep 2026)

• data/fafb-v783/meta.json:1 'FlyWire FAFB Codex v783', neurons 139255, edges 2700513 [direct]
• packages/brain/src/model/lif.ts:71-72 decayMs 20, threshold 1, refractoryMs 2, synapseScale 0.005; :244 spike propagation weight x plastic gain x scale [direct]
• packages/brain/src/model/retina.ts:41-66 one pixel per L1 column, luminance x gain; docs/limitations.md:25-31 'no claim ... that the retinal mapping resembles fly optics' [direct]
• tools/build_flywire.py:117-119 descending neurons split into N round-robin command_<k> roles; docs/limitations.md:13-15 buckets are a round-robin partition by neuron index [direct]
• packages/brain/src/readout/presets/gameboy.ts:32-33,61-81 hand-set decoder: exclusive D-pad (hold 800 ms, hysteresis 1.05, fatigue 0.08, blocked-direction fatigue 0.35), A/B/Start/Select pulses with boot variant [direct]
• docs/rewards-learning.md:9-30 reward rules read from game memory, 'Rewards are design' [direct]
• services/flysim/flysim.toml.example:137 mode = "raw"; services/flysim/crates/flysim/src/config.rs:601-606 raw is the default; docs/design/macros.md:44-58,170-186 scripted macro and plan modes [direct]
• docs/limitations.md:33-49 learning not shown to improve play; :98-105 after 43 brain minutes direction scores froze into a fixed order and only decoder habituation moved the winner [direct]
• No shuffled-wiring or no-graph comparison found in docs/ or infra/docs/; the random walker (docs/design/room-escape.md:16-20) is used to tune decoder timings, not as a control for the connectome [direct]
• docs/stream-mvp-plan.md:838-852, 901-916 the stream's own run log: progress through Pewter Gym and Mt. Moon is recorded in terms of macro actions (GO OBJECTIVE, GO WARP; '1,500 of 1,500 macros from the checkpoint'), i.e. the streamed runs use the macro mode in which the network picks among scripted multi-step actions (services/flysim/flysim.toml.example:121-126 'while a macro runs it owns the pad') [direct]

Limits Grade C: the whole FAFB brain is simulated and screen pixels really reach it, but what the stream shows is not mainly the network's doing. The eye is one pixel per L1 column; the motor side is an arbitrary index-based split of descending neurons into eight buttons; a hand-tuned decoder with fatigue, hysteresis and a blocked-direction rule decides much of the play. The author's own 43-minute check found the four direction scores frozen in a fixed order, with only decoder habituation changing the winner (docs/limitations.md). The stream's run log describes progress through scripted macro actions (walk to an exit, go to a warp) that the network only selects; in the default raw-button mode the project would sit on the B/C border. Reward detectors read game memory. There is no shuffled-wiring or random-agent control for the connectome, and learning has not been shown to improve play. The author documents these limits openly. Not linked to the Raspberry Pi 5 Pokémon stream covered by XDA Developers on 28 Sep 2026: that stream reads game memory into looming-detector neurons, while this project reads screen pixels.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-21 (not an update date) · Last push, any branch: 2026-09-30; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/acamilo/flybrain [direct]

Project's own claim “A fruit fly's brain wiring, taught to farm wheat in Minecraft (video: I Put a Fly's Brain in Minecraft and Made It Farm).” source

Mechanism Wiring: Filtered subset of FAFB v783: the top cells by internal connection strength from six olfactory-pathway groups (256 ORN, 128 LN, 256 PN, 512 KC, 96 MBON, 288 LH). Edges crossing the sample boundary are dropped. Signed log(1+count) weights, normalised by input.. Neuron model: rate: leaky tanh units, 4 propagation steps per decision, learned leak and bias per neuron. Input: learned (trainable CNN image encoder, a 3-D world-block encoder and a game-fact MLP project onto ORN-group cells). Output: learned (LayerNorm + linear readout on MBON and lateral-horn cells, then actor/critic heads that score candidate jobs). Trained parts: Everything except topology and sign: per-edge gains (0-2x), per-neuron leak and bias, encoders, readout, actor and critic. Trained by imitation of a scripted teacher, then PPO.. Body: none (Minecraft player). Scripted parts: Candidate jobs are listed by code from the mod's game state. Walking, route finding, aiming, clicks, chest and inventory handling are done by a scripted motor controller. Demonstrations come from scripted teachers. Actor output priors are hand-set..

Measured result (by the authors unless stated) Author reports the frozen finale checkpoint passed 12 of 12 fresh-world checks (README; brain/finale/summary.json, brain/finale/arena-checks/). Measured by the author, not reproduced by us. No control comparison reported for the finale.

Grade basis (checked 28 Sep 2026)

• scripts/prepare_data.py:24 group quotas {6:256, 8:128, 9:256, 17:512, 19:96, 23:288}; :50 provenance 'FlyWire FAFB v783', edges crossing the sample boundary omitted [direct]
• brain/finale/source/model.py:1-5 docstring 'Engineered sensory mapping and rate dynamics, not a biological fly simulation' [direct]
• brain/finale/source/model.py:38-62 trainable edge_gain, leak, bias, CNN encoder, world/context encoders, readout, actor and critic heads [direct]
• brain/finale/source/model.py:88-96 weight = initial_weight*sign*2*sigmoid(gain); 4 tanh propagation steps; readout from output groups 19/23 [direct]
• brain/finale/source/model.py:24-31 'shuffled' and 'disconnected' variants exist in code [direct]
• brain/finale/source/farm_model.py:1-6,23-53 finale job scorer on the same 1,536-cell circuit; 'Scripted motor control is outside this decision network' [direct]
• brain/finale/source/farm_motor.py:1-4 motor assistance shared by teacher and learner (walking, camera, clicks, inventory) [direct]
• results/ and docs/: no stored fly-vs-shuffled or fly-vs-disconnected comparison for the farming finale found; docs/HUMAN_CONTROLS_EXPERIMENT.md:33 lists the shuffled comparison only as a plan [direct]

Limits The network is about 1% of the brain: a filtered smell-pathway subset, with every edge gain, leak and bias trained, plus trained CNN encoders and a trained policy readout. The fly wiring is a constrained recurrent layer inside an ordinary deep-RL/imitation policy. Movement, aiming and clicking come from scripted controllers, and the candidate jobs come from game state supplied by the mod. Shuffled and disconnected variants exist in code, but we found no stored result comparing them for the farming finale, so the circuit has not been shown to be needed. The README states most of these limits openly. Not a copy of an already catalogued project; circuit data are mirrored from snedea/flybrain.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 10 (5 Oct 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-22 (not an update date) · Last push, any branch: 2026-09-22; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/swotstudio/FlyBridge [direct]

Project's own claim “A tic-tac-toe agent driven by a small circuit pulled out of the male Drosophila CNS connectome” source

Mechanism Wiring: Small signed MaleCNS v1.0 sub-circuit around descending neurons (about 100 neurons), weights normalised by the maximum. Neuron model: rate: leaky integrator (the README calls it intentionally simpler than a spiking model). Input: hand-set: board cells -> injected activation on chosen neurons. Output: hand-set: mean activation of a neuron group per cell. Trained parts: none. Body: none. Scripted parts: minimax solver (unbeatable=True by default) limits moves to optimal ones; the circuit only breaks ties.

Measured result (by the authors unless stated) No measured result or control in the repository.

Grade basis (checked 30 Sep 2026)

• src/flycns/simulate.py:1-3,31-37 leaky integrator on the signed core graph, weights / max weight [direct]
• src/flycns/agent.py:31,49,87-89 unbeatable defaults to True: candidates = optimal_moves(board) from minimax, the circuit scores choose among them [direct]
• README.md: board-to-neuron mapping is a deliberate engineering convention; "not a fly brain that plays games" [direct]

Limits By default the minimax solver decides which moves are allowed, so the play quality is ordinary game code and the fly circuit only chooses among equally good moves. The circuit is a small hand-chosen piece of MaleCNS run as a simple rate model. The README says this plainly.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 2 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-23 (not an update date) · Last push, any branch: 2026-09-28; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/50RISHU/FlyCNS-TicTacToe [direct]
• https://news.ycombinator.com/item?id=49888926 [direct, 2026-09-29]

Project's own claim “A whole Drosophila brain playing Minecraft Education. ... No behaviour is scripted.” source

Mechanism Wiring: FlyWire v783 whole brain (138,639 neurons) through the eonsystemspbc/fly-brain submodule. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none (calibrate.py picks the feeding motor neurons most driven by sugar and records baselines). Body: custom. Scripted parts: body.py computes navigation 'drives' (forward onto DNp09, seek/home/heading onto DNa01/DNa02, landing onto MDN) from game state. The readout uses the same DNp09, DNa01/02 and MDN pools, so these decisions pass almost straight through the network. Sleep and heading memory live in Python. Winner-take-all picks discrete Agent commands, and 'feed' runs a fixed destroy-and-collect sequence..

Measured result (by the authors unless stated) README 'Searching new ground', against a scripted game stand-in: a 150 s run with nothing to seek walked 141 steps over 136 distinct cells. Seeking sand took 12 steps / 10 blocks out, vs 24 steps / 13 blocks without the heading drive. This ablates a scripted drive, not the connectome.

Grade basis (checked 28 Sep 2026)

• flyminecraft/brain.py:1-27 steps the whole-FlyWire LIF from the fly-brain submodule [direct]
• flyminecraft/neurons.py:48-64 vs 66-74: drive groups (DNp09, DNa01/DNa02, MDN) are the same cell types as the motor readout groups [direct]
• flyminecraft/body.py:214-244 stimulus(): code-decided forward, homing, seek, goal and landing drives injected as rates [direct]
• flyminecraft/body.py:325-337 winner-take-all over motor pools gives the Agent command [direct]
• README.md:14 'No behaviour is scripted.' vs README sections 'Why there are drives' and 'Searching new ground' [direct]

Limits This is not a MakeCode script: a real whole-brain FlyWire v783 LIF runs. But the headline 'No behaviour is scripted' conflicts with the code and the author's own README. Walking, target seeking, homing, exploring and sleep are decided in Python and pushed into the same descending neurons that are read out, so for navigation the connectome mostly relays the decision. Feeding (sugar to feeding motor neurons) and the giant-fibre escape climb are genuinely routed through the network. The fly-brain submodule (eonsystemspbc/fly-brain, gitlink a3db62f) was not in the clone, so it was not inspected here. The licence is GPL-2.0.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-14 (not an update date) · Last push, any branch: 2026-09-16; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/jjedwards2081/FlyCraft [direct]
• https://github.com/eonsystemspbc/fly-brain

Project's own claim “"A subgraph of a real fly brain (MaleCNS v1.0 connectome, Janelia/Google, 2026) plays no-limit Texas Hold'em, via a spiking neural network simulation with a small trainable readout layer on top." (README)” source

Mechanism Wiring: MaleCNS v1.0 subgraph of 6,194 neurons: input pools seeded from chosen cell types (for example LC4/LPLC1/LPLC2 for equity, LC9/LC12/LC17 for pot odds, JO for opponent aggression), 4,000 relay neurons and 90 descending output neurons (DNg types). Neuron model: spiking (src/flypoker/brain.py). Input: hand-made: equity (Monte Carlo, computed outside the brain, gain 8), pot odds, stack depth, street, position and opponent aggression drive chosen populations. Output: learned: linear softmax decoder over about 90 output-neuron spike counts, with a 12% uniform floor on every action. Trained parts: the decoder only: behaviour-cloned from public hand histories (pretrain.py); self-play REINFORCE collapsed and was not used for the shipped weights (README). Body: none. Scripted parts: poker rules, Monte Carlo equity and the rule-based EquityBot opponent are ordinary code.

Measured result (by the authors unless stated) None reported as a number for the brain's contribution. The README documents training failures (fold-collapse, input-independent collapse) and ships behaviour-cloned decoder weights instead of self-play ones.

Grade basis (checked 3 Oct 2026)

• data/circuit_meta.json at e1ed8f6: source male-cns:v1.0, min_synapses 8, seed_types_by_role, 6,194 nodes (4,000 relay, 90 out:action) [direct]
• src/flypoker/encoder.py:8-66: monte_carlo_equity computed before the brain and injected as in:equity with EQUITY_GAIN 8 ('equity is the channel the decision leans on most') [direct]
• src/flypoker/decoder.py:1-110: SoftmaxDecoder, the only thing that learns; README: shipped runs/decoder.npz is pretrain.py output, fold weights untouched, 12% action floor [direct]
• No wiring control or brain-free baseline result in the repository; synthetic_circuit.py is a placeholder random circuit for development [direct]

Limits The poker decisions come mostly from a hand equity computed outside the brain and a decoder cloned from human players; the connectome subgraph sits in between as a feature generator, and no run compares it with a scrambled or no-brain version. The README is candid about the training failures. No licence file.

More facts Data licence: MaleCNS v1.0 derived data committed (CC BY 4.0 per Janelia; not stated in the repository) · Peer review: none · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-10-01 (not an update date) · Last push, any branch: 2026-10-01

Sources

• https://github.com/0909-BoB/flypoker [direct]

Project's own claim “"A real reduced FlyWire FAFB v783 network: 128 neurons and 2,048 directed signed edges, including 20 surviving sugar sensory IDs and one MN9" and "A compact heuristic controller handles locomotion, flight, grooming, and energy. The extracted neural circuit controls the feeding gate through MN9." (README)” source

Mechanism Wiring: FlyWire v783 subgraph of 128 neurons (20 sugar GRNs, 1 MN9 and 107 neurons chosen by 3-hop relevance), 2,048 signed edges. Neuron model: other: integer LIF, 33.3 ms ticks, threshold 100, leak 1/8, one-tick refractory (src/sim.c; the README states it does not reproduce the Shiu model). Input: hand-made: ground contact with sugar drives the 20 sugar neurons (drive = stimulus x 3). Output: hand-made: MN9 spikes gate food intake; nothing else. Trained parts: none. Body: flybody-derived sprites rendered offline (Apache-2.0 meshes); no physics. Scripted parts: locomotion, flight, grooming, obstacle avoidance, energy and all pet needs are a heuristic controller and game rules.

Measured result (by the authors unless stated) None (a game; the author's emulator check confirms that sugar contact leads to circuit-driven intake).

Grade basis (checked 5 Oct 2026)

• tools/import_connectome.py at 0ce81d9: reads the Shiu sugar list and MN9, selects 128 nodes by 3-hop relevance, keeps the 2,048 strongest edges; metadata says 'Illustrative integer LIF, 30 Hz; not the calibrated Shiu model' and 'heuristic locomotion; MN9 gates feeding' [direct]
• src/sim.c lines 18-38 and 105: integer LIF update, sugar-only drive into group 0, MN9 (group 2) spike count gates feeding [direct]
• docs/validation.md: ROM built and checked in mGBA 0.10.5, including a sugar-contact feeding test [direct; not run by us]

Limits Only the feeding gate is connectome-driven, by a 128-neuron subgraph with quantised weights and a toy integer LIF; everything the fly visibly does besides eating is a heuristic controller, and the neural map uses a synthetic layout. The ROM is the author's own CI build (an original project, not a copy of another repository); we did not run it.

More facts Data licence: FlyWire FAFB: CC-BY-NC-4.0 (the repository's import metadata also says CC BY-NC 4.0) · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/LakoMoor/FlyWireGBA [direct]

Project's own claim “MaleCNS v1.0, the published connectome of a male fruit fly, races an LLM through a Roblox maze to an apple; descending neurons do the moving (video 0zY_yzrcF9c).” source

Mechanism Wiring: Whole MaleCNS as supplied by the flybrain package (stated 166,700 neurons), frozen. Neuron model: spiking, inside the flybrain package (not inspectable in this repository). Input: hand-set: game objects are sorted into fruit/threat/other by name and passed to the package's FeatureDetectors, which inject into visual feature-detector cells. Output: hand-set: forward = tanh(8*(DNg100-MDN)+5*DN mean), turn = tanh(10*(DNa02 R-L)+5*(DN R-L)), jump from DNp01. Trained parts: A ridge readout is fitted to a scripted teacher during play and saved, but it is not used to produce the action. Body: Roblox humanoid rig. Scripted parts: Output is 0.35 brain + 0.65 scripted steering whenever the distance ring is present, 0.2 + 0.8 near walls; the scripted steering chooses open space toward the apple smell and penalises visited cells. Rest/walk bouts are chosen by code with random timers. A Lua bumper reverses near walls. The LLM opponent is ordinary API code..

Measured result (by the authors unless stated) No measured result in the repository; the video shows one race.

Grade basis (checked 29 Sep 2026)

• src/fruitfly_roblox/malecns.py:278-284 FlyBrain() and FeatureDetectors from the flybrain package; DNg100, MDN, DNa02, DNp01 cell groups [direct]
• src/fruitfly_roblox/malecns.py:603-617 8 brain steps per request, spike rates of DN groups [direct]
• src/fruitfly_roblox/malecns.py:652-661 hand-set tanh mapping from DN rates to forward/turn/jump [direct]
• src/fruitfly_roblox/malecns.py:620-641 scripted teacher_action and _steer_from_ring (open space toward apple) [direct]
• src/fruitfly_roblox/malecns.py:674-678 raw = 0.35*native + 0.65*taught with ring; 0.2/0.8 near walls [direct]
• src/fruitfly_roblox/malecns.py:425-455 visited-cell memory penalises revisits (maze solving in code) [direct]
• src/fruitfly_roblox/malecns.py:669,697,703-731 readout fitted in background but mix=0.0 and never applied to the action [direct]
• src/fruitfly_roblox/malecns.py:402-423 rest/walk bouts from random timers [direct]
• studio/FlyBrainServer.server.lua:471-490 applies forward/turn; bumper raycast forces reverse near walls [direct]

Limits The maze is mainly solved by code: whenever the distance ring is available, 65% of the command (80% near walls) comes from a scripted steering routine that seeks open space toward the apple and avoids cells already visited. The brain's share is a hand-set formula over a few descending-neuron spike rates. A readout is trained during play but not used. The simulator is a third-party package whose model we did not inspect, and the Roblox place file is not published. No control (for example a run with the brain share removed or rewired). The README presents the race as brain versus LLM without this split.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 0 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/SolidifiedPlayDoh/fruitfly-roblox [direct]
• https://youtu.be/0zY_yzrcF9c [not viewed]

Project's own claim “Kick-the-buddy game where the buddy is a live 166,700-neuron connectome” source

Mechanism Wiring: MaleCNS v1.0 flat-connectome tables downloaded from the flyem-male-cns bucket; filtered by superclass and weight >= 3, signed by predicted neurotransmitter. Neuron model: LIF, rate-normalised input, global gain controller. Input: hand-made: tools drive named touch, heat/cold, ORN, taste, JO, looming populations. Output: hand-made: DN group rate / calm-baseline thresholds (THRESH dict) trigger reactions. Trained parts: optional dopamine-gated plasticity on mushroom-body synapses (training mode). Body: 2D/3D cartoon ragdoll. Scripted parts: All movement is game physics. The direction of jumps and runs (away from the hit), stunning, damage, eating, flight paths, drunkenness, death, pain index and several reactions are game rules, which the code labels RULE..

Measured result (by the authors unless stated) Measured by the author, not reproduced by us. Circuit-level validation (n = 10 seeds): looming detectors drive DNp01 x11.8 vs x0.80 for controls (pass); sugar neurons drive MN9 x2.11 vs x1.25 for bitter (pass); JO-C/E drive aDN1/aDN2 x4.87 vs x0.85 (pass); MDN activation does not drive leg motor neurons (fail); aDN drives front-leg MNs only x1.13 (fail) (docs/validation.md). Release 2.12.0 (29 Sep 2026) adds a headless larva-brain mode whose two validation tests fail: nociceptive and chordotonal inputs do not excite their target neurons more than random sensory inputs (docs/larva.md).

Grade basis (checked 29 Sep 2026)

• kickthefly/sim/connectome/loader.py:1-40, 202-300 downloads MaleCNS v1.0 flat-connectome, filters and signs edges (MIN_WEIGHT = 3 at :208) [direct]
• kickthefly/sim/connectome/sim.py:1-40 LIF over the signed CSR connectome [direct]
• kickthefly/game/kick_the_fly.py:407 THRESH dict (jump 3.0, run 2.4, kick 2.0, fly 1.58 ... x calm) gates scripted reactions [direct]
• kickthefly/game/kick_the_fly.py:169-187, 1794-1816 states ragdoll physics, direction of jumps and runs, and movement are game rules; REAL/RULE tagging [direct]
• kickthefly/lab/validation.py and docs/validation.md: driven vs matched control sets, seeds 1000-1009, Wilcoxon tests; some pass (looming to DNp01, sugar to MN9) and some fail (MDN backward walking) [direct]
• Re-grade 2026-09-29 after release 2.12.0 (commit a125c32): kickthefly/sim/connectome/larva_loader.py:1-35 adds the Winding et al. 2023 larval connectome (2,952 neurons) as a headless-only option; docs/larva.md: 'The windowed game (2D and 3D) always runs the adult brain', and both larva validation tests FAIL ('no excitation'); kickthefly/core/individuality.py adds per-fly parameter variation. The game's reactions are still triggered scripted programs, so the grade stays C [direct]

Limits The whole filtered graph is simulated and its activity decides when reactions fire. The reactions themselves are scripted motor programs with game physics, so the behaviour shown is connectome-triggered animation. The validation suite is an honest circuit-level check against matched controls, with published failures, but it tests neuron responses, not the game behaviour. The thresholds were chosen after exploratory probing. The code discloses what is a game rule and what is not. Since 2.12.0 a larval connectome can be loaded for headless tests only; the playable game always uses the adult brain, and the larva validation tests fail, so larva reactions would be game rules.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 5 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-13 (not an update date) · Last push, any branch: 2026-09-28; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/legendarylolo318-cloud/kick-the-fly [direct]

Project's own claim “A chess agent built from the connectivity of the fruit-fly brain, used as a fixed neural reservoir and trained with reinforcement learning.” source

Mechanism Wiring: 8,192 neurons chosen by breadth-first search from the highest-degree neuron; signed synapse counts, row-normalised, fixed. Neuron model: rate: tanh units, 6 leaky update steps per position. Input: hand-set: 782 board features written directly onto the first 782 patch neurons. Output: learned: linear readout on 1,024 random patch neurons gives a position score; python-chess lists legal moves and the best-scoring one is played. Trained parts: Readout weights only (self-play TD-style updates with a small material reward). Body: optional FlyGym fly animation. Scripted parts: Legal move generation, search over one ply and game rules are ordinary code. The FlyGym joint angles are readout-weighted activity split into joint groups, an animation, not motor control..

Measured result (by the authors unless stated) Stored comparison notebook (quick mode, 5 seeds, 80 games per pairing, flagged by the author as a code check): the fly patch scored 0.506 against the same patch with rewired connections (no difference), 0.531 against classical features, 0.738 against random moves and 0.306 against a simple material-count player. Measured by the author, not reproduced by us.

Grade basis (checked 30 Sep 2026)

• scripts/fly_chess_trainer.py:18-19,72-76 Shiu Completeness_783 / Connectivity_783 files [direct]
• scripts/fly_chess_trainer.py:69,90-100 RESERVOIR_NEURONS = 8192, breadth_first_order from the highest-degree neuron [direct]
• scripts/fly_chess_trainer.py:117-121 1,024 readout neurons chosen at random [direct]
• scripts/fly_chess_trainer.py:127-141 six tanh propagation steps; features = state[readout_indices] [direct]
• scripts/fly_chess_trainer.py:189-221 value = tanh(value_weights @ features) over legal moves [direct]
• scripts/fly_chess_inference_flygym.py:115-138 FlyGym joint angles from readout-weighted features split into groups (animation) [direct]
• notebooks/connectome_vs_classical_architectures.ipynb cell 12: rewire_reservoir shuffles postsynaptic rows of the patch [direct]
• notebooks/connectome_vs_classical_architectures.ipynb cells 4, 22, 24: stored run in 'quick' mode ('for code checks only'); fly vs rewired mean score 0.506 (CI 0.406-0.607, 5 seeds, 80 games); fly vs material-count 0.306 [direct]
• Re-opened by the runner at HEAD 4ddc9b5 (unchanged): scripts/fly_chess_trainer.py:69 RESERVOIR_NEURONS = 8192; :117-121 1,024 readout neurons by rng.choice; notebook cell 4 RUN_MODE = 'quick'; cell 24 output 'Quick mode is for code checks only'; 0.506 in the stored results table [direct]

Limits The fly wiring is a fixed random-feature layer: about 6% of the brain, picked by graph distance rather than by circuit, with only a linear readout trained. The author's own rewired-wiring control, run in a quick mode the author says is only for code checks, shows no advantage for the real wiring, and the agent loses to a simple material counter. Move generation is ordinary chess code. The 3-D fly moves by animation, not by motor neurons. The README is open that only the readout is trained.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 7 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-08-20 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/mncrftfrcnm/making-fly-play-chess [direct]

Project's own claim “Autonomous Drosophila (MaleCNS v1.0 / FlyWire) connectome agent playing Half-Life” source

Mechanism Wiring: Procedural: region blocks (3,600 photoreceptors, 4,800 optic lobe, 1,200 central complex, 2,400 KC, etc.) wired by modular-arithmetic tracts or random draws, not a connectome. Neuron model: LIF (PyTorch sparse). Input: hand-made: screen pixels to a 60x60 photoreceptor grid. Output: hand-made: rate thresholds on labelled 'DNp20/DNpe017/MDN/DNp09' indices to mouse/keys. Trained parts: dopamine-modulated STDP and a mushroom-body avoidance module on the synthetic graph. Body: none (game character). Scripted parts: Image-derived steer bias (left/right brightness, depth balance) injected into the steering neurons; 'target in crosshair' injects attack current; damage triggers a scripted 180-degree turn, return fire and strafe; obstacle saccades; panic mode; auto-respawn.

Measured result (by the authors unless stated) none reported beyond runtime benchmarks

Grade basis (checked 28 Sep 2026)

• data_loader.py:129-330 build_canonical_flywire_connectome() builds tracts with add_tract() using index arithmetic ((i*3+shift) % dst_len); real data only if the user supplies an npz [direct]
• core/connectome.py:73-219 _build_biological_connectome(): random positions and rng.integers random synapses per region pair [direct]
• main.py:361-384 steer bias computed from left-vs-right image brightness and depth balance, later added to DNp20 stimulus (main.py:385-390) [direct]
• main.py:486-497 damage or 'is_target_in_crosshair' injects 45-70 units of current straight into the attack readout neuron [direct]
• main.py:289-296 and input_bridge.py:342-348 damage calls trigger_combat_retaliation(): scripted 180-degree flick, counter-fire and evasion [direct]

Limits The network is not a connectome: it is a synthetic graph with region labels, and the MaleCNS/FlyWire and v783 naming in files and cache names does not match what the code builds. The game behaviour comes mainly from image heuristics and scripted reflexes that set the output neurons directly, so the neurons act largely as a relay. There are no controls. The optional FlyWire CAVE downloader is not wired into the default run.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 50 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-28; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Yusuftmle/FlyBrain-HalfLife [direct]

Project's own claim “the fly brain can play beat saber” source

Mechanism Wiring: not stated (third-party coverage links the demo wave to MaleCNS v1.0; the author does not confirm). Neuron model: other: not stated. Input: none. Output: learned. Trained parts: By the author's replies (seen only via search): the motor side was 'overfit to a replay' of one track, the input included replay data, and visual reactivity was still being trained with RL. Body: none. Scripted parts: cannot inspect; the author says the motor output was fitted to a replay of one track.

Grade basis (checked 28 Sep 2026)

• Post text via https://api.fxtwitter.com/_lyraaaa_/status/2097527368919470162: only 'the fly brain can play beat saber' plus a 31 s video, no code link [direct]
• Author replies reported in search results: 'still getting the visual cortex reactivity trained, this is so far just the motor cortex overfit to a replay'; 'overfit to one track, and has some replay data in the input' [search-summary]
• https://www.neuroai.science/p/are-flies-playing-beat-saber: critiques the demo wave in general (hand-mapped descending neurons, noise-driven output, no real sensorimotor loop); does not analyse this demo's code [fetch-summary]
• GitHub web search 'fly beat saber' found only unrelated Beat Saber mods [direct]

Limits No code, weights or method description, so the mechanism cannot be checked (grade U). By the author's own replies, the clip shows motor output fitted to a replay of one song, with replay data in the input. It is not a fly reacting to game pixels, and visual/RL training was said to be unfinished. The replies were seen only through search summaries; the reply URLs were not fetched directly. Views were about 23.06 M at fetch time (reported ~22 M earlier), and the post is dated 2026-09-09 03:27 UTC. The dataset (MaleCNS) comes only from third-party coverage.

More facts Data licence: unknown · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://x.com/_lyraaaa_/status/2097527368919470162 [direct]
• https://www.neuroai.science/p/are-flies-playing-beat-saber [fetch-summary]
• https://raw.githubusercontent.com/townie/awesome-fruit-fly/main/README.md [direct]
• https://www.dexerto.com/gaming/googles-digital-fly-brain-gets-its-own-heaven-after-going-through-beat-saber-hell-3407304/ [search-summary]

Project's own claim “A digital fruit fly brain with over 1,000,000 simulated neurons, trained for a month on 20+ TB of professional gameplay, scored its first kill in Rainbow Six Siege (as reported by dev.ua, 28 Sep 2026).” source

Mechanism Wiring: not stated; the stated size (over 1,000,000 neurons) is about six times the largest fly central nervous system reconstruction (MaleCNS v1.0, 166,700 neurons). Neuron model: not stated. Input: not stated (claimed: real-time vision and sound). Output: not stated. Trained parts: claimed: trained for a month on 20+ TB of gameplay footage. Body: none (game character). Scripted parts: unknown.

Measured result (by the authors unless stated) None published. The only reported result is a single in-game kill, described by the author on social media.

Grade basis (checked 29 Sep 2026)

• No code, model or write-up found: web searches for the author's name, handle and project on 2026-09-29 returned only the dev.ua report [search-summary]
• Google News RSS entry 'Ukrainian Man Made Fly's Digital Brain Play Rainbow Six Siege - dev.ua', 2026-09-28T06:44:00Z (leads/raw/news-scan-2026-09-29.json) [direct]
• dev.ua article text (claims of 1,000,000+ neurons, 20+ TB of footage, first kill, X post of 26 Sep 2026) known only through search summaries; the page returned HTTP 403 (bot challenge) to our fetches on 2026-09-29 [search-summary]
• Neuron counts for comparison from our catalogue dataset entries: FlyWire FAFB v783 139,255; MaleCNS v1.0 166,700 [direct]

Limits Unverified claim. Nothing can be inspected: no code, model, data or method. As described it cannot be a fly connectome simulation on its own: the stated size of over 1,000,000 neurons is about six times the largest fly central nervous system map (MaleCNS v1.0, 166,700 neurons), and training on 20 TB of human gameplay footage means any skill would come from ordinary machine learning. One kill is not a measure of play. The report relies on the author's own post; the author's tone was partly joking.

More facts Data licence: unknown · Peer review: social media post, reported by one news site · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://dev.ua/en/news/mukha-v-sidzhi-1790577179 [search-summary]
• https://news.google.com/rss/search?q=%22fruit%20fly%20brain%22%20when:7d [direct]
• https://liquipedia.net/rainbowsix/GHOOD_BHOY [search-summary]

Project's own claim “"Using Its OPEN SOURCE BRAIN, The Fly Learned To Move Around As A Gorilla And Got SUPER Good At It... It Even Learned How To Play INFECTION!" (video description, chapters Phase 0 to Phase 7)” source

Mechanism Wiring: not stated; the description says only "its open source brain". Neuron model: not stated. Input: not stated. Output: not stated (claimed: the fly moves a Gorilla Tag avatar). Trained parts: claimed: the fly "learned" over seven phases; method not stated. Body: none (VR game avatar). Scripted parts: unknown.

Measured result (by the authors unless stated) None published. The video shows the creator's account of seven training phases; no numbers, baseline or code are given in the metadata.

Grade basis (checked 1 Oct 2026)

• Watch-page metadata read 2026-10-01 ~10:58Z: title, description, chapter list, 527,756 views, 7.8K likes, upload date Sep 26, 2026 (leads/raw/youtube-watch-meta-2026-10-01.json) [direct]
• Description links only to linktr.ee/supercatcraze; its 76 links (fetched 2026-10-01) are Gorilla Tag maps on mod.io, Google Drive files, Discord, social accounts and sponsors; none names a fly, brain, connectome or code repository [direct]
• Channel search for "fly" on @supercatcrazegt (2026-10-01) lists this video, a short of the same claim (slfEv4o3GVI) and an earlier "I Trained an AI to Beat Gorilla Tag's Fastest Player" (3gpJ-X9yvTc); no code link [direct]
• GitHub repository search for "gorilla tag fly brain", "gorilla tag connectome", "gorilla tag flywire" and "gtag fly brain" on 2026-10-01: 0 results each [direct]
• The video itself was not watched (no browser in this run); on-screen claims are not recorded

Limits Unverified claim. Nothing can be inspected: no code, model, map or method. "Open source brain" suggests one of the public fly-brain projects, but none is named, and a named base project would not show how the fly was coupled to the game or what "learned" means. The channel's earlier video trained an ordinary AI on Gorilla Tag, so a trained controller is a plausible source of any skill. Most-viewed unrefereed fly-brain claim in our scans (527,756 views on 2026-10-01).

More facts Data licence: unknown · Peer review: YouTube video · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://www.youtube.com/watch?v=wK4lixw7p4M [direct]
• https://linktr.ee/supercatcraze [direct]
• https://www.youtube.com/@supercatcrazegt [direct]

Project's own claim “All 139,255 neurons of FlyWire FAFB v783 (connections of five or more synapses) simulated on a Raspberry Pi 5 alongside mGBA; the layout of walls, doors and people is read from game memory and fed to LPLC1, LC10 and LPLC4 as left/right drive ('there's no retinotopy'); descending-neuron activity decodes into button presses; viewers can stimulate reward/punishment neurons for about 10 minutes.” source

Mechanism Wiring: claimed: whole FAFB v783, edges of five or more synapses; not inspectable. Neuron model: not stated. Input: claimed: game-memory layout of walls, doors and people as left/right drive to LPLC1, LC10 and LPLC4; no image processing. Output: claimed: descending-neuron activity decoded into button presses; decoder not described. Trained parts: unknown; chat commands (!pain, !pleasure) stimulate reward/punishment neurons. Body: none (Game Boy Advance player). Scripted parts: unknown.

Measured result (by the authors unless stated) None published. The Twitch title on 2026-09-29 reported in-game progress (Wartortle level 35, beat Brock, on Route 25), but it is not stated how much of this came from the fly, the decoder, chat or other code.

Grade basis (checked 29 Sep 2026)

• No public code found: GitHub profile github.com/leetzerzz returns 404; searches for Leetzerzz with GitHub, fly and Pokémon return only other projects; the XDA article gives no code link [search-summary]
• acamilo/flybrain and blackicon-eth/fly-plays-games do not match the described setup (neither mentions Leetzerzz, Raspberry Pi, or LPLC4 input; acamilo uses pixel input to L1 columns, blackicon uses MaleCNS with PyBoy) [direct]

Limits Only the creator's description is available: a Reddit post and the XDA summary of it. Without code there is no way to tell how buttons are decoded, whether menus, battles or movement are helped by scripts, or how much chat stimulation steers progress. The creator says openly that the input is game-memory layout rather than vision.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://www.xda-developers.com/someone-wired-up-a-digital-flys-brain-in-a-pi-5-to-play-pokmon-and-you-can-help-it-progress/ [fetch-summary]
• https://www.reddit.com/r/raspberry_pi/comments/1wrz7hs/pi_5_running_a_real_fruit_flys_brain_playing/ [search-summary]
• https://www.twitch.tv/leetzerzz [fetch-summary]
• https://news.google.com/rss/search?q=%22fruit%20fly%20brain%22%20when:7d [direct]

Project's own claim “run the full retained MaleCNS v1.0 fruit fly connectome, all 166,700 neurons, inside Minecraft, with its simulated neural activity driving a fly's movement” source

Mechanism Wiring: not inspectable; README self-reports a retained MaleCNS graph of 166,700 neurons and 25,582,938 edges. Neuron model: other: not stated, and no code to check. Input: hand-made. Output: hand-made. Trained parts: none in current demo per README; README mentions an earlier trained readout that performed worse than a direct controller. Body: custom. Scripted parts: Self-reported: readouts 'select and modulate scripted body programs'. The approach stimulus uses scripted scene preparation, and the video includes an operator-selected scripted movement tour. Cannot be checked in code..

Measured result (by the authors unless stated) Self-reported and unverifiable without code (README.md:53-58): an earlier trained readout had 95.66x higher raw error than a direct controller. An offline probe found DNp01 changes about 300x the wing-pool changes, and TTMn activity 35.1x baseline. The video includes shuffled-weights and no-input conditions without reported numbers.

Grade basis (checked 28 Sep 2026)

• git ls-tree HEAD: 10 files, none of them source code. CHANGELOG.md, CITATION.bib, CITATION.cff, LICENSE (MIT), README.md (landing page), ROADMAP.md, media/README.md (recording notes), media/manifest.json (checksums/chapters), media/brush-demo.gif (7 s clip), media/neurocraft-demo.mp4 (2:27 video) [direct]
• README.md:33-35: the mod and companion source are 'being prepared', and 'software downloads and runnable assets are not available here yet' [direct]
• README.md:10-18: pipeline is inputs -> modelled activity -> labelled readouts -> 'scripted body programs' -> movement [direct]
• README.md:90-93: the MIT licence covers 'project-owned documentation'; no bulk connectome data [direct]
• media/README.md:24-29: some responses remain under shuffled weights, and baseline cruise moves the body with sensory input switched off [direct]
• Launch post text (via api.fxtwitter.com, 2026-09-04): 'Code and mod coming soon!' [direct]

Limits CONFLICT resolved: both directories are partly right. The repo exists and has an MIT LICENSE, but the licence covers only documentation, and the simulation code and mod are not in it (README.md:33-35; the launch post says 'Code and mod coming soon'). flybrain.info's 'code not released' is correct for the code. Fly Brain Hub's 'repo exists, MIT' is literally true but misleading as a code release. The author's own notes are frank: the body moves through scripted programs, some responses survive weight shuffling, and the body moves even with inputs off. So the connectome's share of the visible behaviour is unclear. 166,700 neurons is fewer than the full MaleCNS v1.0 table (176,422 in fly-brain-minecraft's stats), so a filter was applied but is not described. The video was not reviewed frame by frame. Re-check when the code is released.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 170 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-06 (not an update date) · Last push, any branch: 2026-09-06; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/evnsnclr/neurocraft-fly-public [direct]
• https://x.com/evnsnclr/status/2095975490708291948 [direct]

Project's own claim “"I Made Two Real Flies Brain Fight Each other in JJS" (title); "i made two flies fight each other in JJS" (description)” source

Mechanism Wiring: not stated ("real flies brain"). Neuron model: not stated. Input: not stated. Output: not stated (claimed: two fly brains control two Roblox fighters). Trained parts: not stated. Body: none (Roblox avatars). Scripted parts: unknown.

Measured result (by the authors unless stated) None published.

Grade basis (checked 1 Oct 2026)

• Watch-page metadata read 2026-10-01 ~10:58Z: title, description (Discord and Roblox group links only), 139,364 views, upload date Sep 21, 2026 (leads/raw/youtube-watch-meta-2026-10-01.json) [direct]
• GitHub repository search for "jjs fly brain" (0 results), "jujutsu shenanigans fly" (9 results, all Roblox script-download repositories unrelated to the creator) and "roblox fly brain" (9 results, none linked to the creator) on 2026-10-01 [direct]
• The same creator's "I Forced FLY to Listen AIZO (Brain Dead)" (AXiv0AIBnt0, 15,244 views) found in the same scan; no code link [direct: search result and watch-page count]
• The video itself was not watched (no browser in this run); a second watch-page fetch was refused (HTTP 429)

Limits Unverified claim. Nothing can be inspected. Roblox games do not accept outside controllers without client scripts, so any coupling would be the creator's own code, which is not published. Found only by the views-sorted month catch-up (139,364 views, uploaded 21 Sep 2026).

More facts Data licence: unknown · Peer review: YouTube video · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://www.youtube.com/watch?v=KC7-fpjIRN4 [direct]

Project's own claim “A 3D fruit fly living on your macOS desktop, driven by a live spiking simulation of the real FlyWire connectome” source

Mechanism Wiring: subset: 668 neurons / 18,968 connection rows of FlyWire v783 (11 chosen cell types such as LC4, LPLC2, giant fibre, DNa01/02, DNp09, DNg11, MDN, plus their 330 strongest partners) + subset: 1,045 neurons / 17,224 edges of MaleCNS v1.0 (descending -> VNC -> leg motor neurons). The 23,210 points in the brain window are soma positions drawn for display, not simulated. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none (knee torque and damping coefficients hand-calibrated). Body: custom. Scripted parts: Neuron rates cross hand-set thresholds to switch an ordinary state machine (walk, idle, groom, fly, sleep). Flight is a random-target timed trajectory, grooming a leg sine animation, darting a coded turn away from the cursor with random speed, and some take-offs are random. Sleep follows the computer's idle time and the clock, not a neuron. Only walking in v1.1 is driven by simulated leg motor neurons..

Measured result (by the authors unless stated) Only in-model checks (EVALUATION.md, native run 5 Sep 2026): bilateral DNp09 at 40 Hz for 8 s gives 10.64 model units forward; MDN at 70 Hz gives -12.66 backward; removing all synapses gives zero propulsion. The results are in model units and are not compared with fly data.

Grade basis (checked 29 Sep 2026)

• FlyModel.swift:652-714 brainBehavior(): every state change compares a neuron rate with a hand-set threshold, then runs code: giant-fibre spike -> startFlight; DNg11 rate > 0.5 -> grooming; DNp09 rate > 0.22 -> walking; MDN burst -> 0.5 s backward; arousal -> random take-off [direct]
• FlyModel.swift:448-482, 786-817 startFlight/updateFlight: random landing target and timed smoothstep trajectory; FlyModel.swift:861-865 grooming is a leg sine animation [direct]
• main.swift:1003-1007 sleepy = (idle > 600 s and hour 22-6) or idle > 1800 s: sleep comes from user idle time and the clock, not from a neuron [direct]
• etl.py:37, 104-112 MAX_PARTNERS = 330: the FlyWire part is 11 chosen cell types plus their strongest partners (668 neurons, 0.5% of 139,255); Sim.swift:310-322 hand-set x6 boost on looming -> giant-fibre edges [direct]
• Locomotor.swift:122-128, 202-213 and FlyModel.swift:587-593: in the walking state the MaleCNS leg circuit (fed by FlyWire DN rates through a modelled cross-specimen interface) drives the legs and body motion [direct]
• EVALUATION.md:188-189 (author): 'Grooming, flight, sleep and behavioral state selection still use the existing modeled rules and animations.' Only in-model checks (EVALUATION.md:73-80), no comparison with fly data and no wiring control [direct]

Limits Grade C: the network's activity mostly switches coded animations. Only 668 FlyWire neurons and 1,045 MaleCNS neurons are simulated; the 23,210 points in the brain window are drawn, not simulated. The two circuits come from different flies (female FlyWire, male MaleCNS) and are joined by a modelled rate interface, not by synapses. Neuron rates cross hand-set thresholds to switch between behaviour states. Walking legs are driven by simulated motor neurons, but flight, grooming and darting are coded animations, and sleep follows the computer's idle time and the clock. The author's own tests check the model against itself, not against real flies, and the author states that grooming, flight, sleep and state selection use modelled rules and animations. Licence: code MIT; the LICENSE file adds that FlyWire-derived data are CC BY-NC 4.0, and data/DATA_LICENSE.md puts the MaleCNS extract under CC BY 4.0 (GitHub's detector reports NOASSERTION because of the added text). There are no official app downloads: build from source. Ports by others exist for Android, Linux and Windows. A repository named caucasiadoublevision2701/desktop-fly contains no DesktopFly code, only a zip with a Windows program; do not download it.

More facts Data licence: FlyWire FAFB: CC-BY-NC-4.0; MaleCNS: CC-BY-4.0 · Peer review: none · GitHub stars: 1053 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-08-18 (not an update date) · Last push, any branch: 2026-09-05; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/DenisSergeevitch/desktop-fly [direct]
• https://github.com/DenisSergeevitch/desktop-fly/releases/tag/v1.1.0 [direct]

Project's own claim “Real-time LIF simulation of the 166,700-neuron MaleCNS fruit fly connectome driving a 3D MuJoCo fly that hunts sugar and strikes piano keys.” source

Mechanism Wiring: MaleCNS v1.0 (166,700 neurons, 25.58M synapses in data/graph.npz). Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none live; an offline ridge readout script (src/train_leg_readout.py) exists but is not used by play_piano.py. Body: flybody. Scripted parts: Key sequence from a song file; leg choice by key position; press motion is a fixed IK raise-hover-descend-hold-release ramp; the 'sugar side' gate compares plume concentrations computed from geometry, not neural activity; 'known' comes from stimulus strength; a hand-set reward gain boosts tarsal drive.

Grade basis (checked 28 Sep 2026)

• scripts/fetch_graph.py:33-49 downloads the MaleCNS v1.0 feather files [direct]
• src/native_brain.py:42,185 LIF kernel with bincount spike delivery [direct]
• src/brain_driver.py:58-61 'play_piano.py always runs its own scripted choreography; the brain never picks the note'; it only shapes press force [direct]
• src/play_piano.py:265-268 the side gate uses plume concentrations cL/cR, not spikes [direct]
• src/brain_driver.py:319-320 intent 'known' is stimulus strength above a threshold, not neural output [direct]
• src/brain_driver.py:449-453 motor output = T1 motor-pool rate x a lateral weight computed from the stimulus [direct]
• src/play_piano.py:205-210,310-334 pool rate -> press force; leg chosen from key y position and IK [direct]

Limits README says the connectome drives the fly and the antennae decide the sugar side. In the code, the side check uses plume concentrations from geometry (play_piano.py:265-268), so the neural simulation does not gate or choose movements; it only scales press force. The author's own comment in brain_driver.py:58-61 says the choreography is scripted. The whole-brain LIF does run on real MaleCNS v1.0 wiring. No control or benchmark. Linux only; an optional Rust brain viewer lives in a separate repo not included here.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 3 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-20 (not an update date) · Last push, any branch: 2026-09-23; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Noir-infini/pianist-fly [direct]

Project's own claim “Connect a Drosophila connectome simulation to a physical robot; the default backend is a small demonstrator and MaleCNS support is an experimental integration target.” source

Mechanism Wiring: none. 8 hand-designed groups with hand-set drive formulas, no connectome. Neuron model: first-order leaky integrators (tau 0.12 s). Input: Hand-made: Farneback optical-flow magnitude in the left and right image halves plus radial expansion ('looming'), and IMU yaw rate. Output: Hand-made: two motor groups scaled to wheel speed; looming above a threshold triggers fixed reverse. Trained parts: none. Body: Physical two-motor robot (M5 Atom Matrix firmware); not validated on hardware. Scripted parts: The whole controller: forward bias 0.15, crossed motion-to-motor gains 0.7, fixed reverse on escape.

Measured result (by the authors unless stated) none reported

Grade basis (checked 28 Sep 2026)

• src/flybrain_robot/brain/mock.py:1-49 docstring 'Eight hand-designed leaky populations, not a connectome simulation'; drive formulas hard-coded at 33-44 [direct]
• src/flybrain_robot/brain/malecns.py:1-34 'Extension seam only: no graph loader or biological simulation'; every method raises NotImplementedError [direct]
• src/flybrain_robot/vision.py:20-36 optical-flow heuristics for motion and looming [direct]
• src/flybrain_robot/motor_decoder.py:39-56 escape >= threshold gives fixed full reverse, otherwise scaled left/right [direct]
• docs/VALIDATION.md:13-14 webcam, UDP link, firmware and hardware not validated; MaleCNS deliberately unimplemented [direct]

Limits No connectome is loaded or simulated. The behaviour comes entirely from hand-written optical-flow heuristics and eight hand-set leaky units, so the neuron names are cosmetic. The README itself says it is a proof of concept with a mock backend. The demo GIF is software output, not a robot recording. The GitHub account was renamed: github.com/Himas1211/flybrain-robot-bridge redirects here (HTTP 301, checked 2026-09-28), which explains the older name in the LICENSE and docs.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 223 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-14 (not an update date) · Last push, any branch: 2026-09-16; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Frankweb33/flybrain-robot-bridge [direct]

Project's own claim “A real fruit-fly brain that makes music and DJs.” source

Mechanism Wiring: Whole FlyWire v783 brain, Shiu weights. Neuron model: spiking: Shiu et al. LIF, fast real-time reimplementation. Input: hand-set: audio frequency bands -> JO-A/JO-B neuron groups (40 Hz to 2.2 kHz bands). Output: hand-set: bursts (fast rate above slow baseline) in named DN types -> DJ actions (DNa01/02 steering -> deck, DNp01 -> loop roll, DNg24/29 -> scratch, ...). Trained parts: none. Body: none. Scripted parts: Beat matching, key lock, set planning, stems and the 29 DJ styles are ordinary audio code; the brain triggers moves.

Measured result (by the authors unless stated) No measured result or control in the repository.

Grade basis (checked 30 Sep 2026)

• flybrain/brain.py:1-18,35-36 real-time Shiu LIF on Completeness_783 / Connectivity_783 [direct]
• flybrain/mapping.py:18-24 Johnston's organ JO-B/JO-A groups by frequency band [direct]
• web/js/flydj.js:3-13 burst in named DN types -> DJ move table [direct]

Limits The brain really runs and hears the music through its antennal hearing neurons, but which descending neurons trigger which DJ move is the author's choice, and the musical skill (beat matching, key lock, set planning) is ordinary audio code. No scrambled-wiring comparison.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 1 (5 Oct 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/izntariq/fly-with-me [direct]

Project's own claim “A whole-brain emulation using the FlyWire connectome: 139,255 neurons driving a simulated fruit fly in a terrarium.” source

Mechanism Wiring: FlyWire FAFB v783, all 139,255 neurons and 2,700,513 edges (Codex >=5-synapse threshold), synapse count x transmitter sign. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none (global gains, noise and baseline drive are hand-tuned). Body: flybody. Scripted parts: Sugar input is always on. Wing postures and a small foot-lift pattern ('ours, not a reconstructed gait') are supplied by code and only scaled or triggered by descending-neuron rates (DNg11 grooming, DNa01/02 steering). There is no walking. Random noise kicks and a random tonic baseline drive keep the network active..

Grade basis (checked 28 Sep 2026)

• web/brain.ts:1 header: whole-brain LIF over FlyWire FAFB v783, 139,255 neurons / 2,700,513 edges [direct]
• tools/fetch_flywire.sh downloads the Codex FAFB 783 dumps; tools/build_brain.py:2 builds the graph from them [direct]
• web/brain.ts:188 step() updates all N neurons every 1 ms (20 ms tau, threshold, refractory, delayed inhibition); weights loaded from w2.bin.gz at web/brain.ts:135 [direct]
• web/brain.ts:109 sweet stimulus drives the grn_sweet / grn_sweet_leg populations; web/app.ts:802 turns sugar on at start [direct]
• web/app.ts:664 brain.step(1) runs every 10 MuJoCo steps, then applyBrainToActuators (web/app.ts:571) [direct]
• web/app.ts:467 DRIVE table maps motor-neuron pools (mn_proboscis, mn_neck, mn_antenna) to actuators; wing rows from DN pools are marked as supplied 'command' mappings (web/app.ts:458) [direct]
• web/app.ts:593 and :649 foot shuffle is a fixed sin^2 flexion pattern triggered when DNg11 activity builds up [direct]

Limits Page responds (HTTP), not played. Needs WebAssembly (mujoco_wasm), WebGL (three.js) and DecompressionStream; no WebGPU. The brain runs in plain TypeScript on the main thread. FAFB is brain-only, so only proboscis, head and antenna are driven directly by motor neurons, and the README says so. Candidate list typed this browser-demo; set to demo-art because the project presents itself as an artwork. No wiring control or benchmark: tools/shuffle_test.mjs tests the foot-shuffle routine, not shuffled wiring. No licence file.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 25 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-08 (not an update date) · Last push, any branch: 2026-09-14; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/cnqso/infinite-sugar [direct]
• https://infinitesugar.cnqso.com/ [direct]

Project's own claim “Bad Apple but it's playing on a fly's brain” source

Mechanism Wiring: MaleCNS v1.0 full flat connectome (minconf 0.5). Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none. Body: FlyGym. Scripted parts: Motor output uses FlyGym PreprogrammedSteps and HybridTurningController (recorded walking steps). Grooming and other movements are hand-written gestures, weighted by the rates of chosen descending neurons (DNg100/DNg97 forward, MDN backward, DNa02/DNg13 steering, grooming DNs)..

Grade basis (checked 28 Sep 2026)

• backend/video.py:1,19-50 VideoProjector: dark pixels (brightness below 96) select neurons whose soma XY falls on them, at every depth. The picture is imposed as stimulation, not seen by the fly [direct]
• backend/app.py:184-193 stimulus_inputs(): each selected neuron is driven at rate_hz (default 100 Hz) [direct]
• backend/brain.py:1 'Sparse, delayed LIF dynamics on MaleCNS'; scripts/download_data.py:8-12 MaleCNS v1.0 feather files [direct]
• backend/body.py:1,19,43-47,65-98 FlyGym PreprogrammedSteps + HybridTurningController; _gesture() is described as 'explicit qualitative motor programs' [direct]
• backend/evidence.py:20-32 hand-made map from descending-neuron types to movement programs, with literature citations [direct]

Limits AUTHORSHIP CONFLICT: the X page is titled 'Kevin on X' under the handle @linguinelabs. Resolved: the post's author profile (fetched through the fxtwitter API) is named 'Kevin', says 'bad apple engineer' and links to kevinlinxc.com. The only commit in the repo is by Kevin Lin. So @linguinelabs and GitHub kevinlinxc are very likely the same person. The post (6 Sep 2026, about 20.8 M views at fetch) came a week before the repo was created (13 Sep). The public code may therefore differ from what made the viral clip. MECHANISM: the Bad Apple image in the brain view mostly shows the stimulus itself. The neurons under dark pixels are forced to fire, so the picture is drawn onto soma positions rather than produced by the network. Network propagation does add spread-out activity. The README says plainly that this is 'not a real brain simulation': parameters are invented, the video is not something the fly sees, there is no sensory feedback, and the female NeuroMechFly body is paired with a male connectome. Graded C because connectome activity only switches scripted or pre-recorded motor programs. No licence file, so default copyright applies. A full run of the video can take an hour or more.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 3 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-13 (not an update date) · Last push, any branch: 2026-09-13; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/kevinlinxc/badapple-fly [direct]
• https://x.com/linguinelabs/status/2096487329091441090 [direct]

Project's own claim “"A terminal audio visualizer that runs your music through the actual FlyWire whole-brain connectome ... Real audio in, real neurons firing, real time." (README)” source

Mechanism Wiring: FlyWire v783 whole brain, signed weights from synapse counts and transmitter fractions (tools/preprocess.py, W_SCALE 0.075). Neuron model: other: discrete-time leaky threshold units with refractory steps and hashed threshold jitter (src/sim.rs tick). Input: hand-made: ten tonotopic bands, each injected into the neurons of one horizontal stripe of the 2-D layout (preprocess.py: band = x * 24 // width), not into auditory neurons. Output: hand-made: per-band mean activity of the same band's neurons drives disk diameter, rim bumps and anomalies (src/figure.rs:475-489). Trained parts: none. Body: none. Scripted parts: the disk geometry, shockwaves and flares are drawing code; bass onsets also trigger effects.

Measured result (by the authors unless stated) None (a visualiser; no measurement).

Grade basis (checked 3 Oct 2026)

• tools/preprocess.py at ab0e853: builds the network from the FlyWire v783 feather; band assignment by layout x position (line 135) [direct]
• src/sim.rs:305-345: leak, threshold, spike delivery along the edges, then audio current into band_members [direct]
• src/figure.rs:475-489: the drawing reads pools.band_act, the mean activity of each band's own injected neurons [direct]
• No comparison with a scrambled or no-network version; the 'r' key rewires to a random reseed but no result is reported [direct]

Limits The connectome really is loaded and stepped, but the picture is read from the same neuron pools the audio is injected into, chosen by screen position rather than by any auditory pathway, so the network acts mostly as a relay of the music's band energies. Without a scrambled-network comparison there is no sign that the wiring shapes what you see. The crates.io build falls back to a small synthetic network.

More facts Data licence: FlyWire v783 derived data committed (CC BY 4.0 per FlyWire; not stated in the repository) · Peer review: none · GitHub stars: 6 (6 Oct 2026) · Repository created: 2026-09-17 (not an update date) · Last push, any branch: 2026-10-02

Sources

• https://github.com/emiliano-go/neurafly [direct]

Project's own claim “Sobre el mismo mapa puedes reproducir Bad Apple!! o jugar al episodio shareware de DOOM, pintados solo con las neuronas.” source

Mechanism Wiring: FlyWire v783 positions and connections for display only. Neuron model: none. Input: none. Output: none. Trained parts: none. Body: none. Scripted parts: Video frames and the DOOM screen are painted onto neuron positions; the game is ordinary DOOM.

Measured result (by the authors unless stated) No measured result; no simulation.

Grade basis (checked 30 Sep 2026)

• README.md (Spanish): 3-D viewer; Bad Apple!! and DOOM painted with neurons [direct]
• app/app.js: three.js rendering, search and partner tables; code_scan found no neuron model (only three.js matches for "spike") [direct]

Limits A connectome display, not a brain simulation: the fly does not play DOOM, its neurons are used as screen pixels. It is a different project from badapple-fly (kevinlinxc), by a different author with different code.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 2 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-12; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/fazchile17/FLYBRAIN-BAD_APPLE_X_DOOM [direct]

Project's own claim “A spiking model of the whole fruit fly brain steers a simulated body toward dark poles; after two legs are cut mid-walk it keeps finding the poles; scramble its wiring and it can't.” source

Mechanism Wiring: Whole FlyWire v783 brain as used by Shiu et al., unmodified weights. Neuron model: spiking: Shiu et al. leaky integrate-and-fire, ported to Warp for batched GPU runs. Input: FlyVis (pretrained, connectome-constrained optic-lobe model) output types drive same-type FlyWire neurons as Poisson inputs, column by column; per-type scale set from responses to moving bars. Output: hand-set: turn asymmetry = clip(-k*(DNa02 L - R)/100 Hz - b, +-0.8); gain k chosen on separate training flies. Trained parts: None in the brain. Two settings tuned (handoff scale per cell type, turn gain k); FlyVis was trained by its authors. Body: NeuroMechFly (flygym) on MuJoCo-Warp. Scripted parts: Leg rhythm is a hand-built tripod pattern generator (the brain only sets turning; walking pace is not from the brain). Pole images are computed analytically. Poles respawn ahead when reached..

Measured result (by the authors unless stated) Poles reached per 10 s, from the stored per-fly table (our recomputation matches the README): intact flies 2.96 with real wiring, 0.34 with scrambled wiring, 0.12 with turn neurons disconnected; after the two-leg cut 3.14 real, 0.12 scrambled, 0.52 disconnected. Author reports scrambled brains' DNa02 falls from about 30 Hz to 2 Hz or less for every gain tried. Measured by the author, not reproduced by us.

Grade basis (checked 29 Sep 2026)

• scripts/download_data.sh:9-20 Shiu Connectivity_783.parquet and Completeness_783.csv at a pinned commit with md5 checks [direct]
• src/flyloop/data.py:1-45 FlyWire v783 edges from Shiu files ('Excitatory x Connectivity') [direct]
• src/flyloop/brain.py:19,153-156 Shiu LIF constants (W_SYN 0.275); wiring argument used for the null model [direct]
• src/flyloop/vision_loop.py:1-6,158,166 Poisson handoff from FlyVis; asym = clip(-k*(L-R)/100 - bias) sets CPG turning [direct]
• src/flyloop/wiring.py:8-12 null model: postsynaptic targets permuted across all connections, keeping presynaptic neuron, sign and synapse count [direct]
• src/flyloop/vision_loop.py:301-322 shuffle_test sweeps k = 1, 2, 4, 8 on scrambled wiring [direct]
• src/flyloop/vision_loop.py:324-362 scramble_at_cut clones each fly at the cut with real vs scrambled wiring [direct]
• assets/results_per_fly.csv: per-fly poles; recomputed means intact 2.96 (n=48) real vs 0.34 (n=32) scrambled vs 0.12 (n=48) unplugged; after cut 3.14 (n=64) vs 0.12 (n=16) vs 0.52 (n=48) [direct]

Limits Walking itself comes from a hand-built pattern generator; the brain only supplies the turn signal through one hand-set formula on DNa02, with a gain chosen on training flies. The eye model was fitted by its own authors. The control scrambles postsynaptic targets across the whole brain, which shows the mapped wiring is needed to route the eye signal to DNa02, but it is a strong perturbation; the post-cut scrambled condition has only 16 flies from one shuffle. Only the per-fly summary table is stored; raw run files are regenerated by the scripts, and GPU runs are not bitwise reproducible. Builds on the Eon Systems embodied fly and Shiu et al. model, which the author credits. Not a copy of a catalogued project.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 1 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/vib2810/fly-brain-zero-shot [direct]

Project's own claim “"If the real wiring matters, scrambling it should hurt the flies. It does." Real wiring 54 hits (longest rally 54) vs shuffled wiring 10 (4), parked fly 14 (6), DNa01/02 steering 12 (6) in one 40 s match each (README)” source

Mechanism Wiring: MaleCNS v1.0 brain and nerve cord, edges with at least 5 synapses, signs from predicted neurotransmitter (flypp/connectome.py). Neuron model: rate (graded): flyvis formulation, tau dV/dt = -V + b + sum w ReLU(V) + x, inputs scaled by each neuron's total synapse count, firing rate capped (flypp/network.py). Input: hand-made: analytic eye model of FlyGym's 721 ommatidia mapped onto the medulla column grid (flypp/vision.py, RetinotopicMap in flypp/loop.py); a dark ball on a plain background. Output: hand-made: BumpDecoder population-vector azimuth of the 16 most deviating Mi1/Tm3/T2/T3 cells against a ball-free twin network (no trained parameters) sets lateral speed along the baseline, up to 16 mm/s. Trained parts: none in the match (--ckpt "" loads no checkpoint); training scripts from earlier phases are in the repository but unused by the match. Body: custom kinematic: the fly slides along its baseline (no leg movement); FlyGym meshes for display only. Scripted parts: racket swing trigger, return direction (a random landing target inside the court), ball physics, court scaled about 3x smaller so the ball stays visible.

Measured result (by the authors unless stated) Author's committed logs, one 40 s match per condition, seed 1: real wiring 54 hits (one unbroken rally), shuffled wiring 10 hits (max rally 4), parked fly 14 (6), DNa01/02 steering 12 (6). Open loop, the decoded bearing falls monotonically across 9 ball positions with the real wiring and is disordered with the shuffled wiring.

Grade basis (checked 6 Oct 2026)

• flypp/tennis.py at c0b5e17: docstring states what is scripted (swing trigger, return velocity); --shuffle calls net.shuffle_edges_(0); return target drawn uniformly in the court (lines 248-262) [direct]
• flypp/network.py: shuffle_edges_ permutes postsynaptic endpoints across edges (weights and signs stay with the presynaptic side; in- and out-degree kept), one seed [direct]
• cache/v2/logs/bump2.log: 40 s, hits 54, max rally 54; open-loop bearing sweep 13, 10, 8, 3, 1, -4, -8, -9, -16 deg; closed-loop steer check corr A = -0.230, B = +0.020 (log says it should be positive) [direct]
• cache/v2/logs/shuffle.log: hits 10, max rally 4; open-loop sweep 4, 6, -16, -15, -12, -9, 2, 26, 18 deg [direct]
• cache/v2/logs/none.log: hits 14, max rally 6; cache/v2/logs/contrast.log (DNa01/02 steering): hits 12, max rally 6 [direct]

Limits Each condition is one 40 s match with one seed and one shuffle, so the 54 vs 10 hits gap has no spread. In the 54-hit match the logged closed-loop steering check is near zero or negative, so the long rally is not shown to come from tracking; the open-loop bearing sweep is the cleaner evidence. The swing, the return direction and the ball physics are scripted, the fly does not walk, and the court is shrunk so the ball stays visible.

More facts Data licence: MaleCNS v1.0 (CC BY 4.0; downloaded by the user from the public FlyEM bucket, not included) · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/castor639/fly-tennis [direct]
• https://fly.warpfield.me [not loaded]

Project's own claim “Against its own degree-preserving shuffle the gap is +0.09 pp, 95% CI [-0.20, +0.38], p = 0.51.” source

Mechanism Wiring: larval connectome (Winding 2023), 2,956 neurons, 63,545 'ad' edges, spectral radius pinned at 0.95. Neuron model: rate: leaky tanh reservoir, 8 steps. Input: learned (trained linear projection onto 434 sensory neurons). Output: learned (trained linear readout from 346 descending neurons). Trained parts: input projection and readout only; recurrent matrix frozen. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) CIFAR-10 (results/results_cifar10.json): connectome 43.04% +/- 0.40 (n=15), degree-preserving 42.95% +/- 0.37 (n=15), gap +0.09 pp, 95% CI [-0.20, +0.38], p = 0.51; weight shuffle 42.96%, Erdos-Renyi 42.98%, no recurrence 10.00%. MNIST (results/results.json, n=5): connectome 97.30%, degree-preserving 97.28%, weight shuffle 97.38%, Erdos-Renyi 97.53%, no recurrence 11.35%. We recomputed means and the gap from the committed JSON files; we did not rerun training. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• src/connectome.py:63-99 degree_preserving_swap: directed double-edge swap with self-loop and duplicate checks [direct]
• src/connectome.py:102-115,145-184 Erdos-Renyi, weight shuffle, no-recurrence floor; same Dale sign vector and spectral normalisation for all conditions [direct]
• src/model.py:15-47 frozen reservoir, only inject/readout trainable [direct]
• src/run.py:93-95 same torch seed for every condition at a given seed [direct]
• results/results_cifar10.json: recomputed by us from the file: connectome 43.04% (n=15) vs degree-preserving 42.95% (n=15), gap +0.093 pp, Welch t = 0.66 (consistent with p = 0.51) [direct]

Limits Well-controlled negative result, with confounds (spectral radius, shared init, fixed signs) handled in code. Limits: one substrate, image tasks the larva never evolved for, excitatory/inhibitory signs assigned at random (dataset has no transmitter labels), n=15 resolves only d >= 1.02. Absolute CIFAR-10 accuracy (43%) is well below the BPU paper's 58%. The README's MNIST table and CIFAR table match the committed result files. Measured by the author, not reproduced by us.

More facts Data licence: article CC BY 4.0; no separate data licence found · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-12; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/cqw-acq/connectome-null-models [direct]
• https://networks.skewed.de/net/fly_larva [search-summary]

Project's own claim “A neural network wired like a fruit fly's brain, trained with gradient descent to play Doom; the connectome is treated as an inductive bias and the encoder, decoder and one gain per synapse are learned.” source

Mechanism Wiring: FlyWire v783, 138,639 neurons / 15.09 M edges, or MaleCNS 49k subgraph, 49,393 neurons / 9.05 M edges; wiring and synapse signs frozen, one learned log-gain per synapse. Neuron model: rate: leaky h <- (1-a)h + a*relu(scale*batchnorm(Wh+u)+shift), 5 steps, learned per-neuron per-step scale/shift. Input: learned (conv stem + MLP from 4 stacked 72x96 grey frames to currents on 10,855 visual sensory neurons). Output: learned (MLP decoder from central + descending + motor neuron states to 512 units, then policy/value heads over 22-23 actions with per-scenario masks and scenario embedding). Trained parts: encoder, decoder, heads, per-synapse gains, per-neuron scale/shift; distilled from PPO teachers (soft cross-entropy), then GRPO/RLOO fine-tuning. Body: none (ViZDoom first-person game). Scripted parts: none found in the policy; teachers are ordinary Stable-Baselines3 PPO CNNs.

Measured result (by the authors unless stated) Negative result. Distillation controls, step 60,000, 10 eval episodes per scenario (docs/controls.md): MaleCNS-49k connectome basic 78.2+/-7.5, defend_the_center 18.6+/-1.8, health_gathering 1728+/-616, deadly_corridor 2280.5+/-2.4, defend_the_line 21.0+/-5.9; degree-preserving shuffle seed 0: 78.2, 19.0, 1602, 2280.6, 21.7; seed 1: 78.2, 18.4, 1921, 2281.0, 22.2; no connectome (27.7 M vs 48.2 M params, 22x faster training): 77.5, 18.3, 1373, 2279.9, 23.0. All gaps inside one std. Free play on MAP01 after 500 GRPO iterations, 30 held-out episodes: mean return connectome 6.57, shuffled 6.71, no-connectome 7.39 (deaths 13, 14, 10 of 30). Training logs themselves are in S3, not the repo; the tables and held-out JSONs are. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• doomfly/connectome/build.py:1-54 downloads Shiu et al. Connectivity_783 and Schlegel annotations with SHA-256 checks, marks visual sensory inputs and central/descending/motor readout [direct]
• doomfly/model/flynet.py:135-168 5-step connectome dynamics between learned stem and learned decoder/heads [direct]
• doomfly/model/flynet.py:45-76,105-120 degree-preserving edge shuffle control and a no-connectome control (stem straight to decoder) [direct]
• doomfly/train.py:4,97 training loss is cross-entropy to the PPO teacher's policy (distillation) [direct]
• docs/controls.md:21-24 end-of-training table (10 eval episodes each): connectome, two shuffles and no-connectome score within one std on all five scenarios [direct]
• docs/results/freeplay_heldout_{conn,shuffled_s0,noconn}_{init,final}.json: 30 held-out Freedoom MAP01 episodes per backbone after GRPO; mean return conn 6.57, shuffled 6.71, no-connectome 7.39 (our recomputation from the episode lists) [direct]

Limits Well-controlled negative result: the fly wiring gives no measurable benefit over a degree-preserving shuffle or over removing the neuron layer; the learned conv encoder and MLP decoder (about two thirds of parameters) do the work. The controls were run on the MaleCNS-49k backbone only; the FlyWire v783 backbone has no shuffle control of its own. One training seed per condition (two shuffle seeds), 10-episode evals on saturated scenarios. The 'control' credited to this author by doom-fly-control corresponds to these 10-episode evaluations in docs/controls.md. Neurons are rate units, not spiking. The README says the project was built largely by an AI coding agent (Strands harness). Not the same project as nftechie/doomfly.

More facts Data licence: CC-BY-4.0 · Peer review: none (blog post) · GitHub stars: 0 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-18 (not an update date) · Last push, any branch: 2026-09-28; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/nonatofabio/doomfly-rl [direct]
• https://huggingface.co/fabiononato/doomfly-rl [not checked]
• https://nonatofabio.github.io/blog/posts/doomfly_autonomous.html [paper]

Project's own claim “"At 1 Hz the real wiring ranked first against 19 degree-preserving shuffles ... In closed loop it had the lowest mean RMS yaw rate of 11 wirings on both plants (p = 1/11 ...). The fly controller reduces yaw-rate RMS by 14-19% relative to the bare airframe; the classical yaw damper reduces it by 52-57%." (README)” source

Mechanism Wiring: FlyWire v783 subcircuit from the horizontal-motion T4/T5 cells to DNa02 and DNg02 (20,556 neurons, 251,358 edges), with all edges among the selected neurons. Neuron model: LIF with the Shiu et al. 2024 parameters, unchanged (scripts/brain.py SHIU dict: v_th -45 mV, t_mbr 20 ms, tau 5 ms, w_syn 0.275 mV), Brian2, dt 0.1 ms. Input: hand-made: horizontal T4/T5 cells are Poisson sources with rate = r_base + g * max(0, s * yaw rate), s set by eye and preferred direction (front-to-back motion per side). Output: hand-made: rudder = clip(K * washout(DNa02_R - DNa02_L - b), -1, 1), with the same 1 s washout as the classical damper; one gain K per controller chosen on tuning seeds by the same procedure. Trained parts: none (one scalar gain K per wiring and controller, selected by the same tuning procedure as the classical damper; test seeds 100-119 held out from tuning). Body: none (aircraft: JSBSim c172x 6-DOF and a linear 2-state Dutch-roll model, moderate MIL-spec Dryden turbulence). Scripted parts: the aircraft simulators, a wings-level roll hold on the 6-DOF model and the washout filter.

Measured result (by the authors unless stated) Open loop (Poisson seeds 0-4): DNa02 R-L follows yaw rate with coherence 0.968-0.998 up to 2 Hz; at 1 Hz the real wiring ranks first of 20 against degree-preserving shuffles (coherence 0.98 vs median 0.31) and, only just, against type-preserving shuffles (0.98 vs max 0.97). Closed loop (20 held-out seeds): RMS yaw rate on JSBSim 3.92 deg/s with no controller, 3.19 with the fly wiring, 3.31 for the best shuffle and 1.69 for a classical yaw damper; the real wiring is lowest of 11 wirings on both plants (p = 1/11). Lesion hypothesis untestable (no departures in 1,040 flights).

Grade basis (checked 5 Oct 2026)

• scripts/brain.py at d3fa996: SHIU parameter dict (line 39), T4/T5 Poisson source equations (lines 160-165), lesions as Shiu's silence() (lines 17, 183), rudder readout docstring (lines 264-273) [direct]
• scripts/nulls.py: degree- and sign-preserving shuffle by Maslov-Sneppen swaps of post endpoints (pre and w fixed), type-preserving variant with classes=(side, cell type), self-tests [direct]
• results/phase1_summary.md (auto-generated by scripts/analyze_phase1.py, 2026-10-04T14:52Z, 510 shard files): 1 Hz coherence real 0.98 vs 19 degree-preserving shuffles (median 0.309), rank 1/20, p = 0.05; gain 0.666 vs median 0.0751; vs 19 type-preserving shuffles 0.98 vs max 0.97, gain 0.666 vs max 0.609 [direct]
• results/phase2b_metrics.json (JSBSim, test seeds): mean RMS yaw rate bare 0.0685 rad/s (3.92 deg/s), fly_real 0.0558 (3.19 deg/s), fly_shuffle_00 0.0688; fly_shuffle_01 picked K = 0.268 and saturated the rudder in 99.97% of steps [direct]
• results/provenance.json: simulation commits per stage (phase 1: 510 files at e5f90c0; phase 2 test: 47 files at 393e70e; phase 3: 104 files at ab35844) [direct]

Limits A subcircuit, not the whole brain (a full-brain check exists in results/phase1_fullbrain_check.json, not read by us). The input is a hand-made yaw-rate to T4/T5 rate map, not images. The fly controller is far weaker than a classical yaw damper (14-19% vs 52-57% reduction), and against type-preserving shuffles (inputs to HS, VS, H2 and DNa02 kept) the real wiring wins only narrowly. In the seed-100 replays the right DNa02 fired no spikes, so the rudder came from one cell. Ten closed-loop shuffles give a minimum p of 1/11. One author; not peer reviewed; repository created 2026-10-04. Relevant to our looming test: an independent, pre-registered Shiu-model study in which DNa02 steering depends on the wiring.

More facts Data licence: FlyWire v783 derived subcircuit (CC BY 4.0, as stated in the README) · Peer review: write-up in the repository and the app; Zenodo DOI 10.5281/zenodo.23156035 (README badge); the last commit typesets it for bioRxiv, not found posted by us · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/aryawidjaja/flight-test-the-fly [direct]
• https://github.com/aryawidjaja/flight-test-the-fly/blob/main/paper/paper.pdf [paper]

Project's own claim “A frozen language model with a trained readout of the MaleCNS v1.0 fly connectome: 166,700 retained nodes and 25,582,938 directed connections.” source

Mechanism Wiring: MaleCNS v1.0, 166,700 nodes / 25.6 M edges, incoming-normalised contact counts. Neuron model: rate: abstract x = tanh(W(0.6x + 0.4 input)), one update per token. Input: hand-made (fixed seeded random projection of token embeddings onto nodes). Output: learned (seeded random pooling, then a trained 278,528-parameter adapter). Trained parts: adapter only; LLM backbone and graph frozen. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) Paper (3 fit seeds, 32 confirmation conversations, 1,236 target tokens), NLL nats/token: frozen backbone 1.381995; fly readout 1.359816 +/- 0.000110; matched direct-input control 1.359328 +/- 0.000108; relabelled wiring without refit 1.381265; no edges 1.381995. Fly minus direct-input 95% bootstrap +0.000005 to +0.00104 (control slightly better). Source: paper web page, not a file in the repo. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• scripts/prepare_graph.py:20-23,69 downloads MaleCNS v1.0 feather files from flyem-male-cns bucket with SHA-256 checks, manifest release 'MaleCNS v1.0' [direct]
• flm/graph.py:42-90 Reservoir: tanh recurrence over the full graph; modes 'intact', 'no_edges', 'shuffled' (node relabelling, docstring says it is NOT a random-graph control) [direct]
• flm/graph.py:75 project_input = matched direct-input baseline with no fly graph computation [direct]
• scripts/train_conversation.py:142,160 trains fly adapter and direct-input control side by side; reports base, fly_adapter, direct_input_adapter, relabeled_wiring on held-out test [direct]
• https://artificialscientific.com/papers/flies-are-all-you-need results table: direct-input control 1.359328 vs fly 1.359816 NLL [direct]

Limits Negative result: the fly graph changes predictions but a parameter-matched adapter without the graph does as well or slightly better, so no advantage from fly anatomy is shown. The only wiring control is a node relabelling without refit, which the code itself says is an interface check, not a random-graph control; there is no degree-preserving shuffle. The headline numbers come from a separate 'frozen study' whose per-token results and fitted artifacts are private; the repo only has the development recipe (it trains the same controls on dev splits). The 'neurons' are abstract tanh units, not spiking. Language ability comes entirely from the frozen LLM (README uses LFM2.5-1.2B via conversation_config; paths.py still names SmolLM2-135M as legacy). Paper lists an AI agent (Codex) as co-author. Measured by the author, not reproduced by us.

More facts Data licence: CC-BY-4.0 · Peer review: preprint · GitHub stars: 91 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-11 (not an update date) · Last push, any branch: 2026-09-11; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/nftechie/flm [direct]
• https://artificialscientific.com/papers/flies-are-all-you-need [direct]

Project's own claim “A simulated fly circuit recognizes printed letters and numbers from PDF pixels.” source

Mechanism Wiring: MaleCNS v1.0, 166,700 neurons / 25,582,938 connections, frozen. Neuron model: LIF-type spiking point neurons (native C++ kernel adapted from DOOMFLY; tests compare against Brian2). Input: hand-made (image pixels -> retinal receptor map -> photoreceptor/lamina drive). Output: learned (decoder on spike counts of up to 1,024 variance-selected downstream neurons). Trained parts: readout/decoder only (letters: 64 hidden units, 266,628 parameters; digits: logistic regression). Body: none. Scripted parts: segmentation, normalisation, word gaps and table geometry are conventional code outside the circuit.

Measured result (by the authors unless stated) Final letter model: 87.6% on 1,632 glyphs (68 classes), 85.0% on letters; mismatched features 2.3%. Digit task (docs/results.md): fly 89.0% vs raw-pixel linear 99.0%, retinal-samples linear 91.8%, CNN 100%. Digit pilot controls (reports/controls/, n=200): intact 82%, edges removed 10%, three degree-preserving rewirings with retrained heads 65.0% / 63.5% / 54.5%. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• configs/malecns-v1.json: release 'MaleCNS v1.0', feather URLs with SHA-256 [direct]
• src/flyocr/experiments/controls.py:1,47-48 degree-preserving target permutation with in-degree assertion, heads retrained per seed (41-43) [direct]
• reports/controls/controls.json: edge lesion 10% (20/200); randomized seed 41: 65% (130/200) [direct]
• docs/results.md:7-16 fly digits 89.0% vs raw-pixel linear 99.0%, retinal samples linear 91.8%, CNN 100%, shuffled labels 10.4% [direct]
• docs/research-report.md:176-178 intact pilot 82% vs rewired 65.0/63.5/54.5%; mismatched labels 2.3% on 68-class benchmark [direct]

Limits Controls are real and in code, but the wiring control (rewiring) was run only on a 200-image digit pilot, not on the final letter model; rewiring also changes activity scale, which the author flags. Plain pixel classifiers beat the fly circuit (99-100% vs 89% on digits), so no advantage from the connectome is claimed. The decoder is trained; input mapping and segmentation are engineered. The 3D fly in videos is illustrative animation. Measured by the author, not reproduced by us.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 90 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-13 (not an update date) · Last push, any branch: 2026-09-13; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/jerryjliu/fly_ocr [direct]
• https://github.com/jerryjliu/fly_ocr/blob/main/docs/fly-ocr-research-report.pdf [paper]

Project's own claim “The measured wiring of a fruit fly, run as a recurrent network and trained to steer from a 64 x 32 windscreen; on held-out streets with traffic it completes 20, 19 and 19 of 20 (58/60).” source

Mechanism Wiring: MaleCNS v1.0 traced graph, 165,122 neurons, 25,563,197 edges; adjacency fixed. Neuron model: rate: signed rate state, 4 graph updates per 50 ms decision, state carried between decisions (flyhard recipe). Input: hand-made (frozen seeded random signed pixel map onto 4,114 optic-lobe sensory neurons). Output: hand-made (frozen random linear readout from 708 VNC motor neurons, tanh to steering). Trained parts: All 25,728,319 per-synapse gains and per-neuron leaks, by truncated BPTT behaviour cloning then 3 DAgger rounds against a pure-pursuit expert. Only the topology comes from the fly.. Body: none (simulated car; FlyGym only in the reproduced wheel pilot). Scripted parts: The expert teacher is scripted. The Blender video is a replay of logged state. No braking behaviour was learned..

Measured result (by the authors unless stated) Street task v5 with traffic, held-out streets: fly connectome + DAgger 20, 19, 19 of 20 (three sets); same recipe on a randomly rewired graph 16/20; linear 12/20; MLP-40 18/20; expert 20/20 (docs/results.md). Speed task v6: 18/19/16 of 20 vs rewired 5/20, but a second training seed gave 13/20. Flat road: rewired graph matched or beat measured wiring, MLP beat both. One training seed per condition. The best-model and rewired street metrics are in docs only, not in results/ JSON. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• tasks/street/train_street.py:1-9 docstring: measured adjacency frozen, per-edge gains and leaks train, frozen random interfaces; '--graph-mode shuffled is the control' [direct]
• tasks/street/train_street.py:26-47 StreetPolicy: SparseConnectome core, random pixel->sensory map and random motor decoder as fixed buffers, 4 updates per decision [direct]
• tasks/street/train_street.py:171,204-205 shuffled mode permutes column indices of the graph with a fixed seed [direct]
• tasks/flat-road/mlp_baseline.py and tasks/street/train_street.py --model linear/mlp: non-connectome baselines (file present, not opened)
• results/street/street-v5-measured-stateful.json: graph sha256 eff4093b..., 25,728,319 trainable params, cloning-only 12/20 with traffic, 20/20 without [direct]
• results/street/street-v4-linear.json, street-v4-mlp40.json: v4 task baselines complete 1/20 with traffic [direct]
• docs/results.md: DAgger w16 20/19/19 of 20 vs rewired graph 16/20, linear 12/20, MLP-40 18/20; flat-road task rewired graph matched or beat measured [direct]

Limits A proper wiring control and non-connectome baselines exist in code, but the gap is small and fragile: one training seed per condition, 20 streets per set, and a second seed on the speed task dropped to 13/20. On the first task the rewired graph did as well and an MLP did better. All 25.7 M synaptic gains are trained, so the fly supplies only the topology, with random, non-biological input and output maps. The stored JSON baselines (v4, 1/20) do not match the v5 baseline numbers in the docs, and the headline and rewired street results are not stored as JSON. The browser site replays logged runs; it does not run the network. Built on flyhard by Mark Unthank (MIT) with patches, but adds new tasks and controls, so not a plain copy. Not a copy of a catalogued project.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 28 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-13 (not an update date) · Last push, any branch: 2026-09-13; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/suanmiao/fly-self-driving [direct]
• https://fly-self-driving.kylon.app [not opened]

Project's own claim “The circuit a fly uses to keep its balance in the air balances the pole: wired from MaleCNS v1.0, 5,459 neurons, no backpropagation; learning only changes five sensor gains.” source

Mechanism Wiring: MaleCNS v1.0 flight-stabilisation circuit (ocellar, haltere, HS cells to wing-amplitude motor neurons), couplings from synapse counts; never changed by learning. Neuron model: rate: linear rate units with leak, settled each step. Input: hand-set: pole angle and drift onto ocellar neurons, pole angular rate onto haltere neurons, cart velocity onto HS cells as optic flow, by side. Output: hand-set: right minus left wing-amplitude motor activity steers the cart. Trained parts: three sensor gains (five with the landmark task) by reward-modulated random search; learning rates from the author's tuning search. Body: none (Gymnasium CartPole). Scripted parts: CartPole physics and reward are Gymnasium's; the reward signal is computed outside the circuit.

Measured result (by the authors unless stated) CartPole mean episode length over the final 100 episodes, 20 fresh seeds (results/linear-retuned/summary.md at a8c6257): self-tuned flight circuit 499.9 ± 0.3, the same circuit with degree-preserving shuffled wiring 165.9 ± 182.8 (author's permutation p = 0.0001), untuned circuit 275.6, the circuit's own linear map tuned the same way 499.6 (p = 0.18), LQR 500.0, random pushes 22.1. Past the 500-step cap the circuit holds station better than its linear map (0 vs 8 track exits of 200) but worse than LQR. The earlier mushroom-body version learned no better than shuffled wiring (392.5 vs 390.3, p = 0.48). Numbers are the author's; not recomputed by us this run.

Grade basis (checked 3 Oct 2026)

• README.md 'Results' at a8c6257 (2026-10-03): the headline experiment is now the flight-stabilisation circuit [direct]
• results/linear-retuned/summary.md at a8c6257: per-seed final-100 means, seeds 160-179: fly-reflex 275.6 ± 9.4, fly-reflex-adaptive 499.9 ± 0.3, fly-reflex-adaptive-shuffled 165.9 ± 182.8, random 22.1 ± 0.8, linear-adaptive 499.6 ± 0.7, lqr 500.0; permutation p: adaptive vs shuffled 0.0001, adaptive vs linear map 0.1797 (two-sided) [direct]
• src/fly_cartpole/reflex.py shuffle_flight + circuit.py shuffle_edges: degree-preserving directed double-edge swaps, couplings travel, sensor and motor identities kept; reflex_report.py line 196 shuffles once per evaluation seed [direct]
• results/lqr-station/summary.md: holding station past the 500-step cap, circuit 0 of 200 track exits vs its linear map 8 of 200; LQR 0.03 m from centre vs circuit 0.12 m [direct]
• results/summary.md (unchanged since 3f676bb, 2026-10-01): the earlier mushroom-body study, fly-bilateral 392.5 vs shuffled 390.3, p = 0.4771 [direct]

Limits Re-graded 2026-10-03 after a redesign: the author's headline is now a MaleCNS flight-stabilisation circuit, and shuffling its wiring does hurt (165.9 vs 499.9). But balancing needs no more than a small linear controller: the circuit's own linear map scores the same and LQR reaches 500 without learning, so the wiring matters mainly through its pathway signs (the author's reading). The real arm sits at the 500-step ceiling. Neurons are linear rate units and the mapping from CartPole to the fly's senses is the author's own; the author says none of this is evidence about real flies. The earlier mushroom-body study (no wiring effect) remains in the repository.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 1 (5 Oct 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-29 (not an update date) · Last push, any branch: 2026-09-30; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Curt-Park/fly-cartpole [direct]

Project's own claim “on our tasks the connectome showed no advantage whatsoever over a controller two lines long” source

Mechanism Wiring: FlyWire v783 full brain via Shiu et al. model (pinned commit). Neuron model: LIF. Input: hand-made (Poisson drive to 150 left / 155 right head-bristle mechanosensory neurons). Output: hand-made (left minus right spike count over 645/646 descending neurons; 3 readout constants grid-searched on calibration seeds to agree with the two-line rule). Trained parts: none (readout constants chosen by grid search). Body: FlyGym. Scripted parts: walking comes from the stock FlyGym hybrid turning controller (CPG + reflexes); brain only sets speed/turn drives every 15 ms.

Measured result (by the authors unless stated) Test seeds (30 per condition): connectome 30/30 on no-stimulus, turn-left and turn-right; two-line rule 30/30 on each (difference 0, conservative 95% interval +/-13.6 pp); replay of another episode 0/30 on each; five degree-preserving shuffles: 30/30 no-stimulus, 0-30/30 left (mostly a constant bias), 0/30 right. Shuffled minus connectome: -69 pp (left, fixed readout, hierarchical bootstrap [-96, -40]), -47 pp after readout recalibration ([-87, -8]), -100 pp (right). Files: results/cd-test-v1/, results/e-compare-*-v1/summary.json. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• brain_loop.py:28-62 shuffle_edges: double-edge swap preserving in/out degree per sign, weight multiset, no self-loops or duplicates; :64-80 self-check asserts these [direct]
• brain_loop.py:85-105 shuffled_connectivity on Connectivity_783; results/shuffled-connectivity-4000.json: 99.997% of 15,091,983 edges changed [direct]
• brain_loop.py:139-155 loads Completeness_783/Connectivity_783, head-bristle inputs, all descending neurons as readout [direct]
• pilot.py:34 policies C (connectome), D (replay of another episode), E (shuffled) [direct]
• results/cd-test-v1/compare-C-vs-B-ab-test-v1/summary.json: C 30/30 and B 30/30 on none/left/right [direct]
• results/e-compare-fixed-v1/summary.json: left E-minus-C -0.69, bootstrap 95% [-0.96, -0.40]; results/e-compare-recal-v1/summary.json: -0.47 [-0.87, -0.08] [direct]

Limits Careful, pre-registered negative result: connectome equals a two-line rule on tasks that need one bit; live activity and real topology are needed for the lateralised pathway in this assembly. Tasks are very simple (1 s episodes, turn toward a touch); stopping is not tested for the brain. Readout constants were tuned to agree with rule B on calibration seeds. Brain pass is computed separately from the body (open loop), shown bit-exact for these stimuli. Gait is entirely the stock FlyGym controller. A side SAT/reservoir experiment reports 95-99% decodability on real vs 68-73% on shuffle (docs/sat-experiment.md). Measured by the author, not reproduced by us.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 2 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-18; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Recluse/FLY-lab [direct]
• https://github.com/Recluse/FLY-lab/blob/main/paper/fly-lab-en.pdf [paper]

Project's own claim “"该 LIF 简化模型 + 静态连接组配置,不承载可用的视觉伺服信号。" ("This simplified LIF model with the static connectome does not carry a usable visual-servo signal.") and the pre-registered verdict "fly 相对零模型 shuffle 无显著优势 (p=1.0000)" ("no significant advantage of fly over the shuffle null") (README)” source

Mechanism Wiring: MaleCNS v1.0 whole CNS, signed CSR matrices W_exc and W_inh (rows postsynaptic), never densified. Neuron model: other: discrete-time LIF (dt 4 ms, tau_m 20 ms, threshold 1.0, refractory clamp; flyaim/brain/lif.py, flyaim/config.py), not the Shiu model. Input: hand-made: an encoder maps screen pixels to ommatidium illumination of the real photoreceptor cells (superclass ol_sensory); colour channels approximate. Output: learned: a readout from the 1,360 descending neurons to 2-D crosshair velocity. Trained parts: the readout (frozen-random, retrained in the game domain, or gradient-trained in later arms); in the plasticity arm also connectome weights by a three-factor rule; the ANN arms train a connectome-shaped RNN by behaviour cloning and DAgger. Body: none (a 2-D aiming arena; later a bridge that injects mouse movement into Aim Lab). Scripted parts: the arena and target respawn, the PID and random baselines, the eye-servo replacement controller.

Measured result (by the authors unless stated) Mean distance from crosshair to target over 10 seeds x 900 frames (lower is better): real MaleCNS wiring 412.5 px, shuffled wiring 430.9 px (not different, p = 0.66), uniform random walker 251.7 px, PID with target access 155.8 px. Hit rate 0 for both network arms. A plasticity arm and gradient-trained readouts were also negative (pre-registered gates failed).

Grade basis (checked 5 Oct 2026)

• flyaim/baselines/shuffle.py at 15d800f: shuffle null permutes CSR column indices, keeping every neuron's out-degree and the weight multiset; 'global' mode also keeps the in-degree multiset and shared E/I targeting [direct]
• flyaim/brain/lif.py header and flyaim/config.py: LIF equations, dt 4 ms x 8 steps per frame, tau_m 20 ms [direct]
• flyaim/runs/20261003-195410-phase3/REPORT.md (generated by flyaim/report.py): 10 seeds x 900 frames, mean target distance fly 412.5 px, shuffle 430.9, PID 155.8, random 251.7; verdict 'no causal contribution of the wiring' (p = 1.0) under the rule registered in CONTRACT.md section 3 [direct]
• flyaim/runs/plastic/verdict.json: three pre-registered gates failed (real plastic 432.9 px vs frozen 430.6; shuffle plastic 432.2, p 0.68; tail slope CI includes 0) [direct]
• README: paired tests fly vs random +160.8 px (p 0.0069), fly vs shuffle -18.4 px (p 0.66); gradient-trained (DAgger) arm 391 px vs random walk 278 px (p 0.012) [README; the first two traced to the REPORT above, the DAgger figure not checked against flyaim/runs/ann-dagger/verdict.json]

Limits A clean pre-registered negative result for one simplified model: discrete-time LIF with a 4 ms step, not the Shiu model, and an image encoder onto photoreceptors that the author calls a design choice. The README's hit rate is a flat metric by the author's own analysis (ceiling about 6%); mean target distance is the working metric. The later eye-servo success bypasses the connectome entirely and must not be read as a fly result. Chinese-language documentation; one author group; created 2026-10-03 and still changing.

More facts Data licence: MaleCNS v1.0 (CC BY 4.0, as stated in the generated report) · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/0Sakura721/flyaim [direct]

Project's own claim “Does the simulated fly still do the things a real fly is known to do?” source

Mechanism Wiring: FlyWire v783 (139,255 neurons, >=5 synapses) and MaleCNS v1.0 (neuPrint male-cns:v1.0). Neuron model: LIF (Shiu 2024 reference; also adaptive LIF and terminal-aware LIF variants). Input: hand-made (named cell types driven at set rates; optional flyvis front end for vision). Output: hand-made (named readout neurons, e.g. MN9, giant fiber, TTMn). Trained parts: none in the brain; flyvis front end is a pretrained published model. Body: FlyGym (optional embodied tasks 33-36). Scripted parts: embodied tasks: TTMn/GF spikes trigger a fixed middle-leg extension (jump) program.

Measured result (by the authors unless stated) From results/*.json (LEADERBOARD.md): reference LIF on FlyWire v783, gain 0.45, 3 seeds: core 1.00, hard 0.51, graded 0.64 [0.64, 0.65], shuffled-wiring specificity +0.20. Shiu 2024 settings (gain 1.0): graded 0.63, specificity +0.18, ~34% of brain active. Adaptive LIF: graded 0.75, specificity +0.31. MaleCNS gain 0.65 (Minecraft demo settings): core 0.57, graded 0.66, specificity +0.22. Terminal-aware LIF: 0.70 on both brains. Through a flyvis eye the loom does not reach the giant fiber (0/3) while a flash does. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• flybench/controls.py:59-78 rewire_degree_preserving (permutes postsynaptic endpoints, keeps out-degree, weights, signs); :81-91 Erdos-Renyi matched; :94-105 sign shuffle [direct]
• flybench/bench.py:881-901 runs each task on control connectomes, specificity = score(real) - max(score(control)), flags non_diagnostic [direct]
• flybench/models/reference_lif.py:27-29,42 LIF parameters with provenance [direct]
• results/flywire783_gain0.45.json specificity 0.1998, graded 0.644; results/shiu2024.json specificity 0.180; results/malecns-gain-0.65.json specificity 0.219 [direct]
• pyproject.toml:7 version 0.2.1; CHANGELOG.md 0.2.1 dated 2026-09-24 [direct]

Limits A benchmark, not a single demo; results are a leaderboard of parameter settings. Most rows are 'self-reported' by the maintainer, who also wrote the reference and adaptive models (declared in the table). The 'rewired' control permutes edge targets (configuration-model style), so in-degree is kept only as an endpoint multiset and duplicates are merged; it is not a strict double-edge swap. Specificity is only computed for rows where controls were run. Tasks measure listed cited manipulations, not overall realism. Zenodo DOI is a software archive, not a paper. Measured by the author, not reproduced by us.

More facts Data licence: several (see dataset entries) · Peer review: none · GitHub stars: 2 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-10 (not an update date) · Last push, any branch: 2026-09-24; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/brandoncho369/flybench [direct]
• https://www.fly-bench.com/bench [direct]
• https://doi.org/10.5281/zenodo.22886374 [paper]

Project's own claim “Benchmarking a whole-brain connectome model of Drosophila against experimental data: diagnosing knockout-prediction failures and a candidate excitatory role for the water-taste neuron Usnea” source

Mechanism Wiring: Whole FlyWire v783 brain as used by Shiu et al.. Neuron model: spiking: Shiu et al. leaky integrate-and-fire, NumPy/SciPy port validated against the Brian2 original. Input: hand-set: literature-defined sensory neuron sets (sugar, water, bitter GRNs, JO, LC4, LPLC2, ORNs) at 150 Hz Poisson. Output: read-out of named neurons (MN9, aBN1, giant fiber, PNs) scored against pre-set thresholds. Trained parts: none. Body: none. Scripted parts: none.

Measured result (by the authors unless stated) Pre-registered benchmark v2 (benchmark/results/bm2_scores.json, variant D0): the model predicts published single-neuron knockout effects with sensitivity 0.769 and specificity 0.989 (balanced accuracy 0.879); 11 of 17 activation-change criteria and 3 of 3 grooming-rate criteria pass. The author proposes that the water-taste neuron Usnea is excitatory. No shuffled-wiring control. Measured by the author, not reproduced by us.

Grade basis (checked 30 Sep 2026)

• README.md:3-12 preprint, contents, model/flybrain.py re-implementation of Shiu LIF validated against Brian2 [direct]
• benchmark/BENCHMARK_PLAN.md:1-30 pre-registered criteria written 2026-09-25 before simulation (F1-F9 feeding, G1-G2 grooming, E1-E2 escape, O1 smell, N1 navigation) with literature sources [direct]
• benchmark/results/bm2_scores.json key D0.A_primary: knockout prediction sensitivity 0.769, specificity 0.989, balanced accuracy 0.879; D0.B_pass 11/17; D0.C_pass 3/3 [direct]
• benchmark/results/: raw_bm2..4 and results_raw*.jsonl committed simulation outputs [direct]

Limits A careful test of the model against fly data rather than a demo: criteria were fixed before the runs, and failures are reported. It tests the Shiu model with its original parameters, so it says how far the model can be trusted, not whether wiring beats a scrambled copy (there is no wiring null). Some scripts still use absolute Windows paths. Plan files are partly in Thai.

More facts Data licence: CC-BY-NC-4.0 · Peer review: Zenodo preprint · GitHub stars: 0 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-28 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/vichienFF/flybrain-connectome-benchmark [direct]
• https://doi.org/10.5281/zenodo.23025560 [paper]

Project's own claim “Is a real fly brain a better reservoir computer than random wiring? ... Short answer: no, and it replicates on FlyWire.” source

Mechanism Wiring: MaleCNS v1.0 whole CNS (166,700 neurons) and a 3,000-neuron sensory-grown subgraph; FlyWire 783 whole brain (~139k neurons). Neuron model: rate. Input: hand-made. Output: learned. Trained parts: linear ridge readout only (standard for reservoir computing); recurrent weights fixed, rescaled to spectral radius 0.9. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) Negative result against random-wiring controls. Memory capacity (readout noise), whole MaleCNS CNS at standard gain: connectome 2.2, degree-preserving 15.5, weight shuffle 2.4, sign shuffle 2.9, Erdos-Renyi 7.4 (README.md:96); at each wiring's best gain 2.9 vs 22.8 / 2.9 / 3.1 / 30.8 (README.md:145). 3,000-neuron circuit best gain: 6.7 vs 6.0-7.4, a tie (README.md:144). FlyWire 783 whole brain: 3.0 vs 21.8 and 72.4 (README.md:354). NARMA-10 NRMSE whole CNS: 0.77 vs 0.42 (degree-preserving) and 0.48 (ER) (README.md:276). Markets: Sharpe differences at most 0.06, all CIs include zero (README.md:79-85). Volatility 5-day: all wirings about -16.5% to -17.1% log MSE vs HAR, linear HAR+inputs -14.9% (README.md:400-405).

Grade basis (checked 28 Sep 2026)

• src/flyres/connectome.py:38-42 MaleCNS v1.0 flat-connectome files; :11-15,49 FlyWire release 783 [direct]
• src/flyres/reservoir.py:3 leaky-tanh ESN x[t]=(1-a)x[t-1]+a*tanh(W x + W_in u + b) [direct]
• src/flyres/controls.py:26,64,113,128 degree-preserving rewire, Erdos-Renyi, weight shuffle (plus sign shuffle) [direct]
• configs/full.yaml:7-12 and configs/flywire_full.yaml:7-12 same five wirings, 10 seeds [direct]
• README.md:79-85 market: IC ~0.015, Sharpe 0.42-0.51 vs 0.59 buy-and-hold, all bootstrap CIs for differences include zero [direct]
• README.md:93-98 memory capacity with readout noise, whole CNS: connectome 2.2 vs degree-preserving 15.5, ER 7.4 [direct]
• README.md:142-145 best valid gain, whole CNS: 2.9 vs 22.8 (degree-preserving) and 30.8 (ER) [direct]
• README.md:350-355 FlyWire 783 whole brain: 3.0 vs 21.8 and 72.4 [direct]
• README.md:398-407 volatility 5-day log MSE vs HAR: connectome -16.5%, controls -16.5% to -17.1%, linear HAR+inputs -14.9% [direct]

Limits A well-controlled negative result: five wirings, several seeds, several benchmarks, two connectomes. The numbers are taken from the README tables; the result folders are not in the repo, but the configs pin data dates and seeds so they can be rerun. It is an abstract rate reservoir (tanh units, one global gain, spectral radius 0.9), not a biophysical fly model, so it tests the wiring graph, not fly behaviour. The whole-brain result depends on dense hub clusters that set the spectral radius; the author discusses this. FlyWire connectivity comes from Shiu et al.'s Connectivity_783 table. Small count mismatch: config says 139,248 FlyWire neurons, connectome.py says 139,255 (probably after filtering). Whole-CNS runs need ~32 GB RAM. Licence: LICENSE file is MIT (API says NOASSERTION).

More facts Data licence: several (see dataset entries) · Peer review: none · GitHub stars: 2 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-21 (not an update date) · Last push, any branch: 2026-09-26; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/MilanKalajdzic/flybrain-reservoir [direct]

Project's own claim “A fruit fly's brain plays Doom: the FAFB v783 wiring diagram is simulated, shown Doom through the fly's eyes, and keypresses are read from descending nerves” source

Mechanism Wiring: FAFB v783 whole brain (connections_princeton_no_threshold with own threshold, NT-signed). Neuron model: LIF plus graded (non-spiking) cells, with compartment options. Input: hand-made: 1,581 ommatidial columns to 4,541 lamina L1/L2/L3 inputs; olfaction and mechanosensation channels. Output: hand-made: DNa02 L-R to turn, BPN forward / MDN backward, DNp01 lateral, Schmitt-triggered buttons. Trained parts: none; one global synaptic gain calibrated on a non-visual reflex. Body: none (Doom player), with a custom fly-scale arena. Scripted parts: motion-detection front end (EMD-like) and game arena design; no aiming or game-state shortcuts found in the files inspected.

Measured result (by the authors unless stated) Measured by the author, not reproduced by us. In a visible arena it beats a command-matched random agent on health and survival, and mirroring the eyes removes that advantage. Smell beats a shuffled brain by about 1000x. Sugar drives proboscis extension (77 Hz) and bitter suppresses it by 99%. Motion detection reaches about 2% of a real fly's, and there is no optomotor counter-turn, looming escape or fixation (README scorecard, paper/data).

Grade basis (checked 28 Sep 2026)

• flydoom/sources.py:1-30 documents the FAFB v783 file inventory used (classification, cell types, connections_princeton_no_threshold) [direct]
• flydoom/motor.py:1-25 DN population rates map to ViZDoom DELTA and Schmitt-triggered buttons [direct]
• experiments/m9_behaviour.py:557, 718-726 comparison with an AR(1)-matched random agent [direct]
• experiments/m10_klinotaxis.py, m13_odour_square.py, m18_stripe.py and others use shuffled-wiring controls [direct]
• paper/data/behav_*/fly_{intact,mirrored,frozen,nosmell}_shards: raw results for the control arms [direct]

Limits This is a distinct project from eganeganegan/flydoom: different author, tree and files, with 2 identical blobs out of thousands, and eganeganegan's project uses MaleCNS. The grade rests on the controls present in the code and results files, not on game skill. The author reports that vision helps only narrowly and in one purpose-built arena, and that classic fly reflexes are absent. It runs at about half real time. Only a short inspection was done; the paper was not read.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none (26-page PDF at paper/main.pdf in the repository, not peer reviewed) · GitHub stars: 8 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-08-20 (not an update date) · Last push, any branch: 2026-09-27; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/mutkuoz/flydoom [direct]
• https://github.com/eganeganegan/flydoom [direct]

Project's own claim “"The leaky integrate-and-fire model of Shiu et al. (2024, Nature), built on the FlyWire v783 connectome, is bistable ... about 8,100 neurons keep firing for at least 10 s without input." (README)” source

Mechanism Wiring: FlyWire v783 whole brain, as in Shiu et al. 2024. Neuron model: LIF (Shiu et al. parameters; an exact batched float64 re-implementation plus the original Brian2 model.py for replication). Input: Poisson drive of sugar GRNs, olfactory glomeruli, Johnston's organ or visual neurons (engine/stimuli.py). Output: MN9 rate and the number of active neurons per time bin. Trained parts: none. Body: none. Scripted parts: none.

Measured result (by the authors unless stated) After a strong sugar pulse, about 8,100 neurons stay active for at least 10 s without input in the original Brian2 model and in the re-implementation (identical counts on 3 seeds); none without the pulse.

Grade basis (checked 2 Oct 2026)

• README.md, prereg/GATE_PLAN.md (written 2026-09-24 'BEFORE any run'), results/g1c_brian2.jsonl, results/g1c_fast.json, results/e2_persistence.json at 07b01c8 (2026-10-01), read 2026-10-02 from a depth-1 blobless clone [direct]
• g1c_brian2.jsonl: in Shiu et al.'s own Brian2 model, seeds 8101-8103, a first pulse at s1 = 1.2 leaves 8,054-8,179 neurons active in every later bin after the input stops, against 0 with s1 = 0 (the pre-registered control); the fast engine gives identical counts (g1c_fast.json) [direct]
• e2_persistence.json: fresh seeds 8211-8215, about 8,150-8,200 neurons active in each of ten 1 s bins after the pulse [direct]

Limits A claim about the model, not about fly behaviour: grade A because a pre-registered control (no first pulse) and a replication in the original Brian2 code are in the result files. Relevant to Build your own: our 1 s sugar trials at 150 Hz (21 GRNs) stay at about 380 active neurons, below this attractor's regime; longer or stronger drives may not. The paper itself is not linked from the README.

More facts Data licence: FlyWire data: see the Shiu et al. repository terms (not redistributed here) · Peer review: paper (venue not stated) · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-25 (not an update date) · Last push, any branch: 2026-10-01

Sources

• https://github.com/xiangdoz/fly-connectome-attractor [direct]

Project's own claim “The fly brain isn't what's playing DOOM: a constant turn-right, walk, shoot autopilot survives as long as the untrained spiking fly (52 s vs 53 s), and trained agents score the same with real, random or no wiring.” source

Mechanism Wiring: Upstream projects' graphs: MaleCNS v1.0 full graph (166,700 neurons, 25.6 M edges) for DOOMFLY; a 49,393-neuron MaleCNS subset inside doomfly-rl; FlyWire v630 for the Shiu model. Neuron model: LIF (DOOMFLY's own NativeBrain kernel and the Shiu Brian2 model, both unchanged); doomfly-rl's trained network as published. Input: hand-made (DOOMFLY retina sampling, unchanged) / learned (doomfly-rl CNN encoder). Output: hand-made (DOOMFLY fixed 'bci' decoder, unchanged) / learned (doomfly-rl policy head). Trained parts: none added by this project; doomfly-rl arms are re-trained end to end by the author with each wiring. Body: none. Scripted parts: the 'spray' arms are a deliberately brainless fixed autopilot used as a control.

Measured result (by the authors unless stated) Untrained DOOMFLY (combat_survival): real wiring 53.3 s survival and 12.1 kills (n=20); shuffled wiring 6.7 s (n=12, 3 seeds); no connections 5.5 s (n=8); blind 10.5 s (n=8); brainless autopilot with the fly's average turn/forward 51.9 s and 11.75 kills (n=20). doomfly-rl: real, shuffled and no-wiring arms score the same across 5 ViZDoom scenarios (100 games each); rewiring after training collapses performance. Shiu model: sugar drives MN9 at 66 Hz with real wiring, 0 Hz shuffled. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• src/run_a2.py:1-11 arms for DOOMFLY: real graph.npz, shufK (postsynaptic targets permuted, presynaptic neuron and weight kept), blind (photoreceptors zeroed), noconn (all weights zero) [direct]
• src/run_a2.py:31-66 uses DOOMFLY's NativeBrain, retinal_samples and NeuralControls(mode='bci') unchanged; SPRAY arm = fixed turn/forward with trigger held, no brain [direct]
• results/a2/summary.json: real n=20 survival 53.3 s, 12.1 kills; shuffled (3 seeds pooled) n=12 6.7 s; noconn n=8 5.5 s; blind n=8 10.5 s; spray_matched n=20 51.9 s, 11.75 kills [direct]
• results/a1/summary.json: doomfly-rl, 100 seed-matched games per arm; e.g. basic real 80.57 vs shuf0 80.72 vs noconn 80.72 (Welch p 0.92); rewired after training -148.44 [direct]
• results/shuffle_check.json: shuffle verification for the 49,393-neuron graph (about 1.3% of shuffled edges coincide with real edges) [direct]
• partB/summary.json: Shiu model, sugar 100 Hz -> MN9_L 66.1 Hz (30 trials) with real wiring; bitter -> 0 Hz; shuffled arms in the same file [direct]

Limits A control study, not a demo: its result is negative for the claim that the fly wiring plays DOOM. The matched autopilot's turn and forward constants are taken from the real fly's average output, so it shows the behaviour is reproducible by a constant policy, not that no policy could exist. Shuffled-wiring arms are small (4 runs per seed) and shuffled brains are much quieter overall, so an activity-matched null is still missing (the author says so). Upstream code is not redistributed; reproduction needs three other repositories. Measured by the author, not reproduced by us.

More facts Data licence: FlyWire FAFB: CC-BY-NC-4.0; MaleCNS: CC-BY-4.0 · Peer review: none · GitHub stars: 1 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-27 (not an update date) · Last push, any branch: 2026-09-27; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/gabrycina/doom-fly-control [direct]
• https://github.com/nftechie/DOOMFLY
• https://github.com/nonatofabio/doomfly-rl

Project's own claim “What the null model preserves at the sensory-motor boundary changes the outcome of an evolutionary comparison between a FlyWire v783 connectome brain and randomised wiring.” source

Mechanism Wiring: subset: FlyWire v783 without optic lobes, aggregated to 512 cell-type groups (chosen by sensory-to-descending path score plus mandatory olfactory, gustatory, mushroom-body and named descending groups) plus 1,000 sampled individual Kenyon cells; weights = signed synapse fraction of each group's input. Neuron model: rate: leaky tanh(relu) group units, KC layer with threshold, dopamine-gated plastic KC->MBON synapses. Input: hand-made (odour, sugar, bitter and looming stimuli drive named ORN, GRN and LC4/LPLC2 groups with evolved gains). Output: hand-made prior plus evolved readout (forward from DNp09/MDN/DNp01, turn from DNa01/DNa02 left-right difference, eat from an innate prior; readout weights mutate). Trained parts: evolved: all group weights (scaled, added, deleted by mutation), time constants, biases, input gains, readout weights, plasticity rates. Body: simple 2D point agent (speed, turn, eat). Scripted parts: scripted reference policies (random walk, reflex, chemotaxis, oracle memory) exist only as baselines; the tested agents are brain-driven.

Measured result (by the authors unless stated) Corrected grid, generation 600, pooled over four ecologies, 10 seeds (results/fix_analysis.txt): fitness connectome 1.57, column shuffle 1.78, degree-preserving swap 1.77, interior-only swap 1.58, interior-only shuffle 1.62; connectome minus standard nulls -0.224 (p_holm 0.029) and -0.199 (p_holm 0.016), minus boundary-preserving nulls +0.002 and -0.074 (n.s.). Olfactory output landing directly on descending groups: connectome 0.01 %, standard nulls about 10.7 %. README also reports shortcut transplant +0.44 fitness (10/10 seeds) and a dose-response. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• build_brain.py:1-120 reads FlyWire v783 Connectivity_783 and annotations, drops optic lobes, groups by cell type, keeps 512 groups and 1,000 KCs, zeroes recurrent input to sensory rows [direct]
• evo_fix.py:102-114 recurrent rate update with KC layer and dopamine-gated KC->MBON plasticity; 70-79 descending-neuron readout for forward/turn/eat [direct]
• evo_fix.py:425-443 mutation rescales, adds and deletes weights: the connectome is a starting point, not frozen [direct]
• evo_fix.py:242-342 null conditions: N1 column shuffle, N2 degree-preserving swaps, N3 block shuffle, N4/N5 interior-only randomisation that keeps sensory and descending edges [direct]
• results/fix_analysis.txt and results/equivalence.txt: 10 seeds per ecology, connectome minus control at generation 600 with CIs and Holm-corrected p [direct]
• results/shortcut_check.txt: share of olfactory output landing directly on descending neurons, connectome 0.0001 vs N1 0.107 / N2 0.106 [direct]
• protocols/*.md frozen pre-registration protocols with hashes; RESEARCH_LOG.md dated log including a retraction [direct]

Limits The question is methodological (which random-wiring control is fair), not whether the fly brain produces fly-like behaviour; no comparison with real fly behaviour. The brain is a heavy compression (512 cell-type groups selected by a path score, plus 1,000 sampled KCs) and all weights evolve away from the connectome, so wiring is an initial condition. Input and output neuron choices and the readout prior are hand-made. Seeds are not bit-reproducible (clock reseeding, GPU scatter). One 20-seed extension did not replicate an earlier lead. Raw run logs (about 40 GB) are not in the repo; analysis outputs are. The paper states code and manuscript were written with an AI coding assistant. Measured by the author, not reproduced by us.

More facts Data licence: unknown · Peer review: preprint · GitHub stars: 0 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-23 (not an update date) · Last push, any branch: 2026-09-29; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/gyujeongion/flyconnectome-nulls [direct]
• https://doi.org/10.5281/zenodo.22871090 [not checked]

Project's own claim “On generic similarity search the real connectome is ~20% worse than the idealised random matrix standing in for it” source

Mechanism Wiring: subset: 130 PNs x 1,745 KCs of hemibrain v1.2. Neuron model: other: one-step feedforward projection + top-5% winner-take-all (FlyHash), no time dynamics. Input: hand-made (shared fixed random encoder from data to PN space). Output: hand-made (binary KC code used for nearest-neighbour search). Trained parts: none for hashing (sudoku study trains readouts). Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) out/benchmark.json, precision@16, 5 seeds (MNIST / Fashion-MNIST / correlated): real 0.499 / 0.480 / 0.368; real binary 0.547 / 0.518 / 0.420; degree-preserving 0.552 / 0.524 / 0.427; random FlyHash 0.621 / 0.581 / 0.511. out/specialization.json: in the connectome's own synthetic input world real 0.219 vs random 0.155 (+41%), degree-preserving 0.230; in a uniform world real 0.094 vs random 0.162. Values match the README. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• src/extract_connectome.py:5-6,67 builds real PN->KC matrix from hemibrain v1.2 export, 3-synapse threshold [direct]
• src/extract_connectome.py:89-100 random FlyHash null; :102-140 Maslov-Sneppen degree-preserving swap; :142,156 glomerulus-matched and weight-shuffled nulls [direct]
• src/benchmark.py:46,88-104,126 shared encoder, top-5% KC code, precision@k [direct]
• out/benchmark.json mnist precision@16: real 0.4993, degree_preserving 0.5520, random_flyhash 0.6212 [direct]
• out/specialization.json: own-world real 0.2187 vs random 0.1552; uniform world 0.0944 vs 0.1619 [direct]

Limits Well-controlled negative result for a small circuit: the real matrix hashes worse than random, and even in its 'own world' a degree-preserving shuffle is slightly better, so any specialisation sits in the degree sequence. Model is a single feedforward step with k-winner-take-all, not a dynamic simulation; the 'fly's own world' inputs are synthetic, drawn from the connectome's own covariance. No licence file (GitHub reports none). Sudoku study is a separate readout experiment with trained layers. Measured by the author, not reproduced by us.

More facts Data licence: CC-BY (version not stated) · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-12; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/realgauravvyas/flys-hash-function [direct]
• https://realgauravvyas.github.io/flys-hash-function/ [direct]

Project's own claim “Public connectomes as fixed reservoirs: load a real brain's wiring, simulate it as a spiking network, drive it, read it out — with controls and pre-registration.” source

Mechanism Wiring: MaleCNS v1.0, 165,122 neurons / 6,235,682 connections after min_syn=5 filter; BANC 626 (114,456 neurons) as second brain. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none in the brain; text encoder is a pretrained sentence model (all-MiniLM-L6-v2) with a fixed seeded random projection to sensory-neuron Poisson rates. Body: none. Scripted parts: none found; answer = descending-neuron L/R spike bias minus a handedness offset from neutral sentences.

Measured result (by the authors unless stated) No outcome scoring yet (questions resolve by 2026-12-15, RESULTS.md:49-52). Per-run control values are in experiments/001-fly-oracle/results.csv; our own aggregate of that file: p(yes) real 0.4996 (0.4905-0.5053, sd 0.0028), no_brain 0.4999 (0.4923-0.5082), rewired 0.5009 (0.4801-0.5195), Erdos-Renyi 0.5027 (0.3939-0.6192), coin 0.576. So far the real wiring gives answers close to 0.5, like the no-brain baseline. Calibration: bitter input cuts MN9 firing by 96.8% (docs/MODEL.md:85-87).

Grade basis (checked 28 Sep 2026)

• src/bioreservoir/connectomes/malecns.py:31-33 loads the three MaleCNS v1.0 feather files [direct]
• src/bioreservoir/sim/lif.py:124 LIF equation dv/dt=(v_rest-v+g)/tau_m, Brian2 port of Shiu et al. [direct]
• src/bioreservoir/oracle/encode.py:60-92 text -> MiniLM embedding -> seeded Gaussian projection -> Poisson rates (hand-made input map) [direct]
• src/bioreservoir/oracle/controls.py:165,180,276,291 degree-preserving rewire, Erdos-Renyi, no-brain baseline and coin controls [direct]
• experiments/001-fly-oracle/RESULTS.md:16-20 429 runs: real 99, rewired 99, er 99, no_brain 99, coin 33 [direct]
• experiments/001-fly-oracle/RESULTS.md:35-41 real-brain p(yes) mean 0.5001, range 0.4930-0.5053 [direct]
• experiments/001-fly-oracle/RESULTS.md:49-52 no outcomes yet; no accuracy/Brier numbers exist [direct]
• docs/MODEL.md:74-90 calibration: sugar GRN -> MN9 128.5 Hz, bitter suppression 96.8% (reproduces Shiu direction) [direct]
• docs/MODEL.md:143-155 BANC fails the side-tracking check and is excluded from headline claims [direct]

Limits Controls are built and run, and all per-run values are public, but the project has not yet published a real-vs-control comparison or any outcome score; RESULTS.md only summarises the real condition. The aggregate numbers above are ours, computed from results.csv. Borderline B/A: could move to A once the pre-registered scoring is published. The task (forecasting questions from their text) has no biological ground truth. Input and output maps are chosen by the authors. The BANC run uses materialization 626, not 888; the authors say 888 exists and has not been tried yet (docs/MODEL.md:131-139). The live site runs fresh simulations (~66 s per question). The repo is published as squashed snapshots. Created 2026-09-22.

More facts Data licence: several (see dataset entries) · Peer review: none · GitHub stars: 3 (30 Sep 2026; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-22 (not an update date) · Last push, any branch: 2026-09-24; reused from our 30 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/igdigitallab/bioreservoir [direct]
• https://fly.igdigi.com [fetch-summary]

Project's own claim “Runs the whole Traced universe of the male CNS connectome, 165,122 neurons and every one of the 25,563,197 edges, inside a physical fly body, in closed loop.” source

Mechanism Wiring: MaleCNS v1.0, all Traced bodies and all edges between them; 12 flies share one connectivity allocation. Neuron model: LIF (NumPy/GeNN engines, membrane and adaptation state, noise); photoreceptor output edges zeroed by sign policy. Input: hand-made (analytic bearing and angular size of objects mapped onto lamina L1-L5 cells; no rendered pixels). Output: hand-made (filtered rates of DNp* populations, 160 left / 158 right, chosen after measuring visual input share on the graph -> two drives with thresholds and yaw gain). Trained parts: none (no learning or plasticity in the swarm run); STP/completeness parameters fitted in separate stage-2 validation work. Body: FlyGym (NeuroMechFly, HybridTurningController CPG, fixed leg adhesion). Scripted parts: Gait is FlyGym's engineered CPG. Onset timer holds all flies still for 1.5 s. The decoder has no stop state. In the eon showcase: odor-gated direct DNg97 drive, a raw odor-gradient term in the steering controller, a grooming readout that triggers a published kinematic replay, and MN9 triggering an engineered proboscis pose..

Measured result (by the authors unless stated) Swarm (one seed, one arena): 12/12 flies entered locomotion vs 0/12 in the stimulus-absent control; 12/12 ended within 1 mm of an object vs 0/12; 9,337 vs 164 neurons spiking per fly per interval (README; artifacts/showcase/swarm3d-v1/*summary.json). Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• src/flysim/connectome.py:239 source_release default 'male-cns:v1.0' [direct]
• src/flysim/engines/lif.py:18-160 LIF engine with membrane tau, reset and input frames [direct]
• src/flysim/swarm3d.py:13-16,388 each fly driven by two normalised descending drives into FlyGym HybridTurningController [direct]
• src/flysim/swarm3d_vision.py:124-134 entry layer lamina L1-L5; all 66,533 photoreceptor output edges zeroed; strongest-object drive per cell [direct]
• configs/experiments/demo01-visual-operating-point-v1.json:127-132 decoded populations DNp* 160/158 chosen by measured visual-input share; DNa01/02 recorded but not decoded [direct]
• artifacts/showcase/swarm3d-v1/run-exact-summary.json: graph 165,122 neurons / 25,563,197 edges, shuffle null; decoder thresholds and yaw gain; 12 flies closed on food vs 8 in run-stimulus-absent-summary.json [direct]
• artifacts/showcase/eon-showcase-v1/acceptance.json: input- and readout-ablation controls pass; shuffled-connectome and zero-weight runs are 'diagnostic only' and do not gate; exact seed 3 incomplete; limitations deny 'autonomous connectome-generated behaviour' [direct]
• artifacts/showcase/eon-showcase-v1/showcase-manifest.json:29-37 declared bridges incl. raw odor-gradient steering term and grooming kinematic replay [direct]

Limits The only control for the swarm is removing the stimulus, not a wiring control. Shuffled and zero-weight runs exist for the eon showcase but are marked diagnostic, not activity-matched, and do not gate acceptance. The swarm is one seed in the third arena tried, with headings bounded so food falls in the encoder's field. Vision is analytic (exact object positions), not optical. The readout population was picked after measuring the graph, and walking is FlyGym's engineered CPG. The eon showcase adds shortcuts around the network (a raw odor-gradient steering term, a direct DNg97 drive) and turns grooming and feeding readouts into replayed or engineered motor programs, so those behaviours are C-level. The artifacts themselves disclaim 'autonomous connectome-generated behaviour'. Female body with male CNS. Very large AI-agent-style documentation (AGENTS.md 74 KB), matching HN criticism. Not a copy of a catalogued project; stage-2 work compares against the Shiu model and published physiology.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 21 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-15; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Ibtisam-Mohammad/Fly.exe [direct]

Project's own claim “"A frozen, complete fruit-fly central nervous system (MaleCNS v1.0: 166,700 neurons, 10.5 M measured connections) is the controller of a simulated Franka arm." and "Whether the measured wiring trains better than another graph is not yet claimed." (README)” source

Mechanism Wiring: MaleCNS v1.0 whole CNS; weights = synapse counts x transmitter sign (ACh +1, GABA and Glu -1, others 0), row-normalised. Neuron model: other: rate model h <- (1 - alpha) h + alpha tanh(I + g W h), alpha 0.5, g 0.8, 3 updates per control step (src/flyarm/whole_brain/backend_mlx.py). Input: learned: a trained encoder writes currents into the 1,846 ascending neurons from simulator state and a task cue. Output: learned: a linear decoder from 1,314 descending and 708 VNC motor neurons to the arm action. Trained parts: encoder and decoder (behaviour cloning with DAgger, then PPO with a demonstration term); the connectome weights are frozen. Body: simulated Franka Panda arm (MuJoCo; FrankaKitchen in Gymnasium-Robotics), not a fly body. Scripted parts: the scripted teacher used for imitation, task plans and the task cue.

Measured result (by the authors unless stated) Author's figures: full-task success on held-out articulated manipulation episodes 76.3% (iid), 82.6% (unseen objects), 36.6% (unseen furniture) and 26.6% (unseen compositions) after PPO; FrankaKitchen all four tasks 50/50. Lesions: clearing the recurrent state each step 0/112, silencing everything but the interface 16/112 (intact 87/112). Wiring vs degree-preserving shuffle: pick-and-place lift 58/72 vs 27/72 over 3 seeds, a kitchen ordering 25 vs 0 and 21.25 vs 15, a dexterous-hand tie (62 vs 63 of 64); the author states the wiring advantage is not established.

Grade basis (checked 5 Oct 2026)

• src/flyarm/whole_brain/backend_mlx.py at ab3922e: rate update with tanh, frozen connectome, alpha/gain constants [direct]
• src/flyarm/whole_brain/compiler.py and shuffle.py: MaleCNS v1.0 CSR pack; degree-preserving null that keeps each neuron's in- and out-degree, contact multiset, sign and the input/output sets [direct]
• docs/RESEARCH_LOG.md E1-E3: whole-brain check (no input-to-output bypass: with every edge removed outputs are exactly zero); pick-and-place lift 58/72 connectome vs 27/72 shuffle vs 33/72 GRU over 3 seeds (seed-level p = 0.125) [author's log in the repository; run files not read]
• README Results and Lesions tables (manipulation success 76.3% iid with PPO; state cleared every step 0/112; all-but-interface 16/112) and STATUS.md (shuffle seeds for the manipulation protocol stopped 2026-10-03, not finished) [README; numbers not checked against docs/results/*.json]

Limits The connectome is frozen but sits between a trained encoder and a trained decoder, so much of the skill can live in the interface; the author's own lesions (all-but-interface 16/112) show the recurrent connectome state matters. The wiring-vs-shuffle comparison is partial and mixed across tracks (clear in pick-and-place, absent or tied elsewhere), and the shuffle runs for the headline manipulation protocol were stopped unfinished. The robot is an arm, not a fly body; inputs are simulator state, not vision. One author; not peer reviewed.

More facts Data licence: MaleCNS v1.0 (CC BY 4.0, as stated in the README) · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/yusenthebot/FlyArm [direct]

Project's own claim “"It compares each real network with six families of rewired networks under pre-specified criteria." (README)” source

Mechanism Wiring: leg motor subnetworks of MaleCNS v1.0 and MANC v1.0 (src/build_graph.py, build_graph_manc.py). Neuron model: rate model (src/openloop.py, JAX). Input: hand-made: motor-neuron-to-joint map (src/mn_joint_map.py); stimulation as in the scripts. Output: hand-made: motor neurons mapped to leg joints. Trained parts: none (fixed weights; 132 parameter settings scanned, best eligible setting frozen per network). Body: none (open-loop rate model). Scripted parts: none found.

Measured result (by the authors unless stated) Not public: the repository holds code only; results, derived graphs and the manuscript are to be deposited on publication.

Grade basis (checked 2 Oct 2026)

• README.md and file list at c84104a (2026-09-30), read 2026-10-02 from a depth-1 blobless clone; src/nulls.py, nulls_recip.py, nulls_w.py and analysis/analyze_exp1.py exist [direct]
• No results, figures data or manuscript text are in the repository ('available from the corresponding author on request'), so the comparison with the rewired networks cannot be inspected

Limits Graded B because the controls exist only as code: the outcome of the real-vs-rewired comparison is not published, so nothing about 'how much is in the wiring' can be checked yet. Upgrade to A when the results or manuscript appear (the code already contains six rewiring families and coded decision rules). Candidate for the controls ledger then.

More facts Data licence: MaleCNS CC BY 4.0; MANC: see neuPrint terms (not checked) · Peer review: submitted manuscript, not public · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-30 (not an update date) · Last push, any branch: 2026-09-30

Sources

• https://github.com/kosmoKwan/fly-connectome-wiring [direct]

Project's own claim “The fly sees, walks, grooms, and escapes, driven entirely by 138,639 spiking neurons from the FlyWire connectome; two flies with identical connectomes develop distinct behaviour through Hebbian plasticity.” source

Mechanism Wiring: FlyWire v783, whole graph loaded from the Shiu-model parquet files; weights are changed online by a Hebbian rule (sign-preserving, capped at 3x the original). Neuron model: LIF (PyTorch port of the Shiu et al. model), 0.1 ms step. Input: Hand-made: named sensory neurons (sugar/bitter GRNs, LC4, JO, ORNs, photoreceptors and early visual layers) get Poisson rates from simulated senses or keyboard/auto-demo stimuli. Output: Hand-made: normalised rates of about 18 DNs (P9, DNa01/02, MDN, GF, aDN1, MN9) go into fixed formulas for two drive values and threshold-based mode selection. Trained parts: No trained readout. Hebbian plasticity changes the connectome weights during a run.. Body: NeuroMechFly v2 (flygym, MuJoCo), with the HybridTurningController CPG for walking. Scripted parts: Grooming is a fixed front-leg oscillation. Flight is a state machine with external forces and a direct orientation override. Feeding sets the proboscis joint. Escape runs at a fixed speed. Tactile, bitter and olfactory escape are 'bridge-level backups' that skip the brain. Olfactory attraction and sound orientation are added straight to the turn command. The auto-demo drives forward walking by stimulating the P9 readout neurons themselves..

Measured result (by the authors unless stated) Reported in the preprint and README: after 24 h, two flies starting from the same connectome showed 81% vs 47% escape, CI 0.221 vs 0.198, and 76,034 divergent synapses. Measured by the author, not reproduced by us. The plastic weight files in the repo are Git LFS pointers.

Grade basis (checked 28 Sep 2026)

• brain_body_bridge.py:286-302 loads 2025_Completeness_783.csv and 2025_Connectivity_783.parquet into TorchModel [direct]
• brain_body_bridge.py:385-398 Hebbian update dW = eta*pre*post*sign - alpha*W on all synapses [direct]
• brain_body_bridge.py:37-74 hand-picked DN readout IDs; 94-101 'p9' stimulus drives the same P9 cells used as the forward readout [direct]
• brain_body_bridge.py:609-731 compute_drive(): fixed formulas and if/elif mode selection with thresholds; 664-669 tactile and bitter escape marked 'bridge-level backup'; 721-729 olfactory_attraction_bias (gain 10) and sound bias added directly to turn [direct]
• fly_embodied.py:680-694 olfactory attraction/repulsion biases computed from odour geometry and passed to the bridge, bypassing the network [direct]
• fly_embodied.py:59-74 auto-demo cycles scripted stimuli (p9, lc4, sugar, jo, bitter, or56a) [direct]
• fly_embodied.py:82-95 GroomingController front-leg oscillation; 764-795 flight forces, frozen legs in flight, scripted grooming, proboscis set during feeding [direct]
• flight.py:27-40 flight is a force state machine with direct quaternion override [direct]
• No shuffled-wiring, no-graph or real-fly comparison found; compare_plasticity.py only compares weights of two runs to the starting weights [direct]

Limits Grade C: The whole v783 graph is simulated and continuously steers walking through DN rates, but most of the behaviours shown are scripted programs that start at readout thresholds (grooming, flight, feeding, fixed-speed escape). Several sensory-to-motor paths skip the network: tactile and bitter escape, olfactory attraction (gain 10 on turning), sound orientation, and a T2 visual threat fallback computed outside the brain. The README says 'no hardcoded rules, no if-else chains', but the code contradicts this. In the auto-demo, forward walking is produced by stimulating the P9 readout neurons directly. No controls (shuffled or random wiring, no-graph baseline) and no comparison with real-fly data. The 'consciousness'/integration metrics (phi, CI) are the author's own measures. The neuron model and data files come from the Shiu et al. Drosophila brain model.

More facts Data licence: CC-BY-NC-4.0 · Peer review: preprint · GitHub stars: 64 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-03-11 (not an update date) · Last push, any branch: 2026-03-21; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/erojasoficial-byte/fly-brain [direct]
• https://doi.org/10.5281/zenodo.19152238 [indirect]

Project's own claim “"Closed-loop simulation of the Drosophila male ventral nerve cord driving a biomechanical fly in MuJoCo"; "Closed loop: fly produces 1.17 mm of movement in 400 ms of MDN drive" (README)” source

Mechanism Wiring: MaleCNS v1.0 ventral nerve cord plus descending neurons (24,115 neurons), split into excitatory (acetylcholine) and inhibitory (GABA, glutamate) sparse matrices. Neuron model: LIF with separate excitatory (5 ms) and inhibitory (150 ms) synaptic decay, tau_m 20 ms (src/sim/lif.py). Input: hand-made: constant drive to chosen descending neurons (MDN, DNp09). Output: hand-made, arbitrary: motor-neuron spikes counted over 10 ms and assigned to 42 actuator buckets by a seeded random hash ("Not biology", scripts/09_closed_loop.py); the muscle-based MotorDecoder returns 0.0 for every muscle (src/encoding/motor.py). Trained parts: none found in the code. Body: FlyGym (NeuroMechFly v2, 42 position-controlled leg actuators). Scripted parts: the motor-to-actuator mapping; no proprioceptive feedback yet.

Measured result (by the authors unless stated) Not verified by us: the validation verdicts and the 1.17 mm displacement are stated in the README; no result files are committed.

Grade basis (checked 6 Oct 2026)

• scripts/09_closed_loop.py at c6b50b3: build_motor_to_action_map assigns motor neurons to actuator buckets with a seeded random generator, docstring "Deterministic hash of motor neuron index -> action bucket. Not biology." [direct]
• src/encoding/motor.py: MotorDecoder.decode returns a placeholder 0.0 for every muscle [direct]
• README.md: validation table (MDN raises the motor pool PASS, DNp09 suppression PARTIAL, tripod anti-phase FAIL); the JSON reports and figures are not committed [direct]

Limits The body is not walking under connectome control yet: in the committed loop, motor-neuron spikes move leg joints through a random assignment, so the reported displacement says nothing about gait. The brain-only checks against published experiments are the substantive part, but their outputs are not committed. The README says a thin command interface is learned; no training code was found.

More facts Data licence: MaleCNS v1.0 (CC BY 4.0), fetched by the user from neuPrint; not included · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/sadiqkhzn/fly-vnc-walking-sim [direct]

Project's own claim “Sugar input drives the 'eat' motor neuron (0 to 92 Hz, dose-dependent), bitter vetoes it; the conditioned brain steers the body to the rewarded odor.” source

Mechanism Wiring: Taste demo: whole-brain Shiu et al. 2024 model (v630). Navigation: 8,991-neuron olfactory/mushroom-body subnet (ORN, ALLN, ALPN, KC, APL, MBON, PAM, PPL1) extracted from the v783-based model.. Neuron model: LIF (Brian2, Shiu et al. parameters). Input: hand-made (Poisson drive on listed sugar/bitter/water GRN IDs; odor concentration at each antenna scales ORN class rates). Output: hand-made (MN9 rate read out; navigation: total MBON spikes per antenna -> engineered steering law with gain and arrival rule). Trained parts: none by gradient; 'conditioning' depresses KC->MBON synapses active during rewarded odor pairings (eta 0.5); KC->MBON weights multiplied by a hand-set gain of 20. Body: FlyGym (NeuroMechFly, HybridTurningController CPG). Scripted parts: Walking demo uses fixed timed turn commands. Visual taxis uses FlyGym's example controller with no connectome. Navigation steering polarity, gains and 'arrived' rule are engineered..

Measured result (by the authors unless stated) Taste: MN9 0 to 92 Hz with sugar, 93% suppression with bitter (README; the rates would come from results.jsonl, which is not in the repo). Navigation: trained fly ends 2.5 mm from rewarded source vs 16.4 mm from control source; naive fly reaches neither (experiments/navigation/report.md). Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• demo/track_a_lif.py:3-9,16-34 runs the Shiu et al. Brian2 model with FlyWire v630 sugar/bitter/water GRN IDs and MN9 readout [direct]
• demo/track_a_lif.py:51-56 loads 2023_03_23_connectivity_630_final.parquet from an external Drosophila_brain_model clone [direct]
• demo/track_b_embodied.py:42-50 walking uses fixed time-scheduled [left,right] drives, no brain [direct]
• demo/track_b_embodied.py:81-107 visual taxis maps retina object deviation to leg speeds through a hand-written function, no brain [direct]
• experiments/navigation/nav_demo.py:38-72 builds the olfactory-MB subnet from v783 annotations; KC->MBON weights multiplied by gain 20 (line 72) [direct]
• experiments/navigation/nav_demo.py:117-140 train() depresses active KC->MBON synapses; valence = sum of MBON spikes [direct]
• experiments/navigation/nav_demo.py:179-192 turn = steer_gain*(vL-vR)/total, plus an 'arrived, feeding' rule when valence is silenced [direct]
• experiments/navigation/runs/film/summary.json holds only the naive run (final distance 34.5 mm to A, 36.0 mm to B) [direct]

Limits The author says most of the science and code already existed. The sugar-to-MN9 result reproduces Shiu et al. 2024, running their model from an external clone; it is not copied into the repo. That result has a bitter/water specificity check, but its comparison with real flies is Shiu's, not this repo's. The embodied demos do not use the full brain: walking and visual pursuit have no connectome at all, and navigation uses an 8,991-cell filtered subnet with a hand-set KC->MBON gain of 20. There, the brain supplies only a scalar valence per antenna, and an engineered steering law turns it into movement. The naive-vs-trained comparison controls for learning, not for wiring (no shuffled graph). Only the naive trajectory summary is stored. The trained run's numbers are in the report only.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · GitHub stars: 10 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-08 (not an update date) · Last push, any branch: 2026-09-08; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/dtch1997/fly-api [direct]

Project's own claim “"On this evidence the fly's wiring makes learning faster and driving more consistent, though with one seed per core the differences in mean are small." fly 903.2 vs signs 896.9, mlp 894.0, random 883.7 mean score over 100 held-out tracks (README)” source

Mechanism Wiring: MaleCNS v1.0 subgraph selected by cell-type patterns (LPLC2, LC4, LC9-16, ER ring neurons; EPG, PEN, PFL, PFN, hDeltaB; descending neurons) plus the strongest bridging neurons. Neuron model: rate: leaky units v <- v + (dt/tau)(-v + W r + b + I), r = tanh(relu(v)), 6 settling steps per frame (flyracer/models/flyrnn.py). Input: learned: a CNN encoder on 4 stacked 96x96 grey frames projects 256 features onto the input neurons. Output: learned: Beta readout from descending neurons to steer, gas and brake, initialised with a left/right steering prior. Trained parts: PPO trains synapse strengths (log_w), a global gain, per-neuron time constants and biases, the CNN encoder, the input projection, the readout and an MLP critic. Body: none (a 2D car in CarRacing-v3). Scripted parts: none beyond the Gymnasium environment.

Measured result (by the authors unless stated) Not verified by us: the four-core comparison (one seed each) exists only as a README table and a figure.

Grade basis (checked 6 Oct 2026)

• flyracer/models/flyrnn.py at 71ede00: sign buffer fixed per presynaptic neuron, trainable log_w, log_gain, log_tau and bias (lines 48-55) [direct]
• flyracer/connectome/shuffle.py: degree_preserving_shuffle (permutes postsynaptic endpoints, keeps in- and out-degree and per-neuron signs) and shuffle_signs [direct]
• configs/tier_s.yaml: dataset male-cns:v1.0, cell-type patterns for inputs, central complex and descending neurons [direct]
• Control scores are given only in the README table and docs/core_comparison.png; no run, eval or episode files are committed (runs/ is not in the repository) [direct]

Limits A trained agent with connectome topology, not a simulation of fly driving: most of the skill can sit in the trained encoder, weights and readout. The wiring controls are implemented in code, but their results are only in the README (one seed per core, final means within 20 points, the MLP ahead at the end of training), so they do not raise the grade.

More facts Data licence: MaleCNS v1.0 (CC BY 4.0), fetched by the user from neuPrint with a personal token; not included · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://github.com/supat-roong/fly-racer [direct]

Project's own claim “does the topology of the real Drosophila male CNS connectome provide a useful inductive bias for reinforcement learning?” source

Mechanism Wiring: subset: up to ~5,000 neurons of MaleCNS v1.0 (sensory/LC4 to descending k-hop subgraph). Neuron model: rate: leaky tanh message passing, 5 steps per observation. Input: learned (CNN encoder by default; optional hand-made 'fly-inspired' features) into designated sensory nodes. Output: learned (policy/value heads on descending nodes). Trained parts: default connectome_rate config trains internal edge weights plus encoder and heads with PPO; fixed_internal/readout_only/three_factor modes exist. Body: none. Scripted parts: none found.

Grade basis (checked 28 Sep 2026)

• src/flydoom/data/controls.py:11,37,44-60 Erdos-Renyi, weight shuffle and degree-preserving double-edge swap controls implemented [direct]
• src/flydoom/models/connectome_network.py:60-80 leaky tanh sparse message passing on subgraph edges [direct]
• configs/model/connectome_rate.yaml: training_mode trainable_internal, encoder cnn [direct]
• configs/experiment/flydoom_basic.yaml: variants real_connectome, erdos_renyi, degree_rewired, mlp, gru, lstm; env backend mock [direct]
• repo tree: no results, metrics or learning-curve files committed [direct]

Limits Controls are well designed and implemented in code, but no measured results (connectome vs rewired vs ordinary networks) are reported anywhere in the repo, so there is nothing to grade A on. With default settings the connectome weights are trained by PPO on a small subgraph behind a CNN, so behaviour comes largely from learning, not from the wiring as measured. README says itself it is not Doom in a biological brain and states no result. No licence file (GitHub reports none). Contains a stale build/lib copy of the package. Could move to A if the author publishes the control comparison. Repository eganeganegan/flydoom returns HTTP 404 on 2026-10-01 and 2026-10-02 (git ls-remote asks for credentials: gone or private); the record is kept with the last catalogued commit b047fab (2026-09-14). A third HTTP 404 on 2026-10-03 (git ls-remote again asks for credentials): link status set to gone. The record is kept, with no working code link.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 8 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-14; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/eganeganegan/flydoom [direct]

Project's own claim “"a direct bridge from the BANC v888 real neural connectome ... into FlyGym's motor control loop, demonstrating a closed-loop pipeline: real neuron spikes -> CPG modulation -> leg actuators -> walking simulation" (README)” source

Mechanism Wiring: BANC v888 subsets: (bridge) one descending neuron with the most outputs plus its top 50 targets; (closed loop) 18 leg sensory neurons, 20 randomly chosen interneurons (np.random.seed(7)), 12 leg motor neurons. Neuron model: LIF (numpy, hand-set parameters; bridge: tau 15 ms, syn_gain 60; closed loop: syn_gain 40). Input: hand-made: (bridge) a tonic current I_ext = 25 into the chosen descending neuron, which has no inputs in the sub-circuit; (closed loop) joint angles encoded as currents into sensory neurons assigned to random legs. Output: hand-made: (bridge) amplitude gain = clip(rate/60, 0.3, 2.0) applied equally to all six CPG oscillators of FlyGym's tripod CPGController; (closed loop) motor spikes per leg min-max scaled to gains 0.2-2.0 multiplying a hand-written sinusoid. Trained parts: STDP in the closed-loop script (A_pre = A_post = 0.01, tau 20 ms). Body: FlyGym. Scripted parts: the stepping pattern: FlyGym's tripod CPG (bridge) or a hand-written 0.3*gain*sin(phase) joint target (closed loop).

Measured result (by the authors unless stated) None reported beyond printed rates and gains (for example '96 Hz -> 1.60x') and rendered videos; no comparison or control.

Grade basis (checked 2 Oct 2026)

• scripts/banc_flygym_bridge.py, scripts/banc_flygym_closed_loop.py, scripts/build_banc_subnet.py, scripts/test_banc.py and README.md at 8a794e33 (2026-09-26), read 2026-10-02 from a depth-1 blobless clone [direct]
• In the bridge, neuron 0 (the descending neuron) receives no synaptic input inside the sub-circuit (recurrent edges are added only among the 50 targets), so its rate, and therefore the CPG gain, is set by the tonic current and the LIF constants, not by the connectome [direct, read from code]

Limits Grade C: a small selected or random subset with hand-set parameters, and the walking itself is FlyGym's CPG or a hand-written sinusoid; in the bridge script the connectome cannot change the drive at all. A fork of FlyGym 2.1.0 (not a lure copy: the added scripts are original). Closest existing design to our own 'Add a body' test; differences are in body/results.md of run 6.

More facts Data licence: BANC: see Harvard Dataverse terms (not checked) · Peer review: none · GitHub stars: 0 (6 Oct 2026) · Repository created: 2026-09-25 (not an update date) · Last push, any branch: 2026-09-25

Sources

• https://github.com/arisliwind/flygym [direct]

Project's own claim “A connectome-constrained fruit-fly brain controlling an FPV drone in Liftoff” source

Mechanism Wiring: MaleCNS v1.0 subgraph selected by population queries (haltere, wing campaniform, LPTC, ocelli, JO, EPG compass, premotor, wing MNs), min 3 synapses, optic-lobe intrinsic excluded. Neuron model: rate units (sigmoid), learnable per-neuron time constant, gain and bias. Input: learned population encoders from telemetry/vision channels into sensory populations. Output: trained readout from wing motor / premotor neurons to 4 stick channels. Trained parts: Per-edge weight magnitudes (sign and structure fixed by the connectome), unknown signs, neuron parameters, encoders and readout. Trained by gradient descent and imitation of an MLP teacher.. Body: simulated quadcopter in the game Liftoff. Scripted parts: Race-cue visual pilot (heuristic checkpoint guidance) supplies the velocity goal and yaw; obstacle clearance heuristics.

Measured result (by the authors unless stated) Measured by the author, not reproduced by us. In a frozen full-race comparison the brain finished 0/2 races and the PD controller 1/2 (docs/flight_cards/2026-09-23_matched_full_races.md). The later fast-brain-08 finished Straw Bale twice in about 5:18 with the race-cue pilot, against a user target of 1:34.8; it has not finished Minus Two or Pine Valley (README). Release fast-brain-11 (29 Sep 2026, experimental) flew one full Straw Bale lap in 1:42.988 with a braking motor readout, but every flight ended in a crash and it has not finished a race; fast-brain-08 remains the author's published race result (docs/fast_brain_11_release.md). Round-6 flights (29 Sep 2026, docs/fast_brain_11_release.md) took fast-brain-11 through the Minus Two hairpin for the first time, still with no race finish.

Grade basis (checked 28 Sep 2026)

• data/built/flight.meta.json: version v1.0, n_candidates 71618, n_nodes 30000, n_edges 2767698, whole_cns false [direct]
• haltere/brain/model.py:1-7, 100-140 ConnectomeRNN: connectome fixes structure and sign; per-edge log-gain, taus, gains and biases are nn.Parameters [direct]
• haltere/brain/model.py:24 BrainConfig model 'mlp' baseline option; artifacts/mlp_baseline.pt used as imitation teacher [direct]
• haltere/liftoff/fast_race_cue.py:1-28 heuristic velocity-level checkpoint guidance that supplies goal and yaw [direct]
• docs/flight_cards/2026-09-23_matched_full_races.md: brain 0/2 finishes vs PD 1/2 [direct]

Limits The network is a filtered subgraph (30,000 neurons) with trained weight magnitudes and a trained readout, and it was taught by imitating a non-connectome MLP. Navigation (velocity goal and yaw) comes from a hand-written visual pilot, so the brain acts as a low-level motor controller. There is a PD baseline, but the n is tiny (2 races each), and there is no shuffled-wiring control for flight. The author openly reports that reliable general racing is unsolved.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 11 (28 Sep 2026; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-12 (not an update date) · Last push, any branch: 2026-09-28; reused from our 28 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/skulitom/haltere [direct]

Project's own claim “Fruit Fly Brain vs AI: a benchmark comparing connectome-topology-constrained neural architectures derived from a real Drosophila nervous system against conventional AI models on controlled tasks.” source

Mechanism Wiring: A 150-neuron MaleCNS subgraph (first 150 rows of the author's neuron parquet, not a named circuit) used as a mask: only real edges carry weights.. Neuron model: rate: graph layers with learned edge scales and biases; a hand-set leaky/decay state ('SA-010', decay 0.05, leak 0.02) for the recall task. Input: learned input projection from a 16-value observation onto the graph nodes. Output: learned readout head from node states to the answer. Trained parts: Edge scales, biases, input projection and readout (A1-BIO); in the 'frozen' variant the graph weights are fixed but the readout and projections still train (2,852 trainable parameters in the stored result). Body: none (abstract classification tasks). Scripted parts: Tasks and training loop are ordinary code. The browser 'Live Arena' does not run the models; it samples outcomes from the reported accuracies..

Measured result (by the authors unless stated) Stored results: T-001 (static classification) all trained models near ceiling; the MaleCNS mask scored 0.98 and the same-density random graph 1.00 (single seed), so no topology effect. T-002 (delayed recall, 5 seeds): MaleCNS mask 94.8%, frozen-mask variant 92.4%, LSTM 57.6%; no random-graph control was run on T-002. Several README figures do not match the stored files. Measured by the author, not reproduced by us.

Grade basis (checked 29 Sep 2026)

• scripts/tasks/run_t001_topology.py:32-37 neurons = read_parquet(...).head(max_nodes): subgraph is the first 150 rows [direct]
• abb/models/topology.py:70,101,230,299-345 Erdos-Renyi, configuration-model and weight-shuffle controls implemented [direct]
• artifacts/t001_topology_results.json: T-001 single seed, A1-BIO 0.98 vs A3-ER 1.00, A3-CONFIG 0.99, A3-DENSE 1.00 test accuracy [direct]
• scripts/tasks/run_confirmation_t002.py:77-83 T-002 confirmation compares only A0-Random, A1-BIO, A1-FROZEN and A8-LSTM; no random-graph control [direct]
• artifacts/confirmation_t002/A1-BIO_0.05_0.02.json: 0.948 mean, 5 seeds, graph_edges 1681 [direct]
• artifacts/confirmation_t002/A1-FROZEN_0.05_0.02.json: 0.924 mean with 2,852 trainable parameters (README says 72.2% and 0) [direct]
• artifacts/confirmation_t002/A8-LSTM.json: 0.576 mean, CI95 0.268 (README says 8.9%) [direct]
• abb/models/bio_variants.py:100-125 trained readout head; freezing applies to graph layers only [direct]
• git ls-files: no abb/data package and no data/ folder in the repository, though tests import abb.data.graph [direct]

Limits The 'fly' network is 150 neurons picked as the first rows of a table, not a named circuit, with every weight trained. The only topology control (random graph of the same density) was run on the task where every model hits ceiling, and it did as well as the fly mask. The headline memory result compares against an LSTM, not against rewired wiring, so it does not show that the fly wiring matters. README numbers (frozen 72.2%, 0 parameters, LSTM CI 8.9%, 3,029 edges) differ from the stored result files (92.4%, 2,852 parameters, CI 26.8%, 1,681 edges). The data-loading module is missing from the repository. The 'Live Arena' page replays sampled outcomes, not the models. The author states many of these caveats.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 3 (29 Sep 2026; reused from our 29 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-15 (not an update date) · Last push, any branch: 2026-09-27; reused from our 29 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Titanium-xd/neuroweave [direct]

Project's own claim “We do think it is the first embodied fly upload, the first to close a sensorimotor loop in a simulated body.” source

Mechanism Wiring: FlyWire whole central brain (~140k neurons) via the Shiu et al. LIF model; vision from the connectome-constrained flyvis model inside NeuroMechFly. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: Walking controllers are modified NeuroMechFly controllers 'trained to imitate' walking; low-level body controllers are trained by imitation learning; flyvis is task-trained. Body: FlyGym. Scripted parts: A few hand-picked neurons drive pre-trained controllers: DNa01/DNa02 for steering, oDN1 for forward speed, antennal DNs for grooming, MN9 for feeding. Sensory rates and DN-to-command gains are 'chosen by hand'. Vision is called 'somewhat decorative'..

Grade basis (checked 28 Sep 2026)

• https://eon.systems/updates/embodied-brain-emulation: a 'small number of descending outputs' influence body controllers 'trained by imitation learning'; mappings 'chosen by hand'; visual activations 'somewhat decorative' [direct]
• Same page, raw HTML: no GitHub or code link [direct]
• local clone: brain-only LIF benchmark code (Brian2/PyTorch/NEST GPU/GeNN, data/2025_Connectivity_783.parquet); no flygym/neuromechfly/mujoco/flyvis code [direct]
• https://github.com/eonsystemspbc org page: fly-brain, flybody (fork of TuragaLab/flybody), drosophila_brain_model_lif (fork of philshiu/Drosophila_brain_model), pathintegrationBPU, NEURD-sandbox; no embodiment repo [direct]

Limits The body/embodiment code is not public, so the loop cannot be inspected (grade U). By Eon's own description the mechanism would be C: connectome activity in a few hand-picked neurons switches or steers pre-trained, imitation-learned motor controllers. The page (dated 10 Mar 2026) is open about the limits: hand-chosen mappings, a sparse DN interface, weak effect of vision, no validation of internal dynamics. The '91%' figure (fly-brain README:117) is the accuracy of the non-embodied Shiu et al. (Nature 2024) LIF model at predicting experimental activation results. It says nothing about the embodied fly. A third-party README (TheFlyExperiment/Virtual-Embodied-Fly, not by Eon) claims '95% motor behavior accuracy' and says it is not an RL policy, which conflicts with Eon's own account. paper_url points to the peer-reviewed brain model; the embodied work itself is a blog post only.

More facts Data licence: CC-BY-NC-4.0 · Peer review: none · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://eon.systems/updates/embodied-brain-emulation [direct]
• https://github.com/orgs/eonsystemspbc/repositories [direct]
• https://github.com/eonsystemspbc/fly-brain [direct]
• https://raw.githubusercontent.com/TheFlyExperiment/Virtual-Embodied-Fly/main/README.md [direct]

Project's own claim “We demonstrate the first-ever nontrivial, biologically realistic connectome simulated on neuromorphic computing hardware.” source

Mechanism Wiring: FlyWire FAFB, release not stated (~140K neurons). Neuron model: LIF (fixed-point microcode approximation of Shiu et al. model). Input: hand-made. Output: none. Trained parts: none. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) Engineering validation only: spike rates compared with the Brian2 reference simulation (sugar experiment, 10 trials). Table 1, wall-clock per 1 s simulated for the sugar experiment: Brian2 4419 ms, STACS 2656 ms, Loihi 2 53.76 ms (0.1 ms step) and 12.40 ms (1 ms step); overall ~3x-~350x faster than Brian2 depending on activity level. No comparison with fly data and no wiring control.

Grade basis (checked 28 Sep 2026)

• https://arxiv.org/html/2508.16792 Sec. 3.1: network model 'replicated from [7]' (Shiu et al., Nature 2024); ~140K neurons, synapses condensed to ~15M connections [direct]
• https://arxiv.org/html/2508.16792 Sec. 3.1.1 / Fig. 6: STACS vs Brian2 spike-rate parity for the sugar neuron experiment over 10 trials [direct]
• https://arxiv.org/html/2508.16792 Conclusion / Table 1: Loihi 2 ran ~3x to ~350x faster than the Brian2 reference; faster than real time at low activity [direct]
• No code or data link found in the abstract page or full text [direct]

Limits This is a hardware/simulation-speed paper, not a new model of behaviour: it is a port of the Shiu et al. model and its validation is parity with the Brian2 reference, not with flies. No public code found, so the mechanism cannot be inspected (grade U); as a simulator it would otherwise sit with infrastructure (n/a). Needs Loihi 2 hardware (Intel research access), not available to the public. FlyWire release not named; ~140K neurons suggests v783 but this is our inference. Fixed-point arithmetic, weight quantisation/capping and timestep changes mean small differences from the reference. arXiv v1, 22 Aug 2025 (cs.DC); an earlier version was presented in an NIH lecture in Oct 2024 [search-summary].

More facts Data licence: CC-BY-NC-4.0 · Peer review: preprint · Repository created: n/a (not an update date) · Last push, any branch: n/a

Sources

• https://arxiv.org/abs/2508.16792 [direct]
• https://arxiv.org/html/2508.16792 [direct]
• https://videocast.nih.gov/watch=55007 [search-summary]

Project's own claim “cross-validated AUC-PR of 0.759 against 0.041 by chance, and none of 500 randomized wirings matched it (p = 0.002)” source

Mechanism Wiring: MaleCNS v1.0 cell-type graph (11,751 types). Neuron model: none. Input: none. Output: none. Trained parts: LightGBM classifier on graph/neuropil/transmitter features. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) results/null_model_summary.json: all 89 features AUC-PR 0.759 vs 500 degree-preserving rewirings 0.712 +/- 0.005 (range 0.696-0.725), 0/500 >= real, p = 0.002; topology only 0.489 vs 0.070 +/- 0.004, p = 0.002. Chance 0.041. Neuropil features alone reach 0.722. Measured by the author, not reproduced by us.

Grade basis (checked 28 Sep 2026)

• pipeline/common.py:15-16 neuPrint server, DATASET = 'male-cns:v1.0' [direct]
• pipeline/null_model.py:28-50 rewire(): igraph degree-preserving swaps (10 x |E|), out-strength kept [direct]
• pipeline/null_model.py:66-76,108-140 recompute topology features, retrain same model with same folds, empirical p with +1 correction [direct]
• results/null_model_summary.json: real 0.7589 vs null 0.7116 +/- 0.0049 (full), 0.4888 vs 0.0696 +/- 0.0038 (topology only), 0/500, p = 0.002 [direct]

Limits Graded n/a because this is a graph-statistics study, not a neural simulation: no activity or behaviour is modelled, so the A-D scale does not fit. The control itself is real and implemented in code (would meet the 'proper control' bar). Most of the signal is anatomical location (neuropil-only 0.722; randomised wirings still score 0.712), so the extra gain from wiring in the full model is small (+0.047). p = 0.002 is the floor for 500 permutations. Correlational only; labels come from existing annotations. One of three pre-specified checks failed (named types ranked 531-591). Measured by the author, not reproduced by us.

More facts Data licence: CC-BY-4.0 · Peer review: none · GitHub stars: 0 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-14 (not an update date) · Last push, any branch: 2026-09-20; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/dhruvin-sarkar/ConnectomeLens [direct]
• https://dhruvin-sarkar.github.io/ConnectomeLens/ [direct]
• https://dhruvin-sarkar.github.io/ConnectomeLens/report.pdf [paper]

Project's own claim “Across 164 predictions we were able to test empirically, 91% were consistent with our empirical results (Supplementary Table 9).” source

Mechanism Wiring: FlyWire FAFB materialization v630 (127,400 proofread neurons per paper Methods); v783 files provided as an option. Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none; one free parameter w_syn = 0.275 mV per synapse, tuned by hand. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) Paper (PMC11446845): 91% of 164 testable predictions matched experiments (84% excluding the split-GAL4 optogenetic activation screen); split-GAL4 screen >90% accuracy; shuffled-weight control activated MN9 in 1/100 runs vs 100% for the real connectome. Robustness: +/-30% w_syn and +/-50% inhibition changes keep 88-96% agreement with the default model ('95%' appears here, not as an accuracy figure).

Grade basis (checked 28 Sep 2026)

• model.py:15-53 default_params: v_0 = v_rst = -52 mV, v_th = -45 mV, t_mbr = 20 ms, tau = 5 ms (synaptic), t_rfc = 2.2 ms, t_dly = 1.8 ms, w_syn = 0.275 mV (free parameter), r_poi = 150 Hz, f_poi = 250 (Poisson input weight = 250 x 0.275 mV) [direct]
• model.py:44-52 equations: dv/dt = (v_0 - v + g)/t_mbr, dg/dt = -g/tau, spike when v > v_th, reset v and g [direct]
• model.py:156-183 loads completeness CSV + connectivity parquet; synapse weight = 'Excitatory x Connectivity' (signed synapse count) x w_syn; on_pre g += w [direct]
• figures.ipynb cell 0 config uses 2023_03_23_completeness_630_final.csv and 2023_03_23_connectivity_630_final.parquet; cells run the sugar/water/bitter/Ir94e GRN and MN9 experiments of the paper figures [direct]
• Readme.md 'Version 783': code is set up for FlyWire v630 as in the paper; for v783 change config path_comp='./Completeness_783.csv' and path_con='./Connectivity_783.parquet' [direct]
• PMC11446845 Discussion: 91% of 164 empirically testable predictions consistent with experiments (84% when excluding the split-GAL4 optogenetic screen) [direct]
• PMC11446845 Results: with shuffled connectivity weights only 1 of 100 simulations activated MN9 vs 100% with the real connectome at 100 Hz sugar GRN input (Supplementary Table 1d) [direct]

Limits The comparison with fly experiments lives in the paper (supplementary tables), not in repo code: the repo produces the model predictions only. The '91%' is the fraction of 164 predictions consistent with experiments; the '95%' figures in the paper are agreement between perturbed and default model (robustness), not accuracy against flies. The paper states it does not trust absolute firing rates; no gap junctions, neuromodulation, or baseline activity. Environment pins Python 3.10 and Brian2 2.5.1; runs on CPU (paper: about 5 min per 1 s trial per CPU thread for sugar activation). Readme links the bioRxiv preprint; the Nature 2024 version is the final one. Last commit 2024-09-14.

More facts Data licence: CC-BY-NC-4.0 · Peer review: peer-reviewed · GitHub stars: 349 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2023-02-25 (not an update date) · Last push, any branch: 2024-09-14; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/philshiu/Drosophila_brain_model [direct]
• https://pmc.ncbi.nlm.nih.gov/articles/PMC11446845/ [direct]
• https://doi.org/10.1038/s41586-024-07763-9
• https://www.biorxiv.org/content/10.1101/2023.05.02.539144v1

Project's own claim “The published Shiu et al. leaky integrate-and-fire model ... runs at 0.29 seconds per biological second on an M4 Pro” source

Mechanism Wiring: FlyWire v630 whole brain (127,400 neurons, 14,687,178 edges); also MaleCNS v1.0 (166,700 neurons). Neuron model: LIF. Input: hand-made. Output: hand-made. Trained parts: none. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) Shuffle control (README.md:50-57; docs/figures/control-demo.svg), 21 right sugar GRNs at 100 Hz, 30 x 1 s trials: real v630 wiring gives MN9 67.30 Hz with 408 active neurons; the degree-preserving shuffle gives MN9 0 Hz with 96 active (seeds 1-4: MN9 silent, 89-99 active); input GRNs fire at 99.40 vs 99.38 Hz. Brian2 parity (README.md:522-527): ref64 is identical to Brian2 in all 4 configs (38 to 24,700 spikes); MLX float32 counts match in 3 of 4 and are 2,974 vs 2,973 in one. Against the upstream Brian2 notebook files (README.md:558-566): MN9 67.03 Hz (Brian2) vs 67.30/67.67 Hz; spikes per trial within |z| 1.90. Speed: 0.29 s vs Brian2 2.07 s per biological second on M4 Pro (README.md:8-9,159).

Grade basis (checked 28 Sep 2026)

• src/lif/compile_pack.py:27,430 builds the pack from Shiu's 'Excitatory x Connectivity' column, dataset flywire-v630 [direct]
• src/lif/shuffle_pack.py:1-16,56-75 degree-preserving shuffle: each neuron keeps its in/out degree and signed output, and targets are permuted [direct]
• src/lif/control_demo.py:1-12,28,145-163 runs the same sugar input on the real pack and the shuffled pack and reads out MN9 [direct]
• docs/figures/control-demo.svg (text labels): real wiring MN9 67.3 Hz, 408 neurons active; shuffled seed 0 MN9 0.0 Hz, 96 neurons; sugar GRNs 99.4 Hz in both [direct]
• README.md:47-58 the same control; seeds 1-4 also leave MN9 silent (89-99 neurons active) [direct]
• README.md:515-540 and src/lif/validate_brian2.py: the float64 oracle matches Brian2 spike for spike on an 800-neuron subnetwork [direct]

Limits Not a new model: the equations, constants and v630 wiring are Shiu et al.'s, and the MN9 result itself is Shiu's. The new parts are the engine and a shuffled-wiring control, which shows that the sugar-to-MN9 signal needs the real wiring (this mirrors the shuffle control in the Shiu paper). The control uses one readout neuron, one stimulus and 5 shuffle seeds. The control numbers come from the README and the figure; we did not re-run them. There is no comparison with fly data beyond Shiu's. Apple Silicon only (Metal GPU). No body. The README reports that the upstream sugarR reference file was run at 200 Hz, while upstream default_params now say 150 Hz (README.md:569-573). Licence MIT.

More facts Data licence: several (see dataset entries) · Peer review: none · GitHub stars: 2 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2026-09-14 (not an update date) · Last push, any branch: 2026-09-26; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/Kisame76/drosophila-brain-mlx [direct, local clone e417b33]

Project's own claim “A connectome-constrained deep mechanistic network (DMN) model of the fruit fly visual system in PyTorch.” source

Mechanism Wiring: FlyEM FIB-25 + FIB-19 medulla/optic lobe column connectome (file fib25-fib19_v2.2.json), 65 node types tiled on a hexagonal lattice of radius 15 columns (721 columns, ~45,669 neurons per paper). Neuron model: other: graded/rate passive point neurons with instantaneous graded-release synapses and ReLU output (PPNeuronIGRSynapses). Input: hand-made. Output: learned. Trained parts: per-cell-type time constants and resting potentials (bias), per type-pair synapse strength scale, plus a convolutional optic-flow decoder; synapse counts and signs are fixed from the connectome. Body: none. Scripted parts: none found.

Measured result (by the authors unless stated) Paper (PMC11525180, quotes checked 2026-10-03): the ensemble median predicts the preferred contrast (ON/OFF) of all 32 cell types with known polarity, the best single model 30 of 32; models with better task performance predict T4/T5 direction selectivity better (r = 0.60, P = 2.6e-6); predictions agree with measurements from 26 studies. Controls: random parameters on the full connectome still get contrast right but direction selectivity and preferred direction poorly; with only cell-type connectivity, trained models predict activity poorly; contrast needs only synapse signs, and direction selectivity (not preferred direction) is possible without synapse counts. No shuffled-wiring network was tested. The authors' 50 pretrained models have validation losses from 5.137 to 5.678 (median 5.300), read by us from their files.

Grade basis (checked 28 Sep 2026)

• flyvis/config/network/connectome/connectome.yaml:1-4 - loads ConnectomeFromAvgFilters from fib25-fib19_v2.2.json, extent 15 columns [direct]
• flyvis/connectome/connectome.py:109-160 - builds the network graph (cells + synapse sets with column offsets and synapse counts) from the JSON connectome [direct]
• flyvis/network/dynamics.py:152-218 - PPNeuronIGRSynapses: weight = sign * syn_count * syn_strength; dV/dt = (-V + bias + sum(w*ReLU(V_pre)) + input)/tau [direct]
• flyvis/config/network/edge_config/sign/sign.yaml:3 - synapse signs fixed (requires_grad: false); syn_strength.yaml:3 and node_config/time_const/time_const.yaml:6 - strength scale and time constants trained [direct]
• flyvis/config/task/task.yaml:1-4,30-39 - training task is optic flow on Sintel movies with a learned DecoderGAVP readout [direct]
• flyvis/network/stimulus.py:128-131 - visual input is written only to the input cell types (photoreceptors R1-R8) on the hex lattice [direct]
• flyvis/utils/groundtruth_utils.py:13-60,484-530 - literature ground truth: ON/OFF polarity per cell type, known direction-selective types, T4/T5 tuning curves from Maisak et al. 2013 [direct]
• flyvis/analysis/flash_responses.py:101-105 and flyvis/analysis/moving_bar_responses.py:442-507 - model flash/moving-edge responses scored against that ground truth (polarity, DSI, tuning-curve correlation) [direct]
• Europe PMC full-text XML PMC11525180 read 2026-10-03: 64 cell types, 45,669 neurons, 1,513,231 connections, 721 columns; 734 free parameters; ensemble median FRI right for all 32 characterised cell types, best model 30 of 32; r = 0.60, P = 2.6e-6 (task performance vs DSI prediction); 26 studies; random-parameter and ablation statements (quotes on https://shaduf.ai/p/digital-fly-catalog/projects/flyvis/) [direct]
• results_pretrained_models.zip (sha256 71c78d40...281db1, equal to upstream's checksum) read 2026-10-03: 50 models, validation loss median 5.300 (IQR 5.279-5.333), from validation_loss.h5 [direct]
• Pretrained-model licence: license.txt (MIT) in the authors' public Drive folder, created 2026-09-29 [direct]

Limits Connectome is a small, column-averaged optic lobe model from FlyEM FIB-25/FIB-19 data (paper credits Shinomiya/Takemura et al.), not FlyWire or a whole-brain release; the file name 'v2.2' is the authors' compilation version, not a public dataset release. The dataset enum has no FIB-25/FIB-19 value, so 'several' is used. Comparison is with published literature values (polarity, DSI, tuning curves), not new recordings. Neuron model is a passive graded rate model; many parameters are trained (flagged). Docs say tested on Linux, Python 3.9-3.12 (pyproject.toml:67 requires >=3.9,<3.13). GPU helps for training; inference with pretrained models can run on CPU (not verified here). Could not open nature.com directly (login redirect); paper numbers come from the PMC copy.

More facts Data licence: FlyEM FIB-25/FIB-19 reconstructions (Janelia), compiled per column by the authors; no separate data licence stated. Pretrained models: MIT (license.txt in the authors' Drive folder, 2026-09-29) · Peer review: peer-reviewed · GitHub stars: 190 (27 Sep 2026; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026) · Repository created: 2023-03-12 (not an update date) · Last push, any branch: 2026-08-18; reused from our 27 Sep 2026 check, not re-queried on 6 Oct 2026

Sources

• https://github.com/TuragaLab/flyvis [direct]
• https://turagalab.github.io/flyvis/ [direct]
• https://pmc.ncbi.nlm.nih.gov/articles/PMC11525180/ [fetch-summary]
• https://doi.org/10.1038/s41586-024-07939-3 [paper]