How to Create Low-Poly Models for Mobile Games: Polygon Budgets, Workflow & Optimization

You modeled a character, exported it to Unity, built for Android, and dropped it to 22 frames per second on a Pixel 6. The model was only 8,000 triangles.

That is the part nobody tells you. An 8k-tri character seems low. In a desktop game, it practically is. But on mobile, polygon count is the wrong number to stare at. Draw calls and fillrate will wreck your scene long before tri count gets interesting. The model needs more than fewer triangles. It needs a performance budget and an export pipeline built for mobile from the first vertex.

By the end of this article you will have a polygon budget table you can use immediately, a step-by-step Blender-to-engine workflow, and the specific LOD and material batching rules that distinguish a mobile build from a desktop one.

Why Mobile Changes the Low-Poly Math

Three Numbers That Actually Matter on Mobile

Triangle count is the number beginners watch. It is not the number that breaks mobile performance.

Fillrate is the pixel budget. A mid-range Android GPU processes roughly one quarter of a desktop GPU per frame. The same model that renders fine on an RTX card will overshade a mobile GPU, which means the GPU spends more cycles per pixel than it has budget for. The model is not too complex. The model is rendering too many pixels.

Draw calls are CPU commands to the GPU. Mobile CPUs are power-limited, not clock-speed-limited. You cannot send the same number of draw commands to a mobile GPU that you send to a desktop. Every unique material on a mesh triggers a draw call. A hero character with five material slots eats five calls before the environment is counted.

Setpass calls are worse than draw calls on mobile. When Unity switches between shaders, it triggers a setpass, which costs three to four times more than a standard draw call. A scene that hits 80 draw calls across 12 setpasses runs 10 frames slower on an Android device than the same calls across 2 setpasses. Reducing materials and batching surfaces fixes this before triangle count ever enters the conversation.

The Mobile Performance Budget

The biggest mistake beginner mobile game developers make is treating phone hardware as a single target. A Pixel 7 and a budget Samsung A-series are not the same machine. You need tiered budgets.

The Android Developers team gave a useful real-world benchmark in their Armories demo, presented at GAMESCon. Crowd characters in that demo run at approximately 360 triangles per character, and the whole scene holds 60 fps on mid-range hardware. That is not an extreme low-poly bar. It is what a practical mobile game scene looks like when the budget is set first and the artwork is built to it.

The frame budget is simple. At 60 fps, you have 16.6 milliseconds per frame. The GPU gets roughly half of that for rendering the scene. Every vertex shader call, every pixel shader invocation, and every texture fetch counts against that window. If the model has too many materials, the CPU side will fail before the GPU side even starts.

Low-Poly Modeling Workflow for Mobile Game Development

Set Up Blender for Mobile Export

Start Blender and check the unit scale. Open Scene Properties and confirm that Unit Scale is set to 1.0 and Unit System is Metric. Mobile engines work in meters by default, and a scale mismatch between Blender and the engine results in an invisible frame rate hit from aggressive texture filtering on a 100x scale model.

Set the FBX export preset to match your target engine. Under Geometry, set Smoothing to Face to avoid splitting vertices on import. Check Apply Scalings and set it to FBX Units Scale. For Unity, leave Forward as -Z and Up as Y.

Normals need a hard look before export. Turn on Auto Smooth and set the angle to 30 degrees. That keeps the visible creases clean without splitting edges everywhere. Avoid Bevel modifiers on mobile models. Every beveled edge adds triangles and creates more edge splits at import. Use the sharp edge flag instead, and let the engine collapse those vertices at build time.

Build the Mesh Within Triangle Budget

Character topology on mobile follows the same rules as desktop, but the margin is narrower. Model in quads for deformation and export as triangles for the engine. Every quad gets split into two triangles on import, so build as if the real count starts after triangulation.

