Mobile Game Texture Budget Guide

Start with the worst-case scene, not the install

The install can contain textures that never coexist. Runtime risk comes from the working set visible or retained during one demanding scene, camera path, UI overlay, or transition. Record that set by asset identifier so the test can be repeated after content changes.

Reserve memory for render targets, depth buffers, meshes, animation, audio, scripts, the engine, and the operating system before assigning the remainder to textures. A texture-only number is not a total application memory limit.

Use exact block and mip math

For block compression, each mip costs ceil(width ÷ block width) × ceil(height ÷ block height) × bytes per block. ASTC uses 16-byte blocks across its footprints; ETC2 RGB uses 8-byte 4×4 blocks and ETC2 RGBA uses 16-byte 4×4 blocks. Sum every mip because the smallest levels still allocate complete blocks.

The familiar one-third mip overhead is a useful approximation for square power-of-two textures. The exact byte count is the sum of every level, especially for block formats and non-square textures.

Separate color interpretation from compression

Base color and color-bearing emission are normally decoded as sRGB. Normal, roughness, metallic, ambient occlusion, height, opacity data, and ORM-style packed masks stay linear. A compression format does not correct the wrong color-space flag.

Alpha changes the candidate format and byte rate. Remove alpha only after pixel inspection and shader-contract review prove it is unused; a fully opaque preview does not prove an alpha channel is irrelevant to every material path.

Treat transfer, staging, and residency as different limits

Download or package bytes affect delivery. A CPU decode buffer or KTX2 transcode buffer affects the load spike. GPU-compressed mip payload affects residency. Reporting only one of these can make a build look safe while the transition still crashes.

The worked cold-load column is deliberately a network-profile calculation, not a phone benchmark. Measure storage, parsing, transcode, upload, and shader work in the cooked runtime before publishing a device claim.

Move from the decision to the shipped package

Measure the actual files in Texture Budget & VRAM Analyzer, send the reviewed plan through Texture Doctor, then apply the approved resolution, mip, color-space, channel, and compression rules in the target runtime package.

Use Game Texture Optimizer when source resizing or cleanup is the next job. Use the Texture Troubleshooting Field Guide when a cooked build already shows a symptom. Those pages keep their own jobs; this URL remains the educational owner for the budget decision.

Mobile texture budget settings that change the result

Resolution and mip ceilings

Set ceilings by screen coverage and map role before choosing a compression format.

• Color and normal maps: Preserve silhouette-adjacent color detail and surface direction that remain visible at the closest supported camera distance. Raise the ceiling only when a same-size crop or device capture shows a visible loss. Lower it when the asset never covers enough pixels to use the top mip.
• Masks and utility maps: Store scalar material controls that often carry less spatial detail than color or normals. Start one tier below color, then inspect packed channels individually for banding, edge loss, or cross-channel contamination.
• Mip policy: Adds filtered lower-resolution levels for distance stability and streaming. Keep mips for world and character textures. Consider disabling only for fixed-resolution UI or other assets that never minify, and verify aliasing and memory separately.

ASTC and ETC2 delivery

A format choice is valid only when the target GPU and the cooked package agree.

• ASTC 6×6: Uses 3.56 bits per pixel and preserves more local detail than larger ASTC footprints at a higher byte cost. Use for prominent color, normals, or other artifact-sensitive maps on an ASTC-capable high tier after crop review.
• ASTC 8×8: Uses 2 bits per pixel and cuts payload versus 6×6, with a higher risk of softened edges or block artifacts. Use for mid-tier maps, broad gradients, or lower-information content that passes the final-size crop test.
• ETC2 fallback: Provides a widely compatible OpenGL ES 3-class target, with RGB and alpha-capable variants at different byte rates. Include it through texture-compression targeting or a separate build when ASTC support is outside the device floor. Verify that unsupported formats do not expand to RGBA8.

Engine handoff checks

These labels match documentation reviewed on August 29, 2026; confirm them against the engine version used by the project.

• Unity 6.0 Android override: Set platform-specific Max Size, texture format, compression quality, mipmaps, and sRGB by texture role. Android App Bundles can target multiple compression formats. Profile the built player because unsupported ASTC or ETC2 fallback behavior can change memory and load time.
• Unreal Engine 5.8 Android formats: Android Multi can include ETC2 and ASTC, and format priority selects the highest-priority supported target. Inspect cooked output, texture groups, maximum size, LOD bias, and streaming residency on each supported device class.

Turn a texture ceiling into import and delivery rules

A mobile game texture budget is the explicit ceiling for textures resident in one worst-case scene, plus temporary staging memory and delivery time. Keep these numbers separate, choose GPU formats by supported hardware, and prove the result on representative devices.

Step 1: Define the worst-case scene

Pick one reproducible camera path or gameplay beat and list only the textures that can be resident together. Project size is a delivery concern; simultaneous residency is the runtime budget concern.

Step 2: Assign per-role ceilings

Keep color and normal maps only as large as screen coverage can justify. Start utility masks one tier lower, then raise a map only when a crop at the final on-screen size proves the loss is visible.

Step 3: Ship ASTC with an ETC2 fallback

Use ASTC block size as a per-role quality control on supported GPUs. Keep an ETC2 path or an explicit device exclusion so an unsupported ASTC asset does not silently expand to RGBA8.

Step 4: Profile the cooked build on devices

Record scene-entry time, peak texture residency, the largest staging spike, memory warnings, thermal state, and the exact device and build. The cooked runtime—not source PNG size—is the authority.

Open Texture Budget & VRAM Analyzer

Texture budget mistakes that survive desktop testing

• Using PNG or JPEG file size as the resident GPU-memory number.
• Budgeting the complete project instead of the textures that coexist in one scene.
• Quoting the 33% mip rule without summing small compressed blocks.
• Applying one ASTC block size to albedo, normals, masks, and UI without crop review.
• Shipping ASTC without a verified compatibility path for the supported device floor.
• Treating a KTX2 container size as proof of its final GPU residency.
• Measuring steady-state memory while ignoring the scene-transition staging peak.
• Calling an emulator or transfer profile a physical-device benchmark.

What is a reasonable mobile game texture budget?

There is no safe universal number. Set a worst-case-scene ceiling inside the memory left after the engine, render targets, geometry, animation, audio, scripts, and platform reserve are counted. Then validate peak residency and staging on the lowest supported device.

Do mipmaps add 33% memory?

A complete power-of-two mip chain approaches one third more texels than the base level. Exact compressed bytes differ because every small mip still occupies whole compression blocks, so calculate every level for the chosen format.

Should mobile textures use ASTC or ETC2?

ASTC is the flexible primary choice when the supported devices expose it because block size can trade quality for memory. ETC2 is a useful compatibility target for OpenGL ES 3-class hardware. Package both only when the delivery system selects the right variant instead of installing both.

Is KTX2 the same as ASTC?

No. KTX2 is a container. It can carry a GPU-native format or a universal payload that transcodes at runtime. Resident memory follows the final GPU format, dimensions, and mip chain—not the KTX2 filename.

Which texture maps should be sRGB?

Base color and color-bearing emission are normally sampled as sRGB. Normal, roughness, metallic, ambient occlusion, height, opacity data, and packed masks are data and should be sampled linearly unless a documented shader contract says otherwise.

Can this guide replace on-device profiling?

No. The worked matrix exposes the math and a repeatable test shape. Final authority belongs to the cooked build on representative low, mid, and high devices with memory, loading, thermal, and visual evidence recorded together.