Neural Networks and Physics Simulation: How AI Is Rewriting the Rules of Game Engines

Physics simulation is one of the oldest unsolved problems in real-time computing. The real world obeys differential equations that describe how fluids flow, how cloth folds, how rigid bodies collide, and how soft tissue deforms — equations that, solved with full accuracy, require supercomputer-scale computation. Game engines have always lived with approximations: simplified collision geometries, pre-baked animations for destruction, cloth that clips through geometry, water that looks like animated texture rather than actual liquid. For nearly 40 years, the answer to "why doesn't this look real?" was almost always "because real is too expensive to compute at 60 frames per second." Neural networks are providing a new answer. By learning to approximate physical systems from data rather than solving equations from scratch, machine-learning-powered physics is reaching levels of simulation fidelity that traditional methods could not reach in real time, and it is beginning to ship in production research pipelines at NVIDIA, DeepMind, and major engine studios.

Key takeaways

• Neural networks learn to approximate physics from simulation data, trading exact equation-solving for real-time performance.
• Rigid-body dynamics is the branch of physics that governs how solid, non-deformable objects move and collide, and it remains the backbone of most game physics engines even as neural layers are added around it.
• DeepMind's Graph Network Simulators, published at ICML 2020, showed that a single learned model can generalize across fluids, rigid solids, and deformable materials by representing physical state as a graph of particles.
• Position Based Dynamics, the technique underlying most real-time cloth and soft-body simulation in games today, was developed by Matthias Müller and collaborators starting in 2007 and remains the substrate that neural cloth research builds on top of.
• Ubisoft La Forge's "Learned Motion Matching," presented at SIGGRAPH 2020, replaced a memory-hungry animation database with a compact neural network, cutting the runtime memory footprint dramatically while preserving motion quality.
• Full neural fluid and destruction simulation at game frame rates is still mostly a research result rather than a shipped feature; neural motion synthesis and upscaling are the parts of this stack already running in commercial titles.

The Approximation Problem: Why Game Physics Has Always Been Fake

When you see water in a video game, you are usually not seeing fluid dynamics simulation. You are seeing a carefully designed visual effect: animated vertex displacement on a flat mesh, shader tricks that fake refraction and surface tension, and particle systems for splashes. It looks like water because artists are skilled at mimicking water's appearance. It is not water in any physically meaningful sense, and you can usually tell the moment you try to interact with it in an unscripted way.

Real fluid simulation means solving the Navier-Stokes equations, the set of partial differential equations that describe how a fluid's velocity and pressure change over time and space. These equations have no general closed-form solution; every practical simulation approximates them numerically, and higher accuracy costs more computation. Fluid simulations for visual effects in film can take hours per frame on rendering clusters. Running an equivalent simulation at 60 frames per second for an interactive game, where the player can poke the water from any angle at any moment, is not feasible with direct equation-solving on consumer hardware.

The traditional solution has been game-specific approximation: simplified physics models, tuned by hand, that are cheap to compute and look plausible from the angles players are likely to see. This works well enough that most players never question the physics of game water. It fails the moment someone tries to fill a bucket and the water just plays a splash sound instead of actually rising.

Neural networks offer a genuinely different approach to the same problem. Train a model on a large dataset of accurate physics simulations, and the model learns to predict how a physical system evolves from one time step to the next without solving the underlying equations at inference time. The prediction is not exact, but it can be close enough for visual purposes, and it runs at a small fraction of the computational cost of full simulation. This is the same trade that makes weather forecasting neural networks like GraphCast useful: you give up exactness for speed, and for many practical purposes speed wins.

DeepMind's Graph Network Simulators, published at ICML 2020, trained on particle-based physics data and demonstrated that a single learned model could generalize from thousands of training particles to at least ten times as many particles at test time, across fluids, rigid solids, and deformable materials, without being told which category of material it was simulating. ([DeepMind, 2020](https://deepmind.com/research/publications/2020/Learning-to-Simulate-Complex-Physics-with-Graph-Networks))

Rigid Body Dynamics: The Foundation Neural Physics Builds On

Before neural networks entered the picture, game physics already had a well-established mathematical foundation, and understanding it is necessary to see where machine learning actually adds value. Rigid body dynamics is the branch of classical mechanics that treats objects as perfectly solid shapes that do not deform, tracking their position, orientation, linear velocity, and angular velocity over time as forces and collisions act on them. A crate sliding down a ramp, a car body responding to a collision, a ragdoll tumbling down stairs — all of these are rigid body problems.

