Reports

A report is a snapshot of a scan: every mesh with its LODs and what each target renders, the Nanite or LODs verdicts and every finding. LOD Tailor writes it in up to three formats:

File	For
lod_report.html	Reading and sharing: target cards, a sortable and filterable mesh table, LOD pictures, the Nanite or LODs verdicts and the findings. One file, no server and no internet connection needed.
lod_report.csv	Spreadsheets: one row per mesh with the numbers of every LOD and target.
lod_report.json	CI, dashboards and your own tools: everything the scan read.

Writing a report

From	How	Formats
Editor panel	Export report in the header, after a scan	All three
Commandlet	Runs by default; -Report=<folder> changes the folder, -NoReport writes none	All three, or the ones in -Formats=html,csv,json
Python	export_report(report, options)	The ones turned on in the options

See Command line & CI and Python.

Output folder

Reports are written to the Report Directory from the settings, by default Saved/LODTailor/Reports in your project folder. Relative paths start at the project folder; absolute paths are used as they are. The folder is created if it doesn’t exist.

Every export writes its files with the same names, so a new report replaces the previous one. Nothing else in the folder is touched. After an export from the panel, the HTML report opens in your browser when Open Report After Export is on (the default), and the status line says where it was written.

Tip

Saved is usually not under source control. To commit reports or publish them from CI, set the folder to something like Docs/LODReport, or pass -Report to the commandlet.

HTML report

lod_report.html is a single page titled “LOD report” with the project name, the time of the scan, the number of meshes and the scanned scope. It follows the light or dark setting of your operating system. Click a column header in any table to sort it.

Target cards

One card per target that was enabled during the scan:

• the target name, its platform key (or “default values” when it has none), “Nanite” or “no Nanite” and its budget, for example Android · no Nanite · budget 20,000; when the scan has skeletal meshes, the skeletal budget too, for example budget 20,000, skeletal 20,000;
• the share of meshes that are ready for it, with a bar (“meshes ready”); see What “ready” means;
• Over budget: meshes with an Over budget finding on that target, the same meshes as the panel’s tile. A mesh that gets the No platform key suggestion there instead is not counted;
• Need LODs: meshes with a single LOD whose triangles on that target are above its LOD threshold, the same meshes as the No LODs finding and the panel’s tile. Nanite meshes without LODs are not counted here; they appear under the Nanite fallback finding.

Meshes

The Meshes table has one row per mesh. Type in Filter meshes… to show only rows that contain the text.

Column	Shows
Mesh	Name and package path, a skeletal tag on skeletal meshes, and a pictures link to the mesh’s LOD pictures
Nanite	A Nanite tag on Nanite meshes
LODs	Number of LODs
Full triangles	Triangles of the full mesh
LOD chain	Triangles of every LOD, for example 16,128 · 8,063 · 4,032 · 1,612, with an imported tag when the mesh has hand-made LODs
Draw calls	Material sections every LOD draws, for example 4 · 4 · 2 · 2. See Fewer draw calls.
One column per target	Triangles of the first LOD the target renders, red when over its budget, or Nanite when the target renders the mesh with Nanite
LOD1 at, after each target	Where LOD 1 takes over on that target, for the mesh at scale 1; – for meshes with one LOD or rendered with Nanite. See Distances and screen sizes.
Issues	Number of errors and warnings of the mesh, on all targets

LOD pictures

Every LOD from the same camera, for the meshes with LODs and the most triangles (up to Max Picture Meshes, default 50): one card per mesh with a strip of pictures, each with the LOD number, “imported”, “merged” or “fallback” where that applies, its triangles and its draw calls. The pictures are embedded in the page, so it stays one file. The section is left out when the report was written without a graphics device or with the pictures turned off. A report from a commandlet pictures static meshes only, and the section says that skeletal meshes get pictures in the editor. See LOD pictures.

Nanite or LODs

The verdicts of every mesh, the most useful first: meshes with a confirmed material risk, then Switch to LODs, Nanite + fallback LODs, Keep Nanite, Consider Nanite. The meshes that keep their LODs are hidden; tick Show N meshes that keep their LODs to list them too. Filter… filters the rows.

