Robot Wiki

World Models vs Physics Simulators

Learned dynamics, explicit physics and hybrid simulation compared by controllability, coverage, speed, debugging and downstream policy value.

Last reviewed
Reading time
11 min
Citations
16

A physics simulator predicts the next state from explicit geometry, dynamics and contact rules. A learned world model predicts from data. Both are models of what happens under an action; neither is automatically faithful to the real robot. The practical choice is which errors are measurable, which counterfactuals must be queried, and how far beyond the training distribution the system will operate.

The most productive systems increasingly combine them. Physics supplies structure and broad counterfactual coverage. Learning supplies appearance, actuator residuals, contacts or task distributions that are expensive to specify.

Try the check below and choose the actuator-residual option that preserves the strongest known structure for a contact-rich training task.

Self-check

You have accurate arm geometry and rough rigid-body physics, but the simulated actuator response differs systematically from hardware. What is the most data-efficient first correction?
Read the reasoning
  • Replace the entire simulator with an unconstrained video world modelThis discards useful geometry and asks limited robot data to relearn every transition. It also makes forces and constraints harder to inspect.
  • Learn an actuator residual while retaining explicit geometry and physicsThis targets the measured mismatch and keeps known structure intact. The residual can be validated directly against held-out hardware trajectories.
  • Randomize only the rendered texturesTexture randomization can improve visual transfer, but it does not correct a systematic actuator-dynamics error.

Keep trustworthy structure explicit and spend learned capacity on the residual you can measure.

They solve different specification problems

MuJoCo models articulated bodies, constraints and contact with explicit equations and parameters Todorov 2012. Isaac Lab builds a robot-learning workflow around GPU-accelerated simulation, sensors, task definitions and large batches of environments NVIDIA 2025. These systems are strongest when the relevant objects and rules can be represented and their parameters can be estimated.

A learned world model avoids writing every rule. It estimates transitions from observations and actions, often in a latent or video space. This is attractive for complex appearance, deformable interaction and real environments whose full state is unavailable. It also replaces parameter error with dataset and generalization error.

The current survey of world models for robot learning treats learned simulators as one role among planning, policy learning, evaluation and data generation Hou 2026. That role should not erase the distinction between a simulator whose state variables are explicit and a generator whose internal state must be inferred through outputs.

Comparison by engineering property

PropertyPhysics simulatorLearned world model
Dynamics sourceequations and parametersobserved transitions
Counterfactual coveragebroad within modeled mechanicsstrongest near training support
State accessexplicit positions, forces and contactslatent or generated observations
Debugginginspect parameters and constraintsinspect errors and sensitivity indirectly
Appearanceauthored assets and rendererslearned from image or video data
Adaptationidentify parameters or modify modelsfine-tune on new trajectories
Failure modewrong assumptions or parametersaction collapse, drift, hallucination
Compute patternmany small integration stepslarge neural inference calls

The table is not a winner. It identifies where each system makes uncertainty visible.

What each representation costs to run

A world model's usefulness is bounded by what it costs to query. The table below compares four deployed forms of world knowledge on a single machine: a text LLM as a familiar decode reference, an action-conditioned latent world model, an autoregressive or diffusion video world model, and an explicit 3D scene. The figures come from the cited papers and vendor documentation; the FLOP row is a derived order-of-magnitude estimate, not a measurement.

