一只果蝇的大脑，第一次"看见"了一只果蝇的照片。
这件作品不是画出来的，也不是 AI 生成的。它是一段科学仿真的真实记录：我们把一张果蝇的照片投射到一只果蝇的复眼上，然后让它的整个大脑，全部 138,639 个神经元，按照真实的神经连接图去反应。画面上每一个亮起的光点，都是一个神经元在那一刻真的"放电"了。
左边那幅由无数小点慢慢显影出来的素描，就是这只果蝇眼睛里的世界。它是由果蝇眼睛里的感光细胞一次次放电、一点一点"点"出来的。右边是它的整个大脑，从正面看过去，两侧鼓起的是复眼后面的视叶，中间是中枢脑。
我们看到的结果是：影像清晰地进入了它的眼睛，在视叶里激起了一片涟漪，然后就停住了。它的中枢脑几乎一片安静。
一只果蝇看得见自己，但它的大脑并不会因此"认出"什么。这幅自画像，最终只存在于它眼睛后面那一小片神经组织里。
这是怎么做出来的
一张真实的脑接线图
2024 年，一个叫 FlyWire 的国际科学团队完成了一件前所未有的事：他们把一只成年果蝇的大脑切成几千片薄片，用电子显微镜逐片拍照，再由人类和 AI 一起，把每一个神经元和它们之间的每一个连接都描了出来。最后得到的是一张完整的"接线图"：13.8 万个神经元，它们之间 1500 万对连接。这是人类拥有的第一张完整的成年动物大脑接线图。
让接线图"活"起来
有了接线图，科学家 Shiu 等人在 2024 年又做了一件事：给每个神经元装上一个极简的数学模型，让整张图能"运转"。
这个模型可以这样理解：每个神经元像一个底部有小孔的水桶。上游的神经元每放一次电，就往桶里倒一小勺水；桶一直在漏，所以如果水来得不够快，桶就永远满不了。一旦水位漫过桶沿，这个神经元就"放电"，把自己的一勺水倒进它下游所有的桶，然后自己清空，重新开始。有些连接倒的不是水而是"抽水"，那是抑制性的神经元。
全部 13.8 万个水桶按照真实接线图连在一起，每 0.1 毫秒结算一次，就是这件作品的引擎。这个模型已经被验证过：用它预测果蝇尝到糖以后会不会伸出口器，准确率达到 91%。
把照片投进眼睛
果蝇的复眼由大约 700 个小眼组成，每个小眼后面有一组感光细胞。我们查出这只果蝇右眼每一个感光细胞在接线图里的位置，把它们展开成一张"视网膜地图"，就像把一个球形的眼睛剥开摊平。然后把一张果蝇照片铺在这张地图上：照片上越亮的地方，对应的感光细胞放电越频繁。
照片来自维基共享资源，作者 André Karwath，以 CC BY-SA 2.5 许可发布。
然后，按下开始
仿真持续 600 毫秒，也就是半秒多一点的果蝇时间。视频把它放慢了约 33 倍。这期间，感光细胞一共放电 45 万次，眼睛之外的神经元则放电约 3.8 万次。
画面里看到的是什么
左侧：右眼感光细胞的放电记录。每一次放电，就在这个细胞对应的视野位置落下一个小点。点越密的地方，说明那里的光越强。随着时间推移，果蝇的轮廓从点阵中慢慢浮现：左边是头，中间是躯干，右边是翅膀，下面是足。这就是果蝇眼睛"看"到的自己，分辨率只有约 700 个像素。
右侧：整个大脑的正面视图，每一个灰色小点是一个神经元。
- 绿色：感光细胞在放电
- 蓝色：视叶里的神经元被激活，这是眼睛后面负责处理影像的第一站
- 黄色：视觉投射神经元，负责把影像送往中枢脑的"信使"
- 红色：中枢脑的神经元
视频里绿色和蓝色始终在闪烁，而黄色和红色几乎从未亮起。这不是设计的效果，而是仿真的结果。
为什么影像停在了视叶
在接线图里，从感光细胞到中枢脑之间隔着好几站：视网膜层、髓质、小叶，最后才是中枢。每一站都需要上一站足够多的神经元同时放电才能被点亮，就像一排水桶，每个桶都需要好几勺水才能满。
眼睛后面的第一站被点亮了。第二站只有零星几个。到了第三站，几乎已经没有水滴落下。这有两个原因：一是 FlyWire 的接线图在感光细胞这一层的描绘还比较稀疏，感光细胞的连接被记录得较少；二是这个数学模型原本是为味觉和运动通路校准的，视觉系统在它眼里只是一张普通的接线图。
我们没有为了让画面更好看而调整任何一根连接。作品呈现的，就是现有科学工具能给出的答案。
数据来源与致谢
- 脑接线图：FlyWire Consortium，Drosophila melanogaster 全脑连接组，v783 公开版本（Dorkenwald et al., Nature 2024）
- 神经元位置与类型标注：Schlegel et al., Nature 2024（flywire_annotations）
- 神经元数学模型与仿真代码：Shiu et al., Nature 2024，"A leaky integrate-and-fire computational model based on the connectome of the entire adult Drosophila brain"；代码仓库 fly-brain
- 果蝇照片：André Karwath，Wikimedia Commons，CC BY-SA 2.5
- 渲染：p5.js
技术附注
| 神经元数量 | 138,639 |
|---|
| 神经元连接对 | 15,091,983 |
|---|
| 仿真步长 | 0.1 ms |
|---|
| 仿真时长 | 600 ms |
|---|
| 被驱动的感光细胞 | 10,582（双眼 R1-6、R7、R8） |
|---|
| 感光细胞最高放电频率 | 600 Hz |
|---|
| 感光细胞放电总数 | 448,001 |
|---|
| 眼睛以外的放电总数 | 38,020 |
|---|
| 视频 | 2400 × 1350，30 fps，1 帧 = 1 ms 仿真时间 |
|---|
仿真使用 fly-brain 项目的 PyTorch CPU 实现，在一台 Apple M1 Max 上完成，全程约 34 秒。渲染由 p5.js 逐帧确定性绘制，通过无头浏览器截取每一帧，再由 ffmpeg 编码为 H.264。整个流程可复现，随机种子固定为 0。
A fruit fly's brain sees a photograph of a fruit fly for the first time.
This work was not drawn, and it was not generated by AI. It is the faithful record of a scientific simulation: a photograph of a fruit fly is projected onto the compound eye of a fruit fly, and its entire brain, all 138,639 neurons, responds according to its real wiring diagram. Every point of light in the video is a neuron that really fired at that moment.
The sketch on the left, slowly developing out of countless small dots, is the world inside this fly's eye. It is stippled, one dot at a time, by the light-sensing cells of the eye as they fire. On the right is the whole brain seen from the front: the two bulges on the sides are the optic lobes behind the eyes, and the middle is the central brain.
What we see is this: the image enters the eye clearly, sends a ripple through the optic lobe, and then stops. The central brain stays almost silent.
A fly can see itself, but its brain does not "recognize" anything. In the end, this self portrait exists only in the thin sheet of nerve tissue just behind its eye.
How it was made
A real wiring diagram of a brain
In 2024, an international team called FlyWire did something unprecedented. They sliced the brain of an adult fruit fly into thousands of thin sections, photographed each one under an electron microscope, and, with humans and AI working together, traced every neuron and every connection between them. The result is a complete wiring diagram: 138,000 neurons and 15 million connected pairs. It is the first complete wiring diagram of an adult animal's brain that humanity has ever had.
Bringing the diagram to life
With the diagram in hand, the scientist Philip Shiu and colleagues did one more thing in 2024: they fitted every neuron with a minimal mathematical model so that the whole diagram could run.
Think of each neuron as a bucket with a small hole in the bottom. Every time an upstream neuron fires, it pours a small scoop of water into the bucket. The bucket leaks constantly, so if water does not arrive fast enough it never fills. Once the level spills over the rim, the neuron "fires", pours its own scoop into every bucket downstream, empties itself, and starts again. Some connections do not pour water but draw it out; those are inhibitory neurons.
All 138,000 buckets wired together exactly as in the real diagram, settled every 0.1 millisecond, is the engine of this work. The model has been validated: used to predict whether a fly will extend its proboscis after tasting sugar, it is right 91% of the time.
Projecting the photo into the eye
A fruit fly's compound eye is made of about 700 facets, each with its own group of light-sensing cells. We located every photoreceptor of this fly's right eye in the wiring diagram and unfolded them into a "retinal map", like peeling a spherical eye and laying it flat. Then we laid a photograph of a fruit fly over that map: the brighter a spot in the photo, the more often the corresponding photoreceptor fires.
The photograph is from Wikimedia Commons, by André Karwath, released under CC BY-SA 2.5.
Then press start
The simulation runs for 600 milliseconds, a little over half a second of fly time. The video slows it down about 33 times. During that time the photoreceptors fire 450,000 times, and the neurons beyond the eye fire about 38,000 times.
What you are seeing
Left: the firing record of the right eye's photoreceptors. Each time a cell fires, a small dot lands at that cell's position in the visual field. The denser the dots, the stronger the light there. Over time the outline of a fly emerges from the pattern: head on the left, body in the middle, wing on the right, legs below. This is the fly as its own eye "sees" it, at a resolution of only about 700 pixels.
Right: a frontal view of the entire brain, every grey dot a neuron.
- Green: photoreceptors firing
- Blue: neurons of the optic lobe, the first stage of image processing behind the eye
- Yellow: visual projection neurons, the messengers that carry images to the central brain
- Red: neurons of the central brain
Green and blue flicker throughout the video; yellow and red almost never light up. That is not a design choice. It is the result of the simulation.
Why the image stops in the optic lobe
In the wiring diagram, several stations lie between the photoreceptors and the central brain: the lamina, the medulla, the lobula, and only then the centre. Each station lights up only if enough neurons in the previous station fire together, like a row of buckets where each needs several scoops to fill.
The first station behind the eye lights up. The second, only here and there. By the third, almost no drops arrive. There are two reasons. First, FlyWire's diagram is still sparse at the photoreceptor layer, so relatively few of their connections are recorded. Second, this mathematical model was calibrated for taste and motor pathways; to it, the visual system is just another part of the diagram.
We did not adjust a single connection to make the picture prettier. What the work shows is what today's scientific tools can give.
Data and acknowledgements
- Brain wiring diagram: FlyWire Consortium, whole-brain connectome of Drosophila melanogaster, public release v783 (Dorkenwald et al., Nature 2024)
- Neuron positions and cell types: Schlegel et al., Nature 2024 (flywire_annotations)
- Neuron model and simulation code: Shiu et al., Nature 2024, "A leaky integrate-and-fire computational model based on the connectome of the entire adult Drosophila brain"; repository fly-brain
- Photograph: André Karwath, Wikimedia Commons, CC BY-SA 2.5
- Rendering: p5.js
Technical notes
| Neurons | 138,639 |
|---|
| Connected neuron pairs | 15,091,983 |
|---|
| Time step | 0.1 ms |
|---|
| Simulated time | 600 ms |
|---|
| Photoreceptors driven | 10,582 (both eyes, R1-6, R7, R8) |
|---|
| Peak photoreceptor rate | 600 Hz |
|---|
| Photoreceptor spikes | 448,001 |
|---|
| Spikes beyond the eye | 38,020 |
|---|
| Video | 2400 × 1350, 30 fps, 1 frame = 1 ms of simulated time |
|---|
The simulation uses the PyTorch CPU implementation from the fly-brain project and takes about 34 seconds on an Apple M1 Max. Rendering is deterministic, frame by frame in p5.js, captured in a headless browser and encoded to H.264 with ffmpeg. The whole pipeline is reproducible with random seed 0.