Engines like PhysX, Havok, and Bullet solve rigid body dynamics with well-understood numerical integration methods: they detect when two shapes overlap, compute a contact response that pushes them apart, and integrate forces (gravity, friction, applied impulses) forward in small time steps. This is deterministic, debuggable, and fast enough to run thousands of objects per frame on a modern CPU or GPU. It is also the reason competitive games with physics-based mechanics, like pool or golf titles, can rely on precise and repeatable outcomes. Nobody wants a neural approximation deciding whether a shot went in.

Where rigid body dynamics struggles is at the edges: objects with complex, non-rigid contact behavior, large numbers of simultaneously colliding fragments after destruction, and any scenario where the "rigid" assumption breaks down, such as a car crumpling. Traditional engines paper over these gaps with pre-authored destruction states and artist-tuned deformation shaders rather than actually simulating the material response. This is precisely the gap that learned simulators are aimed at closing, not by replacing rigid body solvers but by handling the parts those solvers were never designed for.

What is rigid body dynamics in game physics?

Rigid body dynamics is the simulation of solid objects that do not bend or stretch, tracking how forces, collisions, and gravity change their position and rotation over time. It is the mathematical backbone of nearly every physics engine, from PhysX to Havok to the open-source Bullet and MuJoCo libraries, and it remains largely untouched by neural networks because it is already fast, accurate, and predictable for the cases it was designed to handle.

Learned Physics Simulators: Predicting the Next State Instead of Solving for It

The research area most directly relevant to "neural physics" is what academics call learned or neural simulators. Instead of hand-coding the equations that govern a system, researchers represent the physical state (positions, velocities, material properties of particles or mesh vertices) and train a neural network to predict the next state given the current one, using large datasets generated by expensive, accurate offline simulations.

DeepMind's 2020 Graph Network Simulators (GNS) work, led by Alvaro Sanchez-Gonzalez and Peter Battaglia's team, is the paper most cited in this space. GNS represents a physical scene as a graph: particles are nodes, and interactions between nearby particles are edges. A neural network processes this graph through an "encode, process, decode" architecture, repeatedly passing messages between neighboring particles to predict how the whole system moves forward by one time step. The same trained model reproduced fluid splashing, rigid object stacking, and deformable material behavior in a single framework, and it generalized to particle counts and time horizons far beyond what it saw during training (DeepMind, ICML 2020).

That generalization result is the reason this line of research matters for games specifically. A traditional physics engine needs a different code path, tuned by hand, for cloth, water, and rigid debris. A learned simulator trained broadly enough can, in principle, treat all of them as instances of the same underlying particle-interaction problem, which is a much better fit for how game engines want to scale content without scaling engineering headcount.

The catch, and it is a real one, is that these models are computationally heavy at training time, require enormous amounts of ground-truth simulation data to learn from, and their accuracy degrades on scenarios that fall outside what they were trained on. A model trained on falling sand may not handle a scenario with thick, sticky mud unless mud-like material was represented in training. Robotics and engineering applications of learned simulators, including work adjacent to NVIDIA's Isaac Lab and the newly open-sourced Newton physics engine for robotics simulation, are pushing on exactly this generalization problem, and the results are gradually filtering toward graphics and games use cases (NVIDIA Technical Blog, 2025).

Cloth and Soft Body: Position Based Dynamics Meets Neural Networks

Cloth simulation is one of the clearest examples of how a decades-old numerical method and a much newer neural one are now being combined rather than one simply replacing the other. The dominant real-time technique for cloth, hair, and soft-body deformation in games today is Position Based Dynamics (PBD), introduced by Matthias Müller, Bruno Heidelberger, Marcus Hennix, and John Ratcliff in a 2007 paper and extended in later work on hierarchical and extended PBD (Müller et al., Journal of Visual Communication and Image Representation, 2007).

PBD works by skipping the force-and-velocity layer that traditional physics uses and instead directly adjusting the positions of a mesh's vertices to satisfy constraints, such as "these two points should stay roughly one centimeter apart" or "this point should not pass through that collision surface." Because it works on positions rather than integrating forces, PBD is unconditionally stable even with large time steps, which is exactly the property a real-time game engine needs: better a slightly-wrong-looking piece of cloth than a physics explosion that sends a cape spinning off the map at infinite velocity.

