The full capability map

Everything reality can do, in one engine

Poly Sim OS collapses the walls between physics, biology, chemistry, and math into a single AI-powered canvas. This is the complete picture of what the Everything Engine unlocks.

See it in motion Browse the library

Domains, one canvas

5B+

Particles per cloud run

60 fps

Real-time WebGPU render

Installs required

The Domains

Five disciplines that finally speak the same language

Each domain ships a deep library of typed, unit-aware nodes. The magic is that any node can connect to any other — across every field.

Physics

Rigid bodies, fields, and fluids resolved to the limit of your hardware.

Navier–Stokes fluids
N-body gravitation
Rigid & soft bodies
EM field solvers

Biology

From single-cell kinetics to population dynamics, modeled as living graphs.

Enzyme kinetics
Gene regulatory nets
Lipid nanoparticles
Tissue diffusion

Chemistry

Reaction networks and transport coupled directly to physics and biology.

Reaction-diffusion
Stiff kinetics
Phase transitions
Catalysis models

Mathematics

The solver layer — pure math nodes that drive every other domain.

ODE / PDE solvers
Stochastic processes
Optimization
Spectral methods

Solvers & Energy

Adaptive integrators that auto-tune to the stiffness of your system.

Runge–Kutta RK45
Implicit BDF
Finite element
Symplectic integrators

…and the spaces between them

Biophysics. Electrochemistry. Computational fluid biology. The most important science happens at the seams — and the seams are where Poly Sim OS lives.

PhysicsBiologyChemistryMathSolver

Groundbreaking Capabilities

Six things no other tool puts in one place

No more silos

Multiphysics Coupling

Wire a fluid-dynamics node straight into a nanoparticle node, driven by a math solver. Domains that never spoke before now share the same canvas, units, and time-step.

Prompt → simulation

AI Graph Synthesis

Describe a system in plain English and a model fine-tuned on arXiv and PubMed assembles validated nodes, variables, and formulas — never inventing physics, only assembling proven building blocks.

In the browser

Near-Native WebGPU

A WebGPU + WebAssembly engine renders high-fidelity 2D/3D output in real time, at desktop-class speeds, with zero installs and nothing to maintain.

Provably correct

Typed Node Contracts

Every port carries a type and a physical unit. A deterministic validator checks dimensions, cycles, and solver fit before a single step runs — so graphs are correct by construction.

Fork the world

Open Community Fabric

Publish, share, and fork complex node clusters. A grad student's quantum-superposition cluster becomes a building block for a pharma lab the same afternoon.

See everything

Live Data Inspector

Real-time graphs, heat maps, and raw matrices stream as the simulation runs — instant error-checking instead of post-hoc guesswork.

In Practice

What you'll be able to simulate

A taste of the node clusters that turn a sentence into a running model.

Double pendulum

prompt ▸ Model a double-pendulum under chaotic gravitational interference

\ddot{θ} = - \frac{g}{L} sin θ + ξ (t)

governing equation · Double pendulum

solver ▸ RK45 adaptive · rtol 1e-6 · symplectic option

Gravity FieldChaotic SourceDouble PendulumRunge–KuttaRender Viewport

Lipid nanoparticle

prompt ▸ Simulate lipid nanoparticle delivery through laminar blood flow

\frac{\partial c}{\partial t} = D \nabla^{2} c - u \cdot \nabla c

governing equation · Lipid nanoparticle

solver ▸ Implicit ODE (BDF) · Crank–Nicolson transport

Fluid DynamicsLipid NanoparticleDiffusion SolverMath SolverRender Viewport

Krebs cycle

prompt ▸ Build a kinetic model of the Krebs cycle with enzyme feedback

v = \frac{V _{m a x} [ S ]}{K _{m} + [ S ]}

governing equation · Krebs cycle

solver ▸ Stiff BDF (Gear) · adaptive order 1–5

Substrate PoolEnzyme KineticsKrebs CycleStiff SolverData Inspector

Navier–Stokes

prompt ▸ Visualize turbulent Navier-Stokes flow around an airfoil

ρ (\frac{\partial u}{\partial t} + u \cdot \nabla u) = - \nabla p + μ \nabla^{2} u

governing equation · Navier–Stokes

solver ▸ FEM · k–ε turbulence · SUPG stabilization

Velocity FieldAirfoil BoundaryNavier–StokesFEM SolverRender Viewport

Numerical Accuracy

Provable convergence, not vibes

Every integrator ships with a known order of accuracy. Switch methods below and watch the global error collapse as $O (h^{p})$ — measured live against an analytic solution.

convergence.lab — global error vs step size

measured order p ≈ 4.02

\overset{x}{˙} = - x, x (0) = 1 \Rightarrow x (t) = e^{- t}

test problem with known analytic solution

Global error scales as $ε \propto h^{p}$ for a method of order $p$ . Halving the step size should cut the error by $2^{p}$ .

error(h) — log scale

h=1/4

1.48e-5

h=1/8

8.31e-7

h=1/16

4.93e-8

h=1/32

3.00e-9

h=1/64

1.85e-10

h=1/128

1.15e-11

Integrator accuracy · ẋ = −x on [0,1]
Method	Order p	Err @ h=1/64	f-evals/step
Forward Euler	1	7.7e-3	1
Midpoint RK2	2	4.0e-5	2
Runge–Kutta RK4	4	9.1e-10	4
Dormand–Prince RK45	5	2.3e-12	6

Local vs cloud throughput · particle systems
Particles	Backend	Steps/s	Frame
1e4	WebGPU local	1,920	0.5 ms
1e6	WebGPU local	144	6.9 ms
1e8	Cloud A100×4	61	16 ms
5e9	Cloud A100×64	12	83 ms

* Figures from reference kernels on Apple M2 (local) and NVIDIA A100 80GB (cloud); indicative, hardware-dependent.

The Compute Fabric

Free on your hardware. Limitless in the cloud.

Standard runs render locally on your CPU/GPU through WebGPU — costing nothing. When a run outgrows the browser, Poly Sim OS escalates seamlessly to serverless GPU clusters, metered by Compute Tokens and never trusted to the client.

Local execution

WebGPU + Wasm · near-native speed

Cloud escalation

Serverless AWS / GCP clusters

Metered & secure

Server-side Compute Tokens

The Roadmap

Now

The Unified Canvas

Visual node graph, live render viewport, and the AI Co-Pilot vision — the foundation everything else snaps onto.

Live AI Synthesis

Wire the Co-Pilot to a model so prompts generate real, validated node graphs on the fly.

Then

Cloud Compute Fabric

Seamless escalation to serverless GPU clusters, metered by Compute Tokens, for billion-particle runs.

Horizon

Air-Gapped Enterprise

Dedicated bare-metal clusters and on-prem deployment for pharmaceutical and aerospace R&D.

The most ambitious simulation engine ever built for the browser

Explore the workspace today. The cloud, the live AI, and the enterprise fabric land as we grow.

Open the canvas See the plans