# Brain-to-Body Switchboard

**Live site:** [shreyansatvik.github.io/fly-brain-to-body-drosophila-descending-neurons](https://shreyansatvik.github.io/fly-brain-to-body-drosophila-descending-neurons/)

[![The Brain-to-Body Switchboard with DNa02 selected in simulated-activity mode: the searchable list of descending neurons on the left, a 3D fly in the middle with the leg whose motor neurons fire highlighted, and the readout on the right with the experiment checks and reliability notes](images/switchboard-simulated-activity.jpg)](https://shreyansatvik.github.io/fly-brain-to-body-drosophila-descending-neurons/)

*DNa02, a turning neuron, in simulated-activity mode. Click the image to open the site.*

An interactive map of how a fruit fly's brain reaches its muscles, built from the
**Drosophila male central nervous system (male CNS) connectome v1.0**.

A fly's brain doesn't move muscles itself. It sends commands down the neck to the
**nerve cord** (the fly's spinal cord), where the **motor neurons** that drive the
muscles sit. The only cells that carry those commands down are the
**descending neurons**: 1,314 cells grouped into 481 types. This project treats
each descending neuron type as a switch on a control panel. Flip one, and a
3D model of the fly lights up the legs, wings, halteres, neck, abdomen and head
parts it is wired to, and shows whether that wiring adds up to excitation or
inhibition.

Pick a neuron to see which body parts it reaches, then click a body part to see
the wiring it uses to get there: its direct synapses and the strongest routes
through relay neurons.

> Built from wiring, not recordings. Strong reach is a hypothesis worth testing,
> not a prediction of behaviour. The page checks itself against published
> experiments, flags weak or uncertain results, and adds a rough activity
> simulation (see [Limitations](#limitations)).

---

## Features

- **What you can learn here**: a short guide under the header covering four ideas
  (how the brain reaches the body, how wiring shapes a signal, real circuits found in
  the data, and why wiring isn't behaviour), each with buttons that jump to a live
  example, plus a key to the page's panels and what the site can't tell you. It can be
  hidden, and the page remembers that choice.
- **Neuron switchboard**: search all 481 descending neuron types and filter by the
  body part they reach (legs, wings, neck, abdomen, head). Each row shows the
  neuron's transmitter and a heat strip of its reach to eight body parts.
- **Body map**: a 3D fly you can turn and click, whose parts are shaded by reach
  strength (log scale) and coloured by net sign. **Amber** means excitatory, **blue** inhibitory,
  **grey** mixed or unsigned. Hover a part for its numbers.
- **Side and reach controls**: use left-side cells, right-side cells or both;
  count direct connections only (1 synapse) or paths through up to two relay
  neurons (≤ 2, ≤ 3 synapses).
- **Wiring map**: click a body part to see how the selected neuron reaches it,
  laid out as **descending neuron → relay 1 → relay 2 → motor neurons**:
  - *Direct (1 synapse)*: synapses onto the pool's motor neurons, named by muscle,
    e.g. `142 syn → Sternal anterior rotator MN`.
  - *Via 1 relay (2 synapses)*: the strongest relay neurons, with synapse counts
    into and out of each relay.
  - *Via 2 relays (3 synapses)*: the strongest two-relay chains.

  Arrow labels are synapse counts. Arrow colour is the sending neuron's
  transmitter. Arrow thickness and the bar show each path's share of the motor
  pool's input, and each group reports how much of its hop the listed paths
  account for. The map follows the side and reach controls.
- **Neuron readout**: transmitter, cell count, where its output synapses land
  (motor neurons, nerve cord, brain) and the body parts it reaches.
- **Simulated activity**: switch the body map from *Wiring reach* to *Simulated
  activity* to see which motor neurons actually fire when the selected neurons are
  driven at 75 or 150 spikes/s, and press Play to watch it arrive in 50 ms steps.
- **Actions**: pick an action (fly, flap a wing, jump, move sideways, walk forward,
  roll, walk backward, turn, steer flight, land, turn the head) to see which neurons
  the simulation recruits for it. A timeline shows every neuron type that fires, from
  the switched-on descending neurons through the relays to the motor neurons, with a
  Play button; a table, the body parts reached and a ranking of the neurons best at
  recruiting that action's muscles sit beside it.
- **Checked against experiments**: for seven well-studied neurons (giant fiber,
  Moonwalker, pIP10, DNa01, DNa02, DNp07, DNp09), the wiring and the simulation are
  each scored against the body area the published behaviour needs.
- **How solid is this?**: each neuron's transmitter confidence, which body parts
  lose most of their reach under a stricter synapse cut-off, and which net signs flip
  when uncertain transmitters are left out. The giant fiber also carries a note on
  its missing electrical synapses.
- **What feeds it**: the neuron's input traced back up to 3 synapses to vision,
  smell, taste, hearing, touch, body position, temperature and neurons ascending from
  the nerve cord, with the strongest source types.
- **Combinations**: the + button beside each neuron adds it to a combination; the
  body map, readout and wiring maps then show the neurons acting together.
- **Across all descending neurons**: a table of the experiment checks, **families**
  of neuron types clustered by the body parts they reach, and **shared relays**, the
  relay neurons that many descending neurons converge on. Families and relays filter
  the neuron list.
- **Sex-specific filter**: show only neurons with sexually dimorphic, fruitless or
  doublesex labels.
- **Shareable links**: the URL records the current view, e.g. `#DNa02` (a
  neuron), `#DNa02/hl_R` (DNa02 with the right hind-leg wiring map open) or
  `#DNa02+MDN` (a combination).
- Quick picks for well-studied neurons: giant fiber (escape), Moonwalker (backward
  walking), pIP10 (courtship song), DNa02 (turning), and DNge104.

### Try these

| Link | What you'll see |
|---|---|
| `#DNp01/wm_R` | Giant fiber → right wing pool: direct synapses onto TTMn, the jump muscle |
| `#pIP10/wm_L` | Courtship song neuron → left wing: routed through TN1a relays |
| `#DNa02/hl_R` | Turning neuron → right hind leg: direct, single-relay and two-relay routes |
| `#DNg14/hl_R` | A hind-leg specialist with strong direct synapses |

## Quick start

The easiest way is the [live site](https://shreyansatvik.github.io/fly-brain-to-body-drosophila-descending-neurons/).
To run it locally: the site is static, made of `index.html`, `data.js`, `sim.js`,
`actions.js` and the `paths/` folder inside `brain-to-body/`. No build tools are needed.

```bash
git clone https://github.com/shreyansatvik/fly-brain-to-body-drosophila-descending-neurons.git
cd fly-brain-to-body-drosophila-descending-neurons/brain-to-body
python3 -m http.server 8765
# open http://127.0.0.1:8765
```

Double-clicking `index.html` also works, because all data loads as plain script
files.

**GitHub Pages:** the live site is served straight from this repository's `main`
branch. A redirect `index.html` and an empty `.nojekyll` file at the repository root
send visitors to `brain-to-body/`. After rebuilding the data, commit and push the
regenerated files and the site updates within a few minutes.

**Hosting it elsewhere:** upload `index.html`, `data.js`, `sim.js`, `actions.js` and
the whole `paths/` folder, keeping the same relative layout.
`data/`, the Python scripts and this README aren't needed by the site.

## Rebuilding the data

`data.js` and `paths/` are generated by `build.py` from the official bulk release.
You only need to rebuild to change the model or refresh the data. Run every step
below from the `brain-to-body/` folder.

**1. Install the Python dependencies** (Python 3.10+, ideally in a virtual
environment):

```bash
pip install numpy pandas pyarrow scipy
```

**2. Download the three input files (about 560 MB) into `data/`:**

```bash
mkdir -p data && cd data
BASE=https://storage.googleapis.com/flyem-male-cns/v1.0/connectome-data/flat-connectome
curl -O $BASE/body-annotations-male-cns-v1.0-minconf-0.5.feather                         # 14 MB: cell types, classes, sides
curl -O $BASE/body-neurotransmitters-male-cns-v1.0.feather                                # 43 MB: transmitter predictions
curl -O $BASE/connectome-weights-male-cns-v1.0-minconf-0.5-significant-only.feather       # 502 MB: 25.6M connections
cd ..
```

**3. Build:**

```bash
python build.py
```

This writes:

- `data.js`: neuron summaries, reach per body part with its reliability figures,
  upstream senses, feedback loops, families, shared relays and a lookup of neuron
  types (about 3.4 MB)
- `paths/p00.js`, `p01.js`, …: 37 wiring-map files (about 7 MB in total). The page
  loads only the file holding the selected neuron, the first time a body part is
  clicked.

The build takes about 40 seconds and a few GB of RAM. It deletes and rewrites the
old `paths/p*.js` files each time.

**4. Simulate:**

```bash
python simulate.py
```

This drives each of the 953 descending neuron groups (type × side) at two rates and
writes `sim.js` (about 0.3 MB). It takes about 9 minutes on a 10-core laptop and
about 2 GB of RAM.

**5. Actions:**

```bash
python actions.py
```

This scores every descending neuron group against each action and records the
neurons that fire for each action, writing `actions.js`. It takes about 5 minutes.

## Project layout

```
fly-brain-to-body-drosophila-descending-neurons/
├── README.md        # this file
├── index.html       # GitHub Pages redirect to brain-to-body/
├── .nojekyll        # tells GitHub Pages to serve the files as they are
├── flyem.py         # example: query the dataset live through neuPrint
└── brain-to-body/
    ├── index.html   # the website: layout, styles, body map, wiring map and interaction code
    ├── data.js      # generated: neuron summaries and reach (window.FLY)
    ├── paths/       # generated: wiring maps in 37 files, loaded on demand (window.FLYPATHS)
    ├── sim.js       # generated: simulated activity per neuron group (window.FLYSIM)
    ├── actions.js   # generated: action definitions, rankings and spike timelines (window.FLYACT)
    ├── build.py     # computes reach, paths, reliability, upstream senses, loops, families, shared relays
    ├── simulate.py  # leaky integrate-and-fire simulation of every descending neuron group
    ├── actions.py   # which neurons the simulation recruits for each action
    ├── CREDITS.md   # attributions and licences for data, software and fonts
    ├── README.md    # pointer back to this file
    └── data/        # downloaded bulk connectome files (not in the repository; see above)
```

`flyem.py`, at the repository root, queries the same dataset live
through neuPrint. It needs a neuPrint API token in the
`NEUPRINT_APPLICATION_CREDENTIALS` environment variable; the project doesn't store
one.

## How reach is calculated

1. **Weight each connection by input share.** For a connection from neuron *pre* to
   *post*: `A[post, pre] = synapses(pre → post) / total input synapses of post`.
2. **Follow paths.** Reach from a descending neuron type to a motor neuron is the
   sum of these shares along every path of 1, 2 or 3 synapses:
   `A·x₀`, `A²·x₀`, `A³·x₀`, where `x₀` marks every cell of that type on the chosen
   side.
3. **Average per body part.** A body part's value is the mean over its motor neuron
   pool, e.g. all 64 right hind-leg motor neurons.
4. **Sign.** Each neuron's consensus transmitter prediction sets its sign.
   Acetylcholine is **+1**; GABA and glutamate are **−1**; aminergic or unclear
   neurons are **0**. They count toward reach but not sign. Two inhibitory steps
   multiply to excitation. Net sign = signed reach ÷ unsigned reach, from −1
   (all inhibitory) to +1 (all excitatory).

Paths run through **49,448** brain and nerve-cord neurons and **10.8 million**
connections. Sensory and optic-lobe neurons are left out, because commands to
muscles don't pass through them.

### How the wiring map is traced

Each path's value is in the same units as the body part's reach, so paths can be
compared with the hop totals shown above them.

- **Direct:** the share each motor neuron gets from the descending neuron, summed
  by motor neuron type and averaged over the pool. The five strongest types are
  kept.
- **Via 1 relay:** for relay neuron *x*, the path value is
  (descending neuron → *x* share) × (*x* → pool share), averaged over the pool.
  The 40 strongest relay cells are grouped by cell type and the top five types are
  kept, with synapse counts into and out of each relay type.
- **Via 2 relays:** the 12 strongest second relays *y* are found first. For each,
  the 3 strongest first relays *x* feeding it are found. Chains are grouped by
  (*x* type, *y* type) and the top five are kept.
- Motor neurons are not used as relays. A path's sign is the product of the signs
  of the neurons that send along it.
- With **Both** sides selected, the page adds the left-cell and right-cell paths
  together.

### Motor neuron pools

| Code | Body part | Motor neurons | Located in |
|---|---|---|---|
| `fl` / `ml` / `hl` | Front / middle / hind leg | 135 / 116 / 130 | nerve cord (T1 / T2 / T3) |
| `wm` | Wing | 67 | nerve cord (mostly T2) |
| `hm` | Haltere | 16 | nerve cord (T3) |
| `nm` | Neck | 44 | 24 nerve cord + 20 brain |
| `ad` | Abdomen | 214 | nerve cord (abdominal segments) |
| `pm` | Proboscis & pharynx | 67 | brain (gnathal ganglion) |
| `am` | Antenna | 13 | brain |
| `rm` | Other head muscles | 7 | brain |
| `xm` | Multiple segments | 6 | nerve cord |

Each pool is split by side (`_L`, `_R`), giving 815 motor neurons in total. Link
fragments use the same codes, e.g. `hl_R` for the right hind leg.

## How the added analyses work

### Reliability ("How solid is this?")

- **Transmitter confidence** is the dataset's cell-type-level prediction confidence.
  Where the transmitter is known experimentally and agrees, it counts as confirmed.
  Below **0.7** a prediction counts as uncertain; that is about 11% of the neurons on
  the paths.
- **Strong connections only:** reach is recomputed using only connections of **5 or
  more synapses** (still divided by each neuron's full input). A body part is flagged
  when less than half its reach survives. Across all neurons, 28% of reached body
  parts are flagged.
- **Fragile sign:** the signed reach is recomputed with uncertain-transmitter neurons
  set to 0. A body part is flagged when its net sign word (excitatory, inhibitory,
  mixed) changes.

### Upstream senses ("What feeds it")

Each descending neuron type's input is traced backwards through the whole
connectome, up to 3 synapses, averaged over its cells. Sensory neurons, visual
projection neurons (the optic lobe's outputs) and ascending neurons end a trace and
credit it to a channel. Sensory neurons are sorted by their annotated class and
subclass: olfactory → smell; gustatory → taste; auditory and wind/gravity → hearing;
proprioceptive, chordotonal, campaniform, hair plate and haltere → body position;
other mechanosensory → touch; thermo- and hygrosensory → temperature and humidity.

As a sanity check, the giant fiber's strongest inputs come out as LC4 and LPLC2,
the looming detectors known to trigger escape.

### Feedback loops (computed, not shown on the page)

`build.py` still writes these into `data.js`. An ascending neuron closes a loop when the descending neuron reaches it within 2
synapses *and* it synapses directly back onto the descending neuron. Loops are
ranked by (forward reach × share of the descending neuron's input it supplies).

### Families

Each type's reach is summarised over eight body areas (front, middle and hind legs;
wings; halteres; neck; abdomen; head and mouthparts, the last merging the small
proboscis, antenna and other-head pools). Profiles are turned into shares,
square-rooted, and clustered with Ward linkage into 9 families. Names are generated
from each family's average profile. Clusters are a map of the data, not cell classes.

### Shared relays

For each relay neuron type and descending neuron type, the relay's share of that
descending neuron's 2-synapse reach to all motor neurons is computed. A relay
*serves* a descending neuron type when it carries at least 5% of it. The page lists
the 24 relays serving the most types.

### Checks against experiments

For seven neurons with well-studied roles, the page scores:

- **Wiring:** the five body areas (legs, wings & halteres, neck, abdomen, head) are
  ranked by average reach within 3 synapses. *Matches* if the area the behaviour needs
  ranks first, *Partly* if second. For the giant fiber, having TTMn (the jump muscle's
  motor neuron) among its three strongest motor neuron targets counts as a match.
- **Simulation:** motor neurons firing are counted per body area, adding up the left-
  and right-side runs. *Matches* if the needed area has the most, *Partly* if it has
  some, *Doesn't match* if none fire there. For the giant fiber, TTMn firing counts.

Current result: wiring matches for 5 of 7; the simulation for 2 of 7 at 75 spikes/s
and 5 of 7 at 150 spikes/s.

### Simulation 

`simulate.py` follows the leaky integrate-and-fire model of Shiu et al. (2024):
resting and reset potential −52 mV, threshold −45 mV, membrane time constant 20 ms,
synaptic time constant 5 ms, refractory period 2.2 ms, synaptic delay 1.8 ms. Each
synapse from an acetylcholine neuron adds a fixed kick to its target; GABA and
glutamate subtract it; other transmitters add nothing. The chosen descending neurons
fire as random (Poisson) spike trains for 0.5 s from rest. It runs over the same
49,448 neurons and 10.8 million connections as the reach model, one side of each
type at a time.

**Calibration.** The synapse strength had to be tuned for this connectome. With both
sides of each type driven at 150 spikes/s:

| Strength per synapse | What happened |
|---|---|
| 0.275 mV (Shiu et al.) | Every type tried set off 10,000–18,000 neurons, all driving the same flight and abdominal muscles |
| 0.18 mV | Most types still ignited 7,000+ neurons |
| 0.12 mV | Moonwalker and DNp09 ignited over 4,000 neurons |
| **0.08 mV (used)** | Giant fiber → TTMn only; Moonwalker → mostly hind-leg motor neurons; pIP10 → wing motor neurons such as ps1 and hg |
| 0.05 mV | Only pIP10 still reached motor neurons |
| 0.03 mV | Almost nothing fired |

The chosen value sits close to the edge of runaway activity, so simulated results are
rough and sensitive to this one parameter.

### Actions

`actions.py` uses the same model as `simulate.py`, at 150 spikes/s and with the same
random seeds, so its numbers agree with the rest of the page.

1. **What each action needs.** An action is defined by the motor neurons it relies on:

   | Action | Motor neurons | Switched on |
   |---|---|---|
   | Fly | DLM and DVM power muscles | found by search |
   | Flap a wing (courtship song) | ps1 and hg1–hg4 | pIP10 (von Philipsborn et al., 2011) |
   | Jump (escape takeoff) | TTMn and the DLM wing depressors | DNp01, the giant fiber (von Reyn et al., 2014) |
   | Move sideways | leg motor neurons, one-sided | found by search |
   | Walk forward | all leg motor neurons | DNp09 (Bidaye et al., 2020) |
   | Roll (in flight) | wing steering muscles, one-sided | found by search |
   | Walk backward | all leg motor neurons | MDN (Bidaye et al., 2014) |
   | Turn (while walking) | leg motor neurons, one-sided | DNa02, left-side cells (Rayshubskiy et al., 2020) |
   | Steer flight (stroke amplitude) | wing steering muscles b1–b3, i1–i2, iii1, iii3, hg1–hg4 | all seven DNg02 types (Namiki et al., 2022) |
   | Land | front-leg motor neurons | DNp07 (Ache et al., 2019) |
   | Turn the head | neck motor neurons, one-sided | found by search |

2. **Search.** Every descending neuron group (type × side) is switched on alone and
   scored: share of the needed motor neurons that fire × share of all motor neuron
   spikes that land on them, × |left − right| / (left + right) for one-sided actions.
   The page lists the top eight and where the experimentally linked neurons rank.
3. **Timeline.** The switched-on neurons for each action (or, where none is known,
   the top-scoring group) are driven again while every neuron's spikes are recorded
   in 10 ms bins, along with its distance in synapses from the switched-on neurons.
   The page shows up to 30 of the most active relay types and 30 motor neuron types.

**Current results** (150 spikes/s, out of 953 neuron groups):

- **Flap a wing:** pIP10 ranks 1st, firing 8 of the 10 song-related motor neurons;
  pMP2, another neuron of the song circuit, ranks 3rd.
- **Jump:** the giant fiber ranks 5th. Only TTMn fires; the DLM wing depressors, which
  it reaches through electrical synapses in the real fly, stay silent.
- **Walk backward:** MDN ranks 46th. **Turn:** left DNa02 ranks 62nd. **Walk
  forward:** DNp09 ranks 79th. Each recruits only a handful of leg motor neurons.
- **Steer flight** (DNg02) and **Land** (DNp07) recruit none of the motor neurons
  they need in the model.
- **Found by search:** DNa08 (right) for flying, DNa04 (left) for rolling, DNge125
  (left) for turning the head, DNge035 (right) for moving sideways.

So the model recovers song and part of the jump, and mostly misses walking, steering
and landing, which likely need rhythm generators, sensory feedback, electrical synapses
or several descending neurons working together.

## Limitations

- **Wiring is not activity.** The reach model has no spike thresholds, timing,
  gap junctions or neuromodulation.
- **The simulation is a crude model.** Every synapse has the same strength, there
  are no gap junctions (the giant fiber relies on them), no neuromodulators, no
  sensory feedback from a moving body, and the network starts from rest. Its synapse
  strength was tuned by hand (see [Simulation](#simulation)). It drives one side of a
  type at a time and doesn't simulate combinations.
- **Actions show recruitment, not movement.** Walking, flight and song need rhythm
  generators, sensory feedback and a body, none of which are modelled. An action is
  defined only by which motor neurons it uses, so the model can't tell a sideways step
  from a turn, or forward from backward walking. "Found by search" neurons are
  candidates from the model, not known command neurons.
- **Checks cover only seven neurons**, scored by body area, which is coarse:
  matching the right area doesn't mean matching the right movement.
- **Upstream tracing stops at the first sensory, visual or ascending neuron**, so
  a signal is credited once, to the channel nearest the descending neuron.
- **Sign is simplified.** Glutamate is inhibitory at many central synapses but
  excitatory at others, including the neuromuscular junction. Aminergic
  transmitters are treated as unsigned.
- **Transmitters are predicted**, from electron microscopy images, not measured.
- **Averaging dilutes single targets.** The giant fiber drives one jump-muscle motor
  neuron at about 2%, but the wing pool average is under 0.1%. The per-muscle
  target list and the wiring map's direct rows show the undiluted picture.
- **The wiring map shows the strongest paths, not all of them.** Longer routes are
  spread thin: for DNa02 → right hind leg, the listed direct paths cover 85% of the
  direct input but the listed two-relay chains only 6%. Check the coverage figure
  on each group.
- **The two-relay search is a shortcut.** Checking only the top 12 second relays
  and their top 3 inputs can miss chains made of many individually weak links.
- **Grouping by type merges cells.** A relay type's synapse counts add up all of
  its cells that made the cut.
- **At ≤ 3 synapses almost every neuron reaches almost everything a little.** The
  strongest values are what matter.
- Only connections in the release's *significant-only* table (minimum synapse
  confidence 0.5) are included.

## Troubleshooting

- **"The wiring file paths/pNN.js didn't load"**: the `paths/` folder is missing
  or out of date. Run `python build.py` and reload, or upload `paths/` alongside
  the page when hosting.
- **"The dataset file data.js didn't load"**: same cause for `data.js`.
- **Garbled characters such as `·`**: the page is being served without its UTF-8
  declaration. Use the `index.html` from this folder, which declares it.

## Data and credits

- **Connectome data:** [Male CNS connectome v1.0](https://male-cns.janelia.org/) by
  the HHMI Janelia FlyEM Project Team, Google Research and collaborators, licensed
  [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). This project filters and
  combines the release into derived results (reach, wiring maps, reliability checks,
  upstream tracing, families, simulations); they are not endorsed by the data's
  creators.
- **Header illustration:** a schematic outline of the fly's central nervous system
  drawn for this project (inline SVG in `index.html`), not to scale.
- **Please cite** the male CNS paper (Berg et al., 2025; see
  [Research resources](#research-resources)) if you use this project or its data.

Full attributions, including the transmitter predictions, the simulation model,
three.js and the fonts, are in [CREDITS.md](brain-to-body/CREDITS.md).

**Educational, non-commercial use.** This project was made to help people learn
about the fly's nervous system. It isn't sold, has no advertising or paid features,
and its author earns no money from it.

---

## Research resources

### The male CNS connectome

- **Dataset home and downloads**: [male-cns.janelia.org](https://male-cns.janelia.org/) · [Download page](https://male-cns.janelia.org/download/)
- **Janelia project page**: [Male CNS Connectome](https://www.janelia.org/project-team/flyem/male-cns-connectome)
- **Announcement**: [Researchers reveal connectome of the male fruit fly central nervous system](https://www.janelia.org/news/researchers-reveal-connectome-of-the-male-fruit-fly-central-nervous-system) (Janelia news)
- **Paper**: Berg S, Beckett IR, Costa M, Schlegel P, Januszewski M, *et al.* "Sexual dimorphism in the complete connectome of the *Drosophila* male central nervous system." *bioRxiv* (2025). [doi:10.1101/2025.10.09.680999](https://doi.org/10.1101/2025.10.09.680999) · published in *Cell*: [article](https://www.cell.com/cell/fulltext/S0092-8674(26)00942-6)
- **Cell Press collection**: [Drosophila Male Fly Connectome](https://www.cell.com/consortium/male-fly-connectome)
- **Cell Type Explorer** (male CNS): [reiserlab.github.io/celltype-explorer-drosophila-male-cns](https://reiserlab.github.io/celltype-explorer-drosophila-male-cns/)

### Tools

- **neuPrint** (query the connectome in the browser or by API): [neuprint.janelia.org](https://neuprint.janelia.org)
- **neuprint-python** (the Python client used in `flyem.py`): [github.com/connectome-neuprint/neuprint-python](https://github.com/connectome-neuprint/neuprint-python)
- **FlyWire** (female adult brain connectome): [flywire.ai](https://flywire.ai)

### Related connectomes

- Takemura S, *et al.* "A connectome of the male *Drosophila* ventral nerve cord." *eLife* (2024). [doi:10.7554/eLife.97769](https://doi.org/10.7554/eLife.97769)
- Cheong HSJ, *et al.* "Organization of circuits linking descending input to motor output in the *Drosophila* Male Adult Nerve Cord connectome." *eLife* (2026). [doi:10.7554/eLife.96084](https://doi.org/10.7554/eLife.96084)
- Dorkenwald S, *et al.* "Neuronal wiring diagram of an adult brain." *Nature* (2024). [doi:10.1038/s41586-024-07558-y](https://doi.org/10.1038/s41586-024-07558-y)

### Descending neurons and the behaviours featured on the page

- Namiki S, *et al.* "The functional organization of descending sensory-motor pathways in *Drosophila*." *eLife* (2018). [doi:10.7554/eLife.34272](https://doi.org/10.7554/eLife.34272): the anatomical survey behind the DN type names
- **Giant fiber (DNp01), escape takeoff**: von Reyn CR, *et al.* "A spike-timing mechanism for action selection." *Nature Neuroscience* (2014). [doi:10.1038/nn.3741](https://doi.org/10.1038/nn.3741)
- **Moonwalker (MDN), backward walking**: Bidaye SS, *et al.* "Neuronal control of *Drosophila* walking direction." *Science* (2014). [doi:10.1126/science.1249964](https://doi.org/10.1126/science.1249964)
- **pIP10, courtship song**: von Philipsborn AC, *et al.* "Neuronal control of *Drosophila* courtship song." *Neuron* (2011). [doi:10.1016/j.neuron.2011.01.011](https://doi.org/10.1016/j.neuron.2011.01.011)
- **DNa01 / DNa02, steering**: Rayshubskiy A, *et al.* "Neural circuit mechanisms for steering control in walking *Drosophila*." *eLife* (2025). [doi:10.7554/eLife.102230](https://doi.org/10.7554/eLife.102230) · preprint (2020): [doi:10.1101/2020.04.04.024703](https://doi.org/10.1101/2020.04.04.024703)
- **DNp09, forward walking**: Bidaye SS, *et al.* "Two brain pathways initiate distinct forward walking programs in *Drosophila*." *Neuron* (2020). [doi:10.1016/j.neuron.2020.07.032](https://doi.org/10.1016/j.neuron.2020.07.032)
- **DNg02, flight stroke amplitude**: Namiki S, *et al.* "A population of descending neurons that regulates the flight motor of *Drosophila*." *Current Biology* (2022)
- **DNp07, landing**: Ache JM, *et al.* "State-dependent decoupling of sensory and motor circuits underlies behavioral flexibility in *Drosophila*." *Nature Neuroscience* (2019). [doi:10.1038/s41593-019-0413-4](https://doi.org/10.1038/s41593-019-0413-4)

### Methods behind the model

- **Giant fiber inputs, used in the input check**: von Reyn CR, *et al.* "Feature integration drives probabilistic behavior in the *Drosophila* escape response." *Neuron* (2017) · Ache JM, *et al.* "Neural basis for looming size and velocity encoding in the *Drosophila* giant fiber escape pathway." *Current Biology* (2019)
- **Transmitter predictions**: Eckstein N, *et al.* "Neurotransmitter classification from electron microscopy images at synaptic sites in *Drosophila melanogaster*." *Cell* (2024). [doi:10.1016/j.cell.2024.03.016](https://doi.org/10.1016/j.cell.2024.03.016)
- **Whole-brain models from connectomes**: Shiu PK, *et al.* "A *Drosophila* computational brain model reveals sensorimotor processing." *Nature* (2024). [doi:10.1038/s41586-024-07763-9](https://doi.org/10.1038/s41586-024-07763-9)