Batch LODs

The 3 Batch LODs page changes many meshes at once. It builds a LOD chain from a recipe, sets screen sizes from switch distances in metres, writes per-platform screen sizes and Min LOD for your targets, prepares Nanite meshes for platforms without Nanite and can cut the draw calls of far LODs. Nothing changes until you click Apply, every run is backed up first, and Restore last backup puts the old settings back.

The page has three cards at the top, LOD recipe, Meshes to change and Options, the Preview changes list under them, and three buttons at the bottom: Preview changes, Apply to N meshes and Restore last backup.

LOD recipe

Pick a preset in the Preset: drop-down; the list shows each preset’s description under its name. The table below lists the LODs the recipe builds after LOD 0, which is always the imported mesh and is never reduced:

Column	Meaning
LOD	LOD 1 and up.
Triangles %	Share of the full mesh’s triangles the LOD keeps, from `0.5` to `100`.
Distance (m)	Where the LOD takes over, in metres, for a mesh at scale 1 on the reference camera, from `0.1` to `5000`. See Distances and screen sizes.
Bones	Skeletal recipe only: the most bones that may move one vertex on this LOD, from `0` to `12`. Fewer is cheaper skinning; `0` keeps the mesh’s setting. See Skeletal meshes.

Add LOD adds a LOD at the end of the chain with half the triangle share of the last LOD (at least 1 %), twice its distance and the same bones. A recipe has up to seven LODs after LOD 0.
The minus button at the end of a row removes that LOD.
Let Unreal compute screen sizes uses Unreal’s automatic screen sizes instead of the distances. The meshes that get a new LOD chain are switched to automatic screen sizes, and no screen sizes or per-platform screen sizes are written. Static recipe only: skeletal meshes have no automatic screen sizes.

Static and skeletal meshes each have their own recipe. When the scan has skeletal meshes, the chips Static meshes and Skeletal meshes above the table switch which recipe you edit. The static drop-down offers the presets for static meshes, the skeletal one the presets for skeletal meshes (and both offer the presets for any mesh). The page starts with the first static preset (Standard by default) and the first skeletal preset (Characters by default), and edits the skeletal recipe first when the scan has only skeletal meshes. The skeletal drop-down always offers the built-in Characters and Characters (mobile and VR) after your own skeletal presets, unless one of your presets has the same name.

Changes you make here apply to this panel only; the preset in the settings stays as it is. Picking a preset in the drop-down replaces the recipe with it. To keep a recipe, add it to LOD Presets in Project Settings > Plugins > ta LOD Tailor (or in your settings asset), set its Used For (a new preset is for static meshes) and reopen the panel tab to see it in the drop-down. See Settings.

Default presets

Preset	For	Description	LOD 1	LOD 2	LOD 3	LOD 4
Standard	Static meshes	Props and architecture: four LODs out to 80 m.	50 % at 15 m	25 % at 35 m	10 % at 80 m
Small props	Static meshes	Small items that are only seen up close.	40 % at 6 m	15 % at 15 m
Hero / large	Static meshes	Big or important meshes that stay detailed far away.	60 % at 30 m	35 % at 70 m	15 % at 150 m	5 % at 300 m
Mobile aggressive	Static meshes	Strong reduction early, for mobile and standalone VR.	35 % at 8 m	12 % at 20 m	4 % at 45 m
Characters	Skeletal meshes	Skeletal meshes: four LODs out to 45 m, two bone influences from LOD 2.	50 % at 8 m, 4 bones	25 % at 20 m, 2 bones	10 % at 45 m, 2 bones
Characters (mobile and VR)	Skeletal meshes	Skeletal meshes for mobile and standalone VR: strong reduction early, fewer bone influences.	35 % at 5 m, 2 bones	15 % at 12 m, 2 bones	6 % at 30 m, 1 bone

None of them uses Unreal’s automatic screen sizes.

Meshes to change

