BotLab — Browser-Based Robot Simulation and Control Development

BotLab is a robot development and simulation environment that runs in the browser. Open the page and you can write control code, load a robot model, run MuJoCo physics, execute ONNX policy inference and watch the result in a live 3D view. Nothing to install, no Python environment to configure, nothing to compile — between "let me try this policy" and "the robot is moving" there is a web page and not much else.

Open BotLab 中文版

The problem it solves

The cost of getting into robot simulation has always sat in the environment: install the simulator, line up versions, resolve dependencies, fight the graphics driver — a day or two gone before a line of control logic is written. And when the result has to be shared with someone else — a colleague, a reviewer, a customer — they get to install the whole thing again, or settle for a screen recording.

BotLab moves the simulator itself into the browser. MuJoCo runs as WebAssembly, policy inference goes through ONNX Runtime Web (WebGPU first, then WebNN, then WASM), and Three.js does the rendering — all locally, in one page. A project can also be published as a standalone simulation runtime, so whoever receives the link can run it themselves rather than watch a video of you running it.

Project structure: three files

A BotLab project is exactly three entry files, with separated responsibilities and no implicit orchestration:

• botlab.yaml — declares the project name, physics and control rates, resource references and live-tunable parameters.
• main.py — experiment orchestration: obtain the simulation, create the controller, start the control loop.
• controller.py — explicitly selects, assembles and exports the controller. Standard controllers reuse the SDK implementations configured by a resource preset; custom algorithms go here.

Editing happens in a built-in Monaco editor with schema validation on the YAML, so a wrong resource id, type, source or parameter fails immediately instead of at run time. Complex controllers can add Python helper modules alongside, imported explicitly by project code.

Core capabilities

• In-browser physics — MuJoCo compiled to WebAssembly, with MJCF and URDF robot models, terrain and scene configuration.
• Policy inference — ONNX Runtime Web loads pretrained policies, with execution providers falling back WebGPU → WebNN → WASM.
• Live 3D view — Three.js renders robot state, contacts and terrain, driven directly by simulation data.
• Time-series scopes — uPlot panels plot observations, control signals and sensor readings as the simulation runs.
• Modes and teleoperation — a state-machine mode switch, with gamepad and keyboard commands mappable onto control modes.
• Motion references — load reference motion data and drive playback and interpolation per simulation step, for imitation-style setups.
• Resource ecosystem — geometry and physics models (mesh, URDF, MJCF), pretrained ONNX policies, and motion reference data.
• Publish standalone runtimes — package a project as .botlab.zip, or publish it as a simulation page that opens and runs on its own.

Typical uses

• A trained ONNX policy needs a quick sanity check in simulation before it goes anywhere near hardware.
• A course or workshop where a room full of people has to run simulations without each installing a stack.
• Demonstrating a robot behaviour to a customer or reviewer who should be able to change parameters themselves, not just watch a recording.
• Tuning IK, trajectory planning or impedance control on an arm, where the value is in a short edit-and-see loop.
• Comparing one robot across terrains or policies, with a reproducible project configuration behind each run.

Where it sits in the platform

BotLab owns the validation stage of the robot development flow and sits downstream. Robot models come from BotWorld and URDF Studio, motion assets from Motion Studio, and BotLab composes them into a loop you can actually run. All four products work standalone, and together they form a continuous chain around one shared asset.

• BotWorld — robotics asset platform for discovering and distributing models, motions, skills, scenarios and cases.
• URDF Studio — online robot model editor for URDF, MJCF, SDF and USD.
• Motion Studio — motion-capture processing and multi-robot retargeting workbench.
• Platform documentation — the full manual from asset to simulation.

Frequently asked questions

Does BotLab need to be installed?

No. Simulation, inference and rendering all run in the browser.

Which simulator does it use?

MuJoCo today, compiled to WebAssembly and running in the page. Simulator-specific code is confined to dedicated modules, leaving room for a second backend later.

Which robot models are supported?

MJCF and URDF with their mesh resources, including models edited in URDF Studio.

Can I run a policy I trained myself?

Yes. Export it to ONNX, reference it as a project resource, and ONNX Runtime Web runs the inference in the browser.

How do I share a finished project?

Package it as .botlab.zip, or publish it as a standalone simulation runtime that opens from a link with nothing to install.

What are the browser and hardware requirements?

A modern desktop browser with WebAssembly support. WebGPU makes inference noticeably faster where available; without it, execution falls back to WebNN or WASM.