Polygon and triangle budgets

A triangle budget is the number of triangles you allow an asset, or a whole frame, to use so the game hits its target frame rate on its target hardware. It is a planning number, not a fixed rule: the full budget also covers draw calls, materials, texture memory, overdraw and LODs, and on engines with virtualised geometry the triangle part changes a lot.

This page explains what is being counted and why, then collects more than a hundred published numbers from real games, platforms and asset types. It ends with a method for setting a budget yourself.

#Triangles versus polygons

Your modeling app shows quads and n-gons, but engines count triangles. Every quad or n-gon is split into triangles on export or import (see triangulation). That is why most technical numbers you will meet are stated in triangles:

• Meta's headset budgets are given as triangles per frame (Meta Horizon Developers: Device Optimization Comparison).
• Unreal's LOD tools reduce meshes by "Percent Triangles" (Unreal Engine Documentation: Static Mesh Automatic LOD Generation).
• Blender's Decimate modifier calculates its Ratio using triangles, so a quad mesh can keep more faces than the ratio suggests (Blender Manual: Decimate Modifier).
• Nanite, Unreal's virtualised geometry system, stores meshes as clusters of 128 triangles (SIGGRAPH 2021: Nanite: A Deep Dive).
• VRChat's documentation now says "Triangles" and notes that the word "Polygons" was used incorrectly in the past (VRChat Creator Documentation: Performance Ranks).

A quick conversion: a clean quad mesh has about twice as many triangles as faces. A "2,000 poly" quad prop is roughly a 4,000-triangle asset. Always ask which unit someone means.

Press articles and studio marketing usually say "polygons". Often nobody knows whether that means triangles, quads, the in-game LOD0 or the authoring model. The tables below keep the unit exactly as each source states it.

#Other limits besides triangles

Triangles are the easiest number to read in a viewport, so they are often blamed for performance problems they did not cause. In practice a scene usually hits other limits first.

Draw calls. Each object the game renders costs the CPU a request to the GPU, and Meta notes this cost is "largely independent of the complexity of the object being rendered" (Meta Horizon Developers: WebXR Performance Optimization Workflow). Meta's own example: submitting 1,000 single triangles as separate draw calls would likely drop a Quest app below 72 frames per second (Meta Horizon Developers: WebXR Performance Optimization Workflow). A thousand triangles is a small load, while a thousand draw calls is a large one. See draw calls.

Materials. Objects can be combined into one call when they share a material (Meta Horizon Developers: WebXR Performance Optimization Workflow). Every extra material on a prop is something that cannot be batched with its neighbours. This is a big reason environment artists use trim sheets, texture atlases and master materials and instances.

Texture memory. A low-poly mesh with a 4K normal map can be larger on disk than a dense mesh. Epic measured a 19,066-triangle mesh with 4K base colour and normal maps at 31.04 MB, against 27.83 MB for a 1.5-million-triangle Nanite version using a shared detail normal map (Unreal Engine Documentation: Nanite Technical Details). See texture formats, compression and mipmaps.

Overdraw. Pixels drawn more than once cost GPU time. Epic notes that "smaller objects that are closely stacked together create more overdraw than larger ones" (Unreal Engine Documentation: Nanite Technical Details), and Fortnite's team found that the empty, alpha-masked parts of foliage cards add overdraw (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…). Google's Android guide adds that triangles smaller than about 10 pixels in area are inefficient on mobile GPUs (Android Developers: Geometry). See overdraw and foliage and vegetation.

LODs and shadows. Distant objects should switch to cheaper versions; see level of detail. Shadows have a cost of their own: on Fortnite, large non-Nanite meshes rendered shadows into Virtual Shadow Maps more slowly than equivalent Nanite meshes (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).

Instances. Even with Nanite, instance data has a price: Brian Karis gives 457 MB for the transforms of 10 million instances alone (SIGGRAPH 2021: Nanite: A Deep Dive).

#Budgets with Nanite

When Epic revealed Unreal Engine 5 in 2020, it promised "there are no more polygon count budgets, polygon memory budgets, or draw count budgets" (Unreal Engine blog: A first look at Unreal Engine 5). Nanite splits meshes into clusters and streams in only the detail the screen can show, in its own rendering pass that bypasses traditional draw calls (Unreal Engine Documentation: Nanite Virtualized Geometry). The current documentation is more careful. It says "practical limits still remain" for instance counts, triangles per mesh, material complexity, output resolution and performance, and that these must be measured on your own content and hardware (Unreal Engine Documentation: Nanite Virtualized Geometry).