Neural networks are now being layered on top of PBD rather than discarding it. Recent research on hybrid neural network and physics engine approaches for real-time 3D cloth simulation trains a network to predict the high-frequency wrinkling and folding detail that a coarse, cheap PBD solve misses, letting the traditional solver handle overall stability and collision response while the network fills in visual detail that would otherwise require a much finer, more expensive simulation mesh (ResearchGate, 2024). This hybrid pattern, cheap traditional solver plus a neural detail layer, is a template that shows up repeatedly across the neural physics research space, and it is a more honest description of where the field actually is than "neural networks are replacing physics engines."

Character Motion: From Motion Matching to Learned Motion Matching

The most visible application of neural networks to game physics-adjacent systems is character animation, and it has already shipped. Traditional character animation blends between hundreds of hand-authored clips — idle, walk, run, jump, crouch, strafe — based on player input. A technique called motion matching, popularized in games like For Honor and The Last of Us Part II, improved on clip blending by searching a large database of motion-capture clips at runtime for the pose that best matches the character's current state and desired trajectory, then playing that clip forward.

Motion matching looks great, but its memory cost scales with how much motion-capture data you store; more variety and quality means a bigger database that has to live in memory. Ubisoft La Forge's "Learned Motion Matching," authored by Daniel Holden, Oussama Kanoun, Maksym Perepichka, and Tiberiu Popa and presented at SIGGRAPH 2020, addressed this directly by replacing each step of the motion matching algorithm (the database search, the pose lookup, the trajectory prediction) with a small trained neural network, producing a system that needs no animation database in memory at runtime while preserving the responsiveness and quality that made motion matching popular (Ubisoft La Forge, 2020). This is a genuine production win: smaller memory footprint, comparable visual quality, and no loss of the designer control that motion matching gave animators over how characters respond to player input.

A related line of Ubisoft La Forge research, DReCon (Data-Driven Responsive Control of Physics-Based Characters), combines motion-capture-trained neural controllers with actual rigid body physics simulation for the character's skeleton, so that a character reacting to an unexpected push is genuinely being simulated by physics constrained toward learned, human-like motion, rather than just playing back a canned ragdoll response.

Do games currently ship with neural network physics?

Yes, in narrowly scoped but real applications. Learned motion matching and related neural animation systems are in shipped Ubisoft titles. Neural upscaling technologies like DLSS use trained models to reconstruct frames rather than physics per se, but run on the same GPU tensor cores increasingly used for physics research. Full neural fluid simulation, neural destruction, and general-purpose learned simulators remain primarily research results (DeepMind, NVIDIA, and academic labs) rather than shipped game features, though the gap between research and engine tooling has been closing steadily since 2020.

Destruction and Fracture: Why This Remains the Hardest Case

Destruction simulation in games has historically relied on one of two approaches: pre-authored destruction sequences that play the same way every time (a wall always collapses along the same pre-modeled fracture lines), or analytical geometric fracture methods, popularized by Red Faction: Guerrilla, that compute fracture patterns from a Voronoi decomposition of the object at the moment of impact rather than an artist-drawn crack pattern.

Neither approach captures the actual material physics of fracture: how the specific angle, velocity, and force of an impact interacts with a material's internal stress to determine where it breaks. Full physically accurate fracture simulation, the kind used in engineering analysis and some film visual effects, solves for stress propagation through a deformable solid and is far too slow for real-time use.

This is the frontier where learned simulators like GNS are most directly relevant but least deployed in games so far. A model trained on offline fracture simulations could, in theory, predict plausible break patterns conditioned on impact parameters at a fraction of the cost, but destruction is also one of the domains where "plausible but wrong" is most visually obvious to players, because a wall breaking in a physically nonsensical way is immediately noticeable in a way that a slightly-off cloth wrinkle is not. That asymmetry, some errors are invisible and some are glaring, is a big part of why cloth and motion have shipped in commercial games while destruction and fluid have not.

Fluid Simulation: The Frontier That Has Not Shipped Yet

Fluid simulation in real-time games remains the least solved of these problems, for the reasons described earlier: Navier-Stokes solving is expensive, and games need results at a fixed frame budget regardless of scene complexity. Research groups, including the same lineage of work that produced GNS, have demonstrated learned fluid models that run at interactive rates with visual quality that approaches, though does not match, offline reference renders.

