Skip to content

Platforms and GPU Tiers#

Linux with an NVIDIA GPU is the tested platform of ACRES. The game selects one of two render tiers from the memory of the GPU, and the sensors use a pinned sensor profile.

Render tiers: the dedicated GPU memory selects the low tier or the high tier, each tier sets the main view, and a recording camera or LiDAR pins the render state to a sensor profile, which the datasets name in the label sensor_profile. TIER SELECTION AT THE START OF A SESSION GPU memory dedicated memory from the RHI, in MiB Tier selection 11 776 MiB or more: high tier less than 11 776 MiB: low tier Option -RenderTier=low|high replaces the selection low high Low tier render state when no sensor records main view at 60 % resolution, TSR to the output size anti-aliasing, shadow, post-process, effects: level 2 global illumination and reflection: level 1 surface cache 2048, shadow pool 2048 pages Nanite 4 pixels for each edge, mesh LOD scale 2 cloud shadow map 128, leaf masks to 60 m High tier render state when no sensor records main view at 100 % resolution, TSR anti-aliasing all scalability groups: level 3 full Lumen global illumination and reflections surface cache 8192, shadow pool 4096 pages Nanite 1 pixel for each edge, mesh LOD scale 1 cloud shadow map 2048, authored leaf masks while a camera or a LiDAR records while a camera or a LiDAR records Sensor profile reduced-6gb the calibrated list with: surface cache 2048, texture pool 2048 MiB, shadow pool 2048 pages, radiance cache 16 texels for each probe also on the high tier with -SensorRenderProfile=reduced Sensor profile calibrated the render state of the Polaris camera and LiDAR validation, the same list as the high tier also on the low tier with -SensorRenderProfile=calibrated Label sensor_profile in episode.json and in the episode log polaris-calibrated · polaris-reduced-6gb · tractor-default · tractor-default-reduced-6gb · custom
The GPU memory selects the render tier. A recording camera or LiDAR pins the render state to a sensor profile. Open the diagram

Supported Platforms#

Platform Graphics Interface Status
Linux Vulkan, shader model 6 Packaged and tested. All components run: the game, ACRES Core, the ROS 2 workspace and the learning stack.
Windows DirectX 12, shader model 6 Built and packaged one time, at commit 1e193ce. The test was a drive without sensors. No test of the other components exists.
macOS Metal, shader model 6 Configured in Acres/Config/DefaultEngine.ini. Not built from this repository.

The file Acres/Config/DefaultEngine.ini sets the graphics interface of each platform.

Component Platform Limit
The game Unreal Engine 5.8 on the three platforms of the table above.
CAN transport of the vehicle bridge Linux only: SocketCAN and CAN frames in UDP.
Publish time of the sensor stream CLOCK_MONOTONIC on Linux. Other platforms use the timer of the engine.
ACRES Core Built and tested on Linux.
ROS 2 workspace ROS 2 Humble in a conda environment on Linux.
Benchmarks Tools/Performance/benchmark_linux.py and Tools/Performance/benchmark_windows.ps1.

Note

Commit 1e193ce records a Windows build, cook and package. The current release checks use Linux.

Hardware Requirements#

Item Requirement
Engine Unreal Engine 5.8. Linux needs a source build with its clang toolchain.
GPU Hardware ray tracing with inline ray queries for the full sensor model. The low tier is for GPUs with 6 GB to 11 GB of memory.
GPU memory for the high tier 11 776 MiB or more. This is a GPU with 12 GB.
Disk Approximately 20 GB for the first build. The assets in Git LFS use approximately 2.7 GB.
Windows Visual Studio 2022 with the C++ game workload and a Windows SDK.
macOS Apple Silicon and the Xcode version of Unreal Engine 5.8.

Without hardware ray tracing, the LiDAR uses its CPU path and the lighting uses software Lumen. Refer to CPU LiDAR Path.

The development computer of the project has these parts. All measurements on this page come from it, unless the text gives a different source.

Part Value
GPU NVIDIA GeForce RTX 5060 Ti with 16 311 MiB
CPU AMD Ryzen 7 9700X, 8 cores and 16 threads
Memory 92 GiB
Operating system Fedora Linux 43

Render Tiers#

Source: Acres/Source/Acres/AcresRenderTier.cpp.

