CARLA Simulator on Unreal Engine 5.5: What the ue5-dev Branch Actually Requires

The problem CARLA solves for autonomous driving research

Testing a self-driving stack on real roads is slow, expensive and unsafe. CARLA exists to move that work into simulation. The README describes it as an open-source simulator for autonomous driving research, developed from the ground up to support development, training and validation of autonomous driving systems. The important part is what ships alongside the code: open digital assets including urban layouts, buildings and vehicles, created for this purpose and usable freely. That matters because a simulator without maps and traffic participants is only an engine. CARLA also supports flexible specification of sensor suites and environmental conditions, which is what lets a researcher change the sensor configuration or the weather without changing the vehicle code. The audience is narrow by design. This is a research platform, not a driving game and not a production validation tool. If you are training imitation learning or reinforcement learning policies, or you need to reproduce a scenario under controlled conditions, the project is aimed at you. The ecosystem listed in the README reinforces that: a leaderboard for validating autonomous driving stacks, scenario_runner for executing traffic scenarios, a ROS bridge, and separate repositories for conditional imitation learning and reinforcement learning.

How CARLA is put together: Unreal, LibCarla and the Python API

The repository layout tells you most of the architecture before you read a line of documentation. The Unreal directory holds the Unreal Engine project, and on this branch that engine is version 5.5. LibCarla is the C++ client library, and PythonAPI is the Python binding that most users actually touch. The README points to a Python API reference and a blueprint library in the documentation, which confirms that the intended workflow is to script the simulation from Python while the C++ layer handles transport and the engine renders the world. The build system is CMake, with CMakeLists.txt and CMakePresets.json at the top level, and requirements.txt lists the Python-side dependencies: psutil, requests, scikit-build-core, wheel, numpy>=1.24.4, setuptools>=47.3.1, build and pygame. There is also a Ros2Native directory, which is notable because it puts the ROS 2 interface inside the main repository rather than only in the separate ros-bridge project. Examples/CppClient and Examples/QtClient show that a C++ client is a supported path, not just Python. The data flow is conventional for a simulator: the server runs the Unreal world, clients connect over the network and request sensors, vehicles and map data. That separation is why the Python API can drive a simulation running on a different machine, and it is also why network configuration becomes a real concern once you scale past a single host.

Installing CARLA on Linux and Windows

There is no pip install for the simulator itself. The README directs you to clone the repository from GitHub on the ue5-dev branch, and the clone command names the target directory CarlaUE5.

git clone -b ue5-dev https://github.com/carla-simulator/carla.git CarlaUE5

Before the build can work you need access to the CARLA fork of Unreal Engine 5.5. The README states that you must link your GitHub account to Epic Games by following the guide on the Unreal Engine site, and then use your git credentials to authorise the download of the Unreal Engine 5.5 repository. This is the step people miss. Without the account link, the setup script cannot fetch the engine and the build stops.

On Linux, the interactive path runs the setup script from the CARLA root directory. It will prompt for your sudo password to install prerequisites, then for your GitHub credentials to authorise the Unreal Engine download.

cd CarlaUE5
./CarlaSetup.sh --interactive

The script installs Python 3 via apt by default. If you want it to target an existing Python installation instead, the README documents the --python-root argument, and suggests using whereis python3 in your chosen environment and stripping the /python3 suffix from the path.

For unattended Linux builds, your git credentials go into an environment variable. The README shows adding it to .bashrc as GIT_LOCAL_CREDENTIALS in the form username@github_token, then running the setup script with sudo -E so the variable is preserved.

export GIT_LOCAL_CREDENTIALS=username@github_token
cd CarlaUE5
sudo -E ./CarlaSetup.sh

The README notes this downloads and installs Unreal Engine 5.5, installs prerequisites and builds CARLA, and that it may take some time and use a significant amount of disk space. It does not quantify either. On Windows the entry point is a batch script, and unattended mode is currently unavailable there, so you will be prompted for GitHub credentials or administrator privileges.

cd CarlaUE5
CarlaSetup.bat

Once setup completes, subsequent builds use commands run from the CARLA root directory. The README lists a First steps tutorial in the documentation as the place to go after the build, which is where a new user should look for the first simulation run rather than guessing at API calls.

The hardware and operating system limits are hard limits

The recommended system section is unusually specific, and it is the first thing to check before you spend an afternoon on a build. CARLA asks for an Intel i7 or i9 from the 9th to 11th generation, or an AMD Ryzen 7 or Ryzen 9, with more than 32 GB of RAM. On the GPU side it lists NVIDIA RTX 3070, 3080 or 3090, RTX 4090, or RTX 5090, or better, with 16 GB or more of VRAM. That is a workstation-class machine. A laptop with integrated graphics will not run this, and a 8 GB VRAM card is below the stated floor.