Game deployment of full neural fluid simulation is still limited to research demos and technical showcases rather than shipped titles. NVIDIA's ongoing work on GPU-accelerated physics for its Omniverse and robotics simulation platforms (including the Newton engine built with Google DeepMind and Disney Research as collaborators) is the most likely near-term path for these techniques to reach game engines, since the same GPU compute and simulation infrastructure serves both robotics training and game graphics use cases (NVIDIA Technical Blog, 2025).

Reinforcement Learning and Physics: A Different but Related Thread

A separate but related use of machine learning in physics simulation comes from reinforcement learning research, where physics engines are used not to render a game but to train an agent. MuJoCo (Multi-Joint dynamics with Contact), originally a commercial physics engine, became the standard simulation environment for robotics and locomotion reinforcement learning research; Google DeepMind acquired it in October 2021 and open-sourced it in 2022, and it remains a benchmark environment cited across reinforcement learning literature for tasks involving contact-rich physical interaction (arXiv review of physics engines for RL, 2024).

This matters for game physics indirectly: the same GPU-parallelized physics simulation techniques that let researchers train thousands of reinforcement learning agents simultaneously in simulated environments are architecturally similar to what a game engine needs to simulate thousands of destructible objects or cloth-covered characters at once. Readers curious about how reinforcement learning itself works, including the training loop that turns simulated trial-and-error into a trained policy, can find a fuller treatment in our explainer on how reinforcement learning trains AI systems.

What This Means for Players and Developers

For players, the practical effect of this research so far is subtle rather than dramatic: characters that fall and stumble with more apparent weight, cloth that folds with fewer visible artifacts, and, in a few showcase titles, destruction that varies more convincingly from one playthrough to the next. None of this is being marketed loudly as "AI physics" the way DLSS was marketed as "AI upscaling," partly because the improvements are incremental refinements to existing rigid body and Position Based Dynamics pipelines rather than wholesale replacements of them.

For developers, the more significant shift is in tooling and cost. Learned motion matching's memory savings are a concrete production benefit independent of visual quality. Hybrid cloth systems that use a neural detail layer on top of a cheap PBD solve let smaller studios approximate results that used to require much finer simulation meshes and more engineering time. The pattern across nearly every example in this article is the same: neural networks are not replacing the rigid body solvers, PBD constraint solvers, or motion-capture pipelines that games already rely on. They are being trained to fill in the parts of those pipelines that were always the most expensive to author by hand or the most expensive to compute exactly, and they are, so far, being deployed as targeted layers within traditional engines rather than as wholesale replacements for them.

Common Misconceptions About Neural Physics in Games

A recurring misunderstanding is that "neural physics" means a game engine has replaced its physics engine with a neural network end to end. In every shipped example described in this article, that is not what happened. Learned Motion Matching still relies on the character's underlying skeletal rig and, in systems like DReCon, an actual rigid body simulation constrains the output. Hybrid cloth research still runs Position Based Dynamics for the base solve and uses a network only for surface detail. The rigid body solver handling collision and gravity in nearly every AAA game today is the same class of deterministic, hand-coded system that has been standard since the 2000s.

A second misconception is that learned simulators like DeepMind's GNS are already running inside game engines. They are not, as of this writing; they are research results that demonstrate feasibility and inform the direction that engine vendors like NVIDIA, Epic, and Unity are moving toward, particularly as GPU compute earmarked for AI inference (tensor cores originally built for upscaling and ray tracing denoising) becomes available for other real-time neural workloads during a frame budget.

A third misconception worth correcting is that neural approximation is inherently less accurate or more "fake" than traditional game physics. Traditional real-time physics is already an approximation, tuned by hand for speed rather than correctness; a PBD cloth solver does not conserve energy exactly, and rigid body engines routinely resolve overlapping collisions with artificial correction impulses rather than physically exact contact resolution. The relevant question is not whether an approximation exists, since one always has, but whether the specific approximation a neural network learns produces fewer visible artifacts than the specific approximation a hand-tuned traditional method produces, at comparable computational cost.

FAQ

How accurate are neural network physics approximations compared to real physics? Accuracy depends heavily on how close the scenario is to the network's training distribution. DeepMind's Graph Network Simulators generalized well to particle counts and time horizons beyond training data within the material types they were trained on, but learned simulators broadly can fail unpredictably on scenarios that differ meaningfully from what they saw during training, which is a real limitation for physics-critical gameplay (DeepMind, 2020).

Do games currently ship with neural network physics? Yes, in specific, narrow applications. Ubisoft's Learned Motion Matching and related neural animation research are deployed in shipped titles. Full neural fluid simulation, generalized learned physics simulators, and neural destruction remain primarily research work from labs like DeepMind and NVIDIA rather than shipped, general-purpose engine features.