Quantity8B text LLM (decode)Latent WM (V-JEPA 2-AC)AR / diffusion WM (Cosmos Predict)Explicit 3D world (3DGS)
Model memory16 GB fp16, ~5 GB Q4~2.6 GB fp16 (1B encoder + 0.3B predictor)32.5 to 56.4 GB required VRAM (Predict2 Video2World, 2B to 14B); Predict1 14B tops 80 GB without offloading0; the scene is an asset, not weights
Runtime state per stepKV cache, ~128 KB per tokenblock-causal context: patch features, actions and poses of the current and earlier stepslatents plus KV, grows with clip lengthsplat set, 0.1 to 2.5 GB typical scene plus LoD pool
Single-GPU fit24 GB class, easy24 GB class, easyH100 80 GB for 14B with offloading; 2B fits far smaller cardsany rasterizer GPU; very large scenes need LoD or offload
Unit of work1 token1 latent step1 clip x N denoise steps1 camera view
Sequence tokens in that unit1256 patch tokens per frame (16 x 16 map) plus action and pose tokenstens of thousands of latent tokens per clip0 transformer tokens
Parallel multiplierbatching shares weightsCEM samples, 10^2 to 10^3 (the paper uses 800)4 to 50 denoise steps1 raster pass
Latency to useful output10 to 50 ms per tokenabout 16 s per planned action (800 samples x 10 refinements)Predict2: about 26 s (2B, GB200) to over 30 min (14B, DGX Spark) per 480p, 16 fps clip; Predict1 14B: about 10 min per 5 s clip on one H100under 30 ms per frame
Approx. FLOP per unit vs 8B token1x~10x per latent step; ~10^5x per planned action (800 samples x 10 refinements)~10^5 to 10^6x per framenear 0 transformer FLOP
Bottleneckweight bandwidthbatched predictor GEMMsdenoise FLOPs plus KV trafficsplat sorting and fill rate
Scaling with horizonKV grows linearly with contextcontext grows with each predicted step; the paper plans one step aheadlinear in tokens times stepsfree; the asset already exists
Scaling with batchlinear KV, then compute-boundbatched CEM is the intended modeusually batch 1 per clipextra cameras render nearly free

The LLM column anchors the scale. An 8B dense decoder such as Llama 3 8B keeps about 16 GB of weights in fp16 and emits a token in tens of milliseconds on a consumer card; at that size, decode is bound by reading weights rather than compute Meta AI 2024. The Llama 3 paper gives the 8B model 32 layers and 8 key-value heads under grouped-query attention Grattafiori 2024. In fp16 that works out to a KV cache of about 128 KB per token, so memory grows linearly with context length.

The latent column is where planning gets cheap enough to run on a robot. V-JEPA 2-AC pairs a frozen 1B-parameter ViT-g video encoder with a 300M-parameter block-causal predictor, so the whole planning stack fits in a few GB Assran 2025. Its planner runs the cross-entropy method with 800 samples over 10 refinement iterations and produces an action in about 16 seconds, while a Cosmos video-generation planner took about 4 minutes per action with only 80 samples. The paper reports the two times, not a ratio; they work out to roughly 15x Assran 2025. Cheap per step does not mean flat in horizon. The predictor is block-causal: each patch feature attends to the patch features, actions and end-effector states of the current and earlier steps, so a longer rollout carries a longer context, though of 16 x 16 latent patch maps rather than pixels. Both planners in that comparison looked one step ahead Assran 2025.

The generative-video column is the expensive one. Cosmos Predict spans autoregressive models at 4B to 13B and diffusion models at 7B to 14B over continuous and discrete video tokenizers NVIDIA 2025. NVIDIA's own measurements put Predict2's 14B Video2World variant at 56 GB of VRAM and roughly 85 seconds on a GB200 to over 30 minutes on a DGX Spark per clip at 480p and 16 fps, with 720p slower still NVIDIA 2025; the Predict1 14B Video2World card lists more than 80 GB without offloading for a five-second 1280x704 clip NVIDIA 2025. These are offline generators rather than 24 fps runtimes, and a policy that calls one per action step inherits that latency.

The explicit-3D column inverts the trade. 3D Gaussian Splatting stores the scene as rasterizable primitives, so a query is a raster pass: no weights, no tokens, and tens of milliseconds or better per frame on ordinary GPUs Kerbl 2023. Memory moves to the asset itself, typically a few hundred MB to a few GB per captured scene, and hundred-million-splat scenes outgrow consumer cards until level-of-detail or offload steps in. The limitation is semantic rather than computational: a splat answers what a view looks like, not what an action does, which is why the real-to-sim-to-real pattern below attaches explicit physics.

Two rows carry the design lesson. Batch behavior is the tell for robot use: LLM decode batches KV-bound streams, CEM planning is built to be batched, video diffusion usually runs one clip at a time, and rasterization makes extra cameras nearly free, which is why splats are attractive for evaluation and sensor simulation. The horizon row is a difference of degree: the latent predictor's context also grows with each step, by one 256-token patch map at a time, while token generators pay linearly in both KV and steps. For a training loop that asks the model for thousands of imagined rollouts, as in the model-based RL guide, those two rows decide what is affordable.

