How to Slash Unreal Engine Android APK Size: Proven UE4/UE5 Optimization Techniques

Package Size Distribution

The Android APK mainly consists of three parts: executable code (e.g., lib/arm64-v8a), game resources packed into main.obb (Pak files and DirectoriesToAlwaysStageAsNonUFS), and third‑party component files copied into the APK.

Each part requires a dedicated optimization approach.

Compress NativeLibs

When installing an APK, native libraries can be handled in two ways:

Extract .so files to the app’s internal storage ( /data/app/<package_name>/lib/).

Load .so directly from the APK, which speeds up installation.

The compression behavior is controlled by the extractNativeLibs flag in AndroidManifest.xml. In newer engine versions you can set bExtractNativeLibs in AndroidRuntimeSettings. For older versions (< 4.27) you may need to replace extractNativeLibs with useLegacyPackaging in Gradle and force the value via UPL:

<addAttribute tag="application" name="android:extractNativeLibs" value="true"/>

Note: This only controls whether the .so is compressed in the APK; it does not reduce the actual .so size.

Code Size Optimization

For Android the goal is to shrink the size of each .so, especially libUE4.so / libUnreal.so, while keeping runtime performance acceptable.

Disable Unnecessary Modules

// disable modules
bUseChaos = false;
bCompileChaos = false;
bCompileAPEX = false;

Control Inlining

Inlining improves performance but enlarges the .text section. You can disable it by setting bUseInlining = false in target.cs (iOS/Linux/Mac/Win) and adding the -fno-inline-functions flag for Android:

if (TargetInfo.Platform == UnrealTargetPlatform.Android)
{
    if (bUseInlining)
        AdditionalCompilerArguments += " -finline-functions";
    else
        AdditionalCompilerArguments += " -fno-inline-functions";
}

Disabling inline may slightly affect performance for hot‑path functions, but the impact is usually negligible.

Disable Exception Handling

bEnableExceptions = false;

This removes the .eh_frame section from the binary.

Use O3 or Oz Optimization

// optimization level
if (!CompileEnvironment.bOptimizeCode)
    Result += " -O0";
else
{
    if (CompileEnvironment.bOptimizeForSize)
        Result += " -Oz"; // size‑first
    else
        Result += " -O3"; // performance‑first
}

-O3

favors performance (aggressive inlining, loop unrolling); -Oz favors size (avoids inlining, keeps loops).

Enable LTO

bAllowLTCG = true; // LTO
if (bAllowLTCG)
    AdditionalCompilerArguments += " -flto=thin";

LTO removes dead code and enables cross‑module optimizations.

Strip Exported Symbols

By default all symbols are exported. For UE only a few JNI entry points need to be kept. Use a version‑script and pass it to the linker:

string VersionScriptFile = GetVersionScriptFilename();
using (StreamWriter Writer = File.CreateText(VersionScriptFile))
{
    Writer.WriteLine("{ global: Java_*; ANativeActivity_onCreate; JNI_OnLoad; local: *; };");
}
AdditionalLinkerArguments += " -Wl,--version-script=\"" + VersionScriptFile + "\"";

Data Optimization

After applying the above code‑size techniques, the original libUE4.so size of 258 MB (Shipping) was reduced to 146 MB, and its compressed size dropped from 74.3 MB to 44.67 MB, saving 29.63 MB.

Original size: 258M → 146M
Compressed size: 74.3M → 44.67M

Relocation Table Compression

For MinSDKVersion >= 28 (Android 9) enable RELR compression:

AdditionalCompilerArguments += " -fPIC";
AdditionalLinkerArguments += " -Wl,--pack-dyn-relocs=android+relr,--use-android-relr-tags";

Verify with readelf -d libUE4.so for a RELR entry. This reduces the relocation table from 25.82 MB to 280 KB, shaving ~25 MB off the .so and ~4 MB from the APK.

SDK 23 Alternative

AdditionalCompilerArguments += " -fPIC";
AdditionalLinkerArguments += " -Wl,--pack-dyn-relocs=android";

Works for MinSDKVersion >= 23 and still yields a noticeable size reduction.

Resource Trimming

Third‑Party Plugin Files (GVoice Example)

Identify unused model files (e.g., wave_dafx_data.bin, wave_3d_data.bin, cldnn_spkvector.mnn) and remove them. Keep only required files such as libgvoicensmodel.bin. Adjust the copy logic in GVoice_APL.xml to copy only the needed files:

<resourceCopies>
    <log text="Start copy res..."/>
    <!-- Only copy libgvoicensmodel.bin and config.json -->
    <copyFile src="$S(PluginDir)/../GVoiceLib/Android/assets/libgvoicensmodel.bin" dst="$S(BuildDir)/assets/libgvoicensmodel.bin" force="true"/>
    <copyFile src="$S(PluginDir)/../GVoiceLib/Android/assets/config.json" dst="$S(BuildDir)/assets/config.json" force="true"/>
</resourceCopies>

Game Assets

Assets are either packed into pakchunk0 or placed in DirectoriesToAlwaysStageAsNonUFS (e.g., Content/Movies). Optimize by:

Keeping only essential engine assets ( /Engine shaders, ini files, startup map, etc.).

Removing non‑startup resources.

Lazy‑loading optional assets (e.g., localization files).

Splitting fonts and other large assets for dynamic download.

Configure DefaultEngine.ini to exclude .pak files from the APK on Android:

; Config/DefaultEngine.ini
[/Script/AndroidRuntimeSettings.AndroidRuntimeSettings]
+ObbFilters=-*.pak
+ObbFilters=pakchunk0-*

For other platforms a custom filter (e.g., the “HotChunker” extension) can be used.

Overall Results

Combining all the above techniques reduced the game’s APK from 1.23 GB to ~130 MB, the original libUE4.so from 258 MB to 132 MB, and runtime memory usage by dozens of megabytes, while keeping full functionality and enabling dynamic asset delivery.

Additional References

UE Plugin & Tool Development: Core Concepts

Resource Management: Reshaping UE Package Splitting

UE Resource Management: Engine Packaging Analysis

Reducing Packaged Game Size (Epic Docs)

Google Play App Size Limits