Nanite also does not run everywhere. It needs DirectX 12 with Shader Model 6 class hardware, and it does not support stereo VR rendering or forward rendering (Unreal Engine Documentation: Nanite Virtualized Geometry). If you build for mobile, a standalone headset or any platform without Nanite, classic budgets apply in full. See virtualised geometry.

#Published examples

The tables in this section only contain numbers from a published source. Read three things before you compare two rows:

• Unit. Triangles, "polygons" or vertices, exactly as the source says. "Polygons" in a press quote is ambiguous.
• Scope. A per-frame budget, a platform limit, one LOD0 asset and a marketing headline are different kinds of number.
• Source quality. Rows marked (compiled) come from a long-running Polycount forum thread where members collected figures that artists posted on ArtStation and elsewhere (Polycount forum: Polycounts in next gen games thread!). They are real reported numbers, but this handbook could not open each original post, so treat them as second-hand.

Unless a row says otherwise, assume the number is the highest-detail version (LOD0) the player sees, not the sculpt.

#1. Platform and frame-level budgets

What the table shows. Frame budgets span more than two orders of magnitude, from roughly 100,000 triangles on a headset you wear to tens of millions drawn per frame on a console running Nanite. The headset and mobile numbers are close to each other: Vision Pro, Quest 2 and Google's phone demo all sit between 200,000 and 750,000 triangles. Fighting games and arena scenes can spend more per object because the camera sees little else. Nanite projects stop counting triangles per frame and start counting instances, which is why the Witcher 4 and Matrix numbers are instance counts. Even those vary by report: Epic's documentation gives about 500,000 tree instances for the Witcher 4 forest (Unreal Engine Documentation: Nanite Foliage), while a 2026 report on Nvidia's path-traced version describes "approximately 1 million trees" (TechSpot: Nvidia shows The Witcher 4 forest demo…).

For the Nintendo Switch and last-generation consoles (PlayStation 4, Xbox One), no official per-frame triangle budget could be verified. Treat any single figure quoted for these platforms with suspicion, and use the method in How to set a budget yourself.

#2. Examples by game type

What the table shows. Game type changes the budget mainly through how many things share the screen. Google's two demos show this within one source: a lone robot gets 11,000 triangles, a soldier in a crowd gets 360 (Android Developers: Geometry). Platforms built for user content (Roblox, VRChat, UEFN) publish hard numbers because they cannot review every upload by hand. Racing and flight games spend the most on a single object because the vehicle fills the screen for the whole session. The open-world rows show the largest change: a Mafia building grew from about 25,000 to over a million triangles once the studio moved to Nanite (mafia.2k.com: The Technology Bringing Mafia: The Old…).

#3. Examples by asset type

Unreal's LOD Group presets show how Epic expects categories to differ. These are LOD settings, not triangle targets (Unreal Engine Documentation: Static Mesh Automatic LOD Generation).

What the tables show. Without Nanite, shipped AAA assets cluster in recognisable bands. Modular pieces sit in the hundreds to low thousands of triangles, because they repeat everywhere (modular kits). Furniture and medium props sit around 5,000–12,000. Hero props, weapons and arcade cars land around 13,000–30,000. First-person weapons get a lot for their size because they fill the screen the whole time. Simulation vehicles, creatures and Nanite assets jump by one to two orders of magnitude. Epic's UEFN table is much tighter than any AAA example because it targets phones as well as consoles. Unreal also gives architecture extra weight on silhouette, and that "high detail" assets get more LOD steps and a tighter error. See also hero assets, props and filler and modeling rocks, trees and terrain pieces.

#4. Historical growth

What the table shows. A hero character grew from a few hundred polygons on the PS1 to over 200,000 on the PS5. That is roughly a 250-fold increase for Cloud alone across 27 years (PlayStation.Blog: Final Fantasy VII Rebirth: The polygonal…). The biggest single jump in each series tends to come with normal-map baking and a new console, not steady yearly growth: Killzone's characters quadrupled between PS3 and PS4 (Guerrilla Games: Killzone Shadow Fall Demo Postmortem). Since Nanite, environment assets are growing faster than characters. A whole PS1 view in Crash Bandicoot held about 800 polygons (All Things Andy Gavin: Making Crash Bandicoot – part 3); one Quest 3 frame is asked to stay under 1.5 million triangles (Meta Horizon Developers: Device Optimization Comparison).

#Rule-of-thumb tables (unsourced, use with care)

Many blogs publish per-asset ranges. The two below are typical. Neither cites a source, and they disagree, so use them only as a sanity check against the sourced tables above.