Where physics remains difficult to replace

Planning queries actions the dataset did not take. A physics engine can usually integrate those actions as long as its modeled regime remains valid. A learned model is being asked to extrapolate. A planner can exploit that extrapolation error by selecting actions whose predicted reward is high only because the model is wrong.

Safety constraints also favor explicit state. Joint limits, collision geometry, force bounds and signed distances can be checked directly. A video prediction may imply a collision without representing the quantity a safety monitor needs.

Throughput is workload-dependent. GPU physics can advance thousands of low-dimensional environments in parallel. A large video diffusion model may spend several denoising passes on one rollout. Learned latent dynamics can be faster than either. “Neural” does not determine speed; state size, horizon and sampling procedure do.

Where learning has the advantage

Rendering a real workcell with every texture, reflection, cable and background object is expensive. A learned visual model can absorb that distribution from video. Contacts with deformable objects, unmodeled actuator dynamics and wear can also resist clean parameterization.

Robotic World Model is an example of pushing the learned system toward a neural simulator for policy optimization Li 2025. RoboWorld pushes toward policy evaluation, using a neural simulator plus task-progress scoring and validating rankings against real robot results Jeon 2026. Their usefulness depends on downstream agreement, not on replacing a physics engine in name.

Three hybrid patterns

Learn appearance, keep dynamics

Real-to-sim systems reconstruct a scene's visual geometry while retaining a conventional physics engine for motion and contact. RoboGSim uses Gaussian-splatting-based scene reconstruction in a real-to-sim-to-real pipeline Li 2024. The learned renderer makes observations resemble the workcell; it does not by itself supply action-conditioned physics.

This pattern is strong for visual policy transfer when rigid-body mechanics are adequate. It is weak when the missing effect is friction, deformation or tool compliance.

Generate content, keep the engine

Generative simulation uses models to author objects, layouts, tasks and assets inside a physics simulator. RoboCasa supplies large-scale everyday manipulation environments Nasiriany 2024, and RoboCasa365 expands the framework for training and benchmarking generalist robots Nasiriany 2026.

The generator solves a coverage problem while the engine still solves transitions. This avoids asking a video model to maintain contact causality over long rollouts.

Learn residual dynamics

Start from explicit dynamics and learn the difference between simulated and measured transitions. Residuals can target actuator delay, torque response, contact impulses or observation noise. This is the most conservative hybrid because the learned component has a named error to fit.

Residual models still need support checks. A correction learned around nominal walking may not extrapolate to a fall. The explicit base model provides a fallback, not a guarantee.

Evaluation must use the same real anchor

Both simulator types can be wrong in correlated ways. A policy may exploit contact softness in physics or visual shortcuts in a world model. Evaluate the environment by whether policies and interventions transfer.

SIMPLER formalizes this for conventional simulation: build matched environments and measure correlation between simulated and real policy performance Li 2024. Apply the same protocol to learned worlds. Include several policy families, physical perturbations and held-out environments. The world-model evaluation guide details the ranking and calibration tests.

Do not compare a physics engine on task success with a world model on frame similarity. Put both behind the same decision: select a policy, select an action sequence or generate training experience, then measure the real consequence.

A selection rule

Use explicit physics when the state and mechanics can be specified, broad counterfactuals matter, constraints must be inspected, or massive parallel stepping is the main value. Use a learned world model when real observations contain structure the simulator cannot economically author, available trajectories cover the decisions of interest, and downstream validation can anchor model error.

Use a hybrid when the mismatch is localized. That is the default worth defending: geometry, constraints and reliable mechanics stay explicit; appearance, residual dynamics and task distributions are learned where data has an advantage. The result is not philosophically pure. It is easier to validate, which is the property robot learning needs.

See also

  • Model-Based Robot Learning

    Learn dynamics, plan through them, and improve from imagined rollouts: the common structure behind Dreamer, TD-MPC2 and robotic world models.

  • Generative Simulation

    Generated content inside real physics engines beats generated dynamics: RoboGen, Holodeck, RoboCasa.

  • Sim-to-Real Transfer

    Domain randomization, teacher-student distillation, system identification, and real-to-sim correction.

  • World Model Evaluation for Robotics

    Visual fidelity is not enough: evaluate action sensitivity, rollout consistency, task progress, policy ranking and real-world agreement.

