An Open Operating-System Architecture for Biological Neural Computing
What if the next computer you program isn't made of silicon?
What if its computational substrate is a living neural network?
Not a neural network in the metaphorical sense.
A biological neural network.
A system capable of adaptation, plasticity, homeostasis, and learning through mechanisms fundamentally different from conventional digital computation.
That question led to OrganoidOS.
👉 GitHub: https://github.com/modarresi1913/OrganoidOS
The Computer After Silicon
For decades, computing has been built around a remarkably stable abstraction:
Application
↓
Operating System
↓
Hardware
↓
Silicon
Linux, Windows, macOS, Android — different operating systems, different architectures, same fundamental assumption:
the hardware is electronic.
But biological computing challenges that assumption.
Cortical organoids and neuron–electrode systems are making it possible to cultivate neural tissue, stimulate it electrically, observe its activity, and study learning-like behavior.
Research platforms such as biological neural cultures coupled to microelectrode arrays have demonstrated that living neurons can interact with computational environments and exhibit adaptive behavior. (GitHub)
Yet there is a missing layer.
There is no broadly shared operating-system abstraction between:
Application
↓
???
↓
Neural substrate
That missing layer is the problem OrganoidOS is designed to explore.
Introducing OrganoidOS
OrganoidOS is an open operating-system specification and reference emulator for biological neural networks.
The goal is not to pretend that a Python simulator is already a biological computer.
It isn't.
The goal is more ambitious:
Define the software abstractions that could allow biological neural substrates to become programmable computing platforms.
The current v0.1 release contains a stable specification and an L0 reference emulator that runs entirely in software. The project roadmap targets multi-vendor conformance with independent L1 implementations. (GitHub)
In other words:
We are designing the operating system before the hardware ecosystem fully exists.
The Architecture
OrganoidOS introduces a layered architecture:
┌───────────────────────────────────────┐
│ Application Layer │
│ Games • Tasks • Classifiers • Agents │
└───────────────────┬───────────────────┘
│
Behavioral API
│
┌───────────────────▼───────────────────┐
│ OrganoidOS Kernel │
│ │
│ Scheduler │
│ Synaptic Plasticity │
│ Migration │
│ Health Monitoring │
└───────────────────┬───────────────────┘
│
Driver API
│
┌───────────────────▼───────────────────┐
│ Biological HAL │
│ │
│ MEA • Organoid • Emulator • Vendors │
└───────────────────┬───────────────────┘
│
┌───────────────────▼───────────────────┐
│ Biological Substrate │
│ │
│ Living Neural Networks │
└───────────────────────────────────────┘
The key idea is substrate independence.
An application should not need to know whether its neural substrate is:
- an in-silico emulator,
- an MEA-coupled neural culture,
- a cortical organoid,
- or eventually another biological computing platform.
The driver layer should absorb those differences.
That is the beginning of a true biological computing stack.
A Kernel for Living Neural Networks
Traditional operating systems manage computational resources.
OrganoidOS asks:
What does resource management mean when the resource is alive?
The kernel currently explores four major subsystems:
1. Neural Scheduling
How do we allocate neural resources to competing computational tasks?
Instead of CPU cores and threads, the abstraction becomes closer to:
Neuron pools
↓
Task allocation
↓
Stimulation / computation
↓
Observed response
This opens the door to the concept of biological processes — computational tasks running over neural populations.
2. Synaptic Plasticity
Silicon systems generally separate computation from learning.
Biological systems don't.
Learning is embedded in the substrate itself.
OrganoidOS therefore includes a plasticity layer based on mechanisms such as:
- pair-based STDP
- homeostatic normalization
- adaptive synaptic weights
The objective isn't to imitate biology perfectly.
The objective is to create a programmable abstraction around biological-style learning.
3. Neural Migration
This may be the strangest idea in the entire project.
What if a learned behavioral state could be captured?
What if it could be transferred to another neural substrate?
OrganoidOS introduces a migration abstraction:
Organoid A
│
│ learned state
▼
Snapshot
│
▼
Organoid B
│
│ re-training / adaptation
▼
Behavioral convergence
This is not a claim that we can currently copy a human memory from one brain to another.
It is a software-level experiment:
Can a learned computational state be represented, checkpointed, restored, and evaluated across neural substrates?
That distinction is critical.
The current implementation explores this problem inside the emulator.
But the abstraction could eventually become useful for biological hardware.
4. Health Monitoring
There is one enormous difference between a CPU and a living neural substrate:
the substrate can change because it is alive.
Neurons can die.
Connectivity can change.
Activity can drift.
The system can become unstable.
Biological computation therefore needs something that traditional operating systems rarely need at the same level:
A health-aware runtime.
OrganoidOS includes health-monitoring concepts intended to detect degradation and abnormal activity.
Imagine:
CPU Monitoring
↓
Temperature
Load
Memory
Power
Biological Monitoring
↓
Spike activity
Network stability
Connectivity
Homeostasis
Viability
The operating system becomes aware of the condition of the computational substrate itself.
The L0 Reference Emulator
You don't need an organoid to experiment with OrganoidOS.
The repository includes an L0 Python reference emulator with neural models including:
- Izhikevich neurons
- Hodgkin–Huxley dynamics
- STDP
- homeostatic mechanisms
- scheduling
- snapshots
- restoration
- migration
- health monitoring
The repository also contains an application-facing API, examples, tests, and a CLI. (GitHub)
The idea is simple:
Today:
Developer
↓
Python
↓
OrganoidOS Emulator
Tomorrow:
Developer
↓
OrganoidOS
↓
Biological Driver
↓
MEA
↓
Living Neural Substrate
The same conceptual application layer.
A different substrate.
The Interesting Part: Migration
One of the project's end-to-end demonstrations follows:
TRAIN
↓
SNAPSHOT
↓
MIGRATE
↓
RESTORE
↓
VERIFY
The repository includes reproducible benchmarks covering its major subsystems, including scheduling, plasticity, migration, and health-related behavior. (GitHub)
This is important because the project isn't only proposing an architecture.
It is trying to make the architecture executable.
Why This Is Different From Most Organoid Software
Search the current open-source organoid ecosystem and you'll find many projects focused on:
- microscopy
- segmentation
- morphology
- spike analysis
- image processing
- biological characterization
- drug screening
For example, MOrgAna focuses on machine-learning-based quantitative analysis of organoid images, while other projects analyze neural spiking activity from organoids. (GitHub)
Those projects are valuable.
But OrganoidOS asks a different question.
Instead of:
How do we analyze a biological neural system?
It asks:
How do we program one?
That is a fundamentally different abstraction layer.
From Organoid Research to Biological Computing
This is where the project becomes more interesting.
Imagine a future stack:
BIOLOGICAL APPLICATIONS
│
┌──────────────┴──────────────┐
│ │
AI Agent Adaptive Game
│ │
└──────────────┬──────────────┘
│
Organoid Runtime
│
OrganoidOS Kernel
│
┌────────────────┼────────────────┐
│ │ │
Scheduler Plasticity Memory
│ │ │
└────────────────┼────────────────┘
│
Biological HAL
│
┌──────────────┼──────────────┐
│ │ │
MEA Organoid Emulator
│ │ │
└──────────────┼──────────────┘
│
Neural Substrate
At that point, we are no longer talking about a neuroscience experiment.
We're talking about a potential computing platform.
The Missing Piece: Biological Memory
This is one of the most interesting problems ahead.
In conventional computers:
Cache
RAM
Storage
Checkpoint
But what is memory in a living neural system?
Potential candidates include:
Synaptic weights
Functional connectivity
Network topology
Plasticity state
Oscillatory state
Homeostatic state
This suggests another layer:
BioMemory
A future OrganoidOS memory subsystem could potentially define:
state = organoid.checkpoint()
save(state)
restore(state)
migrate(
state,
target=another_organoid
)
That could transform the concept of neural state into something closer to a first-class computational object.
And that is a very different way of thinking about biological computing.
The Real Challenge: L1
The current project is deliberately honest about where it stands.
L0 is software.
The real scientific challenge begins at:
L0
Software emulator
↓
L1
One biological substrate + MEA
↓
L2
Multiple substrates
↓
L3
Interoperable biological computing ecosystem
The next major milestone is therefore not another simulator feature.
It is a Biological Hardware Abstraction Layer.
Something like:
class OrganoidDriver:
def connect():
...
def stimulate():
...
def record():
...
def get_health():
...
def checkpoint():
...
def close():
...
Then vendor- or lab-specific implementations could sit underneath the same operating-system abstraction.
That is where OrganoidOS could become much more than a GitHub experiment.
The Bigger Vision
Today we have:
Cloud Computing
↓
Virtual Machines
↓
Containers
↓
Operating Systems
↓
Silicon
Tomorrow we may have:
Biological Cloud
↓
Neural Runtime
↓
OrganoidOS
↓
Biological HAL
↓
Living Neural Substrate
The purpose of OrganoidOS is not to declare that this future already exists.
It is to start defining the software primitives required if it does.
A New Programming Paradigm?
For decades, programmers have written instructions for machines.
Biological computing suggests something radically different:
What if programming becomes the process of shaping a living computational system?
Instead of only writing:
if x > threshold:
output = 1
we might eventually define:
Task
↓
Stimulus
↓
Plasticity
↓
Adaptation
↓
Emergent computation
The programmer doesn't necessarily specify every operation.
The programmer defines an environment in which the substrate can learn.
That could be one of the biggest conceptual shifts in computing since neural networks themselves.
What OrganoidOS Is — and Isn't
It is:
- an open specification
- a reference software implementation
- a substrate-agnostic architecture
- an experimental biological-computing runtime
- a framework for exploring scheduling, plasticity, migration, and health monitoring
It is not:
- a replacement for a biological experiment
- proof of human memory transfer
- a claim that organoids currently outperform modern AI hardware
- a claim that the L0 emulator is equivalent to living tissue
That distinction matters.
The project is building the abstraction layer first.
Why Open Source Matters
If biological computing becomes a real computational paradigm, it should not begin as a collection of incompatible proprietary interfaces.
We need:
Open specifications
+
Open drivers
+
Reproducible benchmarks
+
Shared APIs
+
Ethical standards
The goal is interoperability.
A developer should eventually be able to build an application once and target multiple biological substrates.
That is the same reason operating-system abstractions became so powerful in classical computing.
The Question Behind OrganoidOS
The most interesting question isn't:
"Can neurons compute?"
We already know biological neural systems compute.
The deeper question is:
Can we build an operating system for something that is alive, adaptive, plastic, and capable of changing its own computational substrate?
That question has consequences far beyond organoids.
It touches:
AI.
Neuroscience.
Neuromorphic computing.
Biocomputing.
Synthetic biology.
Brain–computer interfaces.
And eventually, entirely new forms of computation.
The Experiment Has Started
OrganoidOS is currently an early-stage v0.1 project with an L0 emulator.
But every major computing paradigm starts with an abstraction.
Unix abstracted hardware.
Virtual machines abstracted physical machines.
Cloud computing abstracted infrastructure.
Neural networks abstracted aspects of biological learning.
OrganoidOS explores the possibility of abstracting living neural computation itself.
The next computer may not simply execute code.
It may learn.
It may adapt.
It may heal.
And perhaps one day, it may be partly alive.
Explore the Project
GitHub:
https://github.com/modarresi1913/OrganoidOS
The repository is open source under the MIT license and includes the specification, L0 Python emulator, examples, benchmarks, tests, documentation, and roadmap. (GitHub)
If you're working on:
🧠 Organoids
⚡ Neuromorphic computing
🤖 AI infrastructure
🧬 Synthetic biology
🔬 Neural interfaces
💻 Operating systems
🧪 Biological computing
this is an invitation to experiment.
The most important part of OrganoidOS may not be the code that exists today.
It may be the question it allows us to ask:
What happens when the hardware starts to live?
created by Seyed Alireza Alhosseini Almodarresieh
Top comments (0)