You can't scale a learned physics simulator out of blowing up
The bet behind world models is that a network fed enough data will absorb the rules of physics. We tested that bet on the smallest honest version of it: a model trained to simulate water, sand, and goop. It works beautifully for about 80 frames, then reality falls apart. So we tried the obvious fixes: 3x the data (no change), a bigger model (made it worse), hard-coded physics laws (much worse). The only thing that helped was letting the model watch its own mistakes during training, and even that just stopped it from getting worse. The 80-frame wall didn't move.
Why you'd care
A lot of ambition right now rests on world models: systems that learn to predict how a scene evolves, and are expected to pick up the rules of physics along the way, purely from watching enough of it happen. Video generators that keep objects solid, agents that plan by imagining consequences, robots that rehearse a motion before making it. The premise underneath all of them is that physical law is learnable from data, and that the path to learning it is more data and more parameters.
That premise is hard to test on a video model, because you cannot cleanly separate "it learned physics" from "it learned what physics videos look like." So we tested it somewhere the question has a crisp answer. A learned particle simulator predicts how water, sand, and goop actually move, and we can check its predictions against a real solver, step by step, and say exactly when it stops being physics. It is a small, well-lit corner of the same bet.
It is also useful in its own right. A physics simulator that runs on a neural network can be much faster than a traditional solver, which matters for anything that runs a lot of simulations: engineering, graphics, robotics, weather. The promise is speed. The problem is that a fast simulator is useless if it stops behaving like physics before the thing you care about happens.
These models predict one time step and then roll forward by feeding each prediction back in as the next input. Small errors at each step compound. After a few dozen steps the scene looks wrong, and after a few dozen more it falls apart. If you want to trust a learned simulator, you need it to stay physically coherent for a long rollout, not just a short one. So the real question is what actually buys you that stability.
The failure mode here is the one world models have to survive. Predicting a plausible next frame is not the same as maintaining a coherent world across many frames, and the gap between the two is where the drift lives.
Learned simulators are fast, and they blow up
The standard model here is a graph-network simulator (GNS): it treats each particle as a node connected to its neighbors, and a neural network predicts how each particle moves next based on what is around it. Run it one step at a time, feed the output back in, and you get a rollout, a full predicted trajectory.
We measure stability with the divergence horizon: how many steps the rollout survives before its error crosses a blow-up threshold. Each step advances the simulation a small slice of time, so about 80 steps is a short clip of motion, not a long one. Our baseline GNS, trained the usual way (predict the next step from ground-truth inputs), reaches a divergence horizon of about 78 steps on held-out scenes of water, sand, and goop (a thick, gluey material). Past that, it explodes. We set out to push that horizon up by an order of magnitude.
You can't scale your way out
The first thing anyone tries is scale. If the model blows up, train it longer, give it more data, make it bigger. We tried all three, and the diagram shows what each one bought.
First-divergence horizon (steps before blow-up) after long training. More data leaves the horizon unchanged; a bigger model lowers it (it overfits rather than generalizing to longer rollouts). No scale lever beats the pushforward curriculum (80), and the one-step baseline sits well below it. The best horizon any configuration reached, about 85, came from a well-tuned baseline at short training, so scale did not push past it either.
Nothing raised the ceiling. Tripling the training data left the divergence horizon unchanged (79 versus 80 steps). Making the model bigger (wider and deeper, with more rounds of information passed between neighboring particles) made it worse, dropping the horizon to 63, because the larger model overfits the training data rather than generalizing to longer rollouts. And longer training was actively harmful to the naive model: trained for a long time, the one-step baseline's rollout stability collapsed, from a horizon around 78 down to 56, with its error more than doubling. No configuration we tried stayed stable past about 85 steps, and the extra data and capacity we tested (up to three times the data) did not move that number. The plateau looks set by the architecture and the amount of data, not by model size.
Each of those three levers is a version of the world-model bet, and in this setting each one came back flat or negative. That is worth sitting with, but it is not a refutation of scaling: our data budget is small, and 3x is a short lever to pull. What the result does show is that scale is not automatic here. Within this regime, more data bought nothing and more capacity cost us, and the thing that mattered was not how much the model saw but what it was asked to predict.
Training the model on its own rollouts
The fix is a different training signal, called a pushforward rollout curriculum. It is a heavier version of a standard stability trick, which adds a little random noise to the model's inputs during training. Instead of just adding noise, you let the model predict a few steps on its own, then train it to correct the state it actually produced. It practices on its own mistakes. It learns to correct a drifting rollout instead of amplifying the drift.
This advantage only appears with long training. At short training, the pushforward model and the one-step baseline are about tied, both near 80 steps, and the plain-noise trick actually did best of all (about 87 steps). The gap that matters opens only once you train for a long time.
6,000 steps (short training). Bars show the divergence horizon (higher is more stable).
At short training the two are about tied. After long training the one-step baseline collapses (horizon 56, error 0.070) while the pushforward model holds (horizon 80, error 0.023). Pushforward's advantage grows the longer you train. The short and long runs also use different amounts of data, so read this as the combined effect of longer training on more data, not training length alone.
Train both models for a long time and they separate. The one-step baseline collapses to a 56-step horizon at a rollout error of 0.070. The pushforward model holds, staying near 80 steps at an error of 0.023, the best accuracy and stability of anything we ran under long training. Pushforward does not overfit the one-step task, because it trains on the distribution of states it actually visits during a rollout. Its advantage grows the longer you train.
What this does not claim
Two things this work does not claim, because the numbers do not support them.
- We did not beat a well-tuned baseline on raw stability. The pushforward model's ~80-step horizon roughly matches the best one-step baseline we could tune (~85 at short training). The win is that pushforward keeps that stability and accuracy under extended training, where the baseline loses it. It is not a higher absolute ceiling.
- We did not move the ceiling at all. Every method we tried plateaus around 85 steps or below, nowhere near the order-of-magnitude improvement we were after. That ceiling looks bound by the architecture and the amount of data: our training used far less data than the large-scale runs in the literature, and the one-step model's overfitting is a symptom of that. Raising the ceiling likely needs much more data than the three-fold increase we could test, not a cleverer loss.
Reporting what did not work is part of the result. A conservation-projection layer, which forces the predicted motion to conserve momentum, consistently hurt, cutting the horizon to about 40 and making the error six times worse, likely because a global correction smears out the sharp local impulses that particle physics depends on. A Sobolev loss, which penalizes errors in how fast the motion changes from point to point, was roughly neutral. Plain input noise, the lighter sibling of pushforward, actually gave the best short-training result of all, but we did not re-run it under long training, so it is an untested competitor to pushforward at convergence, not a failed one. Of the methods we did compare under long training, only the pushforward curriculum held up.
A few limits on how far to read these numbers:
- One benchmark, and it is 2D. Everything here is on a single self-generated 2D benchmark of water, sand, and goop. We have not tested 3D, a second dataset, or generalization to much larger particle counts or unseen obstacle geometry, which is the obvious next step.
- This is not a verdict on world models. We tested one graph-network simulator, on one benchmark, at a data scale far below a frontier video model. A large model trained on internet-scale video is a different animal, and nothing here says it cannot learn physics. What we can say is that in the one setting where we could check the physics exactly, the scaling levers did not deliver stability on their own, and the training objective did more than the data did. Read that as a caution about assuming, not as evidence of a ceiling out there.
- The fine numbers are single runs. Our short-training baseline spans 72 to 86 steps across three seeds, and the long-training numbers are single runs. Treat gaps smaller than that spread (like 79 versus 80) as noise. The baseline's collapse to 56 is below the seed floor and reproduces on longer rollouts, so that one is robust.
Takeaways
- Measure rollout stability under extended training, not just at a checkpoint. The naive model looks fine early and collapses late. The failure only shows up once the model is trained to convergence, so a short training run hides it.
- For this failure, the training curriculum beats scale. Training the model on its own rollouts keeps it stable and accurate where more data, a bigger model, and longer training do not.
- Some physics-inspired fixes backfire. Forcing global momentum conservation hurt stability here, because it flattens the local impulses the simulation relies on. Test a mechanism, do not assume it helps.
- Report the ceiling. Nothing we tried stayed stable past about 85 steps, and the horizon looks bounded by the architecture and the amount of data, not by model size. That negative result marks where this approach currently stands.
- "Enough data and it learns physics" is a hypothesis, not a mechanism. It may well be right at scales we cannot reach. But in the one place we could check physics exactly rather than by eye, the model did not get there on data alone, and what it was trained to predict mattered more than how much it saw. If you are betting on a world model, that is worth measuring rather than assuming.