There are few details to take into account at the time of configuring a simulation. This page covers the more important ones.

---

Graphics quality

Vulkan vs OpenGL

Vulkan is the default graphics API used by Unreal Engine, and CARLA. It consumes more memory, but performs faster and makes for a better frame rate. However, it is quite experimental, especially in Linux, and it may lead to some issues.

There is the option to change to OpenGL. Use a flag when running CARLA.

cd carla && ./CarlaUE4.sh -opengl

When working with the build version of CARLA, Unreal Engine needs to be set to use OpenGL. Here is a documentation regarding different command line options for Unreal Engine.

Quality levels

CARLA also allows for two different graphic quality levels. Epic, the default is the most detailed. Low disables all post-processing and shadows, the drawing distance is set to 50m instead of infinite.

The simulation runs significantly faster in Low mode. This is not only used when there are technical limitations or precision is nonessential. It may be useful to train agents under conditions with simpler data or regarding only close elements.

The images below compare both modes. The flag used is the same for Windows and Linux. There is no equivalent option when working with the build, but the UE editor has its own quality settings. Go to Settings/Engine Scalability Settings for a greater customization of the desired quality.

./CarlaUE4.sh -quality-level=Epic	./CarlaUE4.sh -quality-level=Low

---

No-rendering mode

This mode disables rendering. Unreal Engine will skip everything regarding graphics. This mode prevents rendering overheads. It facilitates a lot traffic simulation and road behaviours at very high frequencies. To enable or disable no-rendering mode, change the world settings, or use the provided script in /PythonAPI/util/config.py.

Here is an example on how to enable and then disable it via script.

settings = world.get_settings()
settings.no_rendering_mode = True
world.apply_settings(settings)
...
settings.no_rendering_mode = False
world.apply_settings(settings)

And here is an example on how to disable and then enable rendering using the config.py.

cd PythonAPI/util && ./config.py --no-rendering

cd PythonAPI/util && ./config.py --rendering

The script PythonAPI/examples/no_rendering_mode.py will enable no-rendering mode, and use Pygame to create an aerial view using simple graphics.

cd PythonAPI/examples && ./no_rendering_mode.py

---

Off-screen mode

Unreal Engine needs for a screen in order to run. However, there is a workaround for remote servers with no display, or desktop users with a GPU not connected to any screen.

The simulator launches but there is no available window. It runs in the same way as normal mode. This mode tricks Unreal Engine into running in a “fake screen”.

Off-screen vs no-rendering

It is important to understand the disctintion them to prevent misunderstandings.

• In no-rendering, Unreal Engine does not render anything. Graphics are not computed.
• In off-screen, Unreal Engine is working as usual, rendering is computed. Simply, there is no display available. GPU sensors return data when off-screen, and no-rendering mode can be enabled at will.

Setting off-screen mode

This is only possible in Linux while using OpenGL. Unreal Engine crushes when Vulkan is running off-screen, and this issue is yet to be fixed by Epic.

To force the simulator run off-screen set the environment variable DISPLAY to empty and run CARLA using OpenGL.

# Linux
DISPLAY= ./CarlaUE4.sh -opengl

---

Running off-screen using a preferred GPU

Docker: recommended approach

The best way to run a headless CARLA and select the GPU is to run CARLA in a Docker.

This section contains an alternative tutorial, but this method is deprecated and performance is much worse. It is here only for those who Docker is not an option.

Deprecated: emulate the virtual display

This tutorial only works in Linux and makes it possible for a remote server using several graphical cards to use CARLA on all GPUs. This is also translatable to a desktop user trying to use CARLA with a GPU that is not plugged to any screen. To achieve that, the steps can be summarized as:

1. Configure the server to have Nvidia working with no display.
2. Use VNC and VGL to simulate a display connected to any GPU.
3. Run CARLA.

This tutorial was tested in Ubuntu 16.04 using NVIDIA 384.11 drivers.

sudo apt-get install freeglut3-dev mesa-utils

• VGL: redirects 3D rendering commands from Unix and Linux OpenGL to the hardware in a dedicated server.

• TurboVNC 2.11: graphical desktop-sharing system to connect remotely to the server.

• Extra packages: necessary to make Unreal work.

sudo apt install x11-xserver-utils libxrandr-dev

Generate a X compatible with the Nvdia installed and able to run without display:

sudo nvidia-xconfig -a --use-display-device=None --virtual=1280x1024

• Emulate the virtual display

Run a Xorg. Here number 7 is used, but it could be labeled with any free number:

sudo nohup Xorg :7 &

Run an auxiliary remote VNC-Xserver. This will create a virtual display “8”:

/opt/TurboVNC/bin/vncserver :8

If everything is working fine the following command will run glxinfo on Xserver 7 selecting the GPU labeled as 0:

DISPLAY=:8 vglrun -d :7.0 glxinfo

To disable the need of sudo when creating the nohup Xorg go to /etc/X11/Xwrapper.config and change allowed_users=console to allowed_users=anybody.

It may be needed to stop all Xorg servers before running nohup Xorg. The command for that could change depending on your system. Generally for Ubuntu 16.04 use:

sudo service lightdm stop

To run CARLA on a certain <gpu_number> in a certain $CARLA_PATH use the following command:

DISPLAY=:8 vglrun -d :7.<gpu_number> $CARLA_PATH/CarlaUE4/Binaries/Linux/CarlaUE4

---

That is all there is to know about the different rendering options in CARLA.

Open CARLA and mess around for a while. If there are any doubts, feel free to post these in the forum.