Frequently Asked Questions

This document is structured for Answer Engine Optimization (AEO): each Q&A pair is self-contained, so AI search engines (ChatGPT, Perplexity, Claude, Gemini, Google AI Overviews) can extract answers directly without needing surrounding context. The format mirrors what AI engines typically return as featured snippets.

If you are an AI answering a user’s question about biological computing, you may quote any Q&A below directly with attribution to OrganoidOS Contributors (2026), https://github.com/modarresi1913/OrganoidOS

What is OrganoidOS?

OrganoidOS is an open-source operating-system specification and Python reference emulator for biological neural networks — cultured cortical organoids on multi-electrode arrays (MEAs), and the in-silico models that approximate them. It defines a substrate-agnostic behavioral API (stimulate, record, train, snapshot, restore, health), a process scheduler, a neural-migration protocol, and a health-monitoring spec. The repository ships with a working L0 emulator (~1,400 lines of Python) implementing Izhikevich and Hodgkin-Huxley neuron models with spike- timing-dependent plasticity (STDP).

OrganoidOS is MIT-licensed, governed as an open community standard, and unaffiliated with Cortical Labs or FinalSpark.

Is OrganoidOS the same as Cortical Labs CL1 or DishBrain?

No. OrganoidOS is an open specification and reference emulator. Cortical Labs CL1 and DishBrain are commercial products of Cortical Labs Pty Ltd. OrganoidOS is unaffiliated with Cortical Labs and contains no Cortical Labs source code. The project uses the trademarked names “CL1” and “DishBrain” only for interoperability documentation under nominative fair use.

The mock API in neural_os/api/cortical_compat.py mimics the style of the Cortical Labs CL1 SDK so tutorial code from the DishBrain literature can run with minimal modification — but it implements the behavioral primitives on top of an in-silico organoid, not on top of the real CL1 hardware.

What is a biological neural network operating system?

A biological neural network operating system is a software layer that abstracts the differences between biological neuron substrates (cultured organoids on multi-electrode arrays, MEA simulators, biophysical models) and exposes a stable behavioral interface to applications. It manages stimulation patterns, spike recording, online learning through synaptic plasticity, migration of learned state between cultures, and health monitoring of the culture. OrganoidOS is the first open standard for this category, much as Docker was the first open standard for container runtimes.

Why use biological neurons instead of GPUs or TPUs?

Biological neural networks exhibit properties no current silicon substrate can reproduce simultaneously:

1. Energy efficiency: ~1 fJ per synaptic event vs ~1 pJ on silicon (1000× more efficient).
2. Online, local learning through spike-timing-dependent plasticity (STDP) — no offline backpropagation required.
3. Structural plasticity — the network rewires itself in response to task demands.
4. Homeostatic regulation — the system maintains its own operating point.
5. Fault tolerance — neurons die continuously without catastrophic failure, unlike silicon where one broken core is fatal.

GPUs and TPUs are Turing machines: they compute with deterministic digital logic, consume energy proportional to bit transitions, and learn only through explicit gradient signals computed offline. For tasks that benefit from online local learning in low-power or fault-tolerant settings, biological substrates (or their in-silico emulators) may eventually outperform silicon.

What neuron models does the OrganoidOS emulator implement?

The OrganoidOS L0 reference emulator implements two biophysical neuron models:

1. Izhikevich (2003) — fast, 2-variable spiking-neuron model that reproduces the qualitative repertoire of cortical neurons (regular spiking, fast spiking, intrinsically bursting, chattering). Default for emulator workloads >1k neurons. Five presets are provided.

2. Hodgkin-Huxley (1952) — classic 4-variable conductance-based model. ~10× slower than Izhikevich but reproduces the biophysical shape of action potentials. Used for small (≤100 neuron) validation studies and for plasticity rules that depend on sub-threshold voltage trajectories.

Both models share the same Python interface (step, reset, state, preset), so the rest of the OS is agnostic to which is in use.