Chip	Changes
Ticked	The meshes ticked in the mesh table on step 1
Shown	The meshes the mesh table shows with its current search and filter
All scanned	Every mesh of the last scan

Each chip shows how many meshes it covers. When you open the page with Next: Batch LODs or the step button, the chip is chosen for you; see Steps bar. Tailor LODs in the mesh details opens the page with Ticked, and Tailor LODs… in the Content Browser with All scanned (the meshes you right-clicked).

Under the chips:

Check box	Default	Meaning
Change static meshes (N)	On	Include the static meshes among the meshes to change.
Change skeletal meshes (N)	On	Include the skeletal meshes among the meshes to change.
Use the folder rules (N)	On	Meshes that match a folder rule get the rule’s preset instead of the recipe (and its Nanite mode, if the rule sets one); untick it to use the recipe for every mesh. Hover the question mark to see the rules, for example `/Game/Props → Small props`. Available when you have folder rules. See Shared settings and folder rules.

Options

Option	Default	Meaning
Build the LOD chain	On	Replace the generated LODs with the recipe. Off: the LODs stay, and only screen sizes and platform settings change.
Replace imported LODs	Off	Also rebuild meshes that have hand-made LODs. Their package file is copied to the backup folder first. Available while Build the LOD chain is on. See Imported LODs.
Screen sizes from the distances	On	Convert the recipe distances to screen sizes for each mesh’s size, on the reference camera. These are the mesh’s default screen sizes.
Per-platform screen sizes	On	Write screen size overrides for every target that has a platform key, from its camera and distance scale. Available while Screen sizes from the distances is on.
Per-platform Min LOD	On	Write a Min LOD override for every target that has a platform key: its fixed value, or the first LOD within its triangle budget. See Min LOD per platform.
Save the changed meshes	On	Save the meshes after the run. Off: they stay modified in the editor until you save them.
Fewer draw calls from LOD	Off, LOD `2`	Static meshes: from this LOD on, the generated LODs draw fewer material sections. With Merge sections with the same material (on), Drop sections under (`2` %) and Main material only (off). See Fewer draw calls.
Remove unskinned bones from LOD	Off, LOD `2`	Skeletal meshes: from this LOD on, the LODs drop the bones no vertex is skinned to. Shown when the scan has skeletal meshes. See Skeletal meshes.
Skip meshes under	`500` triangles	Meshes whose full mesh has fewer triangles are skipped.
Nanite meshes	Skip Nanite meshes	What to do with Nanite meshes. See Nanite meshes.
Fallback	`100` %	Triangles of the Nanite fallback mesh as a share of the full mesh. Available with Keep Nanite, add LODs. Static meshes only.

Screen sizes and per-platform screen sizes are only written when the mesh has more than one LOD after the run. For static meshes they are also not written while Let Unreal compute screen sizes is on.

What happens to each mesh

For every mesh, the preview decides on one of three actions, in this order:

Skip if the mesh has no render data, if its kind is not part of the run (Change static meshes or Change skeletal meshes is off), if it is a skeletal mesh whose LODs come from a LOD Settings asset, if it is a Nanite mesh and Nanite meshes is Skip Nanite meshes, or if its full mesh has fewer triangles than Skip meshes under.
New LODs if Build the LOD chain is on, the recipe has at least one LOD, the mesh has no imported LODs or Replace imported LODs is on, and the mesh doesn’t have this chain already (see Already up to date).
Otherwise Settings: the LODs stay and only screen sizes, per-platform values, Nanite, unskinned bones and draw calls change. If all of these already have the planned values, the mesh is skipped as Already up to date. Screen sizes count as equal within 1 % (at least 0.0005).

Static meshes get the static recipe and skeletal meshes the skeletal recipe. While Use the folder rules is on (the default), meshes that match a folder rule get the rule’s preset instead, and the rule’s Nanite mode when it sets one.

Already up to date

A run doesn’t build a LOD chain again that an earlier run built with the same recipe and options. The mesh keeps its LODs when it has as many LODs as the recipe makes, keeps or lacks Nanite as the run would leave it, and every LOD after LOD 0 is still LOD Tailor’s reduction of LOD 0 with the recipe’s Triangles %. Depending on the mesh, these must match too:

Static meshes: the merged sections of Fewer draw calls from LOD, the Fallback of a Nanite mesh kept as Nanite, and with Let Unreal compute screen sizes on, the automatic screen sizes.
Skeletal meshes: the bone influences of every LOD and the unskinned bones removed from the far LODs.

Such a mesh is then handled like the Settings case: only what differs is written, and when nothing differs, the mesh is skipped as Already up to date. So a second Preview changes right after Apply shows every changed mesh as Already up to date, and running the same batch again changes nothing. Change the recipe or the options to build the chain again.

New LOD chains

LOD 0 stays as it is. All other LODs are removed and rebuilt: every LOD of the recipe becomes a reduced copy of LOD 0 that keeps the recipe’s share of triangles, built with Unreal’s own mesh reduction. Static meshes use the build settings of LOD 0; skeletal meshes use Unreal’s skeletal mesh reduction with the recipe’s bones per LOD, and their clothing is unbound while the LODs change and bound again afterwards. A mesh has up to eight LODs in total.

The preview shows the expected triangles of each LOD:

LOD 1 and up: the full mesh’s triangles × the recipe’s share.
LOD 0: the current LOD 0. For static Nanite meshes kept as Nanite, the full mesh × Fallback; for Nanite meshes that are turned off, the full mesh.

Screen sizes

The default screen sizes come from the recipe distances on the reference camera, the per-platform screen sizes from the distances × the target’s Distance Scale on the target’s camera. LOD 0 gets a screen size of at least 1.0, and every LOD gets a smaller value than the LOD before it. Writing screen sizes turns off a static mesh’s automatic screen sizes. Overrides for platform keys that are not a target stay as they are. See Distances and screen sizes for the formula.

A mesh that keeps more imported LODs than the recipe has gets the recipe’s distances for the first ones, and every further LOD switches at twice the distance of the one before it.

Min LOD per platform

For every enabled target with a platform key, the run writes a Min LOD override:

Case	Min LOD
The target renders Nanite and the mesh stays a Nanite mesh	`0`
The target’s Min LOD is `0` or more	That LOD, at most the last LOD
The target’s Min LOD is `-1`	The first LOD whose expected triangles are within the target’s budget (its skeletal budget for skeletal meshes), or the last LOD if none is

The mesh’s default Min LOD is not changed, and targets without a platform key get nothing. For example, with Standard and Keep Nanite, add LODs at 100 %:

Mesh	Triangles per LOD	Platform Min LOD
SM_Rock_Dense	57,120 · 28,560 · 14,280 · 5,712	Linux 0, Android 2
SM_Cliff_Nanite	159,200 · 79,600 · 39,800 · 15,920	Linux 1, Android 3

Steam Deck (Linux, budget 100,000) starts the Nanite cliff at LOD 1, the first LOD below 100,000 triangles; Meta Quest (Android, budget 20,000) starts it at LOD 3.

Nanite meshes

Mode	What it does
Skip Nanite meshes (default)	Leaves Nanite meshes as they are. They are listed as skipped.
Keep Nanite, add LODs	Nanite stays on. Targets with Nanite keep rendering Nanite; targets without Nanite render the fallback mesh as LOD 0, then the new LODs. This is Epic’s hybrid workflow for projects that ship on Nanite and non-Nanite hardware. When the chain is built, the fallback mesh of a static mesh is set to keep Fallback of the triangles.
Turn Nanite off	Turns Nanite off and uses the LOD chain on every target, including PC. LOD 0 is the full mesh again.