Linked from

  • What Is a World Model?

    An editorial comparison of six world-model example groups: what they predict, in what representation, and for what purpose. The survey-defined functional criterion is decision-relevant prediction, not visual plausibility alone.

  • Generative Video World Models

    Cosmos, Genie, and GR-2: action-conditioned video prediction and the conditioning-strength problem.

  • Generative Simulation

    Generated content inside real physics engines beats generated dynamics: RoboGen, Holodeck, RoboCasa.

  • Model-Based Robot Learning

    Learn dynamics, plan through them, and improve from imagined rollouts: the common structure behind Dreamer, TD-MPC2 and robotic world models.

  • World Model Evaluation for Robotics

    Visual fidelity is not enough: evaluate action sensitivity, rollout consistency, task progress, policy ranking and real-world agreement.

  • Scene Representation and Mapping

    What a robot remembers about the space around it, and why the map that renders best is not the map a planner can use.

References

  1. Emanuel Todorov, Tom Erez, Yuval Tassa, IROS 2012.

    https://doi.org/10.1109/IROS.2012.6386109

  2. NVIDIA, Mayank Mittal, Yunrong Guo, Pascal Roth, David Hoeller, James Tigue, Antoine Richard, Octi Zhang, and 98 more, 2025.

    https://arxiv.org/abs/2511.04831

  3. Bohan Hou, Gen Li, Jindou Jia, Tuo An, Xinying Guo, Sicong Leng, Haoran Geng, Yanjie Ze, and 10 more, 2026.

    https://arxiv.org/abs/2605.00080

  4. Chenhao Li, Andreas Krause, Marco Hutter, 2025.

    https://arxiv.org/abs/2501.10100

  5. Xinhai Li, Jialin Li, Ziheng Zhang, Rui Zhang, Fan Jia, Tiancai Wang, Haoqiang Fan, Kuo-Kun Tseng, and 1 more, 2024.

    https://arxiv.org/abs/2411.11839

  6. Soroush Nasiriany, Abhiram Maddukuri, Lance Zhang, Adeet Parikh, Aaron Lo, Abhishek Joshi, Ajay Mandlekar, Yuke Zhu, RSS 2024.

    https://arxiv.org/abs/2406.02523

  7. Soroush Nasiriany, Sepehr Nasiriany, Abhiram Maddukuri, Yuke Zhu, ICLR 2026.

    https://robocasa.ai/assets/robocasa365_iclr26.pdf

  8. Xuanlin Li, Kyle Hsu, Jiayuan Gu, Karl Pertsch, Oier Mees, Homer Rich Walke, Chuyuan Fu, Ishikaa Lunawat, and 8 more, 2024.

    https://arxiv.org/abs/2405.05941

  9. Byeongguk Jeon, Seonghyeon Ye, JaeHyeok Doo, Sungdong Kim, Minjoon Seo, Hyungmok Son, Kimin Lee, 2026.

    https://arxiv.org/abs/2607.01060

  10. Meta AI, 2024.

    https://ai.meta.com/blog/meta-llama-3/

  11. Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, 2024.

    https://arxiv.org/abs/2407.21783

  12. Mahmoud Assran, Adrien Bardes, David Fan, Quentin Garrido, Russell Howes, Mojtaba Komeili, Matthew Muckley, Ammar Rizvi, and 21 more, 2025.

    https://arxiv.org/abs/2506.09985

  13. NVIDIA, 2025.

    https://arxiv.org/abs/2501.03575

  14. NVIDIA, 2025.

    https://github.com/nvidia-cosmos/cosmos-predict2/blob/main/documentations/performance.md

  15. NVIDIA, 2025.

    https://catalog.ngc.nvidia.com/orgs/nvidia/cosmos/models/cosmos-1.0-diffusion-14b-video2world

  16. Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, George Drettakis, ACM Trans. Graph. 42(4), author manuscript (2023).

    https://arxiv.org/abs/2308.04079

Spot a factual error or missing qualification? Report a content correction.