How to Reduce Unity Build Size (Android, iOS and PC)

An empty Unity project builds small, then a few months later your Android APK is 400 MB and Google Play is complaining. Build size matters: every extra megabyte loses some mobile installs, slows WebGL loads and inflates patch downloads. The good news is that most bloat comes from a handful of causes. This guide shows how to reduce Unity build size on Android, iOS and PC: reading the build report, compressing textures and audio, removing unused assets and packages, code stripping, and delivering content later with Addressables.

Find Out What’s Actually in the Build

Never guess. After building, open the Editor log (Console window menu > Open Editor Log) and search for “Build Report”. You’ll see a size breakdown by category (Textures, Meshes, Sounds, Shaders, Scripts, and so on) followed by a list of every asset sorted by size. The top 20 entries usually explain most of the build.

The free Build Report Inspector package (and several Asset Store build report tools) present the same data more readably, including which scenes pulled each asset in. Compare reports before and after each change so you know what actually helped.

Remember that only referenced assets are included: things used by scenes in the Build Profile’s scene list, their dependencies, and everything in Resources folders. An unused 4K texture in a random folder costs nothing, but one referenced by a forgotten prefab in a scene does.

Textures: Usually the Biggest Win

Textures are typically 50–80% of a build. For each large texture, check its import settings:

• Max Size: a phone screen doesn’t need 4096×4096 textures on small props. Use 1024 or 512 for most, and 2048 for hero assets. Halving the size cuts memory by 75%.
• Compression: use the platform’s GPU format (ASTC on Android/iOS, BC7/DXT on PC), not “None” or RGBA32. ASTC block size trades quality for size: 6×6 is a good default, and 8×8 for backgrounds.
• Crunch Compression: shrinks textures further on disk (not in GPU memory). Great for download size on DXT/ETC formats.
• Generate Mip Maps: off for UI sprites (saves 33%), on for 3D textures.
• Read/Write: off unless scripts read pixels. On doubles memory use.
• Sprite Atlases: packing sprites removes per-texture padding and makes compression work well. Non-power-of-two textures can’t be compressed in some formats.

Use per-platform overrides in the import settings (the Android/iOS tabs) to keep PC quality high while shrinking mobile. For bulk changes, an AssetPostprocessor editor script can enforce rules on import (see Editor scripting 101).

Audio Compression

Sound type	Load Type	Compression	Notes
Music, ambience	Streaming	Vorbis, quality 50–70	Force To Mono if it’s not truly stereo
Short SFX, played often	Decompress On Load	ADPCM or Vorbis	Low latency
Medium SFX, voice	Compressed In Memory	Vorbis	Sample Rate Override 22050 Hz for voice

Never ship uncompressed PCM music, since a 3-minute stereo WAV is 30 MB. Imported WAVs are fine as source files, because Unity compresses them at build time according to these settings. More on audio setup in our Audio Mixer tutorial.

Meshes and Animations

• Mesh Compression (Low/Medium/High) in model import settings quantizes vertex data. Check for visual artifacts.
• Turn off Read/Write on meshes unless scripts modify them.
• Untick Import Cameras/Lights, and don’t import unused normals, tangents or blend shapes.
• Animation Compression: set to Optimal, and raise rotation/position error tolerances slightly. Remove unused clips from imported FBX files.
• Strip unused shader variants. Shaders can quietly add tens of MB. Disable unused URP features in the URP Asset (they generate variants), and check the Shader section of the build report.

The Resources Folder Trap

Everything inside any folder named Resources goes into the build, used or not, because Unity can’t know what Resources.Load will ask for at runtime. Asset Store packages often ship demo content in Resources folders. Search the project for “Resources” folders and move or delete anything you don’t load by name. Better still, replace Resources.Load with direct references or Addressables.

Also delete demo scenes and sample folders from imported packages, or at least make sure none of their scenes are in the build list.

Code Stripping and Packages

• Use the IL2CPP scripting backend (required for iOS, recommended for Android) and set Managed Stripping Level to Medium or High (Player Settings > Other Settings). Test thoroughly: high stripping can remove code used only via reflection. Preserve it with [Preserve] or a link.xml file.
• Remove unused packages in Package Manager. Templates include several you may not need (Visual Scripting, Timeline, Multiplayer Center, Test Framework in builds). Each adds code and sometimes shaders.
• Disable unused built-in modules under Package Manager > Built-in (for example Vehicles, Cloth, Wind, XR if unused). This matters most for WebGL.
• Set IL2CPP Code Generation to Optimize for size where available (WebGL, and Faster (smaller) builds on other platforms).

Platform-Specific Settings

Android

• Build an Android App Bundle (AAB) for Google Play. Play then serves each device only the code and textures for its architecture, so users download far less than the bundle size.
• Target only ARM64 (plus ARMv7 only if you need very old devices). Including x86 adds size for almost no users.
• For APKs over the size limit, use Play Asset Delivery to deliver large assets as asset packs.
• Build failures after changing these? See our Android Gradle build fix guide.

iOS: the App Store thins apps per device automatically. Use Strip Engine Code, IL2CPP stripping and on-demand resources for large content. The size reported in Xcode’s organizer after thinning is what users actually download (see our iOS build guide).

PC: size matters less, but Steam patch sizes depend on how assets are packed. Enabling LZ4HC compression in the Build Profile (Compression Method) shrinks the install. Our Steam and itch.io publishing guide covers upload details.

WebGL: it has its own toolbox of Brotli compression, module stripping and texture choices, covered in depth in optimizing WebGL builds. Try our WebGL build size estimator too.

Download Content Later With Addressables

If the game is still big after all of that, don’t ship everything up front. Addressables let you put later levels, high-resolution textures, cosmetics or optional languages into remote bundles that download on demand or after first launch. The initial download contains only what’s needed to start playing. Our Addressables beginner’s guide walks through remote groups and hosting.

Troubleshooting

The build is huge but my project is small

Check the build report for Resources folders, uncompressed textures (RGBA32), PCM audio, and shader variants. Those four account for most surprises.

The game crashes or errors after raising stripping level

Code used only through reflection (serializers, some plugins) was removed. Add a link.xml preserving those assemblies or types, or lower the level to Medium.

Texture changes didn’t reduce size

A platform override is set and takes precedence over the Default tab, or the texture is in a Sprite Atlas whose own settings control compression.

Google Play says the APK is too large

Switch to an Android App Bundle, and use Play Asset Delivery for large assets.

Size went up after upgrading Unity

New default packages or render pipeline features were added. Compare build reports between versions and remove what you don’t use (see upgrading to Unity 6).

FAQ