10. Performance and quality

This chapter gives you the knobs and what each one trades. Plugin costs, at the end, states what the plugin itself costs in milliseconds and megabytes, part by part, with the machine and conditions of each figure.

Cost breakdown

Cost	Driver	Main settings
Memory	Area, post spacing, residency radius, sculpted tiles	Cell size, Residency Radius, sculpt paging
Draw time	Near chunks, far field, shadows, grass	Render tier, far detail, Far Field Distance, shadows, RVT
Streaming	Tiles loaded around viewers	Residency Radius, Max Concurrent Loads
Edit time	Brush size, strokes per second, collision swaps	Sculpt Refresh Hz, sculpt limits

Project settings

Project Settings > Plugins > Orrery Terrain holds the project-wide defaults.

Setting	Default	Meaning
Default Material	empty	Drawn by every terrain whose actor names no Material. Empty draws the plugin’s default material. It is cooked with your project. On the heightfield tier it must be a terrain wrapper (see Materials and layers); another material draws the default material there, with a warning, and draws itself on the mesh tier.
Quality Profile	Scalability	The terrain quality profile. See Quality profiles.
Residency Radius (m)	2000	The default of each terrain’s Residency Radius.
Sculpt Undo Strokes	32	The default of each terrain’s Sculpt Undo Strokes.
Register Ground Provider	on	The default of each terrain’s Register Ground Provider: other plugins can query the ground through it.
Wrapper Folder	empty (/Game/Terrain/TerrainWrappers)	Editor only: where the editor writes the terrain wrappers of your materials when the source asset names no folder.

The last three are defaults, not overrides. A terrain actor whose value you never changed follows the project setting, also when you change the project setting later. A value you set on the actor stays.

Quality profiles

A quality profile sets the terrain’s far detail, its surface detail near the camera, its grass density and how much of it is in the hardware ray-tracing scene in one go. There are five, one per engine scalability level: Low, Medium, High, Epic and Cinematic. So the terrain moves with the engine’s own scalability settings, level for level.

Profile	sg.LandscapeQuality	Far ring	Finer far normals	Far ring GPU memory	Sub-post levels	Sub-post quads	Parallax	Grass density	Grass cull distance	Ray-tracing radius	Ray-tracing chunks
Low	0	Balanced	none	about 12.5 MiB	0	192	off	0.5	0.75	250 m	32 (about 2.6 MB)
Medium	1	Balanced	level 2 to 4 km	about 21.5 MiB	0	192	off	0.5	0.75	250 m	32 (about 2.6 MB)
High	2	Balanced	level 2 to 8 km	about 46.5 MiB	0	192	off	1	1	400 m	64 (about 5.1 MB)
Epic	3	Balanced	level 2 to 8 km	about 46.5 MiB	0	192	off	1	1	400 m	64 (about 5.1 MB)
Cinematic	4	High	level 1 to 8 km	about 189 MiB	5	256	on	1	1	800 m	192 (about 15 MB)

• Far ring is the far detail preset (see Far detail). Finer far normals add a normal-only level on top of it: the distant ground is lit from finer slopes without drawing more triangles. Level 2 is every fourth post (4 m at the default 1 m cell), level 1 every second post. Low is the floor for an older GPU or a laptop on battery; each level up keeps more detail in the distance. The far ring and its finer far normals belong to the profile itself, not to a console variable, so they apply in every build, Shipping included.
• Sub-post levels add displaced relief near the camera (see Surface detail near the camera). Only Cinematic draws them: they show at a walking or cab view, on displaced layers such as cobblestones and rock, and they cost the most.
• No profile changes the near LOD: r.OrreryTerrain.LodBias keeps its default, 0, at every level. High and Epic are the same today.

The profile in force comes from, in order:

1. r.OrreryTerrain.Quality when it is 0 to 4: 0 Low, 1 Medium, 2 High, 3 Epic, 4 Cinematic, the same numbers as sg.LandscapeQuality. Your options menu sets it, from Blueprint with Execute Console Command or from C++ with OrreryTerrainQuality::Set.
2. Otherwise the project’s Quality Profile. Scalability (the default) follows the engine’s landscape quality, sg.LandscapeQuality, one to one, so the engine’s scalability settings, and a game’s scalability menu, move the terrain with them. The engine’s auto-detect picks Low to Epic (Epic on a recent laptop GPU); Cinematic is only ever set by hand.