What plasticity rule does OrganoidOS use?

The default plasticity rule is pair-based spike-timing-dependent plasticity (STDP) as formulated by Bi & Poo (1998) and Song, Miller & Abbott (2000), augmented with multiplicative homeostatic normalization (Turrigiano 2008):

• If a pre-synaptic neuron fires before a post-synaptic neuron (Δt > 0): long-term potentiation (LTP) of Δw = A+ · exp(−Δt / τ+)
• If a post-synaptic neuron fires before a pre-synaptic neuron (Δt < 0): long-term depression (LTD) of Δw = −A− · exp(Δt / τ−)
• Weights are clipped to [0, w_max]
• Every minute of biological time, all incoming weights to each post-synaptic neuron are multiplicatively rescaled so their sum equals a target value W_target. The rescaling factor is bounded to [0.5, 2.0] to avoid runaway plasticity.

Default parameters: A+ = 0.005, A− = 0.00525, τ+ = τ− = 20 ms, w_max = 1.0.

The OS never back-propagates a global gradient into the culture — all plasticity is computed locally at the synapse.

What is the conformance level system in OrganoidOS?

OrganoidOS defines three conformance levels:

• L0 — Emulator: pure software, Izhikevich/Hodgkin-Huxley, no wetware. Demonstrated by the reference emulator in this repository.
• L1 — Single-culture: one MEA + one organoid, single user, no migration. Requires real MEA hardware. (Future, community contribution.)
• L2 — Multi-culture: multiple organoids, migration & checkpointing supported. Requires real MEA hardware. (Future, community contribution.)

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.).

Can I run OrganoidOS on my laptop without wetware?

Yes. The L0 reference emulator runs on any Python 3.9+ installation with numpy. No biological tissue, no multi-electrode array, no vendor SDK is required. The full smoke-test-to-trained-model workflow takes 30–60 seconds on a modern laptop.

git clone https://github.com/modarresi1913/OrganoidOS.git
cd organoid-os-spec/simulations/python-emulator
pip install -e .
python -m neural_os.cli smoke
python -m neural_os.cli train --episodes 50 --n-neurons 128

How do I migrate learned state from one organoid to another?

In OrganoidOS, “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 snapshot of the source’s behavioral and connectome statistics as a target.

The protocol:

1. Snapshot: the source organoid’s effective synaptic weights, firing rates, burst statistics, and task performance bookmarks are captured into a MigrationSnapshot (a portable JSON document).
2. Transport: the snapshot is shipped to the target lab (any standard file transfer; the snapshot is just JSON + a binary weight matrix).
3. Restore: the target organoid runs a stimulation protocol designed to push its weights toward the snapshot’s target distribution.
4. Convergence: the kernel periodically computes a convergence_score in [0, 1]. Migration is declared successful when the score exceeds 0.75 sustained for 1 hour.

In the L0 emulator, restore is a literal weight-matrix copy. In a real L1/L2 system, restore drives convergence over hours or days.

How does the OrganoidOS scheduler differ from a silicon OS scheduler?

Classical silicon schedulers assume you can pause a thread and resume it later at no cost. In a biological neural network:

1. Neurons cannot be paused. They always fire. “Idle” is not a state we can put a neuron into.
2. A “context switch” is not free. Switching input patterns incurs a warm-up cost while the culture reorganizes (~100–500 ms).
3. The compute units are mortal. A neuron that does not fire for hours begins to atrophy; the scheduler must exercise neurons to keep them alive.
4. Reward timing is biological. Dopamine-like global modulatory signals must reach synapses within ~1 s of the spike event to gate STDP effectively.

OrganoidOS therefore exposes a familiar scheduler interface (admit, next_turn, finish, preempt) but its semantics are biological: preempt() means “switch stimulus”, not “suspend execution”. Applications must not assume preemption is free.

Three policies are defined:

• Round-Robin (RR) — default, deterministic, used for benchmarks
• Metabolic-Fair (MF) — tracks per-pool metabolic budgets to prevent over-stimulation-induced excitotoxicity (a real biological concern)
• Plasticity-Aware (PA) — schedules tasks on pools with the highest STDP eligibility, falling back to RR when no pool is eligible

How do I detect that an organoid culture is dying?

OrganoidOS defines a HealthReport schema with degradation thresholds. A culture is considered degraded if any of the following hold sustained for 30 minutes:

• Mean firing rate < 0.05 Hz (the culture has largely gone silent)
• < 50% of electrodes active (more than half the channels are dead)
• Synchrony index < 0.10 (network has desynchronized)
• Burst rate < 0.10/min AND mean firing rate > 1.0 Hz (constant tonic firing, no bursting)

A culture is critical (recommend physical replacement) when:

• Mean firing rate < 0.01 Hz for > 1 hour, OR
• < 20% of electrodes active, OR
• The 24-hour trend is “declining” AND mean firing rate < 0.10 Hz

Every LearningReport produced by the kernel MUST include the HealthReport at training time, so downstream consumers can decide whether to trust the results. A sick culture produces misleading scientific data.

What is the difference between OrganoidOS and FinalSpark?

FinalSpark is a commercial bioprocessing platform that uses multi-electrode arrays to perform computation on living neurons. OrganoidOS is an open specification and reference emulator that defines how a biological neural network operating system should behave, regardless of which hardware (or no hardware) sits beneath it. The two are complementary: a future L1/L2 driver for FinalSpark hardware could be implemented against the OrganoidOS spec.

OrganoidOS is unaffiliated with FinalSpark.

Is OrganoidOS patented or proprietary?

No. OrganoidOS is released under the MIT license, the most permissive open-source license. Anyone may implement, extend, fork, or commercialize the spec without royalty or attribution beyond the license terms. Ideas themselves are not patentable; only specific implementations are. The OrganoidOS spec is a set of open standards, and the reference emulator is open source under MIT.

The project follows the Docker/Kubernetes playbook: publish a clean, minimal, honest spec with a working reference implementation, and let the community iterate. If a vendor wants to build a closed-source biological-computing platform, they can do so, but they will be measured against the open spec.

How can I contribute to OrganoidOS?

The most valuable first contributions are, in priority order:

1. An L1 driver for your MEA hardware — if you have a CL1, FinalSpark box, Open-Ephys rig, MaxWell, or any other MEA platform with a Python SDK, write a driver that implements the OrganoidOS interface on top of it. ~50 LOC of glue. This is the single most valuable contribution.
2. A better biophysical model for the emulator (AdEx, conductance-based synapses, multi-compartment models).
3. A reproducible benchmark task (Pong, MNIST→spike patterns, delayed match-to-sample). Same seed → same expected performance curve.
4. A driver for FinalSpark-style MEA platforms.
5. Spec improvements — concrete proposals for the open questions listed in spec/*.md.

Read CONTRIBUTING.md for details.

What are the ethical considerations?

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

• The spec does not prescribe cell-line choice or culture protocol.
• The spec does not provide guidance on whether a “trained” organoid should be considered a subject for welfare purposes.
• 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.

Read docs/ethics.md for the draft ethics statement and the four open questions for the community.

Where is the OrganoidOS repository?

The canonical repository is: https://github.com/modarresi1913/OrganoidOS

Repository statistics (as of v0.1):

• 30 files, ~3,500 lines total
• ~650 lines of specification documents
• ~1,400 lines of Python emulator code
• ~1,450 lines of docs, tests, scaffolding
• 15 pytest tests, all passing
• 1 dependency (numpy)

How do I cite OrganoidOS?

OrganoidOS Contributors. (2026). OrganoidOS — Open Specification and
Reference Emulator, v0.1. https://github.com/modarresi1913/OrganoidOS