DEV Community: cosmosoneness

I Simulated an Entire Human Body in Python: From Ion Channels to Sepsis

cosmosoneness — Tue, 02 Jun 2026 15:03:58 +0000

What if you could create a human being inside your computer — not a 3D avatar, but a physiological one? A body with a beating heart whose blood pressure responds to blood loss, lungs that desaturate at altitude, a pancreas that releases insulin after a meal, and an immune system that can tip into sepsis?

That's humanbody: a single Python object you step forward in time.

from humanbody import HumanBody

body = HumanBody()
for _ in range(60):          # 60 seconds of life
    body.step(dt=1.0)

print(body.state_summary())
# HR=72, MAP=93, PaO2=97, SaO2=0.98, glucose=94, cortisol=15, pH=7.40 ...

Every number that comes out of state_summary() is the emergent result of dozens of coupled differential equations — not a lookup table. Change one thing (bleed the patient, feed them, send them up a mountain) and the whole body responds the way a real body would.

It's 255 tests of mathematical physiology, and it's open source.

🔗 Code: github.com/cosmosoneness/Cosmos (under Emulation/Human_Body/)

Why build this?

Textbooks teach physiology one system at a time: here's the cardiac cycle, here's the nephron, here's the HPA axis. But the body isn't a list of chapters — it's a giant feedback network. When you exercise, your muscles demand oxygen, which raises your heart rate, which the baroreflex modulates, which shifts your blood pressure, which changes kidney filtration, which adjusts your fluid balance… all at once.

I wanted to feel those couplings, not just read about them. The only way to really understand a control system is to build one and watch it misbehave.

So I built the whole thing — fourteen phases, from molecules up to clinical scenarios.

The architecture: thinking in scales

The model is organized by biological scale, and the dependency arrow always points up:

molecular   →  enzyme kinetics, Hill dissociation, ATP/PCr/lactate
cellular    →  Hodgkin–Huxley ion channels, membrane potential
tissue      →  Krogh-cylinder oxygen diffusion
systems/    →  9 organ systems (the meat)
integration →  HumanBody aggregator + homeostasis
scenarios   →  clinical challenges you can run

The nine organ systems each implement well-known models from the literature:

System	Model
Cardiovascular	Suga–Sagawa time-varying elastance + Ursino Windkessel + baroreflex
Respiratory	Otis–Rohrer mechanics + alveolar gas equation + Hill O₂ dissociation
Nervous	Wilson–Cowan cortical mass + brainstem rhythm generator + autonomic tone
Endocrine	HPA / HPT / HPG axes + Dalla Man glucose–insulin + ADH/RAAS
Digestive	5-compartment GI transit + liver glycogen + microbiome SCFA
Renal	glomerulus + tubular handling + countercurrent multiplier + acid–base
Musculoskeletal	Hill-type muscle + PCr/lactate buffering + Lemaire bone remodeling
Integumentary	Gagge two-node thermal model
Immune	innate + adaptive + Perelson pathogen dynamics + SIRS criteria

They talk to each other through a shared signal bus — a dictionary of cross-system variables like mean arterial pressure, arterial oxygen, glucose, and cortisol — plus an event bus for discrete events like "a meal was eaten."

The hard part: time

Here's the thing nobody tells you about whole-body simulation — different systems live on wildly different timescales.

The heart beats on the order of milliseconds. A cardiac action potential, valve dynamics, the pressure pulse — all of it is stiff. Meanwhile, your cortisol rhythm plays out over hours, and bone remodeling takes weeks.

My first integration attempt used a naive forward-Euler step at dt = 1 second for everything. The result? Mean arterial pressure exploded to 5 × 10⁴⁹ mmHg. The cardiac ODE was catastrophically unstable at that step size.

The fix was per-system substepping: inside one body.step(dt=1.0), the engine runs the heart and circulation at 1 ms substeps (1000 iterations), the respiratory pump at 50 ms substeps, and everything slower at the full dt.

def step(self, dt=1.0, **perturbations):
    # Cardiac dynamics are stiff — substep finely
    n_cardio = max(1, int(dt / 1e-3))
    for _ in range(n_cardio):
        self.cardio.step(1e-3, signal=self.signal)

    # Respiratory — medium substep
    n_resp = max(1, int(dt / 0.05))
    for _ in range(n_resp):
        self.respiratory.step(0.05, signal=self.signal)

    # Slow systems — one macro step
    self.endocrine.step(dt, signal=self.signal)
    self.renal.step(dt, signal=self.signal)
    self.bus.publish(TickEvent(time=self.t, source="body", dt=dt))