Low, Medium, High, Epic and Cinematic fix the profile whatever the scalability. Manual applies none: every variable keeps its default or ini value, and each terrain draws its own Far Detail, which is Balanced, the ring of the Low profile, until you change it.

A profile writes its variables at the scalability’s priority, or at that of r.OrreryTerrain.Quality when you set it at a stronger one, so the profile your game sets always wins over the project’s. A variable you set at a stronger priority (in DefaultEngine.ini, a device profile or the console) keeps your value. So you can take a profile and change one thing. The far ring and its finer far normals are not variables: no ini value changes them, only the profile or a terrain’s own Far Detail (below).

A terrain whose Render block has Override Far Detail on keeps its own Far Detail preset under every profile; the profile’s finer far normals still apply to it.

Projects from earlier versions. Earlier versions had three profiles: Low, Balanced and High. A project that saved one keeps what it drew: the setting is now stored under a new name, and the old one reads as Low to Low, Balanced to High and High to Cinematic (Scalability and Manual are unchanged). Save the project settings once to store the new name. A Blueprint value of the old Balanced reads as High. A number your game saved for r.OrreryTerrain.Quality is read in the new scale: an old 1 (Balanced) is now Medium and an old 2 (High) is now High, so map them to 2 and 4.

Memory: choose the cell size first

The base cell is the distance between posts of the natural ground: 0.25 to 16 m, default 1 m. Memory scales with the number of posts, so halving the cell size quadruples it.

The New tool shows an estimate before you accept: baked store size on disk, and the memory kept resident for the always-loaded coarse copy. The tool sizes it at about 0.55 MB per square kilometre on disk and 6 KB per square kilometre resident at default settings. A terrain is limited to 2048 tiles along one edge.

For a game that sculpts a lot, the terrain keeps edited tiles in a compact form and can page them to a session file when memory is tight. This is on by default. OrreryTerrain.Sculpt.Paging 0 keeps everything in memory. OrreryTerrain.Sculpt.PageFileMaxMB caps the file.

Streaming settings (Settings block)

Setting	Default	Meaning
Residency Radius (m)	2000	Full-resolution ground around each viewer and invoker. Minimum 100.
Use World Partition Sources	on	Streaming sources of World Partition are viewers. Off, or without World Partition, the player cameras are.
Max Concurrent Loads	8	Tile loads in flight at once (1 to 64).
Max Bake Request Tiles	200	Base tiles past the radius the terrain may hold at once so ground near a plate or corridor can bake (0 to 4096). About 33 KB of heights each, plus paint and ground class.
Generate Navigation	on	Export chunks to the navigation system.
Collision Profile	BlockAll	Collision of every chunk.
Class Physical Materials	empty	A physical material per ground class.
Sculpt Refresh Hz	4	How often collision and render geometry are swapped during a stroke (1 to 60).
Sculpt Undo Strokes	32	Strokes the undo ring keeps (1 to 1024).
Sculpt Limits	see sculpting	Largest radius, strength and so on.

A viewer high above the ground does not need full detail below it. The terrain rounds a viewer’s reach by altitude. Beyond OrreryTerrain.Streaming.AltitudeReach (25,000 m) the far field stands in for the near ground.

If your game has no viewer for a moment, for example while a loading screen is up, the terrain holds the last viewers’ residency (OrreryTerrain.Streaming.HoldViews 1, the default) so ground does not stream out.

Render settings (Render block)

