tempo_sizzle.mov
Tempo is a collection of simulation-focused plugins for Unreal Engine. Tempo makes the power of Unreal accessible to simulation and robotics developers, including plugins for client APIs, sensor simulation, agent behaviors, and more.
Tempo is the foundation on which you can build a simulator for your unique application. Not sure where to start? Want some guidance from the authors? Find us on
Full documentation lives at tempo-sim.readthedocs.io.
| Getting Started | Prerequisites, installation, and a Hello World you can run in an hour |
| Concepts | Deterministic time, units and coordinates, naming, architecture |
| Plugins | TempoCore, TempoWorld, TempoSensors, TempoMovement, TempoAgents, TempoGeographic, TempoPCG, TempoROS, TempoROSBridge |
| Client APIs | Python, Rust and C++ clients, and the example clients |
| gRPC API Reference | Every service, RPC, message and field — generated from the .proto files |
| Guides | Adding your own services, packaging, CI, testing, troubleshooting |
| Migration | What changed between versions, and what you have to do |
Tempo is for building your own robotics simulator on modern Unreal Engine and driving all of it from code - a foundation of composable plugins, not a turnkey product. Among great simulators (CARLA, AirSim/Colosseum, Gazebo, Webots, Isaac Sim, Genesis), here's an honest look at where it fits.
| Key feature | What it means for your simulator |
|---|---|
| Modern Unreal + ecosystem | Runs on UE 5.7 / 5.8 - Lumen, Nanite, PCG, Niagara, MetaHuman, Chaos, and the huge library of real-time content the engine community ships, all for free. |
| gRPC API, no ROS required | The primary interface is gRPC: language-agnostic, schema-first, with HTTP/2 streaming. Clients connect across machines and platforms (Rust on Linux → sim on a Mac) - a step up from the older msgpack-RPC interfaces some sims use, and not tied to an in-process language. |
| Code-generated, reflection-based control | One set of .proto files generates Python / Rust / C++ clients (sync + async). Spawn any actor and get/set any property over the wire - no engine code needed. |
| High-fidelity sensors | Cameras with multiple lens models (incl. wide-FOV fisheye), semantic + instance segmentation, 2D bounding boxes, and hardware H.264 streaming; lidar with per-beam calibration and material-derived reflectivity. |
| Deterministic time | Pause / play / step and wall-clock vs. fixed-step time, all over the API - built for reproducible runs and data generation. |
| Native, optional ROS 2 | rclcpp runs in-process (no separate bridge process) and is entirely optional. |
| Runs where you work | Linux, Windows, and macOS (unusual among photorealistic engine-based sims). Develop locally on the hardware you already have. |
| Extensible by design | Tempo is built entirely as Unreal plugins (plus a few engine patches). If you can build it in Unreal, you can build it alongside Tempo. |
| If you need… | Consider |
|---|---|
| Massive-scale parallel RL (thousands of GPU envs, Gym-style) | Isaac Lab, Genesis |
| Contact-rich / legged-robot physics fidelity | Isaac Sim (PhysX), Genesis (differentiable) |
| To drop in existing robot descriptions (URDF/SDF/USD) | Gazebo, Isaac Sim |
| A turnkey AV stack with prebuilt maps & scenarios | CARLA |
In short: Tempo is the strongest fit for a photorealistic, deeply customizable simulator on modern Unreal, controlled entirely from code, that runs on the hardware your team already has - especially if you're comfortable in Unreal. It's a younger project with a smaller community and content library than the largest established sims, and it deliberately leaves the last mile - your scenarios, robots, and application - to you. That trade-off is the point.
- Linux (Ubuntu 22.04 and 24.04), MacOS (15.0 or newer, Apple silicon only), Windows 10 and 11
- Unreal Engine 5.7 and 5.8
- Linux:
- Unreal: Download and install from https://www.unrealengine.com/en-US/linux
curl:sudo apt update && sudo apt install curljq:sudo apt update && sudo apt install jq
- Mac:
- Unreal: Install using Epic Games Launcher
jq:brew install jq
- Windows:
- Unreal: Install using Epic Games Launcher
- Git Bash (Run all Tempo
*.shscripts using Git Bash, or use the*.batversions) jq: Downloadhttps://github.com/jqlang/jq/releases/latest/download/jq-win64.exeand put it anywhere on your Path, like (C:\Program Files\Git\cmd) and make sure it's namedjq
On Linux only, UNREAL_ENGINE_PATH must be set to your Unreal Engine installation directory (the folder containing Engine). On Mac and Windows, Tempo will attempt to automatically find Unreal via your uproject file, but you can still set this to override it.
See Prerequisites for the full list, and the environment variable reference for the rest.
Follow along the steps below with this video. Sound on!
tempo_first_steps.mp4
The TempoSample project is provided as a reference. If you are starting a new project, consider creating your repo using TempoSample as a template, and renaming the project with Scripts/Rename.sh.
To add Tempo to an existing project (if you are not starting with TempoSample), clone tempo to your project's Plugins directory:
git submodule add https://github.com/tempo-sim/Tempo.git
git submodule update --init --recursive
Run the Setup.sh (or Setup.bat on Windows) script (from the Tempo root, or from Scripts/) once. This script will:
- Modify your project's
*.Target.csfiles to use Tempo's custom toolchain, which is necessary for linking certain third party dependencies properly - Install the Tempo Unreal Engine mods, making some changes to your installed Engine in-place
- Download third party dependencies
- Add git hooks to keep engine mods and third party dependencies up to date automatically as you check out different Tempo commits
Warning
Setup.sh accepts a -skip-hooks flag which suppresses installing the post-checkout and post-merge git hooks. This is intended only for developers actively modifying Tempo itself. If you are simply using Tempo as a dependency in your project, do not use this flag. See Installation.
Use the included Scripts/Build.sh and Scripts/Run.sh (or their .bat counterparts on Windows) to build your project and open it in Unreal Editor.
With your project open in Unreal Editor, activate the Tempo virtual environment (source ./TempoEnv/bin/activate on Linux & Mac, or source ./TempoEnv/Scripts/activate on Windows) and start a Python interpreter:
import tempo_sim.tempo_core_editor as tce
import tempo_sim.tempo_world as tw
tce.play_in_editor() # Simulation should begin
tw.spawn_actor(actor_type="BP_SensorRig") # A tripod with a TempoCamera on top appears
tw.set_float_property(actor="BP_SensorRig", component="TempoCamera",
property="FOVAngle", value=60.0)Note
You don't have to install any Python package or dependencies to use Tempo. The build step automatically generated the tempo_sim Python package and virtual environment.
The full Hello World walkthrough adds streaming sensor images and stepping deterministic time.
Use the included Scripts/Package.sh (or Package.bat on Windows) to package your project into a standalone binary, which you can then run from the Packaged folder. See Packaging.
Building your project also generates client packages so you — or your users — can drive your Tempo server from outside Unreal: a Python package always, and a Rust crate when you opt in with TEMPO_GEN_RUST_API. Tempo's own services ship in the tempo-sim package/crate; your project's services, if you define any, go in a separate project package/crate that builds on top of it.
You can publish these to PyPI / crates.io to share them, or — for a pure client project with no custom services — consume the pre-built tempo-sim straight from PyPI / crates.io without building at all. See Client APIs for the full workflow.
If you would like to set up a GitHub actions pipeline to build, package, run, and/or release your Tempo project, check out the build_and_package reusable workflow in .github/workflows. TempoSample's tempo_sample_build_and_package workflow is a good reference.
For larger projects, you can cut ~10–15 minutes per run by pulling a pre-modded Unreal image instead of applying engine mods in-workflow. See Continuous Integration.
Something not working as expected? Are we missing a key feature you need? Feel free to send us an issue.
Want to contribute to Tempo? We'll be happy to review your PR.
Improving the documentation counts — it lives in docs/ in this repository. See Contributing to these docs for how to build the site locally.