Column	Shows
Mesh	Mesh name, with a skeletal tag on skeletal meshes
Verdict	The verdict over all targets
Nanite data	Size of the Nanite data; ~ marks an estimate
LOD chain	Memory of the LOD chain; ~ marks an estimate
Fallback	Triangles of the fallback mesh of static Nanite meshes
One column per target	The verdict on that target; hover it for the reason
Why	The reason, the material risk and the material notes

See Nanite or LODs for the verdicts and how the sizes are estimated.

Findings

The Findings table lists every finding, errors first, with the number of findings in its title:

Column	Shows
Severity	Error, Warning or Suggestion
Mesh	Mesh name
Rule	Rule name, for example Over budget. See Checks.
Targets	The targets the finding applies to, or all
Message	The finding

The footer reads “Generated with ta LOD Tailor 1.1.0 by tridiART” with the installed version, and notes that screen sizes are converted to distances for a mesh at scale 1 on each target’s camera.

CSV report

lod_report.csv has a header line and one line per mesh. It is UTF-8 without a byte order mark, separated by commas; values that contain a comma, a quote or a line break are put in double quotes.

Column	Meaning
Mesh	Mesh name
Path	Object path, for example /Game/Props/SM_Rock_Dense.SM_Rock_Dense
Type	Static or Skeletal
Nanite	yes or no
LODs	Number of LODs
Imported LODs	yes when the mesh has hand-made LODs
Full triangles	Triangles of the full mesh
Bounds radius (cm)	Radius of the bounding sphere at scale 1, one decimal
Bones	Bones of a skeletal mesh; empty for static meshes
Draw calls per LOD	Material sections every LOD draws, separated by /, for example 4/4/2/2
LOD0 triangles … LOD7 triangles	Triangles of each LOD; empty for LODs the mesh doesn’t have
<Target> triangles	Triangles of the first LOD the target renders, or Nanite
<Target> budget	ok or over (ok when the target renders Nanite), against the skeletal budget for skeletal meshes
<Target> Min LOD	The mesh’s Min LOD on the target
<Target> LOD1 distance (m)	Where LOD 1 takes over on the target, one decimal; empty for meshes with one LOD or rendered with Nanite
Errors, Warnings, Info	Number of findings of each severity, on all targets
Nanite verdict	The Nanite or LODs verdict over all targets, for example Keep LODs
Nanite data (KB), Nanite data estimated	Size of the Nanite data, and yes when it is an estimate
LOD chain (KB), LOD chain estimated	Memory of the LOD chain, and yes when it is an estimate
Material risk	none, possible or confirmed
<Target> Nanite verdict	The verdict on each target

The <Target> columns repeat for every target, in the order of the targets. With the default targets the header is:

Mesh,Path,Type,Nanite,LODs,Imported LODs,Full triangles,Bounds radius (cm),Bones,Draw calls per LOD,LOD0 triangles,LOD1 triangles,LOD2 triangles,LOD3 triangles,LOD4 triangles,LOD5 triangles,LOD6 triangles,LOD7 triangles,PC triangles,PC budget,PC Min LOD,PC LOD1 distance (m),Steam Deck triangles,Steam Deck budget,Steam Deck Min LOD,Steam Deck LOD1 distance (m),Switch 2 triangles,Switch 2 budget,Switch 2 Min LOD,Switch 2 LOD1 distance (m),Meta Quest triangles,Meta Quest budget,Meta Quest Min LOD,Meta Quest LOD1 distance (m),Errors,Warnings,Info,Nanite verdict,Nanite data (KB),Nanite data estimated,LOD chain (KB),LOD chain estimated,Material risk,PC Nanite verdict,Steam Deck Nanite verdict,Switch 2 Nanite verdict,Meta Quest Nanite verdict

and three rows look like this:

SM_Barrel_LODs,/Game/Props/SM_Barrel_LODs.SM_Barrel_LODs,Static,no,4,no,16128,56.9,,1/1/1/1,16128,8063,4032,1612,,,,,16128,ok,0,1.1,16128,ok,0,1.0,16128,ok,0,1.1,16128,ok,0,0.5,0,0,0,Keep LODs,227,yes,719,no,none,Keep LODs,Keep LODs,Keep LODs,Keep LODs
SM_Rock_Dense,/Game/Props/SM_Rock_Dense.SM_Rock_Dense,Static,no,1,no,57120,69.9,,1,57120,,,,,,,,57120,ok,0,,57120,ok,0,,57120,ok,0,,57120,over,0,,0,2,0,Consider Nanite,803,yes,2503,yes,none,Consider Nanite,Keep LODs,Keep LODs,Keep LODs
SK_Character_LODs,/Game/Characters/SK_Character_LODs.SK_Character_LODs,Skeletal,no,3,no,6118,139.5,68,1/1/1,6118,1528,764,,,,,,6118,ok,0,8.3,6118,ok,0,7.4,6118,ok,0,8.3,6118,ok,0,3.6,0,0,0,Keep LODs,86,yes,259,no,none,Keep LODs,Keep LODs,Keep LODs,Keep LODs

JSON report

lod_report.json contains the whole scan: every mesh as LOD Tailor read it, every finding, the Nanite or LODs verdicts, the targets and the scope. It is UTF-8 without a byte order mark.

The field names are the names of the report’s properties with the first letter in lower case. That is why the LOD list is called lODs, the LOD group lODGroup and the LOD chain size lODBytes, and why booleans keep Unreal’s b prefix, for example bNanite. Enum values are written by name, for example "kind": "SkeletalMesh" or "verdict": "NaniteWithFallbackLODs".

Example

From a real report, shortened to one mesh, one finding, one verdict and one target, with shorter paths:

{
  "meshes": [
    {
      "objectPath": "/Game/Props/SM_Barrel_LODs.SM_Barrel_LODs",
      "name": "SM_Barrel_LODs",
      "package": "/Game/Props/SM_Barrel_LODs",
      "kind": "StaticMesh",
      "bones": 0,
      "unskinnedBones": 0,
      "lODSettingsAsset": "",
      "lODs": [
        {
          "triangles": 16128,
          "vertices": 8383,
          "screenSize": 2,
          "platformScreenSizes": {},
          "percentTriangles": 1,
          "bCustom": false,
          "sections": 1,
          "bMergedSections": false,
          "sectionTriangles": [ 16128 ],
          "sectionMaterials": [ 0 ],
          "sectionMaterialGroups": [ 0 ],
          "bones": 0,
          "maxBoneInfluences": 0,
          "bReducesFromLOD0": false,
          "reductionBoneInfluences": 0,
          "removedBones": 0,
          "bytes": 394728
        },
        {
          "triangles": 8063,
          "vertices": 4325,
          "screenSize": 0.91133981943130493,
          "platformScreenSizes": {},
          "percentTriangles": 0.5,
          "bCustom": false,
          "sections": 1,
          "bMergedSections": false,
          "sectionTriangles": [ 8063 ],
          "sectionMaterials": [ 0 ],
          "sectionMaterialGroups": [ 0 ],
          "bones": 0,
          "maxBoneInfluences": 0,
          "bReducesFromLOD0": true,
          "reductionBoneInfluences": 0,
          "removedBones": 0,
          "bytes": 200556
        }
      ],
      "bNanite": false,
      "sourceTriangles": 16128,
      "boundsRadius": 57.165622711181641,
      "boundsSize": { "x": 64.121476173400879, "y": 64.383977890014648, "z": 113.68429565429688 },
      "lODGroup": "None",
      "bAutoScreenSize": true,
      "minLOD": 0,
      "platformMinLOD": {},
      "materials": 1,
      "naniteBytes": 0,
      "naniteFallbackPercent": -1,
      "bTranslucentMaterial": false,
      "bMaskedMaterial": false,
      "bWorldPositionOffset": false
    }
  ],
  "issues": [
    {
      "ruleId": "OverBudget",
      "severity": "Warning",
      "assetPath": "/Game/Props/SM_Rock_Dense.SM_Rock_Dense",
      "message": "Over the triangle budget: Meta Quest 57,120 / 20,000.",
      "targets": [ "Meta Quest" ]
    }
  ],
  "naniteAdvice": [
    {
      "assetPath": "/Game/Props/SM_Barrel_LODs.SM_Barrel_LODs",
      "name": "SM_Barrel_LODs",
      "kind": "StaticMesh",
      "bNanite": false,
      "verdict": "KeepLODs",
      "reason": "A classic LOD chain fits this mesh.",
      "sourceTriangles": 16128,
      "fallbackTriangles": 0,
      "naniteBytes": 232243,
      "bNaniteBytesEstimated": true,
      "lODBytes": 736284,
      "bLODBytesEstimated": false,
      "materialRisk": "None",
      "materialRiskText": "",
      "notes": [],
      "targets": [
        {
          "target": "Meta Quest",
          "verdict": "KeepLODs",
          "reason": "Meta Quest draws its LOD chain: 16,128 triangles up close, within the 20,000 budget.",
          "bRendersNanite": false,
          "triangles": 16128,
          "budget": 20000
        }
      ]
    }
  ],
  "profiles": [
    {
      "name": "Meta Quest",
      "bEnabled": true,
      "device": "Headset",
      "platform": "Android",
      "bNanite": false,
      "maxTriangles": 20000,
      "requireLODsAbove": 1000,
      "maxSkeletalTriangles": 20000,
      "requireSkeletalLODsAbove": 3000,
      "distanceScale": 0.60000002384185791,
      "fieldOfView": 104,
      "aspectRatio": 0.94999998807907104,
      "minLOD": -1
    }
  ],
  "scope": [ "/Game" ],
  "seconds": 0.10110220313072205,
  "time": "2026.10.21-23.25.46"
}