Setting	Default	Meaning
Tier	Auto	Auto picks the heightfield tier on Shader Model 5 and up, the mesh tier otherwise. Heightfield or Mesh force one.
Far Field	on	Draw the whole terrain out to the far-field distance from the always-loaded coarse copy.
Far Field Distance (m)	30000	Beyond this distance from any view, nothing is drawn. Minimum 1000.
Far Field Shadows	on	Whether the far field casts shadows.
Far Detail	Balanced	Mid-distance detail, used when Override Far Detail is on or no quality profile is in force. See below.
Lumen Heightfield	on	Join Lumen’s software tracing and the global distance field as a heightfield.
Rvt Mode	Auto	Colour virtual texture: Auto, Blend (no RVT) or Read (always RVT).
Runtime Virtual Texture	empty	Your own colour RVT. Empty uses the plugin’s.
Rvt Settle Uploads	6	Virtual-texture pages the engine may upload per frame while the RVT settles after an edit.
Shadow Invalidation Height Error (cm)	25	A LOD change that moves the surface by more than this refreshes the cached shadow pages of a chunk. Lower is cleaner, higher is cheaper.

LOD controls are on the same block: Lod0 Screen Size (0.5), Lod0 Distribution (1.25), Lod Distribution (3.0) and Lod Blend Range (0.1). Lower Lod0 Screen Size, or raise Lod0 Distribution or Lod Distribution, to keep finer detail further away; the opposite makes the terrain coarser sooner. r.OrreryTerrain.LodBias adds to every chunk’s LOD (positive is coarser).

Far detail

Value	Ring	GPU memory	Near band	Used for
Low	none	none	254 m	Soft distant summits. No profile uses it; set a terrain’s own Far Detail to Low for it.
Balanced	two levels	about 12.5 MiB	127 m	The Low to Epic profiles, and the default of a terrain’s own Far Detail.
High	three levels	about 61 MiB	64 m	The Cinematic profile. Screenshots and standalone play.

The near band is the stretch where the near terrain blends into the far one. The quality profile sets the far detail at run time, and its finer far normals on top; see Quality profiles. A change re-packs the far field and re-creates the ring, without re-creating the terrain.

Surface detail near the camera

The heightfield tier can add finer rings of geometry around the viewer, at a fraction of the post spacing, that the terrain material displaces. The Cinematic profile turns them on. Set r.OrreryTerrain.SubPost.Levels to a number of rings: 0 (default) draws none. 4 reaches 6.25 cm at 1 m posts. 5 reaches 3.125 cm. r.OrreryTerrain.SubPost.Quads sets how fine each ring is. With the default material the renderer swaps in MI_TerrainDefault_Displaced_W itself; a material of your own needs the same displacement setup.

Console variables

Type these in the console during Play. Put them in DefaultEngine.ini under [SystemSettings] to make them permanent; a value set there wins over the quality profile. These are the variables a game may set, in every build, Shipping included.

