A Fly Connectome on the Daedaluzz Maze Benchmark

On 3 September 2026, Google Research and HHMI Janelia published MaleCNS v1.0, the complete connectome of an adult male fruit fly: 166,700 neurons and about 125 million synapses. Within a week, hobbyists had wired a leaky integrate-and-fire simulation of it to Doom, Super Mario 64 and a Bitcoin trading account. We wired it to a smart-contract fuzzing benchmark.

This note describes one experiment: maze-0 of the Daedaluzz L32 set and the tool versions from our August fuzzer benchmark, with the connectome as a third contender beside Echidna and Wake, each given the same 6,000 transactions. It records the wiring, the numbers, and the asymmetries between the three.

The setup

Daedaluzz, by Consensys Diligence, generates maze contracts: a 7×7 grid, four move functions that each take eight uint64 parameters, and cells that hide an assert(false) behind a chain of arithmetic guards on those parameters. Reaching an assertion means walking the contract to the cell across transactions and then supplying inputs that satisfy every guard. The score is the number of distinct assertions reached.

The maze is maze-0 of the L32 set from the August benchmark: guard constants capped at 2³²−1, inputs uint64, arithmetic unchecked; 43 assertions, 5 walls, and guard chains from 2 to 16 conditions deep.

The tools:

• Echidna 2.3.3, solc 0.8.19, with the configuration from the Daedaluzz repository: exploration mode, sequences of 100 calls with a fresh deployment between sequences, coverage-guided corpus. Violations are read from Echidna’s own coverage report, as the Daedaluzz scripts do.
• Wake 5 rc, the build measured in August, with the revm backend and solc 0.8.19, running the fuzz test published with that benchmark: four flows drawing eight random uint64 values each, 100 sequences of 1,000,000 flows, a found() invariant read after every flow, and SIGINT at the time budget. Two lines were added to the test: a print when the set of found assertions grows, and a flow counter.
• The fly brain, described below.

Hardware: one Apple M4 with 10 cores and 32 GB. Echidna and Wake compile with the optimizer settings of their benchmark-repository configurations, which leave the optimizer off.

The fly brain as a fuzzer

The brain is MaleCNS v1.0 as the fly64 project loads it: 166,700 annotated cells and 25,582,938 synapses between them, each synapse’s weight the measured synapse count, signed by the presynaptic cell’s predicted neurotransmitter (GABA, glutamate and histamine inhibitory), normalised per postsynaptic cell. The dynamics are fly64’s rules, unchanged: every 20 ms, a cell’s voltage decays with a 100 ms time constant, receives 1.5 times its weighted input spikes plus a tonic 0.18 and seeded background noise, fires at 1.0 and resets to 0. Every 20 ms step, the model updates 166,700 leaky integrate-and-fire cells over 25,582,938 signed synapses; around 10,800 of them spike per step. Nothing in the network was tuned for mazes.

The wiring between brain and contract was fixed before any run:

signal	cells	mapping
contract position	R1–R8 photoreceptors, about 122 per cell of a 7×7 partition of the eye atlas	the current maze cell lights one patch of the retina, drive 0.62 per step
reverted transaction	the 16 PPL1 dopamine cells	a pulse for two steps
reward	the 316 PAM dopamine cells	a pulse for two steps; +0.5 for a cell entered for the first time, +0.25 for reaching deeper into a guard chain than before, +1.0 for a new assertion
move direction	DNg100 (north), MDN (south), right and left DNa02 + DNg13 (east, west)	softmax over spikes per two cells
the eight parameters	eight balanced pools of central-complex cell types, about 370 cells each	the pool’s spike count picks a bit length from 1 to 64; a hash of which cells fired supplies the bits
learning	70,053 synapses: Kenyon cell → mushroom-body output neuron, and all synapses onto the four direction pools	eligibility trace × signed dopamine, η 0.05, bounded to 3× the original weight

Each transaction is eight brain steps, 160 ms of brain time. Sequences are 100 transactions long, then the contract is redeployed, matching Echidna’s seqLen. The parameter mapping mirrors the shape of Wake’s integer generator, which also draws a bit length before the bits.

The brain runs against a Python transpilation of the maze contracts with uint64 wrap-around, not against the EVM. Replaying Echidna’s saved corpus through that model reproduces exactly the assertion ids in Echidna’s coverage report for this maze. One brain step costs about 5 ms of compute for the propagation of roughly 1.6 million synaptic events, so the fly executes about 20 transactions per second on one core alone and about 10 beside the other campaigns.

The 6,000-transaction race

Maze-0, seed 0, the same 6,000 transactions for each tool. The fly brain reached 6 of the 43 assertions, Echidna 7 and Wake 7, and every assertion the fly reached was also reached by both fuzzers. The seventh, assertion 34, was reached by Echidna and Wake and not by the fly. The order and timing differ:

tool	assertions reached, in order (transaction of first hit)
fly brain	42 (126), 35 (600), 16 (1,257), 9 (1,313), 27 (1,633), 19 (2,298)
Wake 5 rc	16 (278), 35 (304), 19 (333), 42 (592), 27 (820), 34 (1,639), 9 (2,936)
Echidna 2.3.3	16 (3,774), 35 (3,830), 9 (4,150), 42 (4,294), 19 (4,390), 27 (4,470), 34 (5,398)

Of the fly’s 6,000 transactions, 1,979 reverted (a wall, the grid edge, or a reached assertion) and the walk entered all 44 non-wall cells. Echidna’s transaction indices are interpolated from its three-second status lines; Wake’s come from the flow counter; the fly’s are exact.

The video below replays the race at 10 transactions per frame, 24 seconds for the 6,000. The grid is maze-0: five wall cells, the start cell at the bottom left, and 43 assertion cells that begin unmarked. The fly is drawn as a figure whose head holds the connectome’s 140,638 measured soma positions; the cells that spiked in the displayed 20 ms step light up in cyan, and the same brain is repeated at full size under the grid with its spike count. Echidna and Wake move as labelled tags. When a tool reaches an assertion, the cell takes the colour of the first tool to reach it (cyan for the fly, off-white for Echidna, blue for Wake), shows the assertion id, and lists the letters F, E and W for every tool that reached it. Three bars under the maze count each tool’s distinct assertions of 43 as they land. The soundtrack is generated: a 128 BPM bed and one sound per tool at the frame of each first hit, a two-note blip for the fly, a click for Echidna, a low tone for Wake.

What favours whom

• The fly receives a coverage signal: how far into a guard chain a transaction got. Echidna receives the equivalent through instruction coverage of its corpus. Wake’s harness receives no coverage signal.
• The fly and Echidna redeploy every 100 transactions. Wake’s harness redeploys every 1,000,000 flows, so its walk is never reset within the budget.
• The fly’s parameter values follow the shape of Wake’s prior, a bit length drawn from 1 to 64. Echidna draws from its own distribution and dictionary.
• The fly runs outside the EVM, so its wall-clock throughput is a property of the brain simulation, not of a transaction executor. Comparisons in this note are per transaction.
• Echidna’s discovery times come from the timestamps at which it saved a reproducer with new coverage, and its per-violation call indices are interpolated between status lines.
• The brain’s plastic synapses changed weights on every rewarded or punished transaction.
• The connectome is real; the dynamics, the retina mapping and the readout are engineered. fly64’s authors describe their simulation the same way. Nothing here is a claim about fly biology.

Sources and reproduction

• Connectome: MaleCNS v1.0, Berg et al., HHMI Janelia Research Campus and Google Research, CC-BY 4.0, male-cns.janelia.org.
• Simulation rules and eye atlas: fly64, github.com/ornata/fly.
• Mazes: ack3-ai/daedaluzz-benchmark, L32 set; the Wake fuzz test is the one published with the August benchmark.
• Echidna 2.3.3 via Homebrew; Wake 5 rc from github.com/ack3-ai/wake, built from source at the August commit; solc 0.8.19.