This is the same idea as multi-rate integration in circuit simulators. It's not glamorous, but it's the difference between a model and a number that overflows a float.

Watching it come alive: clinical scenarios

The payoff is the scenario framework. Seven clinical challenges ship built-in:

from humanbody.scenarios import HemorrhageScenario, run_scenario

result = run_scenario(HemorrhageScenario(volume_mL=1000), dt=1.0)
print(result.alerts)
# ['Shock: MAP < 65 mmHg']

Run the hemorrhage scenario and you watch the baroreflex fight to maintain pressure as a liter of blood drains away — heart rate climbs, then pressure finally collapses into shock and the homeostasis monitor raises an alert.

Run sepsis and IL-6 rises, drives a fever and tachycardia, and the system checks itself against the actual SIRS criteria.

Run high-altitude and the barometric pressure drop propagates through the alveolar gas equation into the Hill oxygen-dissociation curve — SaO₂ falls, the chemoreflex kicks in, and ventilation rises.

Run diabetic ketoacidosis and glucose stays sky-high while bicarbonate falls and the pH drops below 7.3.

Each scenario is just a small class — and writing your own takes about a dozen lines:

from humanbody.scenarios.clinical import Scenario

class CaffeineDose(Scenario):
    """200 mg caffeine -> tachycardia + higher cortisol."""
    def __init__(self):
        super().__init__(name="Caffeine",
                         description="200 mg single dose",
                         duration=3600.0)
        self.applied = False

    def step_perturbation(self, body, t):
        if not self.applied and t >= 60:
            body.endocrine.hpa.stress_input += 0.2
            body.cardio.baroreflex.set_point += 5
            self.applied = True
        return {}

What it can — and can't — do

Let me be honest about the boundaries, because that matters more than the demo.

It's good for: teaching integrated physiology, prototyping clinical scenarios, "what-if" experiments, and as a scaffold you can subclass into something research-grade. You learn an enormous amount just by breaking it.

It's not: a medical device, a source of patient-specific predictions, or publication-grade quantitative biology. Every ODE is forward-Euler with substepping — accurate enough to be qualitatively right, not quantitatively certified. Do not use it for medical decisions.

There's also a fun gotcha I left in the docs: ask for blood pressure at the wrong instant and you might see "MAP = 8.9 mmHg." That's not a bug — it's the instantaneous pressure sampled at diastole. The cardiac ODE is genuinely pulsatile at 1 ms resolution, so you have to average over a cycle to get a textbook number. The model is more honest than the summary statistic.

The bigger project

humanbody is actually one chapter of a larger repo I'm calling the Cosmos Research Institute — an umbrella for end-to-end "emulators" of real systems, from a cellular artificial-life world to connectome-level whole-brain emulation. The ambition is to keep building computational models of the world we live in until the name stops being a joke.

But you have to start somewhere, and the body is a beautiful place to start: it's the most sophisticated control system any of us will ever own, and now there's a version of it you can pip install and break to your heart's content.

Try it

git clone https://github.com/cosmosoneness/Cosmos.git
cd Cosmos/Emulation/Human_Body
pip install -e ".[dev]"
pytest tests/ -q          # 255 passed

humanbody run exercise --duration 600
humanbody serve --port 8000   # REST API

🔗 Source: github.com/cosmosoneness/Cosmos
📖 Tutorial: the TUTORIAL.md in the repo has seven hands-on walkthroughs
⭐ If it teaches you something, a star helps others find it

Built in Python with the help of Claude Code. The individual modules credit the papers they implement — Suga & Sagawa, Ursino, Dalla Man, Wilson & Cowan, Lemaire, Gagge, Perelson, and many others whose mathematical physiology made this possible.

I Built an Artificial Life Simulation Where Cells Carry Tiny Neural Networks — and Started Measuring Their Φ

cosmosoneness — Tue, 19 May 2026 14:56:48 +0000

A six-phase journey from Conway's Game of Life to Integrated Information, all in one TypeScript file tree.

There's a particular flavor of programming that feels less like writing software and more like building a small universe — set the rules, press play, and watch what happens. Conway's Game of Life is the canonical example, but the modern Cambrian explosion of compute has made it almost trivial to go much, much further: real ecosystems with energy and nutrients, evolving genomes, chemical communication, multi-cell organisms, embedded neural networks for decision-making, and — at the top of the stack — measurements borrowed from consciousness research.

I spent a few sessions building exactly that. It's a TypeScript + Vite project called Life, the first subproject of an open-source umbrella I'm calling Cosmos Research Institute. The whole thing runs deterministically from a seed, ticks at about 10 Hz in a browser tab, and ships with 75 passing tests that pin every layer in place.