Variable	Range	Default	Effect
r.OrreryTerrain.Quality	-1 to 4	-1	The quality profile, as sg.LandscapeQuality: 0 Low, 1 Medium, 2 High, 3 Epic, 4 Cinematic. -1 the project’s Quality Profile.
r.OrreryTerrain.Draw	0, 1	1	0 hides the terrain (either tier) without destroying it.
r.OrreryTerrain.FarField	-1 to 1	-1	The heightfield tier’s far field: -1 the actor’s setting, 0 off, 1 on. A change rebuilds the tier.
r.OrreryTerrain.LodBias	any	0	Added to every chunk’s LOD; positive is coarser. No profile sets it.
r.OrreryTerrain.Rvt	-1 to 2	-1	The colour RVT: -1 the actor’s Rvt Mode, 0 blend, 1 read, 2 auto.
r.OrreryTerrain.Rvt.MaxRectsPerTick	-1, 1 and up	-1	RVT invalidations per tick at most. -1 the terrain’s setting (8).
r.OrreryTerrain.Rvt.SettleUploads	-1, 0 and up	-1	r.VT.MaxUploadsPerFrame while the RVT settles after an edit. -1 the terrain’s Rvt Settle Uploads.
r.OrreryTerrain.SubPost.Levels	0 to 5	0	Rings of surface detail near the camera. Set by the profile.
r.OrreryTerrain.SubPost.Quads	0 to 4096	192	Quads per side of each ring, at 1080 rows; it scales with the resolution. Set by the profile.
r.OrreryTerrain.SubPost.Parallax	0, 1	1	Parallax occlusion over the displaced relief, while the rings are on. Set by the profile.
r.OrreryTerrain.SubPost.ParallaxShadow	0, 1	0	1 adds the relief’s self-shadow towards the sun (about +0.5 ms with the Cinematic profile at 1080p).
r.OrreryTerrain.Grass	0, 1	1	1 grows grass, 0 releases all grass.
r.OrreryTerrain.Grass.DensityScale	0 to 1	1	Multiplies all grass density, with grass.densityScale. Set by the profile.
r.OrreryTerrain.Grass.CullDistanceScale	0 and up	1	Scales every grass cull distance, with grass.CullDistanceScale. A change rebuilds the grass. Set by the profile.
r.OrreryTerrain.Grass.MaxTasks	1 to 64	4	Grass build tasks in flight at most.
r.OrreryTerrain.Grass.AcceptBudgetMs	0 and up	0.3	Game-thread time per tick for showing finished grass, milliseconds.
r.OrreryTerrain.Grass.DuringStroke	0, 1	1	1 refreshes grass as an edit’s ground lands: a brush stroke reaches it four times a second, a road or other spline edit every tick. 0 waits until the stroke ends. The project settings Grass Edit Budget Ms (4) and Grass Edit Chunks (8) bound that refresh; see Grass.
r.OrreryTerrain.RayTracing	0, 1	1	With hardware ray tracing on, 1 puts the near terrain in the ray-tracing scene (Lumen, ray-traced shadows, the path tracer). 0 keeps the terrain out of it. See Limits.
r.OrreryTerrain.RayTracing.Radius	metres	400	Distance from a view within which near chunks are in the ray-tracing scene. A chunk stays in out to 1.15 times this distance. Set by the quality profile.
r.OrreryTerrain.RayTracing.MaxChunks	0 and up	64	Chunks in the ray-tracing scene at once, nearest first. Each costs about 72 KB of GPU memory at level 2, so 64 is a ceiling of about 4.6 MB. Set by the quality profile.
r.OrreryTerrain.RayTracing.Level	0 to 6	2	Detail of the terrain’s ray-tracing copy: every 2^level-th post. Each level finer costs about four times the memory per chunk.
r.OrreryTerrain.RayTracing.DepthBias	centimetres	0	Lowers the ray-tracing copy further. Each chunk’s copy is already lowered by its own height error at the chosen level, so ray-traced shadows do not streak the ground; raise this only if they still do.
OrreryTerrain.Streaming.HoldViews	0, 1	1	1 keeps the last viewers’ residency when a tick finds none (a loading screen), so ground does not stream out.
OrreryTerrain.Streaming.AltitudeReach	metres	25000	Distance from a view beyond which the far field stands in for its near ground.
OrreryTerrain.Sculpt.Paging	0, 1	1	1 pages sculpted tiles to a session file under memory pressure, for terrains created from then on. 0 keeps them in memory.
OrreryTerrain.Sculpt.PageFileMaxMB	0 and up	0	Caps the page file, MiB. 0 no cap.
OrreryTerrain.Sculpt.StrokeBakeWorkers	0 and up	4	Re-bake jobs in flight during a stroke. 0 no cap.
OrreryTerrain.Sculpt.BlockHoldSeconds	seconds	0	During a stroke, the least time between two full re-bakes of one stretch of ground beside a feature; the ground away from features keeps its pace. 0 re-bakes as soon as the last re-bake has finished. A stroke’s end always re-bakes in full. Raise it (0.25) when many sculptors share one machine.
OrreryTerrain.Sculpt.QueuedStepsMax	1 and up	256	Brush steps a sculpt component holds while ground loads.
OrreryTerrain.Sculpt.QueueDrainPerTick	1 and up	8	Queued steps applied per tick once their ground has landed.
OrreryTerrain.Sculpt.QueueTimeout	0 and up	30	Seconds the oldest queued step may wait for its ground. 0 waits for ever.

Every other r.OrreryTerrain.* and OrreryTerrain.* variable is for development and A/B tests (the render tier, LOD freezing, the far field’s internals, the near band, shadows). Those exist in editor and development builds only, and may change without notice. In Shipping they are absent and the terrain uses their defaults. Two of them, r.OrreryTerrain.Band.Width and r.OrreryTerrain.DebugView, are cheat variables instead.

