💻 computer science

Microcosmos: Reimagining Artificial Life for the GPU Era

The paper introduces Microcosmos, a GPU-optimized, end-to-end differentiable simulation engine that models artificial life as elastic filaments in a 2D viscous fluid, successfully demonstrating physical plausibility, differentiability, and scalability for large-scale open-ended evolution.

Original authors: Mark Tensen, Ciaran Regan, Bert Wang-Chak Chan, Mizuki Oka, Kenneth O. Stanley, Grisha Szep

Published 2026-07-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mark Tensen, Ciaran Regan, Bert Wang-Chak Chan, Mizuki Oka, Kenneth O. Stanley, Grisha Szep

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine trying to teach a computer how to create life. For decades, scientists have faced a frustrating choice: they can either build a world that follows the strict laws of physics (like water resistance and gravity), but it's so slow to run that they can only simulate a few tiny creatures. Or, they can build a world that runs super fast on computers, but it's made of abstract rules that have nothing to do with how real organisms actually move or interact.

Microcosmos is a new "playground" for artificial life that tries to have its cake and eat it too. It's a simulation engine designed to run on modern graphics cards (GPUs), allowing researchers to simulate thousands of lifeforms at once, all while obeying the real physics of swimming in thick, sticky fluid.

Here is a breakdown of how it works, using simple analogies:

1. The Creatures: "Elastic String People"

Instead of simulating complex organs or muscles, Microcosmos builds life out of elastic filaments. Think of these as long, flexible strings or chains of beads.

How they move: Just like a real worm or a jellyfish, these strings can bend, stretch, and wiggle.
The "Genetic Code": The computer program controls how stiff the string is, how long it wants to be, and what angle it prefers to bend at. By tweaking these settings, the "creature" can change its shape and movement style.

2. The World: "Thick Honey"

These string-creatures live in a 2D world filled with a viscous fluid. Imagine swimming in a pool of thick honey rather than water.

Why it matters: In this thick world, you can't just wiggle back and forth symmetrically (like opening and closing a clam shell) and expect to go anywhere. This is known as the "Scallop Theorem." To move, you need to make asymmetric, time-irreversible movements, just like real bacteria or tadpoles do.
The Physics: The simulation calculates how the fluid pushes against the strings and how the strings push back against the fluid. It's a two-way conversation between the creature and the water.

3. The Superpower: "The Magic Eraser" (Differentiability)

This is the most technical but coolest part. Usually, if you want to improve a creature's shape, you have to guess, test, fail, and guess again.

Microcosmos is different: Because the whole simulation is built on a specific mathematical framework (JAX), it is fully differentiable.
The Analogy: Imagine you are trying to fold a piece of string into the shape of the number "7." In a normal simulation, you'd have to guess and check thousands of times. In Microcosmos, the computer can look at the final result, instantly calculate exactly which tiny bend in the string was wrong, and "slide" the string into the perfect shape automatically. It's like having a magic eraser that knows exactly how to fix the mistake instantly.

4. What They Tested

The team ran four main experiments to prove the system works:

The "Hand-Designed" Test: They manually programmed five different swimming styles (like a worm, a tadpole, a jellyfish, and a ray). The simulation confirmed that these creatures moved exactly as physics predicts they should in thick fluid. For example, the "ray" (which moves symmetrically) got stuck, while the "jellyfish" (which moves asymmetrically) swam forward.
The "Folding" Test: They asked the computer to use its "magic eraser" to fold a 1,000-node string into the shapes of handwritten numbers (0–9). The computer successfully learned to fold the strings into recognizable digits, proving the system is mathematically precise.
The "Evolution" Test: They let a computer algorithm "evolve" controllers for the strings. Instead of telling the strings how to move, they let the computer try millions of random variations. The system automatically discovered many different ways to swim and even learned to swim toward "food" (energy packets) in the water.
The "Scale" Test: They checked how fast the computer runs as they added more creatures. Most simulations get exponentially slower as you add more things (like trying to calculate how every person in a city interacts with every other person). Microcosmos, however, scales linearly. This means if you double the number of creatures, it only takes double the time, not quadruple. This allows them to simulate huge populations (up to 500,000 particles) efficiently.

The Bottom Line

Microcosmos is a bridge. It connects the messy, physical reality of how tiny organisms swim with the speed and power of modern computer hardware. It doesn't just simulate life; it simulates life in a way that allows researchers to use powerful mathematical tools to automatically discover new, complex behaviors that might never have been imagined by a human designer.

The authors have released this as an open platform, hoping it becomes a foundation for the next generation of artificial life research, where we can finally run large-scale, physically realistic evolutionary experiments.

Technical Summary: Microcosmos: Reimagining Artificial Life for the GPU Era

Problem Statement

The field of Artificial Life (ALife) faces a fundamental trade-off between physical credibility and computational scalability. Existing simulators generally fall into two categories:

Abstract Substrates: Rule-based systems (e.g., cellular automata, Lenia, Tierra) are computationally efficient and support open-ended evolution but lack grounding in physical principles like fluid dynamics and biophysics, limiting the realism of embodied behaviors.
Physically Grounded Simulators: Systems that simulate realistic physics (e.g., rigid-body collisions, fluid-structure interaction) are often computationally intractable for large-scale evolutionary searches, operate at high levels of abstraction, or are designed for reinforcement learning rather than open-ended evolutionary dynamics.

The authors argue that achieving open-ended evolutionary complexity requires a simulator that is physically credible enough to respect real-world constraints (such as low Reynolds number hydrodynamics), efficient enough to support evolutionary search at scale, and behaviorally rich enough to inspire complex morphologies.