Keep Nanite, add LODs is the usual choice for Fab packs that ship Nanite-only meshes. A fallback mesh at 100 % is as heavy as the full mesh, but per-platform Min LOD lets a weak target skip it and start at the first LOD within its budget. Lower Fallback if a target without a platform key draws it. To see which mode suits a mesh, check its Nanite or LODs verdict.

Skeletal meshes with Nanite (Unreal Engine 5.5 and later) follow the same modes; the Fallback share applies to static meshes only.

Imported LODs

Meshes with hand-made (imported) LODs keep them by default. They get screen sizes, per-platform screen sizes and Min LOD for their existing LODs, and the preview notes Keeps its imported LODs.

With Replace imported LODs on, they get a new LOD chain like any other mesh, and the preview notes replaces imported LODs. Before anything changes, the mesh’s package file (.uasset) is copied to the backup folder, because a backup file can’t hold LOD geometry. The confirmation dialog tells you how many meshes lose imported LODs.

A reimport of the mesh can also remove imported LODs. LOD Tailor keeps a copy before every reimport and puts them back; see Reimport protection.

Preview

Click Preview changes. The preview lists every mesh of the run, with the changes first and skipped meshes last, and a summary such as “9 new LOD chains · 3 settings only · 5 skipped”. Nothing has changed yet.

Column	Shows
Check box	Ticked for every change. Untick a row to leave that mesh out of Apply. The check box in the header ticks or clears every change. Skipped meshes can’t be ticked.
Mesh	Thumbnail, name and folder; hover for the package path
Action	New LODs, Settings or Skip; hover for the LOD count before and after, for example `1 → 4 LODs`
Triangles (per LOD)	The full mesh, then the expected triangles of every LOD after the run, for example `57,120 → 28,560 · 14,280 · 5,712`
Draw calls (before → after)	Material sections per LOD before and after the run, for example `4 · 4 · 4 · 4 → 4 · 4 · 2 · 2`. See Fewer draw calls.
Platform Min LOD	The Min LOD overrides the run writes, by platform key, for example `Linux 0, Android 2`. `–` for skipped meshes and when nothing is written.
Note	What happens or why the mesh is skipped, see below

Note	Meaning
`4 LODs from "Standard"`	A new chain with this number of LODs (LOD 0 included) from this recipe
`replaces imported LODs`	The mesh loses its hand-made LODs
`keeps Nanite, fallback 100%`	The static mesh stays a Nanite mesh with this fallback share
`keeps Nanite`	The skeletal mesh stays a Nanite mesh
`turns Nanite off`	Nanite is turned off
`removes 15 unskinned bones from LOD 2`	The far LODs of the skeletal mesh lose its unskinned bones
`LOD 2+: 4 → 2 draw calls`	From this LOD on, the LODs draw fewer sections
`Screen sizes and platform settings`	Settings only, the LODs stay
`Keeps its imported LODs`	The mesh has hand-made LODs and Replace imported LODs is off
`Already up to date`	The mesh has the planned LODs and settings already, for example after the same run. See Already up to date.
`(folder rule /Game/Props)`	At the end of the note: a folder rule picked the preset
`Static meshes are not part of this run.`	Change static meshes is off
`Skeletal meshes are not part of this run.`	Change skeletal meshes is off
`Its LODs come from the LOD Settings asset LODSettings_Hero; change them there.`	A LOD Settings asset drives the skeletal mesh’s LODs
`Nanite mesh; Nanite meshes are skipped (see Nanite meshes).`	Skip Nanite meshes is selected
`Only 168 triangles, below the minimum of 500.`	The full mesh is below Skip meshes under
`The mesh has no render data.`	The mesh can’t be read

Export preview (next to the summary) writes the preview as lod_plan.html, lod_plan.csv and lod_plan.json to the Report Directory: every mesh with its action, preset, folder rule, LODs before and after, triangles per LOD, draw calls before and after, Min LOD and note. The HTML page opens when Open Report After Export is on.

Changing the recipe, an option or the meshes clears the preview; click Preview changes again.

Apply

Apply to N meshes is available when the preview has at least one ticked row; N is the number of ticked rows. After you confirm the dialog, LOD Tailor:

Loads every mesh to change and writes a backup of its LOD settings. If the backup can’t be written, nothing is changed.
Changes the meshes one by one. An editor that has the mesh open is closed while it changes and opened again afterwards.
Waits for the mesh builds to finish.
Saves the changed meshes, if Save the changed meshes is on. Validate on save doesn’t run for these saves.

A progress dialog (ta LOD Tailor: building LODs) shows each mesh. If you cancel it, the meshes done so far keep their changes and the rest are not changed. Then the panel scans the same meshes again to show their new state, and a result line says, for example, “12 changed, 0 skipped, 0 failed in 4.2 s.” with “Backup: LODTailor_20261011-190229-123.json” under it, followed by any problems. Changed, skipped and failed add up to the ticked rows; a mesh the run didn’t reach because you cancelled counts as skipped. The run is also listed in the Log in the panel footer.

Backups

Every run writes one backup file to the Backup Directory from the settings (by default Saved/LODTailor/Backups), named after the time of the run, for example LODTailor_20261011-190229-123.json. Older backups are kept; a backup that has been restored is renamed to Restored_LODTailor_<time>.json.

For each changed static mesh the backup stores the number of LODs, the reduction and build settings of every LOD, its section settings (material, shadows, collision), which LODs had merged sections, the default and per-platform screen sizes, whether Unreal computes the screen sizes, the LOD group, the default and per-platform Min LOD, the Nanite settings, and for every LOD its source file and whether it was imported. For a skeletal mesh it stores the LOD settings of every LOD (reduction, screen sizes, bones to remove), the default and per-platform Min LOD, the Nanite settings and, for every LOD, its source file and whether it was imported.

The geometry of imported LODs can’t be stored in this file. When a run replaces imported LODs, the mesh’s package file is copied into a folder named after the same time, for example Saved/LODTailor/Backups/20261011-190229-123/Game/Props/SM_Statue_Imported.uasset.

Restore

Restore last backup undoes the newest run that has not been restored yet, after a confirmation that warns that meshes changed after that run lose those later changes. It changes only the meshes in that backup, always saves them, and then scans again. The status line says “Restored N meshes from LODTailor_….json (F failed).”, and the result line “N restored, 0 skipped, F failed in 1.2 s.” with “From:” and the name of the backup under it.

When every mesh is restored, the backup file is renamed from LODTailor_<time>.json to Restored_LODTailor_<time>.json in the same folder. Clicking the button again therefore undoes the run before it, one run at a time. If a mesh fails to restore, the file keeps its name, so you can try again.

What a restore puts back:

The number of LODs: LODs a run added are removed, LODs it removed are added again.
The reduction and build settings of every LOD, so generated LODs are built as before. Skeletal LODs are rebuilt with their old settings, so bones a run removed come back.
The section settings of static mesh LODs. LODs whose sections were merged before the run are merged again from LOD 0; LODs the run merged become plain reductions again.
Default and per-platform screen sizes, automatic screen sizes and the LOD group.
Default and per-platform Min LOD.
The Nanite settings, including the fallback mesh.

What it can’t do:

Bring back imported LOD geometry. A replaced hand-made LOD comes back as a generated LOD with the old settings, and the result lists it: SM_Statue_Imported: imported geometry of LOD 1 (Statue_LOD1.fbx) is now a generated LOD. Reimport it in the Static Mesh Editor, or copy the backed up .uasset back with the editor closed.
Redo a restored run. A restore writes no backup of its own. To apply a run again, apply its recipe again. To restore one specific backup file, restored or not, call restore_backup with its path from Python.
Keep later changes. Settings you changed by hand on those meshes after the run are replaced by the backed up values.