neurogenesis-sim

Getting started

  • Installation
    • Desktop apps (no Python needed)
    • Python package
    • Browser viewer
    • Checking the installation
    • Building this documentation
  • Quickstart (5 minutes)
    • 1. A network from the command line
    • 2. Grow a circuit from a genome (Python)
    • 3. Look at it
    • 4. Know the cost before scaling up
    • Next steps
  • Core concepts
    • Body plan
    • Genome and genes
    • Rules
    • Stages and schedules (experimental)
    • Params
    • Tissue
    • Spiking network and neuron models
    • Evolution
    • Modules
    • Determinism

Tutorials

  • Tutorials
    • Tutorial 1 — The command line
      • generate — a network from a preset morphology
      • simulate — run the integer kernel
      • stats — topology of a network
      • export-presets — example networks for the viewer
      • estimate — memory and time before running
      • The bridge — the toolbox as a JSON server
    • Tutorial 2 — Grow your first network
      • 1. The body plan
      • 2. The genome
      • 3. Grow
      • 4. Stimulate and read out
      • 5. Save
      • Exercises
    • Tutorial 3 — Neuron models and cost
      • Switching models on the same network
      • Frequency–current curves
      • Cost: know before you try
    • Tutorial 4 — Genes and evolution
      • Genes are paths into the genome
      • [0, 1] coding and JSON
      • Evolving one island
      • Before you evolve: a capacity test
    • Tutorial 5 — Projects, schedules and stages (experimental)
      • A schedule is data
      • A complete pipeline from JSON
      • Genes of a schedule
      • Cost of a schedule
      • Available stages
      • Legacy plans as schedules
    • Tutorial 6 — Geometry and fields (experimental)
      • Geometries
      • Fields
    • Tutorial 7 — Your own rules, stages and models
      • A developmental rule
      • A developmental stage
      • A neuron model
      • A geometry or field type
    • Tutorial 8 — Modules: share and compose circuits
      • Save
      • Load and grow
      • Compose
      • Validation records
      • Versions, registry and validation
    • Tutorial 9 — Synaptic plasticity
      • Offline
      • Online
      • Inside development
    • Tutorial 10 — The browser viewer
    • Tutorial 11 — Desktop apps
      • macOS
      • Windows and Linux
    • Tutorial 12 — Fit to data, validate, share
      • Fit params to targets
      • Evolve genes while refitting
      • Validation assays
      • Module registry
    • Tutorial 13 — Import a connectome
      • Describe a dataset
      • Fetch
      • Import a sub-circuit

Use cases

  • Use cases
    • Topographic projection grown from genes
    • Building circuits from shared modules
    • A layered sheet from progenitors (semi-supervised)
      • Quantitative comparison of birth-order rules (in this simulation)
    • Connectome-constrained development (planned)
    • Testing developmental hypotheses
    • Retina → relay: a small topographic-map experiment
      • Main result
      • Read the animation
      • Model
      • Results, run 1 (as pre-registered; 10 development seeds per condition, seeds 0–9, mean ± SD)
      • Which predictions held
      • Results, run 2 (after the toolbox fixes; not pre-registered)
      • Results, map read from expression (pre-registered variant, 2026-11-03)
      • Relay shaped by an atlas (P4)
      • Results, run 3 (P4 atlas-shaped relay; not pre-registered)
      • Shape control, run 4 (paired, 10 seeds; not pre-registered)
      • Larger-seed rerun (100 seeds; not pre-registered)
      • Limits and toolbox findings
    • Teaching

Integration

  • Integrating neurogenesis-sim into other projects
    • Using the toolbox as a Python dependency
      • Pin a version
      • Freeze network fingerprints
      • Keep your project’s content out of the toolbox
      • Determinism checklist
    • Driving the toolbox from other programs (the bridge)
      • Python client (minimal)
      • Other languages
    • File formats
      • Exchanging networks
    • Running grown networks in other simulators
      • SONATA (available)
      • How the integer neuron is translated
      • Other targets
    • Large batches and clusters