Forum advice varies just as much. One Unity forum user in 2014 suggested keeping main characters under 10,000 polygons on mobile and between 70,000 and 120,000 on PC, Xbox One and PS4 (Unity Discussions: Poly count for character?). Note "polygons", not triangles. At the far extreme, the Polycount Low Poly Challenge in 2010 limited a player model, vehicle or whole scene to 1,024 triangles each as a deliberate art constraint (Polycount forum: LPC vol2 #4 - TRON).

#How to set a budget yourself

You can work out a defensible budget from three things: how big the asset gets on screen, how many such assets are visible at once, and the platform's frame budget.

#Step 1: find the screen size

Unity defines LOD transitions as the object's height "as a percentage of the screen height" (Unity Documentation: LOD Group). You can estimate it with basic trigonometry. With a vertical field of view θ, the visible height at distance d is 2 · d · tan(θ/2).

Take a barrel 0.9 m tall with a 0.3 m radius, a 60° vertical field of view and a 1080-pixel-tall screen (see cameras, lenses and field of view).

• At 3 m, the visible height is 2 × 3 × tan 30° ≈ 3.46 m.
• That gives 1080 / 3.46 ≈ 312 pixels per metre.
• The barrel is about 281 px tall (26% of screen height), and its radius is about 94 px.

#Step 2: spend triangles where the silhouette needs them

A round object made of n straight sides deviates from a true circle by s = r · (1 − cos(180°/n)). Keep that error under about one pixel and the player will not see facets.

So 24 sides are enough at 3 m. With six height segments for the bulge and hoops and two 24-sided caps (22 triangles each), LOD0 is 6 × 48 + 44 = 332 triangles. Flat areas, such as the lid, need no extra geometry; let the normal map carry the small detail.

That lands close to the published bands above: under UEFN's 400-poly cap for a simple small object (Fortnite Documentation: Fortnite-Ready Assets Best Practices), and far below Vampyr's 3,140-triangle wheelbarrow (Polycount forum: Polycounts in next gen games thread!). A plain barrel is a simple shape.

#Step 3: build the LOD chain from screen size

Halve the screen size and you can halve the sides for the same pixel error:

Unreal's presets allow more error than one pixel; small props use a PixelError value of 10 (Unreal Engine Documentation: Static Mesh Automatic LOD Generation). That is a reminder that one pixel is a strict target. Relax it for props players never inspect.

#Step 4: check against the frame

Now work from the top down. Say you build a VR room for Quest 3, with a recommended ceiling of 1.5 million triangles and 200 draw calls per frame (Meta Horizon Developers: Device Optimization Comparison). If about 250 meshes are visible at once, the average is 6,000 triangles each. But 250 meshes already exceed 200 draw calls before you count materials, so the main task is merging and instancing rather than trimming triangles. This is the common outcome: the draw call and material budget binds before the triangle budget does.

3D model from sketchfab.comModular dungeon propsShown from the original site when you click. Tip: you can allow all external media below.

#Common mistakes

• Counting quads. Your "polys" may be half the real triangle count.
• Comparing headline numbers. A "500,000-polygon car" and a "25,000-triangle car" may not be measured the same way.
• Budgeting only the hero. One 50,000-triangle prop seen once costs less than a 2,000-triangle prop scattered 500 times.
• Spending triangles on flat areas. Triangles belong on the silhouette and on curves that catch light; flat panels can be very low.
• Forgetting materials. Five materials on one prop can cost more than doubling its triangles. See draw calls.
• Tiny triangles. On mobile, triangles under about 10 pixels in area waste GPU work (Android Developers: Geometry).
• Masked foliage on Nanite. Masked materials carry a significant shading cost in Nanite (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).
• Assuming Nanite everywhere. It does not support stereo VR rendering or forward rendering (Unreal Engine Documentation: Nanite Virtualized Geometry).

#In different tools

• Blender: enable Statistics in the viewport overlays to read triangle counts. The Decimate modifier shows the remaining face count after reduction (Blender Manual: Decimate Modifier). See decimation.
• Unreal Engine: the Static Mesh editor shows triangles per LOD, and LOD Group presets set LOD behaviour per asset category (Unreal Engine Documentation: Static Mesh Automatic LOD Generation).
• UEFN: check the final vertex count in the editor rather than in your modeling app (Fortnite Documentation: Fortnite-Ready Assets Best Practices); the validator flags single-LOD meshes from 500 vertices (Fortnite Documentation: Simplify Static Meshes in Fortnite).
• Unity: the LOD Group component sets transitions by percentage of screen height (Unity Documentation: LOD Group).

#Further reading and watching

Between Tech and Art: The Vegetation of Horizon Zero DawnGilbert Sanders, Guerrilla Games (GDC 2018)Plays from youtube-nocookie.com when clicked