For a supporting NPC at 3,000 tris, think in head-torso-limbs proportions. The head gets roughly 500 tris, the torso 1,200, each arm 300, each leg 350. That is not a rigid split but it forces a decision about where detail goes. A face with 300 tris and a body with 100 looks wrong. Distribute detail proportional to screen size.

Props are where beginners waste the most tri budget. A simple crate, a lantern, a barrel, and none of them needs more than 150 tris. Box model each one. If it looks like a cylinder from the player's distance, add six extra vertices per horizontal edge, not 32.

Environment pieces should run modular. Build wall sections, floor tiles, and pillar bases that share the same material. A temple with 200 wall pieces using one material adds 1 draw call. That same temple with 200 wall pieces using 10 different materials adds 10 draw calls. The game reads the difference in load time and frame pacing.

UV Unwrapping for Mobile

Mobile UVs follow one rule: one UV island per material per mesh. For a guide to clean topology mesh best practices including UV island strategy, see our dedicated walkthrough. Do not scatter UV islands across the texture. A single island for the face and a single island for the body lets you pack the texture atlas tight.

Overlapping UVs are acceptable on mobile when two copies of the same prop share texture space. That is free memory but only works when the two objects are vertex-identical. A rock duplicated 20 times and rotated in place can share UV space. A rock scaled and squashed cannot.

Power-of-two texture sizes matter more on mobile than desktop. Stick to 512x512 for props, 1024x1024 for supporting characters, and only use 2048x2048 for hero characters. GPU texture samplers work in power-of-two blocks, and a non-POT texture wastes memory bandwidth on padding.

How to Optimize 3D Models for Mobile Without Losing Quality

Reduce Draw Calls with Material Batching

Draw calls are the mobile performance bottleneck that polygon count articles almost never mention. A single mesh with five materials generates five draw calls. Five meshes sharing one material generate one draw call. The math is that simple.

Start by auditing your material count. Every PBR material that stays in the scene is a draw call you carry through every frame. Merge materials when the texture difference is small. Two rocks that use different brown noise textures can share one material with a single noise texture. The eye will not catch the difference from playing distance.

Unity's Static Batching takes meshes marked as Static and combines them into larger meshes at build time. Static objects that never move, including walls, floors, and large environment pieces, all belong in Static Batching. The build takes a few seconds longer, but the frame time drops immediately.

GPU Instancing handles identical meshes differently. Instead of combining vertex data, it tells the GPU "draw this mesh here, here, and here" in a single command. Trees, rocks, and crates that are the same mesh rotated and scaled use GPU Instancing. Unity enables it by default on shaders that support it. Check the Material Inspector to confirm Enable GPU Instancing is ticked.

The practical target for a mid-range mobile game is target under 100 draw calls per frame. Games that look modern at 300 calls on desktop need the same scene compressed into 80 calls on mobile. If the draw call count is over 150 on the Unity Profiler, material merging is your first fix, not polygon reduction.

Texture Optimization for Mobile

Texture compression is where mobile and desktop pipelines diverge completely. For a breakdown of 3D file format comparison, including texture atlas strategy and platform-native export, see our guide. Desktop uses BC7 and BC5. Mobile hardware reads ASTC (Android 8+ and iOS) or ETC2 (older Android devices). See the Android texture compression guide for the full format breakdown. Export textures in the platform's native format, not BC7.

Set the texture resolution to the lowest acceptable quality. A prop that occupies 200 pixels on screen at the nearest camera distance does not need a 2048x2048 texture. It needs 256x256. That is 99% less memory than a 2048 texture at full mip chain.

Normal maps should be half the resolution of the base color texture. A 1024x1024 base color map gets a 512x512 normal map. That saves memory, and the GPU does not miss the loss because the normal map is already interpolated across the pixel shader.

Setting Up LOD for Mobile Games

When to Use LOD on Mobile

LOD is not free. The CPU calculates LOD transitions every frame. On a scene with 5 characters, those calculations cost more than they save. On a scene with 50 trees or 30 visible NPCs, LOD consistently helps.