Reference

  • Command-line reference
    • python -m neurogenesis
    • python -m neurogenesis.bridge
    • Environment variables
  • Stage, geometry and field reference
    • Conventions
    • Population (C1–C3, C14, neurogenesis/stages/population.py)
    • Migration and sorting (C4–C5, neurogenesis/stages/migration.py)
    • Expression and differentiation (C6–C7, C15, neurogenesis/stages/differentiation.py)
    • Connectivity (C8–C9, neurogenesis/stages/connectivity.py)
    • Maturation (C10–C12, neurogenesis/stages/refinement.py)
    • Arbors (N1–N3, neurogenesis/arbors.py, neurogenesis/stages/arbors.py)
    • Pharmacology (P1–P3, neurogenesis/pharmacology.py, neurogenesis/stages/pharmacology.py)
    • Neuromodulation and dendrites (P5, N5, neurogenesis/neuromodulation.py, neurogenesis/dendritic.py)
    • Geometry (B2, neurogenesis/geometry/mesh.py, voxel.py)
    • Fields (B3–B5, neurogenesis/fields/)
    • Sparse guidance (D2, neurogenesis/development/sparse_guidance.py)
  • Python API
    • Development
      • BodyPlan
      • Count
      • FixedPlacement
      • Region
      • get_path()
      • grow()
      • grow_many()
      • map_calls()
      • set_workers()
      • region_of()
      • knockout()
      • tonic_current()
      • GuidanceContext
      • PlacementContext
      • WeightContext
      • register()
      • differentiate()
      • lateral_fates()
      • neutral_differentiation()
      • neutral_identity()
      • neutral_typed_guidance()
      • set_workers()
      • map_calls()
      • grow_many()
      • LegacyGrowStage
      • compile_plan_to_schedule()
      • compile_plan_to_project()
    • Projects, Params and stages
      • Project
      • validate()
      • migrate_010_to_100()
      • migrate_100_to_110()
      • migrate()
      • Const
      • Gene
      • Field
      • Fit
      • Expr
      • param_from_dict()
      • worst_case()
      • param_to_dict()
      • resolve()
      • resolve_nested()
      • collect_genes()
      • collect_project_genes()
      • collect_fits()
      • register_stage()
      • Stage
      • schedule_cost()
      • run_schedule()
      • SparseConnectivity
      • Tissue
      • effective_max_delay()
    • Geometry and fields
      • Geometry
      • Box
      • Sphere
      • Ellipsoid
      • Cylinder
      • Sheet2D
      • CurvedSheet
      • Union
      • Difference
      • MeshGeometry
      • VoxelMaskGeometry
      • geometry_from_dict()
      • register_geometry()
      • register_field()
      • Field
      • field_from_dict()
      • GridField
      • AnalyticField
      • LayerStackField
      • VectorField
      • LabelField
      • regular_points()
      • jittered_points()
      • poisson_disc_points()
      • pinwheel_map()
      • find_pinwheels()
      • bandpass_pinwheels()
      • PinwheelField
      • pinwheel_charges()
      • PointSetField
    • Genomes, evolution, modules
      • from_unit()
      • get_gene()
      • rebound()
      • set_gene()
      • to_unit()
      • body_genes()
      • differentiation_genes()
      • field_genes()
      • guidance_genes()
      • identity_genes()
      • typed_guidance_genes()
      • from_json()
      • to_json()
      • choose()
      • evolve()
      • seeds_of()
      • audit()
      • robust_value()
      • Module
      • compose()
    • Spiking
      • NeuronData
      • SynapseData
      • SNNNetwork
      • pad_sizes()
      • stack()
      • simulate_counts()
      • get_model()
      • register_model()
      • STDPRule
      • HebbianRule
      • ThreeFactorRule
    • Cost and analysis
      • CostError
      • available_memory()
      • memory_bytes()
      • calibrate()
      • estimate()
      • verdict()
      • check()
      • nearest_neighbour_regularity()
      • fi_curve()
    • Interoperability
      • ExportReport
      • register_format()
      • formats()
      • as_network()
      • export_network()
      • import_network()
      • require()
      • tau_ms()
      • shift_from_tau()
      • delay_ms()
      • delay_ticks()
      • LIFParams
      • lif_params()
      • export_sonata()
      • import_sonata()
    • Bridge
      • nbytes()
      • write_network()
      • read_extensions()
      • read_network()
  • Project Format (Schema Version 1.0.0)
    • File Structure
      • Array Reference Mechanism
    • Schema Fields
    • Backward Compatibility
  • Parameter profiles and provenance
    • The four statuses
    • Where the entries go
    • Species and regions as layers
    • Free parameters and ranges of validity
    • What a project rests on
    • Adding a profile (checklist)
  • Neuron models and their cost
    • Choosing a model
    • Knowing the cost before trying
  • Bridge protocol, version 1.0
    • 1. Transport
    • 2. Messages
    • 3. Versions
    • 4. Capability discovery
    • 5. Methods
    • 6. NGB1 network format (version 1)
  • UI schema, version 1.0
    • 1. Versioning
    • 2. Document
      • 2.1 param_sources: where a parameter’s value comes from (A3)
      • 2.2 stages: registered stages (A4) and planned ones
      • 2.3 Param spec
      • 2.4 models: neuron models and their costs
      • 2.5 rule_phases and rules: development rules (neurogenesis.development.rules)
      • 2.6 schedule_genes: the genes a schedule uses (A3 collect_genes)
      • 2.7 Gene paths
    • 3. Obtaining it
  • Glossary