A render tier is the quality level of the main view. The game selects it one time at the start of a session.

  1. The game reads the dedicated video memory from the graphics interface, in MiB.
  2. If the memory is 11 776 MiB (11.5 GiB) or more, the tier is high. If not, the tier is low.
  3. The option -RenderTier=low or -RenderTier=high replaces the selection. -RenderTier=auto keeps it.
  4. The menu setting Render Quality in the tab Additional adds the same option.

The log shows the result.

ACRES_RENDER_TIER tier=high vram_mb=16311 source=auto screen_percentage=100 pinned=0 sensor_profile=calibrated

The threshold comes from a measurement: the high tier with the sensors of the Polaris uses 10.6 GB of GPU memory at its peak.

Settings of Each Tier#

The game writes these console variables in code. They have priority over the configuration files. A console command or the option -ExecCmds can replace a value.

Setting Low Tier High Tier
Main view resolution (r.ScreenPercentage) 60 %, then temporal super-resolution to the output size 100 %
sg.ViewDistanceQuality, sg.TextureQuality, sg.FoliageQuality, sg.ShadingQuality 3 3
sg.AntiAliasingQuality, sg.ShadowQuality, sg.PostProcessQuality, sg.EffectsQuality 2 3
sg.GlobalIlluminationQuality, sg.ReflectionQuality 1 3
r.LumenScene.SurfaceCache.AtlasSize 2048 8192
r.Lumen.ScreenProbeGather.RadianceCache.ProbeResolution 32 32
r.Streaming.PoolSize (MiB) 2048 3072
r.Nanite.MaxPixelsPerEdge 4 1
r.StaticMeshLODDistanceScale 2 1
foliage.LODDistanceScale 0.5 1
r.Shadow.Virtual.ResolutionLodBiasDirectional 3.5 0.5
r.Shadow.Virtual.MaxPhysicalPages 2048 4096
r.Shadow.Virtual.NonNanite.IncludeInCoarsePages 0 1
r.Shadow.Virtual.SMRT.RayCountDirectional 4 8
r.VolumetricCloud.ShadowMap.MaxResolution 128 2048
r.VolumetricCloud.ShadowMap.RaySampleMaxCount 16 128
r.TSR.ShadingRejection.Flickering.Period 3 2
acres.FoliageWindDistance (cm) 3000 3000
acres.FoliageMaskDistance (cm) 6000 0 (the authored masks)

acres.FoliageWindDistance is the distance to which the foliage moves in the wind. acres.FoliageMaskDistance is the distance to which crops and ground cover use their leaf masks. Tree crowns always keep their masks.

Sensor Profiles#

The image of the camera and the hits of the GPU LiDAR change with the global render state. The scalability groups, the surface cache, the shadow maps and the mesh detail all have an effect. A dataset must not change with the tier of the computer that recorded it.

While the camera or the LiDAR of a vehicle records, the sensor recorder thus pins the render state to a sensor profile. Only the resolution of the main view stays with the tier. Scene captures do not use it. When the last recorder stops, the render state of the tier comes back.

Sensor Profile Tier Contents
calibrated High The render state of the Polaris camera and LiDAR validation. It is the same list as the high tier.
reduced-6gb Low The calibrated list with four changes, for a GPU with 6 GB.
Setting calibrated reduced-6gb
r.LumenScene.SurfaceCache.AtlasSize 8192 2048
r.Lumen.ScreenProbeGather.RadianceCache.ProbeResolution 32 16
r.Streaming.PoolSize (MiB) 3072 2048
r.Shadow.Virtual.MaxPhysicalPages 4096 2048

The option -SensorRenderProfile=calibrated selects the calibrated profile on the low tier. Use it when the GPU has sufficient memory. The option -SensorRenderProfile=reduced selects the reduced profile on the high tier.

The comments of AcresRenderTier.cpp give these measurements.

  • The calibrated profile animates the foliage only to 30 m. This change keeps the camera image in the spread between two runs and changes less than 0.6 % of the LiDAR beams.
  • The reduced profile has a peak of 5.7 GB of GPU memory with the sensors of the Polaris.

The Label sensor_profile#

Each dataset names the profile that made it. FAcresSensorRecorder::SensorProfile makes the label.

Label Condition
custom A camera or LiDAR setting is different from the shipped files, or a pinned console variable has a different value.
<profile>-reduced-6gb The sensor profile is reduced-6gb.
<profile>-calibrated The sensor profile is calibrated and the sensor configuration has the key profile_validated with the value true.
<profile> The sensor profile is calibrated and profile_validated is false.