Stats and checks

• stat OrreryTerrain and stat OrreryGrass show timings and counters in the viewport.
• Orrery.Terrain.Render.Stats logs the render chunks. Orrery.Terrain.Render.Lod.Stats logs the LOD grid. Orrery.Terrain.Render.Rvt.Stats logs the RVT mode and why it resolved so.
• The log category is LogOrreryTerrain.

Shipping notes

• Development commands (Orrery.Terrain.Render.Dev*, .Near, Orrery.Terrain.Grass.*) and the development console variables are not in Shipping builds. The public variables above are.
• Cook the plugin’s content. The terrain material wrappers are part of your content.
• Hardware ray tracing covers the near terrain, plus one coarse grid for the far field. See Limits.

Quick recipes

• Lowest cost: the Low profile (r.OrreryTerrain.Quality 0), Far Field Shadows off, Lumen Heightfield off, a larger cell size, a smaller residency radius, r.OrreryTerrain.Grass 0.
• Best looking, desktop: the Cinematic profile (r.OrreryTerrain.Quality 4), Rvt Mode Auto.
• Large flat world seen from a plane: the default residency radius with Far Field Distance raised, and the High or Epic profile (finer far normals to 8 km).

Plugin costs

This section states what the plugin itself costs. It gives no frame rate, because a frame rate would mostly measure the rest of your project and your machine: in the Epic column below, the terrain’s own drawing is 2.04 ms of a 12.78 ms graphics frame on a laptop.

Test machine and method

Unless a row says otherwise, every figure in this section comes from one setup, measured on 2026-10-31.

• Machine. Intel Core i7-12700H, 32 GB RAM, NVIDIA GeForce RTX 3060 Laptop GPU with 6 GB (driver 617.42, 115 W power limit), Windows 11.
• Build. Unreal Engine 5.8.4, the Development build of the sample project, in game mode with Shader Model 6. These are not Shipping figures.
• World. The 64 km example world at a 1 m cell size, with the plugin’s default material, a plain sky, no grass and a 3 km residency radius.
• Level. Level N sets all of Unreal’s scalability groups to N, and r.OrreryTerrain.Quality to N.
• Reading. The median of the last 800 of 2,400 frames, one run per cell, with the engine held to a steady pace (t.MaxFPS 30) so the graphics clock stays level. Graphics card times were read while another job was using the processor; a repeat of two Epic cells with nothing else running agreed within 0.08 ms. A cost over “no terrain” is the same run and view with r.OrreryTerrain.Draw 0.

Graphics card time by pass

Milliseconds of GPU time the terrain adds, by pass, at 1920 x 1080, from a camera 2 m above a meadow.

Pass	Low	Epic	Cinematic
Base pass	1.61	1.55	2.15
Depth prepass	0.50	0.49	0.59
Shadow depths	under 0.03	0.26	0.28
Shadow projection	under 0.03	0.59	0.83
Lumen and deferred lighting	not run	2.66	17.62
Lumen scene update	not run	0.14	0.14
Reflection environment	0.15	under 0.03	under 0.03
Light loop	0.08	0.12	0.14
Upscaling	-0.37	0.11	0.54
Sky	-0.06	under 0.03	-0.64
Added, all passes	2.00	6.10	22.03
Whole frame, with terrain and without	4.69 and 2.69	12.78 and 6.68	32.95 and 10.91

Only the base pass and the depth prepass are the terrain’s own drawing. The rest is what Unreal spends on any ground that fills the screen: a terrain pixel also costs in shadows and in Lumen, where the same pixels of sky cost almost nothing. So the terrain pass alone is not the total, and neither is the added total a cost you could save by swapping terrains: another ground surface would pay most of the lighting too. At Low, Unreal runs neither Lumen nor virtual shadow maps. A negative figure means a pass got cheaper with ground on screen. The rows do not add up exactly to the total: passes under 0.03 ms are left out, and the total comes from the card’s whole-frame time. Cinematic is on the high side: the card reached 87 C and dropped from 1702 to 1582 MHz in that run.

Resolution and view

Milliseconds of GPU time the terrain adds over the same view with no terrain. Most of it follows the pixels on screen.

