How to build SparkRover Mini: the whole process
149 steps to build SparkRover Mini, from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the offici…
SparkRover Mini is a friendly classroom robot with arms, a face and a camera. Its manufacturing release provides laser and CNC parts, 3D-printed components, fabrication programs, a BOM, a wire cut list and a step-by-step assembly guide.
Buy parts
- Check OS version and system specifications
Compare the machine against the Minimum, Good and Ideal specifications tables for each listed element; note that Ubuntu 22.04 support is deprecated and will be removed in a future release.
Print and make
- Slice the STL into G-code
Run cura_slice.py to slice part.stl into part.gcode. The part is centred on the bed; --at x,y places it elsewhere.
- Run preflight on the G-code
preflight.py checks the G-code without the engine: time, filament, flow, and what Klipper would refuse.
- Build the print world
world.py turns a repo-relative part.gcode into my_print.omniworld, a world that prints it.
- Slice jobs/cube20.stl with the SV08 profile
Slice jobs/cube20.stl with cura_slice.py using the SV08 profile: 0.2 mm layers on a 0.25 mm first layer, two walls, 10 % grid infill, a 5 mm brim, and PLA at 220 °C.
- Print the cube headless on the printer twin
Print headless on sv08_printer_twin.omniworld with Newton/MuJoCo CPU at 2 ms on an RTX 3060 Laptop machine. The print ran about 2× faster than real time.
- Choose the ideal printer model
Use Ideal for part geometry, volume, layer structure, flow and slicer checks, a long print, or many variants. It stays within the twin by ≤0.03 mm on the mean outer surface, ≤0.06 mm on outer-surface p05/p95, and ≤0.11 mm on the footprint, with the same height, layers and volume.
- Choose the twin printer model
Use Twin for anything dependent on machine movement, including corner overshoot, axis tuning, and the drives' share of the oversize. Use it to watch or film the print.
- Build the GUI simulator only
Run the gui build subcommand, which builds only `src/omnisim`.
- Rebuild when simulator sources change
Use this rebuild when you changed files under `src/omnisim`, including renderer code under `src/omnisim/render`, and did not change `src/glad`.
- Do not use the retired renderer build
The renderer recipe was deleted with WREN on 2026-08-23 and the subcommand now refuses with an explanation and a non-zero exit. Rebuild renderer code with `build core` or `build gui` instead.
- Build controller libraries and launcher
Run the controller-libs subcommand to build only the controller libraries and launcher. Use it when you changed `src/controller` or `include/controller`, or when iterating on controller APIs or launcher behavior.
- Run the packaging path
Run the package subcommand to execute the packaging path; this is not part of the normal fast inner loop.
- Use the equivalent make targets
Root Makefile wrapper targets exist: `make sim-core`, `make sim-gui`, `make controller-libs`, `make tests-smoke`, `make benchmarks`, `make compile-commands`. Do not use `make renderer`, which prints `Nothing to be done for 'renderer'` and exits 0.
Software
- Confirm the Windows Version
Use Windows 10 or 11 and reserve approximately 10 GB for MSYS2, dependencies, and build artifacts, plus approximately 1 GB for the required Newton runtime bundle.
- Install Git for Windows
Install Git for Windows so the repository can be cloned.
- Install CPython 3.12
Download Windows CPython 3.12 from python.org and install it to the default per-user location. Python 3.10 and 3.11 are not usable.
- Set the Checkout Path
Set `OMNISIM_HOME` to the absolute path of the local OmniSim checkout. The top-level Makefile exports `WEBOTS_HOME`, while `build_omni.bat` derives the path from its own location.
- Install MSYS2
Install MSYS2 to `C:\msys64`, then open an MSYS2 MINGW64 terminal and update the system packages.
- Install build dependencies
Install the listed compiler, build tools, Qt 6 modules, networking and archive utilities from the MSYS2 MINGW64 terminal. The document notes that `curl` and `unzip` are used by `scripts/dev/setup_wgpu_native.sh` to fetch and unpack the wgpu-native release, so install them even if Windows `curl.exe` is already on `PATH`.
- Set up nested Qt6 headers
From an MSYS2 MINGW64 terminal, create `include/qt` and copy each `/mingw64/include/qt6/Qt*` directory into a matching nested directory under the project.
- Clone and check out GLM
If `src/glm` is empty, clone the `glm` repository into it and check out version 1.0.1. GLM 1.0.1 is used for compatibility with GCC 15.
- Clone the STB submodule
Clone the `stb` image-loading repository into `src/stb` using the `patch-1` branch.
- Fetch the wgpu-native renderer
Run the setup script once per clone before the first build. It installs wgpu-native under `$OMNISIM_HOME/_scratch/wgpu-native`, the path auto-discovered by the Makefile.
- Build the simulator from MSYS2
From the MSYS2 MINGW64 terminal, build the release target with all available processor cores. The first build takes 5–25 minutes depending on hardware.
- Build with the bundled wrapper
From `cmd.exe` at the repository root, run the bundled wrapper. It derives `OMNISIM_HOME` from its own location and invokes MSYS2's `make`.
- Configure a nondefault MSYS2 path
If MSYS2 is not installed at `C:\msys64`, set `MSYS64_HOME` to its installation path before using the bundled wrapper.
- Override the wrapper job count
Set `MAKE_JOBS=N` before building to override the wrapper's job count. More jobs can be faster but use more RAM, and full parallelism can thrash laptops.
- Build only the core simulator
Build the core simulator release target when iterating on the simulator itself. This skips the controller libraries and sample projects.
- Build only the controller libraries
Build the controller libraries in release mode while passing `OMNISIM_HOME` to the build.
- Set up simulator runtime dependencies
Make the required Qt6 plugins and MinGW DLLs available at runtime by running the documented setup commands once after a fresh build.
- Copy MinGW Runtime DLLs
Copy all MinGW runtime DLL files into the MSYS2 MinGW64 binary directory.
- Install the Qt6 Platform Plugin
Create the platforms directory and copy the qwindows.dll plugin for window creation.
- Install Qt6 Image Format Plugins
Create the imageformats directory and copy the Qt6 image format plugins required for JPEG and PNG texture loading.
- Install Qt6 TLS Plugins
Create the tls directory and copy the Qt6 TLS plugins required for HTTPS; this avoids "No TLS backend" warnings.
- Open the Demo Launcher
Run the included launch.bat at the repository root with no arguments. In the demo launcher, right-click the orb robot, choose Show Robot Window, and pick a demo from the gallery.
- Open a Specific World
Pass a world path to launch.bat to open that specific world directly.
- Run the Simulator from MSYS2
Export the required PATH entries and run omnisim-bin.exe from the MSYS2 terminal.
- Build a console-attached debug binary
Build the supported debug target. It produces a console-subsystem `omnisim-bin.exe` so stdout and stderr appear in the terminal; objects are written to `build/debug/`.
- Relink a separate console binary
To keep the release objects, relink them into a separate console binary using the Makefile's current Windows `LIBS` line. If relinking fails with an undefined symbol, read that Makefile line rather than guessing.
- Choose a supported Ubuntu version
Use Ubuntu 24.04, where Python 3.12 is the system interpreter, or Ubuntu 22.04, where the bootstrap installs Python 3.12 from deadsnakes.
- Run the apt installation phase
The documented fresh-box path begins with the apt phase. The complete path is budgeted at 25–45 minutes, with the apt phase taking 2–6 minutes.
- Clone the OmniSim repository
Clone the project repository as the next phase of the documented setup path. This phase takes 1–3 minutes.
- Build the release binary
Run the `make release` build phase. The build embeds Python 3.12 on Ubuntu 22.04 and asserts the produced binary’s interpreter link with `ldd`; the build takes about 14 minutes on 4 cores or 7 minutes on 24 cores.
- Install GPU physics wheels
Install the physics wheels into the same Python interpreter used by the built binary. The physics-wheel phase takes 2–4 minutes.
- Optionally install PyTorch
Install torch if it is needed; this adds about 2.5 GB and several more minutes to the documented path.
- Install OmniSim on Linux
Run the bootstrap script to install and build the project.
- Install apt prerequisites
Install about 35 apt packages, including libdbus-1-dev, libvulkan1, mesa-vulkan-drivers, the libxcb-* set, and python3-dev. Do not install Qt6 development packages because the build vendors its own Qt 6.5.3.
- Provide Python 3.11 or newer
Ensure the engine can embed Python 3.11 or newer. This is a no-op on 24.04; on 22.04, install Python 3.12 from the deadsnakes PPA and pip through ensurepip.
- Fetch source and submodules
Clone the project, fetch glm pinned to version 1.0.1 and stb from omichel’s patch-1 branch, and re-apply executable permissions to scripts/**/*.sh.
- Install the wgpu-native renderer
Run scripts/dev/setup_wgpu_native.sh to install wgpu-native. The renderer link depends on WGPU_NATIVE_HOME, and the build must contain lib/webots/libwgpu_native.so.
- Build the release version
Build the release with make and the configured JOBS count. The build obtains Qt 6.5.3 automatically through aqtinstall, while JOBS defaults to min(nproc, 32).
- Install the pinned physics stack
Install the pinned physics stack and link it to the Python interpreter.
- Run every installation phase
Run all installation phases in order; this is the default mode of the bootstrap script.
Calibrate and test
- Set printer axis acceleration feed-forward
- Leave the velocity lead trim off
The CNC trims its velocity lead by half its 2 ms substep, but at the printer's 1 ms substeps the trim measured no better than none, so the printer has no lead trim. The drives keep the target fed forward with velocity and acceleration and an integral trim at rest for the gantry's weight on Z.
- Check nozzle error against the planned path
Compare the measured minus the planned nozzle position, sampled every 50 ms; the first layers run at 30 mm/s are left out of the short runs. Z stays within 0.010 mm throughout.
- Account for bead width when sizing the part
A slicer meters plastic as a rectangle, line width × layer height, but a bead is rounded, so the same volume spreads 0.035 mm wider (0.017 mm a side). The axes' remaining error and the step-to-step width variation account for the rest of the oversize.
- Apply the bead fix and re-print the cube
- Set cube and plate offsets
Carry the twin's nozzle out by 0.02–0.03 mm on each side of the cube and plate.
- Set shell long-wall offset
Carry the nozzle out by 0.003 mm on the shell's long walls; the shell is 0.06 mm longer in Y.
- Validate Test Harness Changes
No rebuild is usually required when only test harnesses or world files changed. Run validation directly with `--nomake` when appropriate.
- Run the Renderer Test Loop
Build the GUI, then test the normals rendering world without making additional changes.
- Run the Runtime Smoke Test
Build the GUI and run the smoke test with `--nomake`. Use the core build instead for broad changes or changes affecting physics or controller synchronization.
- Run the Controller API Test Loop
Build the controller libraries, then run the API test group with `--nomake`.
- Run the Accelerometer World
Build the GUI, then run the accelerometer world.
- Check the OmniSim log
After launching, inspect `omnisim_log.txt` in the project root to diagnose warnings and errors.
- Verify the Newton physics backend
Confirm Newton physics through the backend-verdict sidecar. With an NVIDIA/CUDA GPU, the batched profile uses `newtonSolver "mujoco_warp"`; without one, the default `SolverMuJoCo` still runs physics on the CPU.
- Run the headless smoke test
Run the application under Xvfb in headless mode and check the sidecar.
- Run the Xvfb load check
Run the load check under Xvfb because a Qt/XCB context is created even with --no-rendering. Use --until-finalized to stop when Newton finalizes and the sidecar exists instead of waiting for a guessed --duration or ending prematurely.
- Avoid harmless root warnings
Running as root prints a warning on every run. This is normal on cloud pods and default-root WSL setups and is harmless; add a non-root user to remove it.
- Capture the Doctor Output
Run the doctor command and retain its output as evidence.
- Capture and Check the Load
Take a screenshot and include the load-check command used to prove that the edited world loads.
- Define Success Before Implementation
Define success in physical units or an observable state before implementing the robot or task.
- State Success and Failure Criteria
State the criteria for a successful run and a failed run.
- Run the braking assessment campaign
Reproduce the 64-case campaign: 48 grid cases, 12 refinement cases, and four fresh confirmations using a 0.6 m/s target and 16 ms samples on the CPU solver.
- Check immediate-braking travel
At 5° downhill with a 10 kg mounted load, check travel during the 2.5 s after STOP; the measured examples were 1.13 m at μ=0.10 and 0.166 m at μ=0.20.
- Disable light mode while debugging
Load the world with `{"light": false}` so the five silenced event types remain available. The `/sim/contacts` endpoint responds in either mode.
- Check headless runs for runaway physics
Add `--duration N --fail-on-runaway` when the result must establish physics behavior rather than only show that the headless run finished.
- Position and enable the showcase camera
Use `controllers/showcase_camera` as a kinematic supervisor carrying one Camera. For each shot, wait for `at_s` and, for twins, a trigger file; move to the shot position, aim at the target with +x forward, +z up, and no roll, and save the frame.
- Enable the camera only while shooting
Enable the Camera only around each shot. Use a `far` value of 2.5–3 for close shots because the `far` plane also sizes the camera's shadow map.
- Run the declaration honesty gate
Run the declaration test from tests/benchmarks to execute the honesty gate.
Data and training
- Run the Husky assessment sweep
Run the Husky sweep with 12 refinements, 2 confirmations, and 2 workers, writing results to `.tmp/husky-assessment`. Test 0–20° downhill slopes, four friction settings, and 0/10/20 kg mounted loads at 0.6 m/s with immediate braking throughout.
- Inspect stopping behavior and evidence
Inspect the report, per-step traces, native captures, and exact test conditions. The stopping requirement is 0.25 m, and failures are classified as braking failures, inability to reach speed, sliding, or tipping.
- Build and verify the Husky package
Build and verify the US$100 Husky package described by `projects/assessments/packages/husky/SCOPE.md`. It includes a 64-episode reference-controller braking assessment, report, raw evidence, reusable tests, and an offline Windows runtime.
- Qualify the Jackal assessment profile
Start Jackal's profile in a new output directory using one worker. Other robot classes require task-specific adapters.
- Create a robot-specific assessment package
Use the shared package factory to select a model's speed, payload fixtures, requirements, and notices. Run a qualifying campaign and check the Windows delivery.
- Run the Go2 and G1 assessments
Run 17 Go2 walk/stand/walk episodes and 14 G1 standing episodes. The selected G1 stance passed 32 s and held-out 48/60 s standing checks.
- Run the Husky mixed-surface assessment
Run the Husky braking and 90-degree turning assessment on physical rigid friction patches. The frozen study contains 76 episodes and compares 0.6 m/s cruise with a 0.35 m/s mapped-surface cap.
- Run wheeled-model coverage cases
Use the braking adapter with Husky, Jackal, ROSbot, ROSbot XL, TurtleBot3 Burger, Waffle, or Waffle Pi and run the 35 unloaded/loaded coverage cases.
- List robot inventory and coverage
Run the robot assessment command to display the full URDF inventory and each robot’s task coverage.
- Record the Exact Commands
Record the exact prompt or commands used for the edited demo.
- Provide the Changed World
Provide the changed world or a small patch containing the visible edit.
- Document Model and Asset Origins
Provide the provenance of the model and assets used in the contribution.
- Run a Positive and Negative Case
Provide one positive run and one useful negative control.
- Document Known Limitations
Document known limitations, including anything that only works visually.
- Disclose Supplied Evaluation Resources
Disclose any assets, models, or evaluation data supplied by the contributor.
- Run the print world
Run the generated my_print.omniworld with the omnisim run-world command.
- Dump printed beads headlessly
The engine writes its beads when asked: set OMNISIM_PRINTED_PART_DUMP=part.beads and run headless with duration 300.
- Inspect printed beads against the STL
inspect_print.py compares the dumped part.beads with the original part.stl to measure what was printed.
- Display the BuildBench matrix
Run the command from tests/benchmarks to display the expressibility matrix.
- List the registered tasks
Run the command from tests/benchmarks to display the task list.
- Export the task registry
Run the command from tests/benchmarks to output the whole registry as JSON.
- Render and downsample the showcase frame
Render the frame at 3200 x 2000 and downsample it to 1600 x 1000 using Lanczos. Nothing is painted onto the frame.
- Save review frames without publishing
Save raw frames, logs, and alternate angles to the gitignored `.tmp_showcase/` directory. Running with `--review` sends every frame there and publishes nothing.
- Run reinforcement-learning trainers on Linux
The reinforcement-learning trainers run on Linux, including projects/policies/training/run_walk_rl.sh and similar trainers. The early-stop watchdog was MSYS-only, but the trainings themselves work.
Use it
- Open the Warehouse Husky World
Open the warehouse Husky sample world with OmniSim.
- Run a headless demo world
Run the warehouse Husky demo world headlessly with structured exit using the supported run contract.
- List procedural world recipes
List the available procedural world recipes before generating a world.
- Generate a Mars world
Generate a procedural Mars world with seed 42 and write it to `my_mars.omniworld`.
- Launch the generated world
Launch the generated `my_mars.omniworld` world. The world extension is `.omniworld`; generated and authored worlds use this extension.
- Run the G1 box delivery demo
Run the flagship G1 box-delivery locomotion demo to completion as the end-to-end check of the Linux setup.
- Run policy demo launchers on Linux
Use the Bash policy demo launchers on Linux as they are provided. The PowerShell deployment launchers have Bash siblings as of v5.1.
- Run the OmniSim Husky demo
Open the linked demo and watch OmniSim receive live AI instructions, answer follow-up questions, and return the Husky to base. The recorded result is a simulation, not a hardware demonstration.
- Connect an OmniLink account
Connect an OmniLink account to obtain an OmniKey and a model connection. Model usage is billed separately, including on the Free plan.
- Simulate a robot in OmniSim
Use Newton physics to simulate rigid bodies, contacts, cloth, soft bodies, and CUDA granular media. OmniSim provides 52 demo worlds and a procedural world generator.
- Build a robot digital twin
Import the robot with native URDF import or CAD import from STEP. Use the 20+ vendor robot packages available under projects/robots/.
- Program and debug with an agent
Connect Claude Code or Cursor to the first-party MCP server to access 46 tools on a running simulation. When the robot misbehaves, ask the agent what actually happened.
- Review reports and rerun instructions
Open the OmniLink service page for assessment reports, native comparison videos, and public rerun instructions.
- Run Nav2 planning on the Husky
Use Nav2 on the Husky for end-to-end planning and goal execution with ground-truth odometry. The verified case is not a SLAM, AMCL, or obstacle-avoidance benchmark.
- Choose One Contribution Lane
Choose the First edit, Robot or task, or Agent benchmark lane before beginning.
- Add a Robot or Task
Add one robot, sensor, controller behavior, or bounded task to OmniSim.
- Run the World Headlessly
Build the GUI and run the accelerometer world in headless mode.
Common problems
- Disturbance forces must be reapplied every step and are easy to misuse #14
- Headless execution is unreliable across startup, display, and articulation configurations #3 #5 #6
- Default harness tracking can slow simulation steps by hundreds of times #4
- Missing or unsupported wgpu-native prevents rendering entirely #7 #8
- Windows installation reports ready while runtime conformance fails #9 #11
- Controller handshake failures are falsely reported as ABI mismatches #15
- Out-of-box robot models miss stable hover and commanded distances #10 #17
- ROS timing assumptions can stall commands and clock publication #22 #24