Low-poly polygon budgets for mobile/WebGL/console (with real triangle numbers)

Most polycount advice is either too vague or too old to help a working game team. "Keep it low" is not a budget, and a number that works for a hero character on PlayStation 5 can be a disaster for a WebGL scene with 200 props and a hot JavaScript main thread. The useful way to think about low-poly budgets is not one magic number per asset. It is a triangle budget per camera view, per platform, per asset role, and per expected count on screen.

This guide gives practical starting numbers for low-poly game assets. Treat them as production targets, not laws. The right budget still depends on shader cost, material count, draw calls, animation, lighting, post-processing, screen resolution, and whether the asset is a hero object or background dressing. Still, a concrete range beats a blank page when you are building an asset list.

First, budget the frame, not the model

Triangles are only one cost, but they are still a useful planning unit. For low-poly art, you usually hit trouble from a mix of too many visible objects, too many materials, high texture memory, expensive shadows, or unbatched draw calls before raw triangle count alone becomes the only problem. That means your asset budget should include both triangle count and scene density.

A good planning pass asks four questions:

How close can the camera get to this object?
How many copies might be visible at once?
Does it animate or deform?
Does it cast real-time shadows?

A 6,000 triangle low-poly tree can be acceptable if five trees appear near the camera. It can be excessive if 400 trees are visible from a hilltop. A 12,000 triangle boss character can be fine on console, while the same count is wasteful for a mobile NPC that occupies 80 pixels of screen height.

Practical triangle ranges by asset type

For mobile games, use these as initial targets:

Small props such as crates, bottles, rocks, signs, pickups: 50 to 500 triangles.
Medium props such as furniture, weapons, machines, street objects: 300 to 2,000 triangles.
Simple buildings or modular wall pieces: 500 to 4,000 triangles.
Trees and foliage clumps: 300 to 2,500 triangles, with aggressive LODs.
Player characters: 2,000 to 8,000 triangles.
Common NPCs or enemies: 1,000 to 5,000 triangles.
Vehicles: 2,000 to 8,000 triangles.

For WebGL and Three.js, the safe range is similar to mobile, but the deployment constraints are different. Download size, parse time, GPU memory, and the cost of many separate objects can matter more than the top-line triangle number. For a browser scene, a single inspectable hero prop can be 5,000 to 20,000 triangles, but a library prop intended for repeated use should often stay below 1,000 to 5,000 triangles. If your scene needs to load instantly on a mid-range laptop or phone, keep the initial visible scene modest and stream or lazy-load secondary models.

For PC and console, low-poly art gives you more headroom, but you should not spend it automatically. Practical starting targets are:

Small props: 100 to 1,500 triangles.
Medium props: 1,000 to 6,000 triangles.
Large environment pieces: 2,000 to 15,000 triangles.
Hero weapons or inspectable objects: 5,000 to 20,000 triangles.
Main characters: 8,000 to 30,000 triangles.
Bosses or cinematic hero characters: 20,000 to 60,000 triangles when justified.

The point is not that every console prop should be heavier. The point is that console budgets allow selective detail where the player will notice it: hands, faces, silhouettes, wheels, hinges, readable mechanical edges, and close-camera hero props.

Screen size beats category

A prop that fills the screen needs more geometry than a prop that sits in the background. This is why the same barrel may need three versions:

LOD0 near camera: 700 triangles.
LOD1 mid distance: 250 triangles.
LOD2 far distance: 60 triangles or a billboard.

For low-poly art, LOD transitions are less about preserving tiny details and more about preserving the silhouette. If the object is a rock, the outer contour matters more than internal cuts. If the object is a chair, the negative spaces between legs matter. If the object is a sword, the readable blade profile matters. Spend polygons on edges that change the outline. Delete polygons that only add flat interior surface noise.

Use triangle count together with material count

A clean 3,000 triangle GLB with one material is often cheaper and easier to ship than a 1,200 triangle model with eight materials, eight textures, and separate mesh parts that cannot batch. Low-poly production benefits from atlases and shared palettes. If you are building an asset pack, consider one shared texture atlas for many props or simple vertex colors for flat-shaded meshes.

As a rule of thumb, small props should usually have one material. Medium props can have one or two. Characters might need two or three if there is a strong reason, such as body, face, and equipment. If every object arrives with a unique material, your renderer pays for that variety even when the triangles look cheap.

Suggested scene-level budgets

Here are conservative starting budgets for visible triangles in a typical gameplay view:

Mobile low-end: 50,000 to 150,000 visible triangles.
Mobile mid-range: 150,000 to 400,000 visible triangles.
WebGL on broad consumer devices: 100,000 to 500,000 visible triangles.
Desktop WebGL or WebGPU target: 500,000 to 2 million visible triangles, if assets are optimized.
Switch-like handheld target: 300,000 to 1.5 million visible triangles depending on shaders and resolution.
Modern PC or console: 1 million to 10 million visible triangles, but low-poly games rarely need the high end.

These are not engine limits. They are planning ranges that leave room for lighting, shadows, particles, UI, animation, physics, and worst-case camera views. Always profile on the slowest target hardware you actually support.

How to choose a budget before modeling

Start with a spreadsheet or asset list. Give each asset an on-screen count and a role: hero, gameplay, background, or filler. Multiply the triangle target by expected count. A hero object at 12,000 triangles might be fine because only one exists. A grass clump at 300 triangles might be too expensive if 2,000 can render at once.

Then set hard caps:

Filler props should be cheap enough to duplicate freely.
Gameplay-readable props can spend more on silhouette.
Hero props can spend more on close-up details.
Background props should collapse to very cheap LODs quickly.

Finally, test a worst-case scene early. Place too many props on purpose, open your engine profiler, and measure frame time. If the GPU is fine but CPU render submission is high, reduce object count and material count. If GPU vertex cost is high, reduce triangles or add LODs. If memory is high, compress textures and simplify materials.

A useful low-poly rule

Do not optimize the visible identity out of the asset. A low-poly fox still needs ears, tail, muzzle, and stance. A low-poly truck still needs cabin, bed, wheels, and wheel arches. A low-poly tree still needs a readable trunk and crown. Cut the polygons that do not support recognition first, then test the asset at actual gameplay size. The right budget is the smallest number that preserves silhouette, animation, readability, and the style promise of your game.