View	Low	Epic
Meadow, 2 m up, 1920 x 1080	2.00 (base pass 1.61, prepass 0.50)	6.10 (base pass 1.55, lighting 2.66)
Meadow, 2 m up, 2560 x 1440	2.83 (base pass 2.21, prepass 0.57)	8.18 (base pass 2.11, lighting 3.90)
Valley, 300 m up, 1920 x 1080	2.10 (base pass 1.63, prepass 0.52)	4.81 (base pass 1.55, lighting 1.39)

2560 x 1440 has 1.78 times the pixels of 1920 x 1080. The base pass grows by about 1.37 times and the prepass, which follows triangles more than pixels, by about 1.14. With Shader Model 5 instead of 6, the meadow at Low and 1920 x 1080 adds 2.08 ms (base pass 1.72, prepass 0.47).

Render thread

Render-thread time at Epic, 1920 x 1080, in ms. These two views were read with nothing else running; Low and Cinematic were not.

View	With terrain	Without	Added
Meadow, 2 m up	4.64	3.58	1.05
Valley, 300 m up	4.67	3.71	0.96

Where the meadow’s added time goes, with terrain and without:

Part	With	Without
Other scene rendering	1.49	1.28
View setup	0.30	0.10
Render graph, collecting resources	0.44	0.38
Pre-render	0.14	0.01
Distance field scene	0.12	0.02
Shadows	0.15	0.09
Render graph, execution	0.13	0.07

The terrain’s own render-thread steps, measured apart by the plugin’s benchmarks (the same machine and build, nothing else running, medians, 2026-10-31):

Step	Cost	Conditions
Selecting far-field nodes	0.044 ms	415 nodes
Showing a far-field edit	0.057 ms	Worst case 0.306 ms
Uploading a batch of new chunks	7.68 ms	289 chunks at once, as after a long jump. A burst, not every frame

Game thread by part

With the camera still, the whole game thread took 2.03 ms at the meadow at Epic and 2.40 ms in the valley. The same map with no terrain, no sample pawn and no sample HUD took 1.68 ms. Hiding the terrain does not change this figure, because the terrain’s systems keep running.

Part, camera still	With terrain	No terrain
Actor ticks, including the sample pawn, HUD and brush tool	0.32	0.09
Tickable objects, including the terrain’s own tick	0.15	0.07
Grass system, with no grass in this world	0.04

The plugin’s steps, measured apart by its benchmarks. Medians, game thread:

Step	Cost	Conditions
Far-field check when nothing changed	under 0.001 ms	10,368 edited tiles known
Brush tool held still	0.033 ms	0.100 ms beside a corridor
Accepting a finished far-field edit	0.001 ms	Worst case 0.324 ms
Reading one tile’s ground for collision	0.0425 ms	128 by 128 ground points. Swapping in the result takes 0.0045 ms
Accepting a grass component	0.107 ms	First build. A refresh takes 0.0016 ms
Publishing one sculpt step to the network	0.105 ms	Radius 20 m
Refreshing one chunk after an edit	0.168 ms
Starting and finishing a batch of new chunks	0.493 ms and 0.549 ms	289 chunks, on two frames
Planning a save	0.007 ms	64 km world. The file is written on a background task
Height at a point	44 ns random, 16 ns nearby	One query

Cost of an edit by size

Game-thread cost, 1 m cell size unless a row says otherwise, medians.

Edit	Game thread	Conditions
Sculpt step as your game calls it, radius 20 m	0.146 ms	ApplyBrush during a scripted drag at a 2 m cell size. Worst 5 % from 0.223 ms. 0.156 ms beside a corridor
The same step in a running session, radius 20 m	0.110 ms	End of stroke 0.172 ms, undo 0.523 ms
The same step beside a corridor, radius 10, 20 and 30 m	0.234, 0.261 and 0.286 ms	The corridor re-bakes on workers, 2.39 ms per step at radius 20 m. End of stroke 2.755 ms, undo 2.487 ms
The ground edit alone, radius 10, 20 and 30 m	0.049, 0.057 and 0.070 ms	The part that follows the radius
Paint step, radius 10 m and 20 m	0.044 ms and 0.078 ms	One layer
Height stamp, radius 1 km	10.8 ms	2,884,518 ground points, result ready in 14.0 ms on 20 logical cores
Corridor preview, 300 m	1.76 ms
Corridor commit, 1 km	23.03 ms straight, 29.25 ms diagonal
Spline feature replaced, 1 km	20.39 ms	11.23 ms at a 2 m cell size
Spline feature preview, per km	2.98 ms	1.515 ms at a 2 m cell size