This post is a tour through the six phases that turn a 128×128 grid of dead pixels into something I can no longer fully predict.

Phase 0 — The foundation

The architecture is the boring-on-purpose part: TypeScript in strict mode, Vite for the dev server, Vitest for tests, and HTML5 Canvas as the only rendering surface. No frameworks, no DOM-per-cell, no WebGL. The simulation core (src/core/) is pure: every tick takes a WorldState and returns a new WorldState. The renderer (src/render/) is the only place side effects happen.

Two foundational utilities make everything else possible:

// xoshiro256** PRNG — deterministic, fast, good statistical properties
const rng = createRNG(42);
rng.next();      // 0..1
rng.nextInt(0, 100);
rng.nextBool(0.3);

// Toroidal grid — coordinates wrap, so the world has no edges
const grid = createGrid<Cell>(128, 128, () => createEmptyCell());
grid.get(-1, 0); // same cell as grid.get(127, 0)

Determinism matters. Same seed → identical universe, every time. That's what lets me run regression tests on a simulation whose emergent behavior I can't predict.

Phase 1 — Conway's Game of Life, the right way

Conway is famous because it's the smallest interesting cellular automaton. B3/S23: a dead cell with exactly three live neighbors becomes alive; a live cell with two or three live neighbors survives. From two rules you get gliders, oscillators, glider guns, even Turing-complete computation.

The implementation is a pure-function tick:

export function tickWorld(state: WorldState): WorldState {
  const next = grid.clone();
  for (let y = 0; y < grid.height; y++) {
    for (let x = 0; x < grid.width; x++) {
      const cell = grid.get(x, y);
      const n = countNeighbors(grid, x, y, c => c.alive);
      if (cell.alive)  next.set(x, y, (n === 2 || n === 3) ? cell : dead());
      else             next.set(x, y, (n === 3) ? born() : dead());
    }
  }
  return { ...state, grid: next, tick: state.tick + 1 };
}

Two tests pin it down: a blinker oscillates with period 2, a block is a still life. If either ever breaks, I know an upstream change leaked into the rules.

Phase 2 — Energy, nutrients, and the end of binary life

Conway's "alive" is binary. Real cells aren't — they need fuel, they starve, they overpopulate. So Phase 2 adds two grid layers underneath the cell grid:

Energy — added by sunlight (with a top-down gradient and a sinusoidal day/night cycle), absorbed by living cells, returned to the environment when they die ("decay").
Nutrients — regenerate slowly in empty tiles, get consumed by living cells, diffuse via discrete Laplacian to spread.

Now there's a carrying capacity. Dense regions starve themselves. The population oscillates around a stable equilibrium, with boom-bust dynamics that emerge entirely from local rules — no global tuning required.

Phase 3 — Genomes, mutation, speciation

This is where it stops feeling like cellular automata and starts feeling like evolution.

Every living cell carries a 64-bit genome stored as Uint8Array(8). The bits map to traits:

Bits	Trait	Effect
0–3	birth threshold	how many neighbors trigger birth
4–7	survive threshold	how many neighbors are needed to survive
8–11	metabolic efficiency	scales energy consumption
12–15	reproduction cost	energy required to spawn a child
16–19	aggression	probability of attacking neighbors
20–23	cooperation	probability of sharing energy
24–31	color hue	phenotype color (this is what you see)

Reproduction copies the parent's genome and applies per-bit mutation at a small rate. Adjacent compatible cells (Hamming distance < threshold) can also reproduce sexually via single-point crossover. Over generations, a greedy clustering algorithm groups similar genomes into species — and because color hue is part of the genome, related cells naturally cluster visually into colored bands.

Within minutes of starting from a uniform random soup, the simulation reliably evolves dozens of co-existing species. None of this is hard-coded. It's just selection acting on local rules.

Phase 4 — Organisms, signals, terrain

Cells alone get boring. Multi-cell organisms are where the interesting structure lives. Every tick, a flood-fill connected-component algorithm finds clusters of cells whose genomes are mutually similar (Hamming distance < 8). Each cluster gets an organism record with size, centroid, total energy, and a partition into boundary cells (touching at least one non-member) and interior cells. Interior cells share energy with boundary cells (amplified by the cooperation gene). Organisms larger than 20 cells split at their thinnest point.

On top of this sits a chemical signaling layer — three diffusing scalar fields:

Food signal — emitted by cells with surplus energy. Other cells preferentially reproduce toward the gradient (chemotaxis).
Danger signal — emitted by cells under attack. Other cells preferentially reproduce away.
Attract signal — emitted during reproduction readiness. Adjusts mating direction.

