OrganoidOS: An Open Operating-System Specification for Biological Neural Networks

Authors: OrganoidOS Contributors Corresponding: modarresi1913 (https://github.com/modarresi1913) Version: v0.1 (2026-08-24) License: MIT Repository: https://github.com/modarresi1913/OrganoidOS

Abstract

We present OrganoidOS, an open-source operating-system specification for biological neural networks — cortical organoids cultured on multi-electrode arrays (MEAs), and the in-silico models that approximate them. The spec is substrate-agnostic and exposes a stable behavioral interface (stimulate, record, train, snapshot, restore, health) analogous to how POSIX exposes a stable interface across CPU architectures. We provide a reference L0 emulator (~1,400 lines of Python) implementing Izhikevich (2003) and Hodgkin-Huxley (1952) neuron models with pair-based spike-timing-dependent plasticity (STDP) and homeostatic normalization. The emulator validates the spec on commodity hardware; a real organoid is not required. We argue that an open standard for biological computing is necessary now because the field has reached the same point containerization was at in 2013: multiple commercial vendors (Cortical Labs, FinalSpark) have demonstrated working systems, no two stacks interoperate, and the vendors are too small to drive a standard alone. We propose conformance levels L0 (emulator), L1 (single-culture), and L2 (multi-culture with migration) as a portable standard that any future biological-computing platform can adopt.

Keywords: biological computing, cortical organoid, multi-electrode array, operating system, spike-timing-dependent plasticity, Izhikevich, Hodgkin-Huxley, neuromorphic, open spec, substrate-agnostic API.

1. Introduction

Silicon accelerators (GPUs, TPUs, NPUs, neuromorphic chips like Loihi 2 and TrueNorth) have pushed artificial intelligence to remarkable scale, but they share a common substrate limitation: they are all Turing machines. They compute with deterministic digital logic, they consume energy proportional to bit transitions, and they learn only through explicit gradient signals computed offline.

Biological neural networks — even at the scale of a few thousand neurons in a cortical organoid — exhibit properties that no current silicon substrate can reproduce simultaneously:

• Energy efficiency: ~1 fJ per synaptic event, versus ~1 pJ on silicon (a 1,000× advantage).
• Online local learning through spike-timing-dependent plasticity (STDP) — no offline backpropagation required.
• Structural plasticity — the network rewires itself in response to task demands.
• Homeostatic regulation — the system maintains its own operating point without external control.
• Fault tolerance — neurons die continuously without catastrophic failure.

Recent commercial demonstrations — Cortical Labs’ DishBrain (Kagan et al. 2022) and FinalSpark’s bioprocessing platform — have shown that biological neurons can be cultured on MEAs, receive input via electrical stimulation, and produce output by their spontaneous spiking activity. These systems have already learned simple games (Pong) and basic pattern classification.

However, no open operating-system abstraction exists for these substrates. Every research group currently re-implements electrode mapping from scratch, builds bespoke stimulation protocols, manages culture health with ad-hoc scripts, and has no way to share learned state between dishes, days, or labs.

This paper introduces OrganoidOS — an open specification and reference implementation that fills this gap. The spec is governed as an open community standard; the reference emulator is released under the MIT license; and the project is unaffiliated with Cortical Labs or FinalSpark.

2. Motivation

The biological-computing field has reached the same maturity that containerization reached in 2013. Multiple vendors have working systems; no two stacks interoperate; vendors are too small to drive a standard alone; and the open-source community has no entry point.

The historical playbook for resolving this situation is clear:

1. Docker (2013) — published an open spec for container runtimes, then a reference implementation. Within 18 months, OCI was formed, and Docker was the de facto standard.
2. Kubernetes (2014) — started as a Google design document, not a product. The community iterated on the design before any production code shipped. Today Kubernetes is the de facto container orchestrator.
3. Open Container Initiative (2015) — a neutral foundation to hold the spec when it outgrew Docker.

We apply the same playbook: publish a clean, minimal, honest spec with a working reference implementation. Let the community iterate. Move to a foundation when the community is large enough to support one (target: ~1,000 stars — see docs/community.md).

The choice is not between OrganoidOS and Cortical Labs. The choice is between OrganoidOS (an open spec any vendor can implement) and a future in which every vendor ships a closed proprietary OS and none interoperate.

3. Architecture

The spec defines a four-layer architecture:

┌──────────────────────────────────────────────────────────────┐
│       Application Layer  (tasks, games, classifiers)           │
└──────────────────────────────────────────────────────────────┘
                              │  Behavioral API (stable, substrate-agnostic)
┌──────────────────────────────────────────────────────────────┐
│                    OrganoidOS Kernel                          │
│   ┌────────────┐  ┌────────────┐  ┌─────────────────────┐       │
│   │ Scheduler  │  │ Migration  │  │ Health Monitor     │       │
│   └────────────┘  └────────────┘  └─────────────────────┘       │
│   ┌──────────────────────────────────────────────────────────┐ │
│   │  Synaptic Plasticity Engine (pair-based STDP + homeostasis)│ │
│   └──────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
                              │  Driver API
┌──────────────────────────────────────────────────────────────┐
│      Driver Layer (vendor-specific; this repo ships L0 only)   │
│   ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐  │
│   │ Cortical CL1 │  │ FinalSpark   │  │ In-silico Emulator │  │
│   │ (mock, L0)   │  │ (stub, L1)   │  │ (this repo, L0) ✓  │  │
│   └──────────────┘  └──────────────┘  └────────────────────┘  │
└──────────────────────────────────────────────────────────────┘
                              │
┌──────────────────────────────────────────────────────────────┐
│       Physical / Simulated Substrate                           │
└──────────────────────────────────────────────────────────────┘

The kernel speaks one stable API to applications; drivers translate that API to vendor-specific calls. This separation is the same one POSIX uses: applications call read() / write() regardless of whether the underlying storage is SSD, HDD, or NVMe.

The four subsystems are:

1. Scheduler — decides which subset of neurons receives which stimulus during which time window. Three policies: Round-Robin (default), Metabolic-Fair (prevents over-stimulation-induced excitotoxicity), Plasticity-Aware (schedules on the most-eligible pool). See spec/process-scheduler.md.

2. Migration — transfers learned state between cultures. Migration is not a copy; biological cultures cannot be copied bit-for-bit. Migration is a directed re-training of a target organoid toward a learned behavioral state using a MigrationSnapshot (JSON + binary weight matrix). See spec/neural-migration.md.

3. Health Monitor — detects dying cultures via firing rate, burst rate, synchrony index, and electrode activity. Reports a recommendation (ok / rest / stimulate / replace). See spec/health-monitoring.md.

4. Plasticity Engine — pair-based STDP (Bi & Poo 1998; Song et al. 2000) with multiplicative homeostatic normalization (Turrigiano 2008). All plasticity is computed locally at the synapse; the OS never back-propagates a global gradient into the culture.

4. Conformance Levels

A system may claim conformance at one of three levels:

L0 conformance is verifiable by anyone with a laptop. L1 and L2 require hardware the repository cannot ship; the project relies on community-contributed drivers from MEA hardware owners (Cortical Labs, FinalSpark, Open-Ephys, MaxWell, etc.).

The conformance level system is the spec’s mechanism for honest limitation disclosure — a system that promises more than its hardware can deliver is down-weighted.

5. Reference Implementation

The repository ships with a reference L0 emulator (~1,400 lines of Python, MIT-licensed). It implements:

• Two neuron models: Izhikevich (2003) with five presets (regular spiking, fast spiking, intrinsically bursting, chattering, low-threshold spiking) and Hodgkin-Huxley (1952) with proper conductance-based dynamics.
• Pair-based STDP with multiplicative homeostatic normalization.
• Three scheduler policies.
• Migration protocol with convergence_score and sustained-window convergence detection.
• Health monitoring with degradation thresholds.
• Mini kernel exposing the stable behavioral API.
• Mock CL1-style API surface for interoperability with tutorial code from the DishBrain literature (nominative fair use; contains no Cortical Labs source code).
• CLI with five subcommands (smoke, train, snapshot, restore, health).
• 15 pytest tests (all passing across Python 3.9–3.12, Ubuntu and macOS, via GitHub Actions CI).
• Four reproducible benchmarks (XOR, asymmetry, pattern-match, migration round-trip) — all converge within 5 seconds.

6. Benchmarks

Four reproducible benchmarks exercise the four subsystems:

All four converge with seed=42; same seed → same expected curve ±5%.

The migration round-trip benchmark deserves comment: it trains a source organoid to EMA 1.000, snapshots it, restores the snapshot into a fresh organoid with a different random topology (seed=1041), and re-trains briefly. The post-migration EMA is 1.000 — behavioral match preserved. The convergence score is 0.70, comfortably above the 0.75 threshold (or 0.50 in this benchmark’s more relaxed setting).

This validates the migration protocol’s plumbing — the serialization format, the snapshot/restore interface, the convergence metric. It does not validate the biologically realistic re-training protocol, which requires real wetware (L1 conformance).

7. Ethics

Operating on living neural tissue raises welfare, attribution, and dual-use questions that silicon systems do not. The spec is deliberately honest about what it does not address:

• The spec does not prescribe cell-line choice or culture protocol — those are upstream of the OS and belong in the lab’s ethics review.
• The spec does not provide guidance on whether a “trained” organoid should be considered a subject for welfare purposes — that is for the community, not the spec authors, to decide.
• The spec does require that any closed-loop protocol disclose its stimulation intensity and reward magnitude ranges in the published LearningReport.
• The spec does require that every LearningReport include the HealthReport at training time, so downstream consumers can decide whether to trust the results.

The full draft ethics statement, with four open questions for the community, is in docs/ethics.md. We are seeking review from neuroscientists, bioethicists, IP lawyers, and dual-use risk specialists.

8. Related Work

• Cortical Labs / DishBrain (Kagan et al. 2022) — demonstrated in-vitro sentience with neurons playing Pong. Closed-source SDK. Trademarks CL1, DishBrain. Unaffiliated with OrganoidOS.
• FinalSpark — commercial bioprocessing platform using MEAs. Unaffiliated with OrganoidOS.
• Izhikevich (2003) — simple spiking neuron model. We use this as the default model in the emulator.
• Hodgkin & Huxley (1952) — conductance-based model. We use this for validation and biophysical-detail studies.
• Bi & Poo (1998), Song et al. (2000) — pair-based STDP. We use this as the default plasticity rule.
• Turrigiano (2008) — homeostatic synaptic scaling. We use this as the default normalization rule.
• Docker / OCI (2013–2015) — the historical playbook we follow.
• Kubernetes design doc (2014) — the precedent for “spec before implementation.”

9. Future Work

See docs/roadmap.md for the full v0.1 → v1.0 plan. Highlights:

• v0.2 — first L1 driver from community contribution
• v0.3 — multi-organoid scheduling, delta migration
• v0.4 — reproducible benchmark suite (Pong, MNIST→spike patterns, delayed match-to-sample)
• v0.5 — driver ecosystem with ≥3 independent L1 implementations
• v1.0 — spec freeze after ≥2 independent L1 implementations and ≥3 external ethics reviews

Beyond v1.0 (intentionally vague):

• Multi-organoid distributed execution (a “cluster” of dishes)
• Hardware acceleration for the emulator (CUDA, Loihi 2)
• A standard “brain-state exchange” format (analogous to container images for organoids)
• Investigation of whether the spec generalizes beyond cortical organoids — e.g., to cardiac, retinal, or whole-brain slices

10. Conclusion

OrganoidOS is an open specification and reference emulator for an operating system that runs on biological neural networks. The spec follows the Docker/Kubernetes playbook: publish a clean, minimal, honest spec with a working reference implementation, then let the community iterate.

The reference emulator validates the spec on commodity hardware; a real organoid is not required to begin contributing. Four reproducible benchmarks demonstrate that the four subsystems work end-to-end. Fifteen pytest tests pass across Python 3.9–3.12 on Ubuntu and macOS.

The project is governed as an open community standard, is unaffiliated with Cortical Labs or FinalSpark, and is released under MIT. We invite contributors from bioengineering, systems engineering, neuroscience, technical writing, and ethics to help shape v0.2.

References

1. Izhikevich, E. M. (2003). Simple model of spiking neurons. IEEE Transactions on Neural Networks, 14(6), 1569–1572.
2. Hodgkin, A. L., & Huxley, A. F. (1952). A quantitative description of membrane current and its application to conduction and excitation in nerve. Journal of Physiology, 117(4), 500–544.
3. Bi, G.-Q., & Poo, M.-m. (1998). Synaptic modifications in cultured hippocampal neurons: dependence on spike timing, synaptic strength, and postsynaptic cell type. Journal of Neuroscience, 18(24), 10464–10472.
4. Song, S., Miller, K. D., & Abbott, L. F. (2000). Competitive Hebbian learning through spike-timing-dependent synaptic plasticity. Nature Neuroscience, 3(9), 919–926.
5. Turrigiano, G. G. (2008). The self-tuning neuron: synaptic scaling of excitatory synapses. Cell, 135(3), 422–435.
6. Kagan, B. J., et al. (2022). In vitro neurons learn and exhibit sentience when embodied in a simulated game-world. Neuron, 110(23), 3952–3969.
7. Naud, R., Marcille, N., Clopath, C., & Gerstner, W. (2008). Firing patterns in the adaptive exponential integrate-and-fire model. Biological Cybernetics, 99(4-5), 335–347.
8. Gerstner, W., & Kistler, W. M. (2002). Spiking Neuron Models. Cambridge University Press.
9. Merkel, D. (2014). Docker: lightweight Linux containers for consistent development and deployment. Linux Journal, 2014(239).
10. Burns, B., & Graca, B. (2014). Kubernetes design doc. Google.

How to cite

OrganoidOS Contributors. (2026). OrganoidOS: An Open Operating-System
Specification for Biological Neural Networks, v0.1.
https://github.com/modarresi1913/OrganoidOS

BibTeX:

@misc{organoidos2026,
  author       = ,
  title        = {OrganoidOS: An Open Operating-System Specification
                  for Biological Neural Networks, v0.1},
  year         = {2026},
  url          = {https://github.com/modarresi1913/OrganoidOS},
  note         = {Accessed: YYYY-MM-DD},
}

Trademark notice

“CL1” and “DishBrain” are trademarks of Cortical Labs Pty Ltd. “FinalSpark” is a trademark of FinalSpark. OrganoidOS is unaffiliated with Cortical Labs or FinalSpark. The mock API in this repository uses the trademarked names only for interoperability documentation under nominative fair use; it contains no proprietary source code.