Edits also take time to appear, without holding up the game thread:

Edit	Delay
A brush on ground that is not loaded yet	29.27 ms at radius 20 m, 40.98 ms at radius 100 m
A brush stroke, until the far field shows it	49.3 ms, worst case 82.7 ms
A 1 km corridor, at a 2 m cell size, until the near terrain shows it	36 ms
A 2 km plate, 12 m high, at a 2 m cell size, until the near terrain shows it	200 ms

Scaling with tile count

Work	Small	Large
Chunks’ live render data per frame	0.0088 ms for 9 by 9	0.0374 ms for 33 by 33
Far-field node selection	0.0164 ms for 128 nodes in view	0.0440 ms for 415 nodes
Tile index in memory, and the time to read it	1.30 MB and 1.85 ms for a 64 km world	20.71 MB and 35.19 ms for a 256 km world, from a generated index
Procedural tiles built per second, by Max Concurrent Loads	1,950 at 4, 3,291 at 8	4,770 at 16, 4,877 at 32

Memory by kind

Video memory the terrain holds, in MiB, at 1920 x 1080 on the same world.

Kind	Low	Epic	Cinematic
Near terrain tiles	275.1	252.7	229.8
Detail ring around the near terrain	12.5	46.6	188.8
Far-field atlases	20.0	20.0	20.0
Material textures	12.7	12.7	12.7
Virtual texture pool	65.9	65.9	65.9
Terrain total	386.2	397.8	517.1
All of Unreal’s graphics resources, with terrain and without	767 and 404	3,190 and 2,438	4,605 and 3,774

The near figure follows the loaded tiles, about 150 KiB of video memory per tile (1,851, 1,665 and 1,508 tiles when read, on a 3 km residency radius). The last row grows by more than the terrain’s own total at Epic and Cinematic, because Unreal’s shadow and Lumen pools grow once there is a scene to light.

System memory, for the whole process, over the same map with no terrain: the working set grew by 558, 547 and 556 MiB at Low, Epic and Cinematic, and the private bytes by 1,006, 1,190 and 1,425 MiB. Those include the loaded tiles and their collision, and also the sample map’s own objects. The process itself held a 3.1 to 3.4 GB working set in this Development build.

Disk, for the data your game ships or writes:

Data	Size	Conditions
The 64 km example world, baked	5.35 GB	64 by 64 km at 1 m
A save with no edits	312 B	A 4 km square at 1 m cell size
A save after 1,000 brush steps	18,432 B	Same map, 23 tiles touched, a 20 m radius brush lifting 15 cm a step
A save after 10,000 brush steps	174,488 B	Same map, 227 tiles touched
A save of a fully sculpted 64 km world	2.061 GB	Loads and verifies in 1.54 s

Threads

The plugin starts no threads of its own. Its background work runs as tasks on Unreal’s task system and parallel loops, so it shares your project’s worker threads, and each kind of work has a limit you can change.

Work	Where it runs	Limit	Time
Tile loads and procedural tile generation	Worker tasks	Max Concurrent Loads, 8 by default (1 to 64)	See Scaling with tile count
Re-baking tiles during a stroke	Worker tasks	OrreryTerrain.Sculpt.StrokeBakeWorkers, 4 by default	2.39 ms per step beside a corridor
Building collision	Worker tasks		0.129 ms per 128 by 128 tile
Packing a chunk’s render data	Worker tasks		0.596 ms per chunk
Far-field atlas, whole 64 km world	One background task at a time	Fixed	229.7 ms, 244.8 ms when edited
Far-field patch after an edit	Background tasks		0.204 ms per job, worst case 0.464 ms
Detail ring re-pack	Background tasks		1.755 ms at High, 2.737 ms with ring normals
Grass builds	Worker tasks	r.OrreryTerrain.Grass.MaxTasks, 4 by default	6.701 ms per chunk
Writing a fully sculpted 64 km save	Background task		8.29 s for 2.116 GB
Publishing edits, the undo journal, planning jobs and accepting finished ones	Game thread		The tables above
Texture region updates, re-selecting far nodes, marking virtual shadow pages	Render thread		The tables above