Use LOD when: the scene has 20 or more characters or props visible simultaneously, the camera distance varies significantly during gameplay, or the target hardware is a budget phone.

Do not bother with LOD when: the camera is fixed, characters rarely enter the scene, or the build is already under budget at full detail.

Environment LOD pays off faster than character LOD on most mobile games. A forest with 50 trees uses 2-level LOD: near trees at full detail, far trees as 4-triangle billboard cards. That compresses 50 draw calls into 2 without visible quality loss from typical camera angles.

Mobile-specific caveat: LOD switching forces a mesh re-bind on the GPU, which costs roughly one draw call per switch. A burst of 20 simultaneous switches can spike the frame time. Profile on your lowest target device. The Unity editor lies.

How LOD Groups Work in Unity and Unreal

A Level of Detail system swaps a distant mesh for a simpler version automatically. Unity calls this LOD Group. Unreal uses the same name. The system works the same way for characters, props, and environment pieces.

Unity's LOD Group defines four levels by default:

Set the screen-height percentage on the LOD Group component to control when each level activates. Unreal adds Hierarchical LOD (HLOD), which replaces multiple meshes with one combined mesh at distance. See the Unreal HLOD documentation for setup steps. Useful on mobile when an entire village of 30 buildings can collapse to a single mesh at the horizon. Unity handles this use case with GPU Instancing instead, which is less complex to set up.

Export Settings and Engine Import

Export a Mobile-Ready FBX from Blender in 6 Steps

Exporting with the wrong FBX settings inflates mesh size and breaks material references. Here is the exact sequence:

1. Open File > Export > FBX (.fbx). See the official Blender FBX export documentation for the full option reference. Under Include, check Selected Objects only. Uncheck any Object Types that are not meshes.
2. Under Transform, set Scale to 1.0 and check Apply Scalings. Set Forward to -Z and Up to Y for Unity.
3. Under Geometry, check Apply Modifiers. This bakes mirror, subdivision, and array modifiers into the export. Set Smoothing to Face.
4. Leave Animation unchecked for static meshes. A static crate does not need a default animation track that doubles the import file size.
5. Set Tangent Space to Generate. Generating tangents in the FBX removes a compute step on import. The difference is small per mesh and compounds across large asset counts.
6. Import to Unity. Set the Model Scale Factor to 1 if the model appears at the correct size. If it is 100x too big or too small, return to Blender and export with the correct unit scale.

Confirm the scale with a Unit Cube test before importing a character batch. Place a 1m cube in the Blender scene, export it as FBX, and import into Unity. It should read as 1m wide in the scene. If it reads as 100m, the unit scale is wrong and every mesh in the batch will need correction.

Import into Unity for Mobile

Right-click the FBX in the Project panel and open the Model tab. Set the Scale Factor to 1 if the model looks correct. If the model is 100x too big, return to Blender and export with the correct unit scale.

Under Mesh Compression, set it to High. This uses a 64-bit index for large meshes and a 16-bit index for small ones. Mobile draw calls benefit from 16-bit indices because the GPU index buffer takes less memory bandwidth.

Uncheck Read/Write. Unity copies mesh data into GPU memory on load. When Read/Write is on, Unity keeps a CPU copy as well. For static meshes that never change at runtime, the CPU copy is dead weight.

Under Optimization, check Optimize Mesh. Unity reorders vertices for better GPU cache performance. On a mobile GPU with a small vertex cache, this reordering can cut pixel-shading time by 10–15 percent.

Common Low-Poly Mistakes on Mobile

Overdetailing the Hero Character

The hero character always gets too many triangles on the first pass. For a breakdown of how low-poly vs high-poly budgets differ across platforms, see our low-poly vs high-poly 3D models guide.

