Optimize and automate your asset import configuration settings
In our previous article, we looked at how you can use presets to standardize import settings for audio clips so they’re automatically applied when you add them to your project. If you’re new to the preset workflow or simply need a refresher, consider checking out that article first before continuing.
Presets can be applied to much more than audio, providing big performance gains when used to optimize import settings for textures, video clips, and 3D models.
In this article, we’ll look at some recommended settings which can serve as a starting point for your own presets. As always, the best settings are what work for your specific use case, depending on genre, platform, etc. However, with the disclaimer out there, I teamed up with Martin Dejean, senior software engineer from the audio team and Anthony Rosenbaum, senior software development consultant, who helped provide some general guidelines.
I’ve written them as a reference guide, so feel free to skip to the sections you are interested in if they don’t always apply. I should also note that there is rarely a single solution that works for everyone. The specifications will vary a lot depending on whether your target device is a low-end mobile or high-end PC/console, game genre, etc. So I added a brief summary of what the main differences could look like for each. Use them as a starting point for your own project and adapt them to your specific needs.
Table of Contents
TextureImporters
Some of the highest-impact gains come from Texture Importer presets. UI textures, normal maps, and albedo or world textures often represent a large portion of a project’s memory and rendering cost, so consistent import rules can prevent common mistakes and significantly improve performance. Let’s take a look at each type:
UI sprites
UI textures are used frequently, but the files are usually small in terms of size. The performance bottlenecks you want to look out for in UI are rarely texture memory, but are usually related to batching and overdraw. UI compression artifacts are, however, far more noticeable than in-world texture compression. A block compression artifact on a floor tile is invisible at gameplay distance, but the same artifact on a menu button is immediately obvious. In terms of optimization, that means it’s more important that you prioritize visual quality over aggressive compression.
TLDR: Favor quality (RGBA32 or low compression) for UI, and use standard compression for everything else.
Texture
| Setting | Value | Notes |
|---|---|---|
| Texture Type | Sprite (2D and UI) | This ensures correct sprite handling and UI batching. |
| Sprite Mode | Single / Multiple | This depends on if you are using spritesheets, which you generally want to consider to minimize the draw calls. |
| Mesh Type | Full Rect | Full Rect ensures consistent quad geometry and avoids unnecessary vertex generation. Tight meshes add extra vertices for irregular shapes, which rarely benefits screen-space UI and can increase CPU/GPU cost without reducing meaningful overdraw. |
| Extrude Edges | 0 | Use this to primarily prevent bleeding between atlas sprites when mipmaps or compression are involved. For screen-space UI with mipmaps disabled and clamp wrap mode, extrusion is unnecessary. |
| Pivot | Default | UI elements often rely on specific pivots and layout logic, so it’s best to leave as defined by the asset (do not standardize in preset). See the note below on Partial Presets and how to skip it. |
| Generate Physics shape | OFF | UI sprites rarely use physics and generating physics shapes is just overhead. |
Advanced
| Setting | Value | Notes |
|---|---|---|
| sRGB (Color Texture) | ON | UI textures represent color data and should be sampled in sRGB space so Unity correctly converts them to linear color space during rendering. |
| Alpha Source | Input Texture Alpha | Assuming your UI sprites rely on transparency and your texture file (PNG, PSD, etc.), you should use the contained alpha channel for UI. |
| Alpha Is Transparency | ON | This enables alpha dilation during import, reducing filtering artifacts and preventing dark halos along transparent sprite edges. |
| Read/Write | OFF | Leave Read/Write OFF unless you explicitly need CPU pixel access to modify textures at runtime. Setting it to OFF helps you avoid doubling memory footprint. |
| Mip Maps | OFF | UI is rendered in screen space; mipmaps waste memory and introduce blur. |
| Wrap Mode | Clamp | This prevents edge bleeding artifacts when scaling or using sliced sprites. |
| Filter Mode | Bilinear | This prevents pixel crawl on scaled UI. Use Point only for pixel-art UI. |
Compression
| Setting | Value | Notes |
|---|---|---|
| Max Size | 512–1024 (project dependent) | Use this to prevent accidental oversized UI textures. While it’s tempting to go for 2048, you generally want to cap aggressively to avoid GPU bound issues. |
| Resize Algorithm | Mitchell | Mitchell provides a good balance between sharpness and smoothness and is a safe general-purpose default. |
| Format | RGBA32 (or equivalent uncompressed format) | Use this to prevent block compression artifacts and preserve clean alpha channels. |
| Compression | None or Low Quality | UI compression artifacts (especially banding and alpha issues) are highly visible; favor visual clarity. |
| Use Crunch Compression | Option disabled | This gets disabled with the above settings. |
Platform differences – UI sprites
| Platform | Format | Compression | Notes |
|---|---|---|---|
| PC / Console | RGBA32 (uncompressed) | None | Memory is less constrained. Uncompressed preserves perfect alpha and avoids all block artifacts. |
| Mobile (Android/iOS) | ASTC 4x4 | Low Quality | RGBA32 is too expensive on mobile: A single 2048 UI atlas at RGBA32 is 16 MB. ASTC 4x4 is visually near-lossless for UI and 4–8x smaller. Only fall back to ETC2 on devices that don’t support ASTC (rare on modern hardware). |
Tip: Consider using Partial Presets
You don’t have to apply every setting; instead you have the option to use Partial Presets.
In the Preset Inspector, you can right-click specific properties and select Exclude Property. This allows you to create “surgical” presets that only enforce specific settings (like turning off “Raycast Target” on UI components) without overwriting everything else. In our example here you exclude the pivot so the control is with the designer.
For Sprite Atlases you generally want to use the same settings except that large atlases benefit from compression but also need a higher max size. So consider using Max Size: 2048 or 4096 (carefully controlled) and avoid accidental 8K atlases.
Albedo / world textures
World textures (albedo/diffuse) are the color maps applied to 3D surfaces in your scene. Unlike UI textures, these are viewed at varying distances and oblique angles, so mipmaps and anisotropic filtering are essential for visual quality. Compression can be more aggressive here than with UI since in-world artifacts are far less noticeable than on flat screen-space elements.
Texture Type
| Setting | Value | Notes |
|---|---|---|
| Texture Type | Default | This is the standard texture import for 3D surface use. |
Advanced
| Setting | Value | Notes |
|---|---|---|
| sRGB (Color Texture) | ON | Albedo maps represent color data and must be gamma-corrected for correct rendering in linear color space. |
| Mip Maps | ON | This is required for proper distance rendering. Without mipmaps, distant surfaces will shimmer and alias. |
| Mip Map Filtering | Box or Kaiser | Use this to reduce shimmering and moire patterns at distance. Kaiser produces slightly sharper results; Box is a safe default. |
| Wrap Mode | Repeat | Most tiling materials (floors, walls, terrain) require seamless repetition. Use Clamp only for unique, non-tiling textures. |
| Filter Mode | Bilinear | The standard filtering for most use cases. Trilinear smooths visible mipmap band transitions but has a GPU cost — see platform notes below. |
| Aniso Level | See platform notes | Improve clarity on surfaces viewed at oblique angles (floors, roads, walls). The value should differ by platform. |
Compression
| Setting | Value | Notes |
|---|---|---|
| Max Size | See platform notes | Prevents accidental 8K texture imports. The value should differ by platform. |
| Compression | Normal Quality | This uses platform-specific formats automatically and helps to balance quality and memory. |
Platform differences – Albedo
| Setting | PC / Console | Mobile |
|---|---|---|
| Aniso Level | 4–8 (GPU headroom allows it; significantly improves floors, roads, walls at oblique angles) | 1–2 (anisotropic filtering is expensive on mobile GPUs; keep low or disabled) |
| Filter Mode | Bilinear (Trilinear acceptable where mip banding is visible) | Bilinear only (Trilinear has a measurable GPU cost on mobile) |
| Max Size | 1024–2048 default, consider 4096 for hero assets | 1024 default, 2048 and above only for hero assets and in practice you rarely need 4096 |
| Compression Format | BC7 (high quality, 4 channel support) | ASTC 4x4–6x6 (preferred), ETC2 as fallback on older devices. ASTC handles alpha better than ETC2. |
Note: Mipmaps are mandatory for 3D world textures to prevent aliasing. A world texture without mipmaps will shimmer aggressively at any distance beyond close-up, especially on surfaces like floors and walls viewed at grazing angles.
Normal maps
Normal maps encode surface detail as directional data in tangent space. They are not color data — they are mathematical vectors packed into texture channels. Importing them incorrectly (wrong type or wrong color space) will produce visibly broken lighting across your entire scene.
Recommended settings for textures in /Textures/Environment/Normal/:
Texture Type
| Setting | Value | Notes |
|---|---|---|
| Texture Type | Normal Map | This setting is critical as it tells Unity to treat the texture as tangent-space normal data. It enables correct swizzling and platform-specific encoding. |
Advanced
| Setting | Value | Notes |
|---|---|---|
| sRGB (Color Texture) | OFF (auto-set) | Normal maps are linear data. Unity automatically forces sRGB OFF when Texture Type is set to Normal Map. Documented here to explain why — applying gamma correction distorts the encoded directions and produces incorrect lighting. |
| Mip Maps | ON | Use this setting to prevent lighting shimmer and specular aliasing at distance. Normal maps without mipmaps cause noisy, flickering highlights. |
| Wrap Mode | Repeat | Tiling normal maps must repeat seamlessly to match their corresponding albedo textures. |
| Filter Mode | Bilinear | This is a standard filtering setting. Trilinear can help smooth mipmap transitions on normals but has a GPU cost on mobile. |
Compression
| Setting | Value | Notes |
|---|---|---|
| Max Size | See platform notes | Normal maps can often be one step smaller than their corresponding albedo without visible loss. |
| Compression | Normal Quality | Compression uses dedicated normal map formats when Texture Type is set to Normal Map. See platform notes for specifics. |
Platform differences – Normal maps
| Setting | PC / Console | Mobile |
|---|---|---|
| Max Size | 2048 default (match or halve albedo size) | 1024 default (can often be half of albedo without visible loss) |
| Compression Format | BC5 (two-channel RG format, ideal for tangent-space normals) | ASTC 5x5 or 6x6 (normals tolerate slightly more aggressive block sizes than albedo; still visually correct). ETC2 as fallback — note ETC2 is RGB-based and less optimal for two-channel normal data. |
Warning: Incorrect import (sRGB ON or Default texture type) will produce visibly wrong lighting. Surfaces will appear flat, overly shiny, or have strange specular artifacts. If lighting looks “off” on an otherwise correct material, check the normal map import settings first.
Masks (Metallic / Roughness / AO / Packed Maps)
Mask textures store per-pixel material properties like metallic, roughness (smoothness), ambient occlusion, height, or combinations packed into RGBA channels. Like normal maps, these are data textures, not color. The shader reads exact numeric values from each channel, so any color space conversion or heavy compression will directly corrupt your material response.
Recommended settings for textures in /Textures/Environment/Masks/:
Texture Type
| Setting | Value | Notes |
|---|---|---|
| Texture Type | Default | This is the standard texture import. Unity does not have a dedicated “Mask” type. |
Advanced
| Setting | Value | Notes |
|---|---|---|
| sRGB (Color Texture) | OFF | Masks are linear data. Leaving sRGB ON applies gamma correction, which shifts the numeric values the shader reads and breaks shading accuracy (e.g., metallic boundaries shift, roughness response changes). |
| Mip Maps | ON | Maintain correct material response at distance. Without mipmaps, roughness and metallic transitions will alias. |
| Single Channel | ON (if applicable) | When a mask uses only one channel (e.g., a standalone roughness or AO map), enabling this reduces memory by storing only the single channel instead of full RGBA. This is not applicable for packed maps using multiple channels. |
| Wrap Mode | Repeat | This should match the wrap mode of the corresponding albedo and normal maps. |
| Filter Mode | Bilinear | Standard filtering for data textures. |
Compression
| Setting | Value | Notes |
|---|---|---|
| Max Size | See platform notes | Mask textures can often be smaller than albedo without visible loss, since they encode smooth gradients rather than fine detail. |
| Compression | Normal Quality | Avoid very low quality compression — banding artifacts show easily in mask data, especially in smoothness/roughness channels where gradients are critical to specular response. |
Platform differences – Masks
| Setting | PC / Console | Mobile |
|---|---|---|
| Max Size | 1024–2048 (can often be half of albedo) | 512–1024 (smooth gradients compress well at lower resolutions) |
| Compression Format | BC7 (high quality, preserves all four channels for packed maps) | ASTC 4x4–5x5 (keep block size modest to avoid banding in smoothness/roughness gradients). Use higher quality settings than you would for albedo; banding in mask channels produces visible specular artifacts. |
Warning: Mask textures are data, not color. Leaving sRGB ON is the single most common mistake with mask imports and will break shading accuracy across every material using that texture.
3D models (FBX)
Model import settings have a large impact on visual correctness, memory, and runtime performance. A bad default (wrong scale, missing tangents, unnecessary Read/Write) can silently break lighting, inflate memory, or cause physics issues across every mesh in the project. Presets are especially valuable here because model import has many tabs and settings that are easy to misconfigure.
Recommended settings for models in /Models/:
Model Tab
| Setting | Value | Notes |
|---|---|---|
| Scale Factor | 1.0 (Blender) | Blender’s FBX exporter uses meters by default, matching Unity’s unit scale. For Maya/3ds Max, use 0.01 — these tools work in centimeters, so the scale factor converts centimeters to Unity’s meters. |
| Convert Units | ON | This enables Unity to apply the FBX file’s embedded unit scale. It works correctly with Blender’s default export. If you see models at 100x size, this setting or Scale Factor is wrong. |
| Import BlendShapes | OFF (unless needed) | BlendShapes add memory and processing cost. Only enable on models that actually use them (facial animation, morph targets). |
| Import Visibility | OFF | Blender visibility states rarely map correctly to Unity. Control visibility through Unity’s own systems. |
| Import Cameras | OFF | Cameras embedded in FBX are almost never wanted. Use Cinemachine instead. |
| Import Lights | OFF | Light data from DCC tools rarely transfers correctly. Light your scenes in Unity. |
| Mesh Compression | Off | Mesh compression can introduce vertex snapping artifacts, especially on smooth surfaces and small props. The memory savings are minimal compared to texture compression. Only enable this for very high-poly background meshes where minor artifacts are invisible. |
| Read/Write | OFF | This halves mesh memory by not keeping a CPU copy. Only enable it if you need runtime mesh access (procedural deformation, mesh collider baking at runtime). |
| Optimize Mesh | Everything | Use it to reorder vertices and indices for GPU cache efficiency. No visual change, free performance. |
| Generate Colliders | OFF | Do not auto-generate mesh colliders on every imported model. Add colliders intentionally; most objects should use primitive colliders (Box, Sphere, Capsule) for performance. Mesh colliders are expensive and should be reserved for complex static geometry. |
Normals and Tangents
| Setting | Value | Notes |
|---|---|---|
| Normals | Import | Use the normals authored in your DCC tool. Only use Calculate if the source file has broken normals. None strips normals entirely (only for unlit meshes). |
| Tangents | Calculate Mikktspace | This is the industry standard for PBR normal mapping. It matches Blender’s default tangent space. Using a different tangent basis will produce subtle but incorrect normal map lighting. |
Materials Tab
| Setting | Value | Notes |
|---|---|---|
| Material Creation Mode | None | Do not let Unity auto-create materials from FBX files. Extracted/auto-generated materials are hard to manage and usually wrong. Create and assign materials manually in Unity using your own shaders and textures. |
Rig Tab (for static/prop models)
| Setting | Value | Notes |
|---|---|---|
| Animation Type | None | Static props and environment models don’t need a rig. Setting this to None avoids unnecessary skinning overhead. For character models, create a separate preset with Animation Type set to Humanoid or Generic as needed. |
Animation Tab
| Setting | Value | Notes |
|---|---|---|
| Import Animation | OFF | For a general-purpose static model preset, disable animation import. For models with embedded animations, use a separate preset with this enabled and configure clip extraction, compression (Optimal), and keyframe reduction. |
Tip: Consider creating multiple model presets: one for static props/environment (Animation Type: None, Import Animation: OFF), one for characters (Animation Type: Humanoid, Rig configured), and one for animated props (Animation Type: Generic).
Animation clips
Animation compression and keyframe reduction are the primary levers for controlling animation memory and file size. Uncompressed animations can be surprisingly large — a single character’s animation set can easily consume more memory than all of its textures combined if left at default settings. The goal is aggressive compression with error thresholds low enough that artifacts aren’t visible during gameplay.
| Setting | Value | Notes |
|---|---|---|
| Anim. Compression | Optimal | Unity selects the best compression per-curve. Keyframe Reduction only reduces keys; Optimal also quantizes values. The memory savings over Keyframe Reduction are significant with no visible quality loss in most cases. |
| Rotation Error | 0.5 | This determines how much rotation (in degrees) can deviate from the source before a keyframe is preserved. 0.5 is a good default as it’s tight enough for character animation, but loose enough for meaningful compression. Tighten to 0.1–0.2 for facial animation or precise hand movement. |
| Position Error | 0.5 | This sets how much position (in percent of range) can deviate. 0.5 works for most gameplay animation. Tighten for root motion or precise world-space movement. |
| Scale Error | 0.5 | Sets a limit for how much scale can deviate. Most animations don’t animate scale, so this rarely matters. If you use scale animation (squash/stretch), tighten to 0.1–0.2. |
| Animated Custom Properties | OFF (unless needed) | Only enable this if your animations drive custom material properties or script values via animation curves as it adds performance overhead. |
| Resample Curves | ON | Use this to resample curves to match Unity’s fixed timestep. Disabling it can cause interpolation issues. Set to ON if you have specific reasons (e.g., animations authored at exact frame rates that must be preserved). |
Platform differences – Animation
| Setting | PC / Console | Mobile |
|---|---|---|
| Anim. Compression | Optimal (same on all platforms) | Optimal (same – no platform-specific format) |
| Error Thresholds | 0.5 default (tighten for cinematics) | 0.5–1.0 (can afford slightly more aggressive reduction on mobile to save memory) |
Note: Animation compression is not platform-specific in the same way texture compression is; the same compressed clip plays identically everywhere. The main mobile concern is total animation memory budget, so consider slightly higher error thresholds or fewer total clips rather than different compression formats.
Video clips
Video files are often the single largest assets in a build. A single uncompressed or poorly configured video can exceed the total size of all textures combined. Unity’s video importer transcodes source files into platform-appropriate formats, but the defaults are not aggressive enough for most projects. Presets prevent accidental multi-gigabyte builds from a handful of cutscenes.
Recommended settings for video in /Video/:
| Setting | Value | Notes |
|---|---|---|
| Transcode | ON | This converts source video into a platform-optimized format at import. Without transcoding, Unity uses the source file as-is, which may not be playable on all platforms and is usually larger than necessary. |
| Codec | H.264 | This provides the broadest hardware decoder support across all platforms. H.265 offers better compression but has inconsistent hardware support, especially on older Android devices and WebGL. Use H.265 only if you’ve verified target platform support. |
| Bitrate Mode | Low (or Medium for cutscenes) | Use this to control the quality/size tradeoff. Low is fine for UI backgrounds and tutorials. Medium for narrative cutscenes. Avoid High unless you’re shipping a cinematic-quality product and have the budget for large builds. |
| Spatial Quality | Low Quality (or Medium for cutscenes) | Affect spatial detail with this setting. It’s the same tradeoff as bitrate, lower is smaller. UI/tutorial clips tolerate low quality. Full-screen cutscenes may need Medium. |
| Import Audio | ON (if video has audio) | Strip audio tracks from videos that don’t need them (looping backgrounds, UI animations). Keeping unnecessary audio wastes space. For videos with dialogue or SFX, leave ON and control audio through Unity’s audio system. |
| Keep Alpha | OFF (unless needed) | Alpha channel video is extremely expensive in file size. Only enable for transparent overlay videos (rare). Most videos are opaque. |
| Deinterlace | OFF | This setting is only relevant for interlaced source material (broadcast/TV footage). Game assets are almost always progressive. |
| Flip Horizontally/Vertically | OFF | Use this when you only need to correct source material orientation issues. |
Platform differences – Video
| Setting | PC / Console | Mobile |
|---|---|---|
| Codec | H.264 (H.265 acceptable if targeting modern hardware) | H.264 (safest – H.265 hardware decoding is inconsistent on Android; fine on iOS) |
| Max Resolution | 1920x1080 for cutscenes, 1280x720 for UI/tutorial | 1280x720 max for cutscenes, 854x480 for UI/tutorial; mobile screens are smaller so high resolution is wasted |
| Bitrate | Medium–High for cutscenes | Low–Medium (bandwidth and storage are constrained) |
Tip: Consider creating two video presets: one for full-screen cutscenes (higher quality, larger sizes) and one for UI/tutorial clips (aggressive compression, smaller resolution). The size difference can be enormous — a 1080p Medium cutscene at two minutes can be 30–50 MB, while the same clip at 480p Low can be 3–5 MB.
Fonts (TrueType/OpenType)
Font import settings control how Unity rasterizes TTF/OTF files into font textures. The main risks are oversized atlas textures from including unnecessary character sets, and blurry text from incorrect rendering modes. For projects using TextMeshPro, the font import preset covers the source font file — TMP Font Asset generation has its own settings configured through the TMP Font Asset Creator window.
Recommended settings for fonts in /Fonts/:
| Setting | Value | Notes |
|---|---|---|
| Font Size | 32–48 (project dependent) | Use this for the reference rasterization size. Larger values produce sharper glyphs but larger atlas textures. 32 is sufficient for body text, 48 for headers or if you display text at large screen sizes. |
| Rendering Mode | Smooth | This provides anti-aliased glyph rendering. Use Hinted Smooth for small body text where hinting improves readability at low sizes. Use OS Default only if you need platform-native rendering behavior. |
| Character | Dynamic | Rasterize glyphs on demand at runtime. This prevents massive atlas textures from pre-baking every character. Use Unicode or ASCII only if you need guaranteed upfront availability of specific character sets (e.g., localization with known character ranges). |
| Include Font Data | ON | This embeds the font file in the build. It’s required for Dynamic character mode to rasterize new glyphs at runtime. Only disable it if you’re using a fully pre-baked static character set. |
| Font Names | (leave empty) | Fallback font names for platform font matching. It’s only relevant if you’re referencing system fonts, which is uncommon for game projects. |
TextMeshPro font asset notes
TMP font assets are not created through the standard font importer but are generated via Window > TextMeshPro > Font Asset Creator. Key settings to standardize:
| Setting | Recommended Value | Notes |
|---|---|---|
| Sampling Point Size | 42–64 | This sets the SDF sampling size. Higher values produce sharper distance fields. 42 is TMP’s default and works well for most cases. You could consider using 64 for text displayed at very large sizes. Note that the ratio of Sampling Point Size to Padding should be consistent for any fallback fonts to ensure drop shadows/outline have the same look and feel. |
| Padding | 5–7 | This sets the space around each glyph in the atlas for SDF gradient. 5 is minimum for clean rendering while 7 gives more room for effects (outlines, shadows). |
| Atlas Resolution | 1024x1024 in most cases | Larger atlases fit more characters but consume more memory. 1024x1024 is usually sufficient for Latin character sets. |
| Render Mode | SDFAA | Signed Distance Field with anti-aliasing is the standard mode for TMP. Use SDF for slightly smaller atlases if you don’t need AA. Avoid Raster modes unless you specifically need pixel-perfect bitmap text. In the case where a static font is using a point size of 72 or larger, the font might look unclear or might not have a clean edge. In these cases you can change the TMP Font Asset’s Atlas Render Mode to SDF16. |
| Character Set | ASCII or Custom Range | Only include characters you actually use. “Extended ASCII” or full Unicode sets generate massive atlases. For localization, generate separate font assets per language with targeted character ranges. |
Platform differences – Fonts
| Setting | PC / Console | Mobile |
|---|---|---|
| TMP Atlas Resolution | 2048x2048 (4096 for CJK) | 1024x1024 (2048 for CJK) – atlas memory adds up on mobile, especially with multiple fonts |
| Font Size / Sampling | 48–64 (higher res screens benefit from sharper glyphs) | 32–42 (mobile screens are smaller; diminishing returns above 42) |
Important cross-category notes
Platform overrides matter
Use the per-platform texture overrides in the import settings that Unity provides. Each section above includes a platform differences table; this one is a summary.
| Setting | PC / Console | Mobile (Android/iOS) |
|---|---|---|
| Max Size | 2048 default | 1024 default, 2048 for hero assets only |
| Albedo Format | BC7 | ASTC 4x4–6x6 (preferred), ETC2 fallback |
| Normal Format | BC5 (two-channel) | ASTC 5x5–6x6, ETC2 fallback |
| Mask Format | BC7 | ASTC 4x4–5x5 |
| UI Format | RGBA32 (uncompressed) | ASTC 4x4 (near-lossless, much smaller) |
| Aniso Level | 4–8 | 1–2 |
| Filter Mode | Bilinear/Trilinear | Bilinear only |
| Video Codec | H.264 (H.265 where supported) | H.264 only |
| Video Max Res | 1920x1080 cutscenes, 1280x720 UI | 1280x720 cutscenes, 854x480 UI |
| TMP Atlas | 2048x2048 | 1024x1024 |
Mipmaps rule of thumb
The simplest rules to remember for mipmap settings across all texture categories:
| Category | Mipmaps |
|---|---|
| UI Textures | OFF |
| World Textures (Albedo) | ON |
| Normal Maps | ON |
| Mask Textures | ON |
If you remember only one rule from this document, remember this one. Incorrect mipmap settings are the most common cause of both wasted memory (UI) and visual artifacts (world textures).
Limit Max Size globally
The biggest production mistake is accidental 8K textures making it into builds. A single uncontrolled texture can consume more memory than dozens of properly sized ones. Always cap Max Size in presets; it’s easier to selectively increase size for hero assets than to hunt down oversized textures later.
Important workflow notes
-
Retroactive changes: Applying a preset in the Preset Manager only affects new imports. To fix existing assets, you must reimport them or right-click the asset and select “Reset” to force the new preset logic to apply.
-
Team sharing: Presets are actual asset files in your project (
.preset). You can export them as a.unitypackageto share strict import standards across your entire team or multiple projects. -
Presets vs. prefabs: Remember, presets save component settings (like a Light’s intensity or color), whereas prefabs save the entire GameObject hierarchy. They complement each other but serve different purposes.
Wrapping up
We hope this checklist can be helpful. Massive shout out to my colleagues Anthony and Martin for great input. Feel free to cherrypick what works for you and to disagree with my settings. As I wrote in the introduction the right settings vary depending on your specific situation so the right answer is what works for your project. The main takeaway is more that by taking a few minutes to set up these presets and filters, you move from a long to do list of “remembering to configure settings” to “guaranteed performance standards” without having to set it up manually,
With presets every new asset dropped into your project will simplify your optimization rules, leaving you free to focus on building the game. As always let us know if you have any thoughts in the comments.