The real file has one value per line and the barrel’s four LODs.

Top level

Field	Meaning
meshes	One object per scanned mesh, sorted by package path
issues	Every finding
naniteAdvice	The Nanite or LODs verdicts, one object per mesh, in the order of meshes
profiles	The targets that were enabled during the scan
scope	The scanned folders, or the names of the scanned meshes
seconds	Duration of the scan
time	Local time of the scan, as YYYY.MM.DD-hh.mm.ss

Meshes

Field	Meaning
objectPath, name, package	Object path, name and package path
kind	StaticMesh or SkeletalMesh
bones, unskinnedBones	Skeletal meshes: bones of the skeleton, and bones no vertex is skinned to (bones that sockets or physics bodies hang on, and their parents, are not counted)
lODSettingsAsset	Skeletal meshes: the LOD Settings asset that drives the LODs, or empty
lODs	The rendered LODs, see below. For static Nanite meshes LOD 0 is the fallback mesh.
bNanite	Nanite is on
sourceTriangles	Triangles of the full mesh: the Nanite mesh, or LOD 0 before its own reduction
boundsRadius	Radius of the bounding sphere at scale 1, in cm
boundsSize	Size of the bounding box at scale 1, in cm
lODGroup	LOD group, None when there is none
bAutoScreenSize	Unreal computes the screen sizes
minLOD	Default Min LOD
platformMinLOD	Per-platform Min LOD overrides, by platform key
materials	Number of material slots
naniteBytes	Size of the mesh’s Nanite data on disk, in bytes; 0 without Nanite
naniteFallbackPercent	Static Nanite meshes: the fallback mesh’s share of the triangles when it is set as a share (for example 1 after Keep Nanite, add LODs at 100 %), otherwise -1
bTranslucentMaterial, bMaskedMaterial, bWorldPositionOffset	A material of the mesh is translucent, is masked, or uses World Position Offset

LODs

