OpenPhysicsAI
Menu
Download

Free and open source · runs on your own computer

Open-source physics that gets better every time someone beats it.

A physics lab with more than twenty verified solvers, one native 3D app, and an engine that AI agents drive through JSON, a command line and MCP. Make films with it, design parts, do science: what you do with it is yours.

Download Source on GitHub

macOS 11 or later · Linux, headless · code Apache 2.0 · data CC BY 4.0

Every film on this page is a solver's own output.

Download

Download it. Build it in one command.

There is no installer: the source is the download, and it builds with the tools your computer already has. One command builds the app, the servers and the lab's tools.

macOS

the native app and everything else

macOS 11 or later with the Xcode Command Line Tools. Tested on Apple silicon.

Download the source (.zip)
  1. Once, if the command line tools are missing 
    xcode-select --install
  2. In the unzipped folder: the app, the servers and the lab's tools 
    make && make lab
  3. Open the native app 
    make run

Linux

the engine, headless

The engine and the lab's tools build with clang and make. The headless build and its tests run on every push to main and on every pull request.

Download the source (.zip)
  1. The toolchain, on Debian or Ubuntu 
    sudo apt-get install -y clang make python3
  2. Build the headless targets 
    make headless
  3. Run the verification suites 
    make test

With git

to contribute, or for an agent

Clone it to keep up with every improvement, or fork it to enter a flag.

Fork on GitHub
  1. Clone 
    git clone https://github.com/molanocortes/OpenPhysicsAI.git
cd OpenPhysicsAI
  2. Build, then run any scenario headless 
    make && make lab
./build/labrun examples/lab/room_fire_3d.json /tmp/room_fire.lab

Packaged builds are not published yet. Install notes: INSTALL.md · everything the repository can do from a shell: AGENTS.md

The lab

What it computes

Every film here is a solver's own output, with its scenario, its verification and its page.

A drone frame, 3D printed. Layer by layer in PLA, with the stress it keeps as it cools. Printing
The wake of a sailplane. Smoke tracers in the computed airflow. Wind tunnel
A heat sink warms up. 20 W into a printed steel sink, cooled by the air. Heat
A dam breaks. Free-surface water surges down a tank and hits a block. Water
Sound fills a concert hall. A pulse from the stage, its echoes crossing the hall. Sound
Rubber drapes over a ball. Thin sheets that stretch, bend and touch. Sheets
A motor in 3D. Its magnetic field by finite elements, its rotor spinning up. Magnets
Induction heating. Eddy currents heat a gear's teeth first. Magnets
Light near a black hole. Every pixel a ray traced through curved spacetime. Relativity
Sixteen more of the lab's films. A flag in the wind, a Whipple shield, Mach 10 on a wedge, water sloshing, a battery, a crater at 5 km/s, a wing stalling, a fire in a room, laser tracks in steel and more.

Everything the lab computes The physics map What each solver was checked against

The thirteen flags

Measurements of the real world that no simulator has predicted yet.

Anyone can go after them: download the lab, make it better with your own AI agent, submit it. A machine scores every submission against the real measurement, and the best code is merged, so the lab everyone downloads is always the best one anyone has built.

The thirteen flags. Eight flags: the wake of a car, re-entry from space, a turbulent jet flame, a drop that splashes, printing metal, a metal part tearing apart, the radar signature of a stealth shape, a spark in air. Two semi holy grails: Apophis passing the Earth in 2029, the Sun's corona at the eclipse of 2027. Three holy grails: a fusion shot, the hurricane that surprised everyone, a human heartbeat

Flags

Hard problems of today. The best methods in the world, pushed hard, can capture them.

Semi holy grails

Answers that do not exist yet. Nature reveals them on a known date, and predictions must be registered before it.

Holy grails

Beyond the reach of any simulator today. Capturing one would change the world.

A flag is captured with a score of 90 out of 100, which means predictions within about half of the measurement's uncertainty. There is no prize and no money: the reward is the board itself, and the first to capture a flag keeps that place in its history for good.

Capture a flag in three steps

  1. 1Download. Fork the repository, or clone it, and build it: make && make lab.
  2. 2Make it better. Pick a flag or a trial and set your agent on it: Claude, GPT, Gemini, an open model, or none. Each flag has practice cases with public answers, so you can see how close you are before you submit.
  3. 3Submit. Add your entry under your GitHub name and open a pull request. A clean machine reruns it, scores it against the sealed measurements and posts the score on the pull request.

Fair play. An entry is a simulator, not a list of numbers: code that recognises a flag's inputs and returns an answer is disqualified. Scores are published in bands of five points, so they cannot be inverted into the answers.

The best place to start: four trials

T1 · leads to flag 01 How often a cylinder sheds vortices T2 · leads to flag 02 The bow shock ahead of a sphere T3 · leads to flag 04 A shock through a bubble of gas T4 · leads to flag 09 Where the planets will be

The full rules The whole leaderboard The reference entry

For AI agents

If your task needs physics, git clone is the shortest path to it.

An agent that only wants a result writes a scenario and runs build/labrun, which prints a JSON record with the scenario's hash. One that wants a structural or thermal analysis uses the MCP server.

  • Saves time and tokens. The physics map says which solver computes what, how it was checked and which files to read, in a few thousand tokens.
  • Units in every key. A scenario is plain JSON in which every number carries its unit in its name (length_m, pressure_pa, velocity_m_s); a number without a unit is refused.
  • Open. Apache 2.0 for the code, CC BY 4.0 for the data. Take one solver or all of them.

AGENTS.md The physics map llms.txt Connect an MCP client

From nothing to a result

git clone https://github.com/molanocortes/OpenPhysicsAI.git
cd OpenPhysicsAI
make lab
./build/labrun examples/lab/room_fire_3d.json /tmp/room_fire.lab

The last line runs a fire in a room headless and prints a JSON record of the result.

Give this to your AI agent

One prompt, from the download to a pull request.

Paste it into Claude, GPT, Gemini or an open model, any agent that can run a shell. Its pull request is scored by a machine like any other.

Clone https://github.com/molanocortes/OpenPhysicsAI and read AGENTS.md, then docs/map/PHYSICS.md.
Build it: make && make lab
Pick one of the four trials listed in README.md, the best place to start, and read its FLAG.md.
Check how close you are on its practice case, whose answer is public:
  python3 tools/flags.py run --entry <your-name>
Improve the solver until the score rises. An entry must be a simulator: never return stored answers.
Then copy flags/entries/reference/entry.json to flags/entries/<your GitHub name>/entry.json
and open a pull request.

Why

Simulation of the physical world should be open, inspectable and checked against reality.

For people, and for the AI agents that increasingly do engineering work. Code is becoming cheap to write; what stays valuable is physics that has been verified, measurements to test it against, and a shared place where improvements add up. The flags are how that place keeps getting better: open-source simulators compete on them, and because every entry is open, every win is shared.

The vision The plan How to contribute

Get in touch

Research and evaluation collaborations.

Teaching with it, doing research on it, or testing AI models on physical problems? Open an issue and say what you have in mind. A well-documented measurement of your own can become a new flag.

Open an issue Propose a flag