Same scene against Landscape

This is one comparison, with the conditions below, and not a claim that either is faster in general. Both drew the same ground, in alternated runs on the same machine, with a comparable automatic material and two paint layers on each.

GPU time, whole frame, median in ms. The same laptop on its 240 W supply, 1702 MHz, 1920 x 1080 rendered (1422 x 800 at 135 %), t.MaxFPS 30, virtual shadow maps and Lumen off, no painted weights, 2026-10-28.

Camera	No ground	Landscape	Orrery Terrain Low	Orrery Terrain Epic	Orrery Terrain Cinematic
Ground level	2.16	4.85-4.88	4.47	4.45	5.56
On a slope	2.26	5.43-5.55	4.51	4.55	4.57
On a ridge	2.25	6.72-6.75	5.19	5.24	5.80
Overview	2.12	7.08-7.09	4.55	4.67	4.69
Toward the horizon	2.16	5.34-5.42	3.87	3.92	3.97

• At the far cameras Landscape draws more geometric detail in the distance, so those margins are not like for like.
• Cinematic at ground level costs 0.69 ms more than Landscape, for its finer rows between ground points.
• With four paint layers instead of two, Low to Epic add 0.21 to 0.23 ms at ground level. Landscape was not re-timed with four layers.
• Lumen and virtual shadow maps were off, so this says nothing about lit cost with them on.
• The game thread took 1.89 to 2.24 ms with either terrain.

Hardware it ran on

The plugin has run on these machines. They are what we tested, not a line between what works and what does not.

Machine	Ran	Memory seen
Intel Core i7-12700H, 32 GB RAM, GeForce RTX 3060 Laptop GPU 6 GB	Low, Epic and Cinematic at 1920 x 1080 and 2560 x 1440 with Shader Model 6, with Lumen and virtual shadow maps at Epic and Cinematic. All five levels at both sizes with Shader Model 5	The tables above
A 2016 laptop: Intel Core i7-6700HQ (4 cores), 16 GB RAM, GeForce GTX 960M 4 GB	Low and Medium at 1920 x 1080, with Shader Model 5, so with no Lumen and no virtual shadow maps	1.1 to 1.4 GB of video memory in use for the whole scene, 3.9 to 4.2 GB of process private bytes

Both ran with no errors logged. Nothing weaker has been tried, and the 2016 laptop was not tried with Shader Model 6.

Features by graphics card

Feature	Needs	From
Heightfield renderer	Shader Model 5 or higher	The plugin
Mesh renderer	Used below Shader Model 5	The plugin
Lumen	Shader Model 6 on DirectX 12. Unreal did not run it at the Low scalability level	Unreal
Virtual shadow maps	Shader Model 6 on DirectX 12. Unreal did not run it at the Low scalability level	Unreal
Hardware ray tracing	A DirectX ray tracing card, and the project setting on	Unreal

A project built only for Shader Model 5 runs without Lumen and virtual shadow maps, even with their console variables on. Add Shader Model 6 under Project Settings > Platforms > Windows > Targeted RHIs.

Reading the costs on your own PC

Your scene and your machine decide what matters. In any build, Shipping included, stat terrain shows a panel of what the terrain costs on your machine, part by part. In a Development build:

• stat OrreryTerrain and stat OrreryGrass show the plugin’s timings and counters in the viewport.
• r.OrreryTerrain.Draw 0 hides the terrain, so the same view with and without it gives you the cost over no terrain, as above. Compare the two with stat gpu or ProfileGPU, Unreal’s own tools.
• rhi.DumpResourceMemory lists the video memory by resource, and the terrain’s are named OrreryTerrain and TerrainFarAtlas.

The playable demo will let you read the same figures on your own PC, once it is out.