Field	Meaning
triangles, vertices	Triangles and vertices of the LOD
screenSize	Default screen size
platformScreenSizes	Per-platform screen size overrides, by platform key
percentTriangles	Share of triangles the reduction keeps; 1 when the LOD is not reduced
bCustom	The LOD is hand-made (imported geometry) instead of a reduction
sections	Number of material sections
bMergedSections	LOD Tailor merged the sections of this LOD (fewer draw calls); it is not a hand-made LOD
sectionTriangles, sectionMaterials	Triangles and material slot of each section
sectionMaterialGroups	Static meshes: for each section, the first section drawn with the same material and settings; sections with the same number can share a draw call
bones	Skeletal meshes: bones the LOD needs
maxBoneInfluences	Skeletal meshes: the most bones that move one vertex, 0 when not known
bReducesFromLOD0	The LOD is a reduction of LOD 0 to a share of its triangles, the way LOD Tailor builds LODs
reductionBoneInfluences	Skeletal meshes: the bone influence limit of the reduction
removedBones	Skeletal meshes: bones the reduction removes from this LOD
bytes	Estimated GPU memory of the LOD’s vertex and index buffers

bReducesFromLOD0, percentTriangles, reductionBoneInfluences, removedBones, bMergedSections and the mesh’s naniteFallbackPercent tell a batch run whether a mesh already has the chain it would build; see Already up to date.

Issues

Field	Meaning
ruleId	Rule id, for example OverBudget. See Checks.
severity	Error, Warning or Info
assetPath	Object path of the mesh
message	The finding
targets	Names of the targets it applies to; empty for every target

Nanite advice

Field	Meaning
assetPath, name, kind	The mesh
bNanite	Nanite is on for the mesh now
verdict, reason	The verdict over all targets (KeepNanite, NaniteWithFallbackLODs, SwitchToLODs, KeepLODs or ConsiderNanite) and why
sourceTriangles	Triangles of the full mesh
fallbackTriangles	Static Nanite meshes: triangles of the fallback mesh
naniteBytes, bNaniteBytesEstimated	Nanite data in bytes, and whether it is an estimate
lODBytes, bLODBytesEstimated	Memory of a LOD chain in bytes, and whether it is an estimate
materialRisk, materialRiskText	None, Possible or Confirmed, and what the risk is about
notes	Material notes: translucent, masked, World Position Offset
targets	One object per target: target, verdict, reason, bRendersNanite (the target draws the mesh with Nanite today), triangles (what it draws without Nanite) and budget

See Nanite or LODs.

Profiles

The targets with their settings: name, bEnabled, device (Desktop, Handheld, Console, Headset or Mobile), platform (None without a key), bNanite, maxTriangles, requireLODsAbove, maxSkeletalTriangles, requireSkeletalLODsAbove, distanceScale, fieldOfView, aspectRatio and minLOD. See Target settings.

Apart from the Nanite advice, the JSON report holds what the scan read, not the values the panel derives from it. To get the readiness, the triangles per target or the switch distances, use the CSV report, or calculate them as described in Targets and readiness and Distances and screen sizes.

Batch preview files

Export preview on the Batch LODs page, and export_plan(plan, options) in Python, write the preview of a batch run to the same folder as lod_plan.html, lod_plan.csv and lod_plan.json. Each new export replaces the previous one.

File	Contents
lod_plan.html	“LOD batch preview” with the counts of new LOD chains, settings only and skipped meshes, and one row per mesh: Mesh, Action, Preset (and the folder rule that picked it), LODs before → after, Triangles per LOD, Draw calls per LOD (before → after), Min LOD and Note.
lod_plan.csv	Mesh,Path,Type,Action,Preset,Folder rule,LODs before,LODs after,Triangles per LOD,Draw calls before,Draw calls after,Min LOD,Note, with the numbers per LOD separated by /.
lod_plan.json	The whole plan: the options, the targets and every entry, with the same field naming as the report.

For example, a CSV row:

SM_Kiosk_Sections,/Game/Props/SM_Kiosk_Sections.SM_Kiosk_Sections,Static,New LODs,Standard,,1,4,31680/15840/7920/3168,4/4/4/4,4/4/2/2,"Linux 0, Android 1","4 LODs from ""Standard"", LOD 2+: 4 → 2 draw calls"