FlyEye

Let a fly brain see your world — and let developers run real connectome-derived circuits.

FlyEye is a browser experiment and developer kit built around a real, signed Drosophila MaleCNS-derived connectome subgraph. It turns camera-derived looming signals into modeled neural input, propagates activity through a compact escape circuit, and exposes the same graph/runtime stack as reusable JavaScript and Python packages.

Scientific boundary: the wiring is connectome-derived; the camera encoder and neural dynamics are models. FlyEye does not claim to reproduce a living fly or biologically exact retinal processing.

• Live demo: https://fly.fde.fan
• GitHub: https://github.com/tubban1/fly-eye
• Latest release: https://github.com/tubban1/fly-eye/releases/tag/v0.5.0-alpha.9

The first public developer-kit packages are now available across npm, PyPI and Hugging Face.

The compact neuron-level dataset contains 3,376 neurons / 78,797 signed edges in a 959,092-byte FLYGRAPH asset.

npm install @fly-eye/graph-core @fly-eye/escape-neuron-v1

Additional packages:

npm install @fly-eye/runtime
npm install @fly-eye/connectome-tools
npm install @fly-eye/benchmarks

pip install flyeye-graphs

• @fly-eye/escape-neuron-v1 — self-contained 3,376-neuron / 78,797-edge MaleCNS-derived escape corridor.
• @fly-eye/graph-core — FLYGRAPH parser, validators, loaders and adjacency helpers.
• @fly-eye/runtime — declared modeled aggregate escape dynamics.
• flyeye-graphs — Python loader with optional NetworkX conversion.
• @fly-eye/connectome-tools — inspect/cut CLI for task-specific connectome extraction.
• @fly-eye/benchmarks — cross-runtime vectors and graph-integrity checks.

Developer documentation: docs/FLYEYE_DEVELOPER_KIT.md

Janelia FlyEM MaleCNS
        ↓
signed connectome-derived graph
        ↓
FlyEye compact escape circuit
3,376 neurons / 78,797 edges
        ↓
graph-core + escape-neuron-v1
        ↓
runtime / Python SDK / tooling
        ↓
browser experiments, analysis and prototypes

The goal of FlyEye is not merely to distribute connectome files. It provides a small developer layer for turning a measured neural wiring graph into something inspectable and runnable.

FlyEye is also a camera-first experiment. Your environment becomes sensory input for a virtual fruit fly.

The current perception pipeline includes:

• camera calibration before neural input is armed
• global camera-motion compensation
• semantic hand/fingertip tracking when available
• optical looming fallback
• modeled LC4 input
• signed graph propagation through the selected escape circuit
• descending-neuron / flight readouts
• local neural replay
• bilingual EN / 中文 UI

Raw camera frames are processed locally in the browser and are not uploaded by FlyEye.

Connectome data derives from Janelia FlyEM MaleCNS v1.0 and is attributed in the published manifests. MaleCNS source data is published under CC BY 4.0; FlyEye code is released under the repository's MIT License.

The compact public developer dataset contains:

• graph binary
• manifest
• report
• aggregate fast profile
• citation metadata
• license metadata

Dataset: https://huggingface.co/datasets/Tubban/flyeye-escape-neuron-v1

Current publication release:

FlyEye v0.5.0-alpha.9 — Publication & Citation Release

https://github.com/tubban1/fly-eye/releases/tag/v0.5.0-alpha.9

The release includes versioned graph assets, manifests, reports, checksums and the developer-kit archive.

git clone https://github.com/tubban1/fly-eye.git
cd fly-eye
npm install
npm run dev

Camera access requires HTTPS in production or localhost during local development.

FlyEye keeps the lightweight gameplay path and the detailed developer graph separate:

• fast browser path — embedded aggregate escape profile for immediate interaction
• detailed graph path — optional neuron-level compact graph for inspection and development
• published SDK layer — npm + PyPI packages for reuse outside the demo

This separation keeps the public experience fast while preserving a reproducible developer path to the underlying connectome-derived data.

• GitHub publication release
• npm developer packages
• PyPI Python SDK
• Hugging Face dataset
• Zenodo archive published: 10.5281/zenodo.22829797

• reusable graph/runtime/tooling packages
• compact neuron-level escape dataset
• cross-runtime benchmarks
• publication metadata and provenance

• detailed graph loads only on explicit request
• gameplay remains on the zero-download fast profile
• graph progress and metadata shown independently
• advanced graph failures do not block gameplay

• reusable flyeye.escape-fast.v1 developer profile
• browser SDK
• schema and TypeScript definitions
• provenance documentation
• automated SDK regression tests

• Human / Stabilized / Motion Evidence / Loom Evidence / LC4 Input views
• camera-translation compensation
• inspectable modeled perception layers

• client-side result card
• mode, score, closest approach, threat and round metrics
• scientific-boundary disclosure
• native sharing when available

• fingertip/optical target replay
• perception + brain layer toggles
• model-relative neural event timeline
• 0.25× / 0.5× / 1× replay speeds

• calibration
• camera-motion compensation
• hand landmark gating
• optical looming fallback
• perception state machine
• separate perception and neural readouts

Zenodo DOI: 10.5281/zenodo.22829797\n\nFor archival citation, use the Zenodo DOI above together with the tagged GitHub release and published dataset metadata.

FlyEye: a developer kit for turning real Drosophila connectome data into runnable neural circuits.