Unity supports many common image formats as source files for importing your Textures (such as JPG, PNG, PSD, and TGA). However, 3D graphics hardware, such as graphics cards or mobile devices, doesn’t use these formats during real-time rendering. This hardware requires Textures to be compressed in specialized formats which are optimized for fast Texture sampling. Different platforms and devices each have their own proprietary formats.
By default, the Unity Editor automatically converts Textures to the most appropriate format to match the build target you have selected, and only includes converted Textures in the build. Your source Asset files remain in their original format in your Project’s Assets folder. However, most platforms support several Texture compression formats you can choose from.
Unity has default formats for each platform, but you can override them and choose different compression formats for some of your Textures (for example, if you are using a Texture as a mask, with only one channel, you might choose to use the BC4 format to reduce file size but preserve quality).
This page contains the following information:
For general information about importing Textures and how to set up overrides, see Texture Import Settings.
This page uses the following concepts:
The following table shows the default formats used for each platform.
| Platform | Color model | None | Normal quality (default) | High quality | Low quality (higher performance) |
|---|---|---|---|---|---|
| Windows, Linux, macOS, PS4, XBox One | RGB | RGB 24 bit | RGB Compressed DXT1 | RGB(A) Compressed BC7 | RGB Compressed DXT1 |
| RGBA | RGBA 32 bit | RGBA Compressed DXT5 | RGB(A) Compressed BC7 | RGBA Compressed DXT5 | |
| HDR | RGBA Half | RGB Compressed BC6H | RGB Compressed BC6H | RGB Compressed BC6H | |
| WebGL | RGB | RGB 24 bit | RGB Compressed DXT1 | RGB Compressed DXT1 | RGB Compressed DXT1 |
| RGBA | RGBA 32 bit | RGBA Compressed DXT5 | RGBA Compressed DXT5 | RGBA Compressed DXT5 | |
| Android (only when Don’t override is enabled in the build settings) | RGB | RGB 24 bit | RGB Compressed ETC | RGB Compressed ETC | RGB Compressed ETC |
| RGBA | RGBA 32 bit | RGBA Compressed ETC2 | RGBA Compressed ETC2 | RGBA Compressed ETC2 | |
| iOS | RGB | RGB 24 bit | RGB Compressed PVRTC 4 bits | RGB Compressed PVRTC 4 bits | RGB Compressed PVRTC 2 bits |
| RGBA | RGBA 32 bit | RGBA Compressed PVRTC 4 bits | RGBA Compressed PVRTC 4 bits | RGBA Compressed PVRTC 2 bits | |
| tvOS | RGB | RGB 24 bit | RGB Compressed ASTC 6x6 block | RGB Compressed ASTC 4x4 block | RGB Compressed ASTC 8x8 block |
| RGBA | RGBA 32 bit | RGBA Compressed ASTC 6x6 block | RGBA Compressed ASTC 4x4 block | RGBA Compressed ASTC 8x8 block | |
| Default | RGBA | RGBA 32 bit | RGBA 16 bit | RGBA 16 bit | RGBA 16 bit |
The following tables show the Texture compression format options available on each platform, and the resulting compressed file size on disk (based on a 256 by 256 pixel image).
Choosing a Texture compression format is a balance between file size, quality and compression time: the higher the quality, the greater the file size. For the best performance, especially on mobile devices, use the format with the fewest bits per pixel that is supported by the hardware your application targets, as long as that format provides sufficient visual quality.
Different platforms have different hardware, and are optimised to work most efficiently with specific compression formats. When you use a Texture compression format that the target platform supports, the GPU can use it directly and the platform doesn’t spend any resources to decompress the Texture to a supported format. This can improve your application’s performance.
If you use a Texture compression format that the target platform doesn’t support, Textures are decompressed to RGBA 32 bit (unless noted otherwise) and stored in memory alongside the compressed Textures. This increases texture loading time and uses additional memory, which means that choosing non-compatible formats can impact your application’s performance.
The tables below show supported platforms for each compression format.
Note: Size in memory is based on a 256 x 256 pixel Texture.
| Texture compression format | Description | Size in memory | Windows | Linux | Mac | PS4 | Xbox One | Android | iOS | tvOS | WebGL |
|---|---|---|---|---|---|---|---|---|---|---|---|
| RGB Compressed DXT1 | Compressed unsigned normalised integer RGB Texture. | 32KB / 4 bpp | yes | yes | yes | yes | yes | partial (1) | no | no | partial (2) |
| RGB Crunched DXT1 | RGB Compressed DXT1, with additional Crunch compression. | VBR | yes | yes | yes | yes | yes | partial (1) | no | no | partial (2) |
| RGBA Compressed DXT5 | Compressed unsigned normalised integer RGBA Texture. | 64KB / 8 bpp | yes | yes | yes | yes | yes | partial (1) | no | no | partial (2) |
| RGBA Crunched DXT5 | RGBA Compressed DXT5, with additional Crunch compression. | VBR | yes | yes | yes | yes | yes | partial (1) | no | no | partial (2) |
| RGB Compressed BC6H | Compressed unsigned float/High Dynamic Range (HDR) RGB Texture. | 64KB / 8 bpp | partial (3) | yes | partial (3) | yes | yes | no | no | no | no |
| RGB(A) Compressed BC7 | High-quality compressed unsigned normalised integer RGB or RGBA Texture. | 64KB / 8 bpp | partial (3) | yes | partial (3) | yes | yes | no | no | no | no |
| RGB 16 bit | Uncompressed format with 65536 colors without alpha. Uses more memory than the compressed formats, but could be more suitable for UI or crisp Textures without gradients. | 128KB / 16 bpp | yes | yes | yes | yes | yes | yes | yes | yes | yes |
| RGB 24 bit | True color, without alpha. | 192KB / 24 bpp | yes | yes | yes | yes | yes | yes | yes | yes | yes |
| RGB9e5 32 Bit Shared Exponent Float | Floating-point / High Dynamic Range (HDR) texture without alpha channel. | 256 KB / 32 bpp | yes | yes | yes | yes | yes | partial (4) | partial (4) | partial (4) | partial (4) |
| Alpha 8 | High-quality uncompressed alpha channel. | 64KB / 8 bpp | yes | yes | yes | yes | yes | yes | yes | yes | yes |
| R 8 | High-quality uncompressed single-channel texture. | 64KB / 8 bpp | yes | yes | yes | yes | yes | partial (5) | partial (5) | partial (5) | partial (5) |
| R 16 bit | Ultra-high-quality uncompressed single-channel texture. | 128KB / 16 bpp | yes | yes | yes | yes | yes | partial (6) | partial (6) | partial (6) | no |
| RGBA 16 bit | Low-quality true color. | 128KB / 16 bpp | yes | yes | yes | yes | yes | yes | yes | yes | yes |
| RGBA 32 bit | True color with alpha. | 256KB / 32 bpp | yes | yes | yes | yes | yes | yes | yes | yes | yes |
| RGBA Half | Half-precision floating point / High Dynamic Range (HDR) RGBA format. | 512KB / 64bpp | yes | yes | yes | yes | yes | partial (7) | partial (7) | partial (7) | partial (7) |
Notes:
You can import Textures from DDS files, but only DXT, BC compressed formats, or uncompressed pixel formats are supported.
The formats in the table below are only supported on Android, iOS, tvOS, and WebGL.
Note: Size is based on a 256 x 256 pixel Texture.
| Texture compression format | Description | Size | Android | iOS | tvOS | WebGL |
|---|---|---|---|---|---|---|
| RGB Compressed ETC | Compressed RGB Texture. This format is supported by all OpenGL ES 2.0 GPUs. | 32KB / 4 bpp | yes | yes | yes | partial (1) |
| RGB Crunched ETC | RGB Compressed ETC, with additional Crunch compression. | VBR | yes | yes | yes | partial (1) |
| RGB Compressed ETC2 | Compressed RGB Texture. | 32KB / 4 bpp | partial (2) | partial (3) | partial (3) | partial (1) |
| RGBA Compressed ETC2 | Compressed RGBA Texture. This format is supported by all OpenGL ES 3.0 GPUs. | 64KB / 8 bpp | partial (2) | partial (3) | partial (3) | partial (1) |
| RGBA Crunched ETC2 | RGBA Compressed ETC2, with additional Crunch compression. | VBR | partial (2) | partial (3) | partial (3) | partial (1) |
| RGB + 1-bit Alpha Compressed ETC2 4 bits | Compressed RGBA texture with alpha channel limited to either fully opaque or fully transparent. | 32KB / 4 bpp | partial (2) | partial (3) | partial (3) | partial (1) |
| RG Compressed EAC 8 bit | High-quality compressed RG (two-channel) texture. | 64KB / 8 bpp | partial (2) | partial (3) | partial (3) | partial (1) |
| R Compressed EAC 4 bit | High-quality compressed R (single-channel) texture. | 32KB / 4 bpp | partial (2) | partial (3) | partial (3) | partial (1) |
| RGB(A) Compressed ASTC | Variable block size compressed RGB or RGBA Texture. This format is supported by all OpenGL ES 3.1 and Vulkan GPUs. | 12x12: 7744 bytes / 0.89 bpp 10x10: 10816bytes / 1.28 bpp 8x8: 16KB / 2 bpp 6x6: 29584 bytes / 3.56 bpp 5x5: 43264 bytes / 5.12 bpp 4x4: 64KB / 8 bpp |
partial (4) | partial (5) | yes | partial (6) |
| RGB(A) Compressed ASTC HDR | Variable block size compressed unsigned float/High Dynamic Range (HDR) RGB or RGBA Texture. | 12x12: 7744 bytes / 0.89 bpp 10x10: 10816bytes / 1.28 bpp 8x8: 16KB / 2 bpp 6x6: 29584 bytes / 3.56 bpp 5x5: 43264 bytes / 5.12 bpp 4x4: 64KB / 8 bpp |
partial (7) | no | no | no |
| RGB Compressed PVRTC 2 bits (8) | High-compression RGB Texture. | 16KB / 2 bpp | partial (9) | yes | yes | no |
| RGBA Compressed PVRTC 2 bits | High-compression RGBA Texture. | 16KB / 2 bpp | partial (9) | yes | yes | no |
| RGB Compressed PVRTC 4 bits | Compressed RGB Texture. | 32KB / 4 bpp | partial (9) | yes | yes | no |
| RGBA Compressed PVRTC 4 bits | Compressed RGBA Texture. | 32KB / 4 bpp | partial (9) | yes | yes | no |
Notes:
Default texture compression settings (PVRTC) are chosen for broader compatibility. If your application does not include OpenGL ES 2 support, you can choose one of the ASTC formats. They offer better quality and flexibility, and compression is faster than PVRTC.
Unity supports only tvOS devices that have Metal support. ASTC is the default texture compression on this platform. If you manually add OpenGL ES 2, make sure to change the texture compression to either PVRTC or ETC to avoid texture decompression at runtime.
Unless your app targets specific hardware (such as Nvidia Tegra or Imagination PowerVR), you have to choose between several compressed and uncompressed formats, which offer different trade-offs:
| Format | Description | Support |
|---|---|---|
| ASTC | The most flexible format, as it allows you to fine-tune file size and resulting quality using different block sizes. | Supported on all devices running Vulkan or OpenGL ES 3.1, and on some devices running OpenGL ES 3.0. |
| ETC2/EAC | Standard texture compression format for OpenGL ES 3.0. The resulting image quality is quite high, and it supports one- to four-component texture data. It’s not supported by OpenGL ES 2 devices, so the texture is decompressed at run time to the format specified by ETC2 fallback. | Supported on OpenGL ES 3.0. Not supported on OpenGL ES 2. |
| ETC | Block-based Texture compression format. The image is split up into 4×4 blocks, and each block is encoded using a fixed number of bits. The drawback is that there is no direct alpha channel support, so it’s not suitable for textures that have transparency information. Unity provides an automated way of handling texture with alpha channels placed in a texture atlas (you can specify this using a packing tag on sprites). To enable this, enable the Android-specific Split Alpha Channel option for the Texture when importing a Sprite Atlas. Unity splits the resulting atlas into two Textures, one with RGB data and one with alpha channel data duplicated in all three (RGB) channels, and then combines them in the final parts of the render pipeline. |
Supported on all Android devices. |
| RGBA 16 bit | Uncompressed format that has an alpha channel. It takes twice as much memory as ETC2. This is a reasonably good format to choose for pixel-perfect UI without strong gradients. | Supported on all devices. |
| RGBA 32 bit | Uncompressed format that offers highest quality and has alpha channel support. It takes four times as much memory compared to ETC2. This is a format of choice for the best-looking, pixel-perfect UI. | Supported on all devices. |
For high dynamic range (HDR) textures, choose from one of the following formats:
You can publish multiple Android packages (APKs) that target different hardware. For example, to publish two separate APKs (one that targets devices that support OpenGL ES 3.0 and newer, and another for OpenGL ES 2.0-only devices), follow these steps:
1. Build an APK that targets OpenGL ES 3.
2. Build a separate APK that targets OpenGL ES 2
3. Publish both of these APKs to the Google Play Store.
When a user downloads your app, the Google Play Store automatically installs the most relevant APK for their device.
For more information about publishing multiple APK files, see Android Developer documentation on: