The Complete Wiki to the Neuroscience DOOM Project

The Neuroscience DOOM Project is one of those experiments that sounds like a joke until you look at the engineering underneath it.

In September 2026, researchers released a complete connectome of the male Drosophila central nervous system, containing approximately 166,700 neurons. The dataset was produced through a collaboration involving HHMI Janelia, Google Research, the University of Cambridge and the MRC Laboratory of Molecular Biology.

Soon after the connectome became available, developers began connecting the digital fruit-fly nervous system to DOOM.

The resulting projects are not one single official neuroscience experiment. They are a collection of open-source engineering projects that use the newly available biological wiring data in different ways.

One prominent project, DoomFly, uses the full MaleCNS v1.0 connectome, a simulated visual input system, neural dynamics and a controller to interact with a DOOM environment. Its developers explicitly distinguish between the real biological wiring taken from the connectome and the engineering choices required to turn that wiring into something capable of interacting with a game.

Quick Facts

The underlying MaleCNS project contains 166,700 neurons spanning the brain and nerve cord, with 11,710 neuron types.

What Is the Neuroscience DOOM Project?

The basic idea is simple:

Take a digitally reconstructed fruit-fly nervous system, simulate its activity, give it visual information from DOOM, and translate neural activity into game actions.

The difficult part is everything between those steps.

A connectome is essentially a map of which neurons connect to which other neurons. It is not automatically a working digital brain.

To turn the wiring diagram into a playable system, developers need additional software for:

• Neural activity
• Synaptic interactions
• Visual input
• Sensory mapping
• Motor output
• Game-state processing
• Simulation timing
• Action selection
• Training or control

This is why the project is as much a software-engineering experiment as it is a neuroscience demonstration.

DoomFly's own documentation makes this distinction explicitly: the wiring comes from real biological data, while the process of converting that wiring into gameplay involves engineering decisions.

The Fruit Fly Brain Behind the Project

The foundation is MaleCNS v1.0, the complete male Drosophila central nervous system connectome.

The dataset was released by the FlyEM project and collaborators in 2026.

The reconstruction covers the:

• Brain
• Optic lobes
• Ventral nerve cord

The published connectome contains approximately 166,700 neurons and 11,710 neuron types.

The research also provides synaptic-level information and allows scientists to investigate how sensory information can travel through the nervous system toward motor outputs.

That makes the dataset particularly interesting for computational experiments.

What Is a Connectome?

A connectome is a map of the connections within a nervous system.

Think of it as a wiring diagram.

A conventional brain scan can show structure.

A connectome attempts to go much further by describing:

Neuron A → Neuron B

and potentially the synaptic relationships involved.

For computational researchers, this creates a starting point for building simulations.

But a connectome alone does not provide everything required for a functioning digital brain.

It does not automatically specify:

• The complete physiological behavior of every neuron
• Every neurotransmitter effect in perfect detail
• How the network should evolve over time
• How raw pixels should enter the network
• How neural activity should control a computer

Those layers have to be modeled.

The MaleCNS Connectome

The MaleCNS project is particularly significant because it reconstructs the entire male Drosophila central nervous system rather than focusing on a small circuit.

The published research describes the dataset as fully proofread and annotated. It also includes information related to fruitless and doublesex expression, allowing researchers to investigate sexually dimorphic neural circuits.

The official Male CNS project provides tools for:

• Exploring cell types
• Inspecting connectivity
• Comparing male and female neurons
• Querying connections through NeuPrint
• Exploring annotations through Clio
• Downloading datasets
• Programmatically querying the data

That accessibility is one reason developers can rapidly experiment with the dataset.

How Does the Fruit Fly See DOOM?

This is where the project stops being a simple connectome visualization.

The computer game produces video frames.

A simulated fly nervous system cannot simply receive a conventional computer image and magically understand it.

The image therefore has to be converted into something resembling sensory information.

In the DoomFly implementation, DOOM frames are mapped into simulated fly photoreceptor inputs.

The project documents approximately:

• 3,335 brightness inputs
• 811 color inputs

corresponding to modeled photoreceptor channels.

However, an important distinction is necessary.

The mapping between a DOOM frame and these simulated photoreceptors is an engineering approximation.

It is not a complete experimentally validated model of exactly how a real fly would perceive a DOOM screen.

The Visual Pipeline

The simplified architecture looks like this:

DOOM frame

↓

Simulated fly eye

↓

Photoreceptor signals

↓

Visual neurons

↓

Connectome simulation

↓

Neural activity

↓

Controller

↓

DOOM action

This is the central engineering pipeline behind the experiment.

The connectome provides the biological wiring, but software provides the interfaces connecting that wiring to a computer game.

Simulating the Neural Network

A biological connectome contains enormous numbers of connections.

Simply storing the data is not enough.

The project therefore needs a computational model capable of repeatedly updating neural activity.

DoomFly's documentation describes a native C++ simulation kernel that propagates activity through the connectome using simplified spiking/rate-style dynamics and neurotransmitter-signed weights.

This is an important distinction.

The project is not claiming to reproduce every biological detail of a living fly neuron.

Instead, the software uses a computational model operating over a real biological wiring graph.

Real Biology vs Engineering

This is arguably the most important concept in understanding the project.

Real biological data

The project can use:

• Real neuron identities
• Real neuron connectivity
• Real anatomical structures
• Real synaptic relationships
• Real cell-type classifications

Engineering choices

Developers still need to decide:

• How neurons behave computationally
• How game pixels become sensory signals
• How quickly the simulation updates
• Which neural populations control movement
• How neural activity becomes keyboard inputs
• Whether learning is introduced
• How the game environment interacts with the simulation

Therefore:

The connectome is biological data.

The playable DOOM system is a computational construction built around that data.

The Controller Layer

A simulated brain does not automatically press a keyboard key.

The project needs a mechanism that reads neural activity and converts it into actions.

DoomFly documents a controller that reads activity from selected neural populations and chooses game actions such as:

• Advance
• Turn
• Strafe
• Fire

The repository describes a PPO-trained controller reading activity from 20 neural populations.

This is another major caveat.

The controller is not simply a neuron in the original fly brain that says:

"Press fire."

It is a software interface designed by the developers.

Where Reinforcement Learning Fits In

Some implementations use reinforcement learning to connect neural activity to useful game behavior.

This creates an additional layer:

Connectome

↓

Neural simulation

↓

Neural activity

↓

Learned controller

↓

Game action

The learning system therefore does not mean the entire simulated fly brain is being trained from scratch.

In the DoomFly implementation, the underlying wiring is imported from the biological connectome while the controller is an engineered component.

Why DOOM?

DOOM has become a popular benchmark for unusual AI and computing experiments.

One reason is its relatively simple interface.

A system can receive:

Screen → action

and repeatedly interact with the environment.

The open-source ViZDoom platform was specifically designed to make DOOM useful for visual reinforcement-learning research. It exposes game environments to AI systems and allows researchers to build custom scenarios.

That makes DOOM particularly convenient for experiments involving unconventional controllers.

What Is ViZDoom?

ViZDoom is an AI research platform based on the DOOM engine.

Instead of treating DOOM only as a commercial game, ViZDoom provides an environment where researchers can build agents that:

• Observe game frames
• Select actions
• Receive rewards
• Navigate environments
• Train visual agents

The original ViZDoom research demonstrated its use for visual reinforcement learning in first-person 3D environments.

This provides useful infrastructure for connecting a simulated nervous system to a game.

The Open-Source Engineering

One of the most interesting parts of the current DOOM-fly ecosystem is that several implementations are publicly available.

DoomFly's repository contains components for:

• Connectome loading
• Neural simulation
• Game integration
• Controller code
• Data provenance
• Testing
• Documentation
• Experimental results

The repository also provides dataset references and hashes instead of simply embedding the multi-gigabyte biological dataset directly into the project.

That structure makes the experiment easier for other developers to inspect and reproduce.

Data Provenance

Scientific computational projects need to know exactly which dataset was used.

DoomFly includes a dataset registry and provenance information that identifies the source of the MaleCNS data and provides hashes for the relevant files.

This matters because a connectome is not just a small configuration file.

Different dataset versions could contain changes in:

• Neuron counts
• Annotations
• Connectivity
• IDs
• Synapses
• Metadata

Pinning the dataset makes computational experiments more reproducible.

The Software Architecture

A simplified architecture can be represented as:

MaleCNS Dataset

↓

Connectome Loader

↓

Neural Simulation Kernel

↓

Sensory Input Mapping

↓

Selected Neural Populations

↓

Controller

↓

ViZDoom

↓

New Game Frame

↓

Sensory Input

This creates a closed computational loop.

The game generates visual information.

The simulated nervous system processes it.

The controller produces an action.

The game changes.

The cycle repeats.

Full Connectome vs Reduced Models

Not every project using the fruit-fly brain uses the same number of neurons.

Some experiments use the full MaleCNS dataset.

Others use smaller subsets or separate Drosophila neural models because running the complete network can be computationally expensive.

For example, another open-source DOOM-fly implementation describes a pipeline involving FlyVis, an experimental bridge into a Drosophila brain model, and ViZDoom. Its authors explicitly describe the bridge as approximate and biologically unvalidated.

This is why headlines about "the fly brain playing DOOM" should be treated carefully.

There are multiple implementations.

They do not necessarily use identical architectures.

Is It Actually a Digital Fly?

Not in the biological sense.

The software is better described as a computational simulation based on fruit-fly neural wiring.

A real fly contains:

• Living neurons
• Biochemistry
• Neuromodulators
• Cellular dynamics
• Sensory organs
• Muscles
• Body mechanics
• Metabolism

The simulation abstracts many of these systems.

The resulting program can therefore reproduce or model selected aspects of neural processing without being an artificial living organism.

Is the Simulated Fly Conscious?

There is no evidence from these projects that the simulated network is conscious.

The developers describe the system as a computational model and explicitly distinguish the simulation from a living brain.

Playing DOOM is therefore not evidence that a digital fly has developed human-like awareness or subjective experience.

The interesting achievement is computational:

Can real neural wiring be converted into a functioning simulation that interacts with an environment?

What Makes the Project Important?

The DOOM experiment is interesting because it demonstrates a practical use for a newly available whole-nervous-system connectome.

Instead of only viewing the connectome as a static map, developers can attempt to make it computational.

That opens possible research directions involving:

• Neural circuit modeling
• Sensory processing
• Motor control
• Connectome-based AI
• Robotics
• Brain-inspired computing
• Neural simulation
• Reinforcement learning
• Biological circuit analysis

The MaleCNS project itself was created as a resource for studying complete sensory-to-motor circuits underlying behavior.

What the Project Does Not Prove

The DOOM experiment should not be interpreted as proving that:

• A fruit fly has human-level intelligence
• A connectome automatically becomes a working brain
• Digital neural simulations are biologically perfect
• The simulated fly understands DOOM
• The network is conscious
• Every neural connection has been perfectly modeled physiologically
• The controller represents the fly's natural behavior

Those conclusions go beyond what the software demonstrates.

The Bigger Neuroscience Picture

The underlying connectome is arguably more important than the novelty of DOOM.

The MaleCNS project allows researchers to inspect how information flows through a complete Drosophila central nervous system.

The 2026 research specifically examined sensory-to-motor pathways, sexually dimorphic circuits and the organization of higher brain centers.

That means the same data used for a bizarre gaming experiment can also support conventional neuroscience research.

From Fruit Fly to Artificial Brain

The project also demonstrates a broader engineering direction.

Instead of designing an artificial neural network entirely from mathematical abstractions, researchers can start with an actual biological wiring diagram.

The potential pipeline becomes:

Biological nervous system

↓

Connectome

↓

Computational model

↓

Artificial environment

↓

Behavior

This could eventually help researchers investigate how complex behavior emerges from structured neural circuits.

The Drosophila nervous system is small enough to make this approach computationally approachable compared with a human brain.

Why Open Source Matters

The open-source component is important because it lets developers inspect the implementation rather than relying solely on a demonstration video.

A public repository can expose:

• Simulation code
• Controller implementation
• Dataset references
• Configuration
• Testing
• Experimental results
• Failure cases
• Documentation

DoomFly's repository explicitly includes source code, documentation, data provenance and results.

This also makes it possible for other developers to replace individual components.

For example, someone could theoretically modify the:

Visual model

without replacing the:

Connectome simulation

or modify the:

Controller

without replacing the:

Neural network.

Different DOOM-Fly Approaches

The current ecosystem should not be treated as one standardized experiment.

The last category is particularly important.

A petri-dish neural culture playing DOOM is not the same technology as a digitally simulated fruit-fly connectome playing DOOM.

The former involves living biological neurons.

The latter uses computer simulation.

They should not be conflated.

Digital Connectome vs Biological Neurons

The common element is DOOM.

The underlying technology is completely different.

Main Technical Challenges

The project still faces substantial engineering challenges.

Computational Cost

Simulating tens or hundreds of thousands of neurons with millions of connections can require significant computational resources.

Biological Accuracy

A connectome provides wiring, but biological neural activity is more complicated than a graph.

Sensory Translation

DOOM pixels need to be transformed into meaningful neural signals.

Motor Translation

Neural activity needs to become discrete game actions.

Timing

Biological systems operate continuously, while games and computers operate according to digital update loops.

Validation

A successful game run does not automatically validate the biological model.

The Most Important Limitation

The biggest limitation is the difference between structure and function.

The connectome tells researchers a tremendous amount about structure.

But structure alone does not fully specify biological computation.

For example, knowing that two neurons are connected does not necessarily tell you everything about:

• Signal strength
• Timing
• Modulation
• Cellular state
• Plasticity
• Neuromodulatory context

The simulation therefore has to make assumptions.

DoomFly's documentation openly acknowledges that its neural dynamics are chosen computational models rather than a complete fit to biological recordings.

Why the Engineering Is More Interesting Than the Meme

The headline is:

"Fruit fly brain plays DOOM."

The actual engineering story is much deeper.

Developers had to build a pipeline connecting:

Electron-microscopy-derived neuroscience data

to

a computational neural model

to

a simulated sensory system

to

an action controller

to

a real-time game environment.

That makes the project an unusual intersection of:

Neuroscience + Connectomics + AI + Open Source + Game Technology.

Timeline

The MaleCNS project page records the June 2026 v1.0 release and September 2026 publication.

Frequently Asked Questions

What is the Neuroscience DOOM Project?

It refers to a group of experiments that connect a computational model of a fruit-fly nervous system to the DOOM game environment.

What fruit fly is being simulated?

The underlying MaleCNS dataset reconstructs the male Drosophila central nervous system.

How many neurons are in the MaleCNS connectome?

The published dataset contains approximately 166,700 neurons.

Is the entire fruit fly brain being simulated?

Some implementations use the full MaleCNS connectome, while others use reduced or alternative Drosophila models.

Does the simulation use a real fruit fly brain?

No. It uses a digital reconstruction of neural wiring.

Does the fruit fly actually understand DOOM?

There is no evidence that it understands the game in the human cognitive sense.

How does DOOM provide information to the neural simulation?

The game frame is transformed into simulated sensory inputs representing fly photoreceptor signals.

How does the simulated brain control DOOM?

A software controller interprets selected neural activity and converts it into game actions.

Is the project open source?

Several implementations are publicly available, including DoomFly. Its repository contains the simulator, controller, documentation and provenance information.

Is this the same as the human-brain-cell DOOM experiments?

No. Those experiments use living biological neurons, while the fruit-fly connectome projects discussed here use computer simulations.

Is the simulated fly conscious?

There is no evidence establishing consciousness in these simulations.

Current Status

The Neuroscience DOOM Project is best understood as an emerging collection of open-source experiments built around the newly released MaleCNS fruit-fly connectome.

The underlying neuroscience is real: researchers reconstructed approximately 166,700 neurons across the male Drosophila central nervous system, with thousands of identified neuron types and synaptic connectivity data.

The DOOM layer is an engineering experiment built on top of that dataset.

The most important distinction is therefore:

Real biological wiring + simulated neural dynamics + engineered sensory mapping + software controller + DOOM.

That combination turns an enormous neuroscience dataset into something developers can actually run, modify and experiment with.

And that may ultimately be the most valuable part of the project: not that a simulated fruit fly can play DOOM, but that a complete biological nervous-system wiring diagram can become an executable computational platform for experimentation.