The operating system constraint is stricter still. The README states plainly that you must use either Ubuntu 22.04 or 24.04, or Windows 11, and that the Unreal Engine 5.5 version of CARLA will not work on Ubuntu 20.04 or Windows 10 or lower. This is not a soft recommendation. If you are on an older LTS release because the rest of your toolchain depends on it, this branch is the wrong tool and you should be looking at the UE 4.26 version in ue4-dev instead. The README itself warns that the two branches exist in parallel and that there are significant differences between them, and it asks you to be sure this version is suitable for your needs. That warning cuts both ways: choosing ue5-dev for the newer engine may cost you compatibility with the surrounding ecosystem, several parts of which are documented against CARLA 0.9.X.

Where CARLA is the wrong choice, and what to use instead

CARLA is a heavyweight. The build pulls in a full Unreal Engine installation, which the README says requires linking accounts and may consume significant disk space, and the runtime needs a discrete NVIDIA GPU. If your goal is to test a planning algorithm against a few hundred scripted scenarios, you are paying a large setup cost for rendering fidelity you may not need. The same applies if you want to run thousands of parallel rollouts on CPU-only cluster nodes.

A real alternative in that space is the SUMO traffic simulation suite, which models traffic flow and road networks microscopically without rendering a 3D world. The difference in approach is the point: SUMO simulates vehicles as entities on a road graph, so it runs on ordinary hardware and scales to large networks, while CARLA renders a full urban environment with sensors and physics and therefore needs a GPU. If your research question is about traffic signal timing or network throughput, SUMO answers it more cheaply. If your question is about what a camera or lidar sees, or how a control policy behaves in a rendered scene, CARLA is the one that can answer it.

There is also a middle path inside the project's own ecosystem. The README lists scenario_runner as an engine to execute traffic scenarios in CARLA 0.9.X, which suggests that for reproducible scenario testing you may not need to write your own client at all. Note the version qualifier: those companion repositories are described against 0.9.X, while this branch targets UE 5.5, so version alignment between CARLA and its surrounding tools deserves checking before you build a pipeline on top.

Maintenance, releases and the MIT licence

The repository is not archived and the last push was on 2026-09-10, so the branch is receiving changes. The release history is uneven, which is worth knowing when you plan an upgrade. Version 0.9.16 was released on 2025-09-16, 0.10.0 on 2024-12-19, and 0.9.15 on 2023-11-11. There is a gap of roughly two years between 0.9.15 and 0.9.16, and 0.10.0 sits between them in time but not in the version sequence. Anyone pinning CARLA in a research pipeline should treat the release cadence as unpredictable and plan to build from a specific commit rather than waiting for the next tag.

The code is MIT licensed. That is permissive: it allows commercial and academic use, modification and redistribution, subject to the licence terms. Two qualifications belong here rather than in a lawyer's office. First, the repository contains a LICENSE file at the top level, and that file is what governs, not the one-line summary in a repository listing. Second, the build depends on Unreal Engine, which is distributed under Epic Games' own terms and is not covered by the MIT licence on this repository. Linking your GitHub account to Epic Games is the mechanism the README describes for getting access, and the conditions attached to that access are Epic's, not CARLA's. If your organisation has rules about which third-party engines may be used in funded work, that is the question to resolve before the build, not after.

What to check before you commit to ue5-dev

Three checks will save most of the wasted effort. Confirm your operating system is Ubuntu 22.04 or 24.04, or Windows 11, because nothing older is supported on this branch. Confirm your GPU has at least 16 GB of VRAM, since the README sets that floor explicitly and lists RTX 3070 and above. Confirm your GitHub account is already linked to Epic Games, because the setup script will ask for credentials to download the Unreal Engine repository and there is no offline path documented.

Then decide which branch you actually want. The README presents ue5-dev and ue4-dev as parallel versions with significant differences, and several ecosystem tools it lists, including scenario_runner and the ROS bridge, are described against CARLA 0.9.X. A research group whose existing code targets 0.9.16 may find that moving to the UE 5.5 branch means revalidating more than the simulator. The README does not document a migration path between the branches, so that comparison is on you. Once the build finishes, start with the First steps tutorial in the documentation rather than the Python API reference; the tutorial establishes the server and client relationship that everything else assumes.

Editorial conclusion

Adopt CARLA if you are doing autonomous driving research and can meet the platform requirements: Ubuntu 22.04 or 24.04, or Windows 11, with an RTX-class GPU and 16 GB or more of VRAM. Do not adopt it if you are on Ubuntu 20.04 or Windows 10, because the README states the UE 5.5 version will not work there, and do not adopt it if you need a lightweight simulator that installs from a package manager. Before committing, verify three things: that your GitHub account is linked to Epic Games so you can access the Unreal Engine fork, that you have the disk space the setup script will consume, and that the ue5-dev branch is the right version for your project, since the README warns there are significant differences from the UE 4.26 version in ue4-dev.

Frequently asked questions

Official sources

1. carla-simulator/carla on GitHub
2. License: MIT
3. Project website
4. README
5. Releases