Methodology

The authors present Microcosmos, a simulation engine designed from the ground up for modern GPU hardware and end-to-end differentiability. The system models artificial lifeforms as elastic filament chains inhabiting a two-dimensional viscous fluid world.

Core Components

Filament Representation: Lifeforms are modeled as discrete elastic rods (Cosserat rods) composed of connected nodes. Each edge has a material frame angle ( $\theta$ ) and physical parameters including rest length ( $L_{rest}$ ), rest angle ( $\theta_{rest}$ ), and stiffness coefficients ( $k_{bend}, k_{shear}, k_{stretch}$ ). The topology supports loops and branches via a graph representation.
Dynamics Solver: The system uses Position-Based Dynamics (PBD) to solve constraints. This iterative method directly modifies node positions and orientations to satisfy geometric constraints (bending, stretching, shearing). PBD was chosen for its unconditional stability and compatibility with automatic differentiation, avoiding the need to differentiate through implicit linear solvers.
Fluid Simulation: The environment is modeled using the Lattice Boltzmann Method (LBM) with a D2Q9 model (2D, 9 velocities). This mesoscopic approach handles moving boundaries without remeshing and allows for linear scaling ( $O(n)$ ) on GPUs.
Fluid-Structure Interaction: Interaction is handled via the Immersed Boundary Method (IBM). Filament nodes sample local fluid velocity to determine drag, and their velocities are broadcast back to the grid. To prevent fluid leakage through zero-thickness filaments, the authors employ Multi-Direct Forcing (MDF), Two-Relaxation-Time (TRT) schemes, and a two-layer filament broadcasting technique.
Self-Avoidance: Collision avoidance is managed via a grid-based steric repulsion field. Node positions are deposited on a grid, diffused via FFT convolution, and the resulting density gradient generates repulsive forces, avoiding $O(n^2)$ pairwise distance checks.
Differentiability: The entire pipeline, from PBD constraints to LBM fluid updates, is implemented in JAX, enabling end-to-end automatic differentiation. This supports both gradient-based optimization and evolutionary search.

Encoding and Search

Microcosmos is search-method agnostic, supporting:

Direct Encoding: Explicit specification of parameters for each node.
Indirect Encoding: Generative models (e.g., CPPNs) that map spatial/temporal inputs to physical traits.
Optimization Methods: The paper utilizes gradient descent for shape optimization and Neuroevolution (NEAT) and Quality-Diversity (QD) search (MAP-Elites) for discovering locomotion strategies.

Key Contributions

A Scalable, Differentiable Simulator: Microcosmos is the first system to combine differentiable flexible filament simulation with a resolved fluid solver (LBM) for simultaneous morphology and controller optimization.
GPU-Native Architecture: The engine is designed for parallel execution, achieving linear scaling with particle count, unlike particle-based systems that suffer from quadratic scaling.
Open Platform: The code is released as an open-source platform to facilitate large-scale open-ended evolutionary simulations within the ALife community.

Experimental Results

The engine was validated through four distinct experiments:

Hand-Designed Locomotion: Five creatures with manually designed geometries (worm, tadpole, ray, cilia, jellyfish) were tested across a viscosity sweep ( $10^{-3}$ to $2$).
- Result: The simulation correctly reproduced physical constraints, such as Purcell's scallop theorem. Time-reversible strategies (e.g., the "ray") produced zero net displacement at high viscosity, while non-reciprocal strategies (e.g., "cilia") maintained locomotion, confirming the fluid coupling respects low-Reynolds-number physics.
Filament Folding (Differentiability): A 1000-node filament was optimized via gradient descent to fold into MNIST digit shapes.
- Result: The system successfully minimized the loss function, folding the filament into recognizable digit shapes. This confirmed the full differentiability of the pipeline, including the PBD solver and fluid computation.
Neuroevolution of Controllers: A Compositional Pattern Producing Network (CPPN) was evolved to control filament nodes, with fitness based on displacement and chemotaxis (energy collection).
- Result: The system evolved sinusoidal locomotion strategies and demonstrated the ability to navigate chemical gradients, validating the integration of sensory-motor control with physical dynamics.
Quality-Diversity (QD) Search: MAP-Elites was used to discover diverse locomotion strategies based on behavioral descriptors (bending effort and stretching effort).
- Result: A wide variety of swimming gaits emerged, including sinusoidal movements, directional turning, complex motions, and paddle-like circular structures, demonstrating the expressivity of the filament encoding.
Scalability: Runtime was measured against particle count (up to 500k particles).
- Result: Microcosmos demonstrated linear scaling with particle count, contrasting sharply with the $O(n^2)$ scaling of pairwise interaction systems like Particle Life.

Significance and Claims

The paper claims that Microcosmos addresses the historical bottleneck in ALife research: the inability to scale physically grounded simulations. By leveraging the ubiquity of filamentous structures in biology (from flagella to cytoskeletal networks) and the efficiency of GPU-accelerated fluid solvers, the authors provide a tool that bridges the gap between physical credibility and computational tractability.

The authors position Microcosmos not as a final solution, but as a foundational platform. They argue that scaling physically grounded simulations is as critical for the future of Artificial Life as scaling compute has been for modern AI. The system is intended to support future research into multi-agent interactions, birth/death dynamics, self-assembly, and the emergence of individuality and symbiosis in physically plausible virtual worlds. The paper concludes with a call for the community to build upon this open platform to achieve open-ended evolutionary complexity.