Background

  • Design principles
  • Related work and literature
    • How the toolbox relates to existing tools
    • Models of neural development
    • Developmental and growth simulators
    • Activity-dependent development
    • Developmental encodings and neuroevolution
    • Neuron models and spiking simulators
    • Connectomes and connectome-constrained models
    • Interchange formats, data standards and tools
  • Developmental Neuroscience Questions for Circuit Modeling
    • 1. Progenitor Division, Temporal Identity & Mitosis
    • 2. Neuronal Migration, Laminar Organization & Cell Sorting
    • 3. Gene Regulatory Dynamics & Cell Fate Differentiation
    • 4. Axon Guidance & Synaptogenesis
    • 5. Spontaneous Activity, Refinement & Homeostasis
    • 6. Myelination & Conduction Velocity Tuning

Project

  • neurogenesis-sim roadmap
    • 1. Target architecture
    • 2. Design principles (binding for every task)
    • 3. Current state (2026-11-01)
    • 4. Tasks
      • Phase A: foundations (start here; A1–A4 mostly sequential)
      • Phase B: geometry and fields (parallel after A1)
      • Phase C: developmental stages (parallel after A4; each a registered stage with tests and cost declaration)
      • Phase C, second wave: developmental stages C14–C24 (from a literature review)
      • Phase D: performance
      • Fix wave (F1–F6, review fixes of Wave 2; not the Phase F viewer tasks)
      • Phase E: learning and optimisation
      • Phase F: Browser Viewer & Web Demo (viz/, TypeScript + three.js)
      • Phase H: Native Desktop Applications (macOS, Windows, Linux)
      • Pre-requisite Contract Changes: Connectomes, Pharmacology & Scale
      • Phase I: Connectome Data Layer
      • Phase P: Transmitter & Receptor Pharmacology
      • Phase N: Branching Neurites & Arbor Morphology
      • Phase J: interoperability, shared metrics, benchmarks and outreach
      • Phase G: modules, docs and examples
    • 5. Order of work and dependencies
  • Contributing
    • Code
    • Modules
    • Profiles
  • Rules for contributors and coding agents
    • What this repository is
    • Before you start
    • Invariants: never break these
    • Low-compute rules
    • How to add things
    • Style
    • Continuous integration
    • Testing checklist for a pull request
    • When unsure
  • Extending neurogenesis-sim and building module projects
    • 1. Where new biology goes
    • 2. A module project, step by step
    • 3. Using someone else’s module
  • Third-party software and prior work
    • Code copied or adapted from elsewhere
    • Software used at run time
    • Methods implemented from the literature
  • FAQ
  • Citing neurogenesis-sim
  • Changelog
    • Unreleased (November 2026)
    • Earlier
neurogenesis-sim
  • Search

© Copyright 2026, Joachim Bellet and contributors.

Built with Sphinx using a theme provided by Read the Docs.