No install · no account · nothing uploaded
MuJoCo in your browser
DeepMind's own WebAssembly build of MuJoCo, running in a tab. Open a robot, watch it stand up or fall over, write a controller, load a trained policy — without pip, conda, a GPU driver or a Docker image standing between you and a simulation.
There is nothing to install
The engine downloads with the page — about 2.4 MB — and runs on your machine. No environment to create, no version of Python to match, no driver to chase down, and nothing that behaves differently on Windows than it did on the writer's Mac.
That is worth being precise about: this is not a video of a simulation, and it is not a simulation on our server that streams pictures back. The physics steps in your tab, on your CPU, with your model, and the tab is where it stays.
Four things to try in the next minute
Each opens in the physics lab with the model loaded and the controller visible. Press Run.
- A quadruped standing up Twelve motors holding a pose against gravity. The first thing to watch is the sag: the legs settle slightly below where they were told to be, because a position command is a request to a motor with a finite rating.
- The same robot trotting in place Now the feet leave the floor in pairs. Contact, friction and the actual torque each hip is asked for — all of it visible while it runs.
- No control at all The same robot with the motors released. Worth thirty seconds of anyone's time: it is what every simulation looks like before a controller does anything, and it is the baseline your controller has to beat.
- A six-axis arm sweeping its joints An arm bolted to the ground, moving through its declared limits. No feet, no balance — just the motors and what they are asked for.
It is the engine, not an imitation of it
MuJoCo has been free and open source since 2022, Apache 2.0, and it compiles to WebAssembly like any other C library. What runs here is that build: the same solver, the same contact model, the same integrator. A result you get in this tab is a result you can reproduce on a desktop install, which is the only property that makes a browser simulation worth having.
What the browser does not get is the parts that are not the engine. MJX — MuJoCo on JAX, thousands of environments in parallel on a GPU — is a training tool and is not here. Neither is the Python API, nor compiled plugins. If your work needs those, install MuJoCo locally; this is for everything that comes before that decision, and for the times you want to show somebody a robot without asking them to set anything up first.
Your own robot
An MJCF opens directly — drop the file, with its mesh folder or a ZIP if it references any. Anything else goes through the converter first, and every direction states what it could not carry across rather than dropping it quietly:
- URDF to MJCF — the common case, straight out of ROS
- Xacro to MJCF — expanded first, then converted
- SDF to MJCF — out of Gazebo
- USD to MJCF — out of Isaac Sim
- Straight out of CAD — SolidWorks, Onshape or Fusion, and what those exports get wrong
- Or none of the above — open any robot from DeepMind's Menagerie collection, already written for MuJoCo
Ask the converter for a physics model and it adds what a description has no place for: a ground plane, a light, and a free base for a robot with legs — because a legged robot welded to the origin can neither stand up nor fall over.
The controller is code you can read
Your controller is plain JavaScript in an editor beside the scene. It runs once per control tick, receives the robot's state and returns what each motor should aim at — the same shape as a real policy, without a runtime to install. Change a number and the next run uses it.
A movement authored in the motion editor arrives here as its frames written into that file, with the interpolation spelled out above them, so the first thing anyone wants to do with a generated gait — change one step of it — works.
What you can read off a run
Watching a robot stand is a demonstration; the numbers are the measurement. While it runs the lab reports the height of the base, how far it has tilted from upright, the speed it is travelling, which feet are in contact, and what each motor is being asked for against the effort its own description declares. You can shove the robot with the mouse, tilt gravity under it, and rewind the run to look again.
Four repeatable tests answer with a number rather than an impression: does it stand, what shove does it survive, what slope does it hold, what load does it carry. They run headless, which is what makes "it got better" a claim you can check rather than a feeling.
Common questions
Do I need to install MuJoCo to use this?
No. The engine is DeepMind's own WebAssembly build of MuJoCo, running in the page — about 2.4 MB over the wire. There is no pip, no conda environment, no GPU driver and no Docker image between you and a running simulation.
Is this really MuJoCo, or a re-implementation?
It is MuJoCo itself, compiled to WebAssembly and licensed Apache 2.0 like the rest of it. The solver, the contact model and the integrator are the same code the desktop build runs; what differs is where it executes, not what it computes.
Does my model leave my machine?
The simulation is local: physics, controller and rendering all run in the tab. A model is sent to the server only when it needs converting from another format — and that upload is deleted after a day. An MJCF opens without any round trip at all.
What can I load?
MJCF directly. URDF, Xacro, SDF and USD through the converter, which says what it could not carry across rather than dropping it quietly. Meshes come along in a folder or a ZIP.
Can I run a trained policy?
Yes — load an .onnx network and it drives the joints instead of hand-written
code. Inference runs in the tab beside the physics, which is enough to answer the question a
policy is usually loaded to answer: does it keep its feet on a robot whose numbers came from
the description rather than from the training config.
Does it support MJX, or GPU acceleration?
No. MJX runs on JAX and is built for thousands of environments in parallel on a GPU — that is a training tool, and this is not. What runs here is one robot at interactive speed, which is what you want when the question is "why is it falling over" rather than "how do I train it".
Can I use the Python API?
Not in the browser. Controllers here are JavaScript, called once per control tick with the robot's state and returning what each motor should aim at — the same shape as a policy, without a runtime to install. For Python, install MuJoCo locally; this is for the part before that decision.
How big a model can it handle?
A robot, comfortably: the bundled quadruped is 23 bodies with 18 degrees of freedom and runs above real time. What it is not built for is a warehouse full of them — a scene with hundreds of colliding bodies belongs on a desktop build.
Is it free?
Yes, and there is no account. MuJoCo itself has been free and open source since DeepMind released it in 2022, which is the reason a page like this can exist at all.
Where to go next
- The physics lab — the tool this page is about
- The viewer — look inside a model before simulating it: collision against visual, joint limits, where the mass sits
- Motion — author a movement and check the motors can perform it
- check-clips.mjs — the same check in a build, as one file with no dependencies