A face with sculpted cheekbones, individual eyelashes, and a ring of chainmail from a tutorial gets pushed to 15,000 tris before the body is started. At 15,000 on mobile, the scene has no room for anything else.

Set the hero budget before modeling and stick to it. If the budget is 10,000 tris, spend 3,000 on the head, 4,000 on the body, and 500 per limb. Punch the numbers into a note and start from the base of the budget, not from the high-poly sculpt.

Ignoring Material Count

A low-poly, low-tri hero with 10 materials is worse than a high-poly-tri hero with 2 materials. Mobile GPUs handle triangles better than draw calls. The 2-material hero runs faster because the engine issues 2 draw calls instead of 10, even with 3x the triangle count.

The fix is a texture atlas. Pack diffuse, normal, and packed maps for the entire character into one palette. A 2048x2048 atlas with a single material renders the character in 1 draw call. Five separate 1024x1024 textures on five materials cost 5 draw calls plus 5 setpass overheads. See our game-ready 3D models guide for a full checklist of what game-ready quality means in practice.

No Testing on Target Hardware

The Unity Editor runs on desktop hardware. Desktop GPUs are not mobile GPUs. A scene that runs at 120 fps in the editor may run at 22 fps on a real device.

Unity's Profiler shows the frame breakdown by CPU time, GPU time, and memory. Connect an Android device via ADB, select it in the Profiler target dropdown, and run the scene. Look at the Rendering section for draw calls, setpass calls, and batches.

Android's GPU Profiler gives per-frame vertex and pixel shader timings. If the pixel shader time spikes when the character faces the camera, the overdraw on that frame is too high. The fix is fewer materials or a simpler shader, not fewer triangles.

Generate Low-Poly Mobile Game Assets with Triverse AI

Concept iteration is where mobile game projects burn time. A character brief says "steampunk miner with glowing arm" and the artist spends two days modeling something the designer does not like. The model is game-ready but trash-canned because the look was wrong.

Triverse AI's Artist Mesh workflow gets the concept silhouette right before the full pipeline starts.

Step 1: Upload a Reference Image or Rough Sketch

Open Triverse Studio and select Artist Mesh. Drag and drop or paste a PNG, JPG, JPEG, or WebP image. A rough concept sketch or a clean silhouette photograph works equally well.

Step 2: Choose Vertex Count and Generate

Select Triangle topology. Choose the vertex count preset that fits your mobile target: 1K for background props, 2K for standard props, 4K for hero props or detailed characters. Hit Generate. A 25-credit generation typically completes in under a minute.

Step 3: Review and Iterate

Artist Mesh returns a mesh you can immediately judge for proportions, pose, and overall shape. If the silhouette is wrong, delete and regenerate. The cost is 25 credits and a few seconds instead of two days of manual modeling.

Step 4: Export and Confirm If You Should Refine in Blender

Export the concept as GLB or OBJ and import to Blender for proper edge flow and deformation, and apply the optimization rules from the earlier sections. The Artist Mesh result is a starting point, not a final game asset, but it moves the concept phase from days to hours.

FAQs about Low-Poly Models for Mobile Games

What is the recommended polygon count for mobile game characters?

How many draw calls should a mobile game target per frame?

How do I reduce draw calls in a mobile game without merging meshes?

What is the best file format for mobile game 3D models?

Does LOD actually help performance on mobile devices?

Can I use normal maps on low-poly mobile game models?

How do I test 3D model performance on a real Android device?

Bottom Line

The biggest lesson in mobile 3D is that triangles are not the enemy. Draw calls are. Set your polygon budget before opening Blender, build to that budget, and spend more time consolidating materials than trimming vertices. LOD helps once the scene has enough objects to justify the CPU cost. Test on the lowest target device in your market, not on a desktop editor. Everything else in this article is detail. Those priorities are the framework. Additionally, you can directly use Triverse AI's Artist Mesh feature to quickly generate custom, stylized low-poly game models with a single click, and for a limited time, downloading the models is free!