I never coded flocking, herding, or predator avoidance directly. They show up anyway, as side effects of local emission + diffusion + gradient sensing.

Finally there's terrain: multi-octave value noise generates an elevation map, water occupies low areas (cells can't live there), latitude + elevation set per-tile temperature, and a seasonal cycle modulates everything globally. Meteors, plagues, and ice ages strike at random and stress the population from outside.

Phase 5 — Genomes that think

Phase 5 doubles the genome from 64 to 128 bits and uses the new bits to encode a small feed-forward neural network: 4 inputs, 2 hidden, 3 outputs. Fourteen weights, each a 4-bit signed integer.

Inputs:  [normalized energy, neighbor count, food signal, danger signal]
Hidden:  2 nodes with tanh activation
Outputs: [action, direction bias, signal emission]
         action ∈ {STAY, MOVE, REPRODUCE} via thresholded output

Each tick, every cell runs its own neural network and acts on the output. Mutation and crossover operate on raw genome bits, so the neural weights evolve through natural selection — cells with brains that lead to better survival out-reproduce cells with worse brains.

Click any cell in the running simulation and a live inspector pops up: phenotype values, current neural inputs, current output, and a diagram of the network with green/red connections sized by weight magnitude. It's hypnotic to watch the same brain fire across hundreds of related cells in a clade.

Phase 6 — Measuring something like consciousness

Here's where I went off the deep end, in a fun way.

If organisms are forming via natural selection, and they're integrating information across their member cells, then maybe — just maybe — they should register on the metrics consciousness researchers have proposed. Integrated Information Theory (IIT) defines a quantity called Φ (phi) that measures how much information a system generates beyond the sum of its parts. Exact Φ is computationally intractable, but there's a useful approximation called Φ*:

For each organism, sample 24 random bipartitions of its cells.
For each bipartition, compute the normalized mutual information across the cut, using a discrete state token per cell (energy bucket + age bucket + aggression + neighborhood signature).
Report the minimum NMI as Φ* — the bottleneck partition.

High Φ* means the organism's information is integrated: you can't cleanly decompose it into independent parts without losing structure. Low Φ* means it's just a pile of cells that happen to be next to each other.

The Phase 6 dashboard surfaces this alongside a few other complexity metrics:

Shannon entropy of the cell-state distribution (bits/cell)
Compression complexity — the more compressible the grid, the more ordered it is
Spatial mutual information between distant regions — long-range order detection
Lyapunov exponent estimate from population history — chaotic vs stable dynamics

There's also a hypothesis log: whenever an organism's Φ* crosses a configurable threshold, the simulation records the tick, the organism's size, its centroid, and a hex hash of its founder's genome.

In a test run on a 64×64 grid with seed 42, one organism reached Φ* = 1.0. That doesn't mean it's conscious. It means the integrated-information measure detected something — and that something arose from local rules with zero global supervision.

What I take away from this

Determinism is non-negotiable for emergence research. Without seed reproducibility, every weird thing you observe is unfalsifiable. The xoshiro256** + immutable-state-per-tick discipline pays off constantly.
You can't reason your way to good rule sets — you have to run them. I spent more time on the thresholds (mutation rate, reproduction cost, signal decay) than on the algorithms. Good rules are a search problem.
The neural network layer changes the regime. Before Phase 5, behaviors were essentially hand-coded. After Phase 5, behaviors are selected for. You can almost feel the moment when chemotaxis starts emerging from random networks under selection pressure.
Φ* is suggestive, not conclusive. I make no claim that any organism here is conscious. But the metric does flag exactly the structures that look coherent — and that's already useful as an instrument.

Try it

git clone https://github.com/cosmosoneness/Cosmos.git
cd Cosmos/Emulation/Life
npm install
npm run dev
# open http://localhost:5173

Key	Action
`Space`	pause / resume
`.`	single-step
`V`	cycle view (genome / life / energy / nutrients / signals / terrain / phi)
`D`	toggle emergence dashboard
`Click`	inspect a cell (phenotype + neural network)

The whole project is MIT-licensed. It's also part of the Cosmos Research Institute — an umbrella for "computational emulations" that try to run scientific systems end-to-end on a laptop. Alongside Life are two siblings: HumanBody (a 13-organ multi-scale physiology simulator) and WholeBrainEmulation (connectome-level neural simulation with consciousness metrics). The plan is to keep building until the institute earns its name.

If you build something on top of it, or just want to argue about Φ*, I'd love to hear from you.

Built with the help of Claude Code. All bugs are mine.