What is the difference between rigid body dynamics and neural physics simulation? Rigid body dynamics is a set of well-defined mathematical methods, dating back decades, for simulating solid, non-deforming objects using forces, collisions, and numerical integration. Neural physics simulation instead trains a model on data from accurate simulations to predict how a system evolves, without explicitly solving those equations at run time. Most current game engines still use rigid body dynamics for core object physics and reserve neural methods for cloth detail, motion synthesis, or research destruction and fluid systems.

What is Position Based Dynamics and why does it matter for cloth simulation? Position Based Dynamics, introduced by Matthias Müller and collaborators in 2007, is a technique that directly adjusts a mesh's vertex positions to satisfy physical constraints instead of integrating forces and velocities. It is unconditionally stable at real-time frame rates, which is why it became the standard method for cloth, hair, and soft-body simulation in games, and it is the base layer that current neural cloth research builds on top of rather than replaces.

Can players tell the difference between neural physics and traditional physics? In shipped examples like Learned Motion Matching, players generally cannot articulate a technical reason for improved character movement, they simply describe it as looking like it "has weight" or feels less robotic. The improvement is measured in reduced visible artifacts, like awkward transitions between animation clips, rather than in players consciously identifying a neural network at work.

What are the limitations of neural physics systems? Learned simulators require large amounts of accurate training data generated by expensive offline simulation, can behave unpredictably on scenarios outside their training distribution, and their internal reasoning is harder to debug than an explicit equation. For gameplay-critical interactions, like a competitive pool shot or a platforming jump, this unpredictability is a real drawback compared to deterministic traditional physics.

Is MuJoCo used in games or only in research? MuJoCo (Multi-Joint dynamics with Contact) was built for robotics and reinforcement learning research, not for shipping consumer games, and Google DeepMind open-sourced it in 2022 after acquiring it in 2021. It is relevant to this topic because it represents the same lineage of GPU-parallel, contact-rich physics simulation research that is informing next-generation game engine physics work at companies like NVIDIA.

Will neural physics eventually replace traditional physics engines entirely? Full replacement is unlikely in the near term. Traditional rigid body and Position Based Dynamics solvers are predictable, debuggable, and exact in ways that game design sometimes requires, particularly for competitive or puzzle mechanics where deterministic outcomes matter. The pattern across every shipped example in this article is hybrid: traditional solvers handle the gameplay-critical layer, and neural networks fill in visual detail, like cloth wrinkling or motion transitions, where approximation is acceptable and the cost savings are largest.

How is DeepMind's Graph Network Simulator different from a typical game physics engine? A typical game physics engine runs different, hand-coded solvers for rigid bodies, cloth, and fluids. DeepMind's Graph Network Simulator represents all of these as particles connected in a graph and uses a single trained neural network to predict how the whole system evolves, without being told in advance which material type it is handling, which is why the research result matters even though it has not yet shipped inside a commercial game engine.

Why hasn't neural fluid simulation shipped in games yet? Fluid behavior is highly sensitive to small errors compounding over many simulated frames, and a visually wrong splash or flow pattern is immediately obvious to players in a way that subtler artifacts, such as a slightly imperfect cloth wrinkle, are not. Research demonstrations have shown interactive-rate neural fluid simulation with quality approaching offline renders, but the reliability bar for a shipped game feature is higher than for a research showcase, which is the main reason deployment has lagged behind cloth and motion synthesis.

The takeaway

Neural networks are not tearing out game engines' physics code and starting over. They are being trained to handle the specific parts of physics simulation that traditional, hand-coded methods have always struggled with: the fine wrinkling detail in cloth, the memory cost of storing motion-capture libraries, and, in research settings that have not yet shipped, the expensive equation-solving behind fluids and fracture. The rigid body solvers and Position Based Dynamics methods that have powered games for two decades are still doing the load-bearing work; neural layers are being added on top where an approximation is cheap, useful, and forgivable if imperfect. The next few years will likely see that boundary move, as GPU compute built for AI inference becomes available for more of a game's frame budget, but the underlying design principle, use exact methods where correctness matters and learned approximation where it does not, is likely to outlast any specific neural technique.

---

Read next:

• How Neural Networks Are Making NPCs Smarter Than Ever
• Reinforcement Learning Explained: How AI Learns
• Latest Gaming News & Updates