<profile> is the key profile of the sensor configuration: tractor-default for sensors.json and polaris for sensors_polaris.json. Only the Polaris configuration has the value true. The labels of the shipped configurations are thus polaris-calibrated, polaris-reduced-6gb, tractor-default, tractor-default-reduced-6gb and custom.

File Keys
episode.json of the session log sensor_profile, and sensor_profile_detail with the tier, the GPU memory, the changed settings and each pinned variable
Metadata of the episode log render_tier, sensor_render_profile and sensor_profile (one label for each agent)

The file formats are in Session Log and Episode Log.

CPU LiDAR Path#

The GPU path of the LiDAR needs hardware ray tracing with inline ray queries. When the graphics interface does not have them, the sensor recorder uses the CPU path: collision geometry and proxy shapes for crops and tree crowns. The option -SensorCpuLidar selects the CPU path on all computers. If a GPU scan gives no result in 3 s, the recorder also keeps the CPU result for that scan.

The log line ACRES_SENSOR_START shows gpu_lidar=1 or gpu_lidar=0. Each row of lidar.jsonl has the key mode. LiDAR gives the two paths.

Measured Frame Rates#

Tools/Performance/benchmark_linux.py runs the packaged game at 1920 x 1080 without a window. It measures the frame time for 15 s after a start phase of 15 s, the physics rate and the peak of the GPU memory.

python Tools/Performance/benchmark_linux.py --name low-polaris-sensors --vehicle polaris --sensors --field-loop --render-tier low

CAUTION

Stop all other instances of the game before a benchmark. The script starts its own instance.

The table shows the results of 30 September 2026 on the development computer. The source is the file summary.json of each run in Acres/Saved/Performance. That folder is not in the repository.

Tier Vehicle Sensors Frame Rate Frame Time (95 %) Physics Rate Peak GPU Memory
Low Maxxum Off 94.5 Hz 14.6 ms 120.0 Hz 4707 MiB
Low Polaris Off 82.4 Hz 15.3 ms 120.0 Hz 4610 MiB
Low Polaris On, reduced-6gb 34.7 Hz 63.0 ms 120.2 Hz 5708 MiB
Low Polaris On, calibrated (option) 29.5 Hz 75.2 ms 120.0 Hz 10 455 MiB
High Maxxum Off 38.7 Hz 28.3 ms 120.0 Hz 8215 MiB
High Polaris Off 35.5 Hz 30.8 ms 120.0 Hz 8237 MiB
High Polaris On, calibrated 21.0 Hz 63.6 ms 120.0 Hz 10 603 MiB

The Maxxum follows the drive script Tools/Performance/field-loop.json. The Polaris drives the circle of the benchmark. The sensors of the Polaris are the camera at 896 x 512 and the LiDAR with 1800 x 32 beams, each at 10 Hz. The physics keeps 120 Hz in all runs.

One measurement comes from a different computer. The message of commit 1e193ce records the Windows package on a GPU with 6 GB. The Maxxum without sensors gave 46.9 Hz and a physics rate of 120.06 Hz at 1920 x 1080.

A benchmark of the reduced profile on a real GPU with 6 GB is not available.

Speed of ACRES Core#

ACRES Core has no renderer. Core/Scripts/bench.py measures its speed with the Polaris on the ACRE tile.

PYTHONPATH=Core/Build python Core/Scripts/bench.py --envs 64 --seconds 20

Expected Result

A run on 2 October 2026 on the development computer gave these lines. A different process used some of the CPU during the run.

farm_1_thread                   547 x real time (65,605 physics steps/s)
farm_all_threads               3000 x real time (360,025 physics steps/s)
no_farm_1_thread                634 x real time (76,088 physics steps/s)
no_farm_all_threads            3949 x real time (473,907 physics steps/s)
lidar helios  1 thread:      91.5 scans/s, 5,269,936 rays/s
lidar planar  1 thread:   15048.0 scans/s, 5,417,297 rays/s
lidar helios all threads: 687.0 scans/s, 39,570,322 rays/s
Line Meaning
farm_1_thread 64 environments with the soil and crop updates, on one thread. The value is the simulation time in seconds for each second of run time.
farm_all_threads The same with all threads.
no_farm_* Without the soil and crop updates.
lidar helios Scans of the Polaris LiDAR with 57 600 beams.
lidar planar Scans of the planar pattern with 360 beams.

Install

Install the tools for the build.

Camera

The camera model that the sensor profile renders.

LiDAR

The GPU path and the CPU path of the LiDAR.

Command-Line Options

All options of the game.