Why Unity Keeps Importing Your Sprites as Multiple (and How to Stop It)

You drop a new PNG into Assets/Art/Characters, and instead of one clean sprite you get Sprite Mode “Multiple” — chopped into pieces, or into rectangles that clearly belong to a different image. If your project recently moved to Unity 6, that’s very likely Unity itself: since Unity 2023.1, a texture’s first import in a 2D project is sliced automatically. If not, something else in your import pipeline changed, and Unity is doing exactly what it was told.

This guide starts with how Unity decides a texture’s import settings, because once you know the order, the culprit is usually obvious. Then it covers every realistic cause, cheapest check first — the Unity 6 default, the file’s .meta, default presets, and AssetPostprocessor scripts from your code, packages, or plugins — with a fix for each, a safe way to repair sprites that were already changed, and a pattern for automating import settings without surprising your team. It covers Unity 2022.3 LTS and Unity 6.

How Unity picks import settings

Every import starts with one question: does the file already have a .meta file? The .meta holds the asset’s ID and values for all of its import settings. A file that arrives with one — copied from another project, unpacked from an asset package, or replaced on disk under the same name — keeps whatever Sprite Mode that .meta says. Only a file with no .meta gets fresh settings.

Fresh settings are built in layers: Unity’s defaults, which depend on your Unity version and on whether the project is in 2D or 3D mode, then default presets from the Preset Manager, then every AssetPostprocessor script. Unlike presets, scripts also run on reimports of files that already have a .meta.

Two facts from that pipeline do most of the diagnostic work:

• Presets only touch first imports. Unity applies default presets from its own internal postprocessor, only when importSettingsMissing is true — when the file has no .meta. Unity’s docs confirm that Reimport doesn’t reapply them.
• Scripts touch every import. Unity treats texture preprocessor scripts as an import dependency, so adding or removing one, or changing its GetVersion(), reimports your textures. In our tests, adding a script that forced Multiple changed existing sprites without anyone clicking Reimport.

The spec sheet

The hard facts this guide relies on.

What Multiple means

Sprite Mode decides how many sprites Unity makes from one texture. Single uses the whole image as one sprite. Multiple creates one sprite per SpriteRect, each as a child of the texture in the Project window. A Multiple texture with no rects has no sprites at all; one with the wrong rects gets cut in the wrong places.

When Multiple is expected

• Photoshop .psb files. The PSD Importer defaults to Multiple and makes a sprite per layer. Plain .psd files use the Texture Importer unless someone switched them — through the Inspector’s Importer dropdown (PSD Importer 9.x, Unity 6) or a SetImporterOverride script.
• Aseprite files. The Aseprite Importer creates its texture as Multiple. It comes preinstalled in new 2D projects from Unity 2022.3.2f1 on, so an .aseprite file behaves differently from its exported PNG.
• Sheets you sliced on purpose. Sprite Editor slicing works on Multiple textures, so every sheet you sliced yourself is Multiple by design.

If the Inspector shows PSD or Aseprite importer settings (Import Mode, Layer Import) instead of the plain texture settings, nothing is broken — export a PNG, or adjust that importer’s own settings.

Read the symptoms

Note which files are affected and when it started. The pattern usually points straight at the cause.

• New art since moving to Unity 6, in a 2D project. Unity’s own default. Start with Unity 6 changed the default.
• Multiple with no sprites after switching Texture Type to Sprite. Also the Unity 2023.1+ default, common in 3D-mode projects.
• Only brand-new files, and you’re still on 2022.3. Something that runs on first import: a default preset, or a script that checks importSettingsMissing.
• Existing sprites changed after a pull, package update, or reimport. A script, or Slice on Import on that texture. Presets never touch files that already have a .meta.
• Only files from one asset pack or another project. Their .meta files came along.
• Slices match the layout of a different image. A reused .meta, or a preset saved from a sliced sheet.
• Only one folder. A Preset Manager filter or a script that checks the path.

Ask version control

If the project is in Git, history often names the culprit in a minute. Run these from the project root:

# Did the Unity version change? (Unity 6 versions start with 6000.)
git log --oneline -p -- ProjectSettings/ProjectVersion.txt

# Who changed the default presets?
git log --oneline -- ProjectSettings/PresetManager.asset

# Which commits added scripts or preset files?
git log --oneline --name-only --diff-filter=A -- "*.cs" "*.preset"

# When did textures start being saved as Multiple?
git log --oneline -S "spriteMode: 2" -- "*.meta"

Unity 6 changed the default

Unity 2023.1 changed what a first import does in 2D mode, and every Unity 6 version inherits it. The release notes say the first import now generates sprites by detecting regions automatically, the same as Automatic slicing in the Sprite Editor. The texture arrives as Multiple, already sliced along transparent pixels. Unity’s issue tracker closed the matching “Multiple is now the default” report as intended behavior.

For a sheet with gaps between frames, that’s helpful. For a single drawing with detached parts — a lantern with a floating spark, a character with a separate shadow — it produces fragments named hero_0, hero_1, and so on. In our tests, Unity 2022.3 imported the same PNG as one Single sprite; Unity 6.1, 6.2, and 6.4 sliced it into one sprite per blob.

What changed, version by version

• Unity 2022.3, 2D mode. New images import as Sprite (2D and UI), Single.
• Unity 2023.1 and newer, 2D mode. New images import as Multiple, sliced automatically on first import.
• Unity 2023.1 and newer, switching to Sprite. Changing an existing texture’s Texture Type to Sprite gives Multiple with no sprites until you slice it.
• Unity 6.1 and newer, Slice on Import. A Sprite Editor option that re-slices a texture with its saved settings on every import. If one texture keeps re-slicing after art updates, check its Slice settings.

Fix: a Single default preset

A TextureImporter default preset with Sprite Mode Single restores the 2022.3 behavior for new files, no code needed. Make it from a texture that has never been sliced: a preset copies the importer’s saved slice rects, and in Unity 6 even a texture you switch to Single keeps the rects from its automatic first import.

1. Set Edit → Project Settings → Editor → Default Behavior Mode to 3D for a moment, so the next import isn’t sliced.
2. Drop a scratch PNG into the project, set Texture Type to Sprite (2D and UI) and Sprite Mode to Single, and click Apply.
3. Click the preset icon (the slider at the Inspector’s top right), choose Create New, and save it as SpriteSingle.preset.
4. Set Default Behavior Mode back to 2D and delete the scratch PNG.
5. Select the preset, click Add to default, then add a filter in the Preset Manager if only some folders should be Single.

In our Unity 6.4 tests, new PNGs then imported as Single with one sprite, and folders outside the filter kept automatic slicing. Existing textures don’t change — repair those separately.

Check the .meta file

If the Unity version didn’t change, start with the file itself — a .meta beats every other source of defaults. Unity’s docs are explicit: it holds values for all of the asset’s import settings and has to travel with the asset.

• Copied assets. Files copied from another project with their .meta, or unpacked from a .unitypackage (which stores import settings too), keep the original author’s Sprite Mode and slices.
• Replaced files. Overwrite hero_run.png on disk with a re-exported sheet and the old .meta stays. The new pixels get the old SpriteRects, which no longer line up.
• Merges. Taking a teammate’s version of a .meta in a conflict takes their Sprite Mode and slices too.

Check and fix

1. Open the texture’s .meta (same folder, same name plus .meta; the Project window hides it) in a text editor. spriteMode: 2 is Multiple, and each entry under spriteSheet → sprites is a slice.
2. If the art should be one sprite, set Sprite Mode to Single in the Inspector and click Apply.
3. If it’s a sheet with a new layout, open the Sprite Editor, delete the stale rects, slice again, and Apply.

Check default presets

If only new files are affected, open Edit → Project Settings → Preset Manager and look for a TextureImporter entry. A default preset there overrides Unity’s defaults for every new texture its filter matches — including a preset someone added for the Unity 6 fix above, set up wrong.

What to look for

• Sprite Mode. Select the preset asset each row points to and read its Sprite Mode in the Inspector.
• Filters. An empty Filter means every texture. In our tests, glob:"Sheets/**.png" matched a Sheets folder at any depth, a full path such as glob:"Assets/Art/Sheets/*.png" worked too, a plain Sheets without glob: didn’t match files in that folder, and Caps didn’t match caps.
• Order. Presets apply top to bottom, so a broad preset lower in the list can overrule a narrow one above it.
• Presets saved from a sliced sheet. In our tests, a default preset made from a sliced 128 × 128 sheet stamped its four rects onto a new 96 × 64 image, and only the one rect that fit became a sprite. Open the .preset in a text editor: m_SpriteSheet.m_Sprites.Array.size should have value: 0.
• Stray .preset files plus a folder script. The Unity Manual’s “apply default presets by folder” script applies every .preset in an asset’s folder chain on every import. If your project uses it, any TextureImporter .preset saved into an art folder becomes a rule.

Fix

Untick the preset’s checkbox to disable it (the filter is kept), correct it, or remove it, then test with a new file. Textures imported while it was active keep their settings, because Reimport doesn’t reapply presets — repair them instead. The Reset command in an importer’s context menu does reapply default presets, but it resets every other setting on that texture too.

Find import scripts

If existing sprites changed, or the Preset Manager is empty, look for an AssetPostprocessor. A script like this one, anywhere in an editor assembly, forces Multiple on every texture Unity imports, old or new:

using UnityEditor;

class SheetImportRules : AssetPostprocessor
{
    void OnPreprocessTexture()
    {
        var importer = (TextureImporter)assetImporter;
        // No folder check, no first-import check: every texture, every import.
        importer.spriteImportMode = SpriteImportMode.Multiple;
    }
}

It can come from your own code, a teammate’s tool, a package, or an Asset Store plugin — sprite-sheet importer plugins work exactly like this, often through Unity’s GenerateGridSpriteRectangles helper or the Sprite Editor Data Provider API.

Search the source

Packages/ holds embedded and local packages; Library/PackageCache is the project’s cache of installed registry and Git packages. Also check Packages/manifest.json for file: paths, which point at local packages stored elsewhere.

grep -rniE --include=*.cs \
  "AssetPostprocessor|OnPreprocess(Asset|Texture)|spriteImportMode|spritesheet|SetSpriteRects|SpriteRectangles" \
  Assets Packages Library/PackageCache

Get-ChildItem Assets, Packages, Library\PackageCache -Recurse -Filter *.cs |
  Select-String -Pattern 'AssetPostprocessor|OnPreprocess(Asset|Texture)|spriteImportMode|spritesheet|SetSpriteRects|SpriteRectangles'

List what’s actually loaded

Text search misses postprocessors compiled into DLLs. Save this script in any Editor folder and run Tools → Diagnostics → List Texture Postprocessors to log every loaded postprocessor that hooks texture import.

using System;
using System.Reflection;
using UnityEditor;
using UnityEngine;

static class ListTexturePostprocessors
{
    static readonly string[] Hooks =
        { "OnPreprocessAsset", "OnPreprocessTexture", "OnPostprocessTexture", "OnPostprocessSprites" };

    [MenuItem("Tools/Diagnostics/List Texture Postprocessors")]
    static void List()
    {
        const BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
        foreach (var type in TypeCache.GetTypesDerivedFrom<AssetPostprocessor>())
        {
            var used = Array.FindAll(Hooks, hook => type.GetMethod(hook, flags) != null);
            if (used.Length > 0)
                Debug.Log($"{type.FullName} [{type.Assembly.GetName().Name}]: {string.Join(", ", used)}");
        }
    }
}

Unity’s own entries appear too — PresetManagerPostProcessor (in UnityEditor.Presets) applies default presets, and from Unity 6.1 the 2D Sprite package adds SpriteSlicePostprocessor for Slice on Import. Focus on the rest: Assembly-CSharp-Editor is your project’s editor code, and other assembly names usually match a package or plugin.

Fix

• Your own or a teammate’s script. Scope it to a folder and to first imports, as shown in Automate it safely.
• A package or plugin. Look for a setting that limits its folders, or update or remove it. Don’t edit Library/PackageCache — Unity says not to touch the package cache; embed the package in Packages/ if you must change it.
• After removal. In our tests, textures a script had changed stayed changed after it was deleted, because the setting was saved into their .meta. Repair them next.

Repair affected sprites

Once the cause is gone, fix the textures it already changed. Commit first: changing Sprite Mode rewrites .meta files, and version control is your undo button.

A handful of files: the Inspector

1. Select the affected textures in the Project window (Ctrl- or Cmd-click, or Shift-click a range).
2. In the Inspector, set Sprite Mode to Single and click Apply. The texture Inspector edits the whole selection.
3. Spot-check prefabs, animation clips, and tile palettes that use those sprites.

Dozens or hundreds: a menu command

This editor script adds Assets → Sprite Mode Repair → Set Multiple to Single to the Project window’s context menu. It handles selected textures and everything in selected folders, and skips textures that aren’t Multiple or already have exactly one sprite — in Unity 6, a single drawing without gaps is auto-sliced into one working sprite that prefabs may already use.

using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEngine;

static class SpriteModeRepair
{
    // Right-click textures or folders in the Project window.
    [MenuItem("Assets/Sprite Mode Repair/Set Multiple to Single")]
    static void SetMultipleToSingle()
    {
        var paths = new HashSet<string>();
        foreach (var guid in Selection.assetGUIDs)
        {
            var path = AssetDatabase.GUIDToAssetPath(guid);
            if (AssetDatabase.IsValidFolder(path))
            {
                foreach (var found in AssetDatabase.FindAssets("t:Texture2D", new[] { path }))
                    paths.Add(AssetDatabase.GUIDToAssetPath(found));
            }
            else
            {
                paths.Add(path);
            }
        }

        var changed = 0;
        foreach (var path in paths)
        {
            // PSD and Aseprite files use other importers and are skipped here.
            var importer = AssetImporter.GetAtPath(path) as TextureImporter;
            if (importer == null || importer.spriteImportMode != SpriteImportMode.Multiple)
                continue;

            // Exactly one sprite already works, and prefabs may reference it.
            var spriteCount = AssetDatabase.LoadAllAssetsAtPath(path).OfType<Sprite>().Count();
            if (spriteCount == 1)
                continue;

            importer.spriteImportMode = SpriteImportMode.Single;
            EditorUtility.SetDirty(importer);
            importer.SaveAndReimport();
            changed++;
            Debug.Log($"Sprite Mode set to Single ({spriteCount} sprites before): {path}");
        }
        Debug.Log($"Sprite Mode Repair: changed {changed} of {paths.Count} texture(s).");
    }
}

It only uses spriteImportMode and SaveAndReimport(), which behave the same in 2022.3 and Unity 6, and it doesn’t touch slice data, which lives behind ISpriteEditorDataProvider. In our Unity 6.4 tests the rects stayed in the .meta, so switching a texture back to Multiple restored its slices.

Automate it safely

Automating import settings is fine; automation without limits is the problem. A well-behaved postprocessor only handles its own folder, only acts on a file’s first import, and only sets what it owns. This one gives Lantern Drift’s character art one sprite per file and leaves every other folder to Unity’s defaults.

using UnityEditor;

// Lantern Drift: character art imports as one sprite per file.
class CharacterSpriteDefaults : AssetPostprocessor
{
    const string CharacterFolder = "Assets/Art/Characters/";

    void OnPreprocessTexture()
    {
        // Only this folder. Everything else keeps Unity's defaults and your presets.
        if (!assetPath.StartsWith(CharacterFolder, System.StringComparison.Ordinal))
            return;

        // Only the first import. Files that arrive with a .meta keep their settings,
        // and later Inspector changes survive reimports.
        if (!assetImporter.importSettingsMissing)
            return;

        var importer = assetImporter as TextureImporter;
        if (importer == null)
            return;

        importer.textureType = TextureImporterType.Sprite;
        importer.spriteImportMode = SpriteImportMode.Single;
    }
}

In our tests on 2022.3 and Unity 6.4, new PNGs in Characters imported as Single with one sprite, new PNGs elsewhere kept the version’s default, an Inspector change to Multiple survived reimports, and a file copied in with its .meta kept its settings.

What works

• Scope by folder. One path check means the rule can’t leak into sprite sheets or UI art.
• Check importSettingsMissing. It’s true only when the asset has no .meta, so the script sets a starting point and never fights later edits or copied assets.
• Cast safely. Use as TextureImporter and return on null rather than a hard cast.
• Prefer a filtered preset when it’s enough. A TextureImporter default preset with a glob: filter does the same job with no code, and it only applies to first imports.

Testing and iterating

Don’t call it fixed until a brand-new file imports correctly and an old one survives a reimport. Five minutes with a scratch folder proves both.

1. Create Assets/_ImportTest/, outside any folder your rules target.
2. From outside Unity, copy in a PNG that has never been in a Unity project, so it has no .meta. In 2D mode, 2022.3 should give Single; Unity 6 gives Multiple, sliced automatically, unless a preset or rule says otherwise.
3. Copy the same PNG into a folder your rules do target, such as Assets/Art/Characters/, and confirm it gets the intended settings.
4. Right-click an existing, correctly set-up sprite and choose Reimport. Its Sprite Mode must not change.
5. Change a setting on the test texture, click Apply, then Reimport. If it flips back, a script without an importSettingsMissing check is still running.
6. Delete the scratch folder.

Fix checklist

Work down the list in order — it follows the cheapest-first order of this guide.

Diagnose

• Unity version: on 2023.1 or Unity 6, the automatic first-import slicing is expected in 2D mode
• Importer: the file uses the Texture Importer, not the PSD or Aseprite importer
• .meta: spriteMode and the spriteSheet entries match what this image should be
• Preset Manager: no TextureImporter default preset sets Multiple outside its intended folder
• Presets: m_SpriteSheet.m_Sprites.Array.size is 0 in every TextureImporter .preset
• Scripts: Assets, Packages, and Library/PackageCache searched for AssetPostprocessor and spriteImportMode
• Loaded postprocessors listed with TypeCache, including ones compiled into DLLs

Repair

• Backup: project committed before any bulk change
• Cause removed, scoped, or covered by a Single default preset
• Affected textures set back to Single; real sheets, .psb, and .aseprite files left alone
• Prefabs, animations, and tiles spot-checked for missing sprites

Prevent

• Import scripts: scoped to a folder and guarded by importSettingsMissing
• Default presets: filtered with glob: and built from never-sliced textures
• Scratch test: a fresh PNG imports as expected, and existing sprites survive Reimport

Sources

Facts in this guide were checked against Unity’s documentation, release notes, issue tracker, and published C# reference source in October 2026. Behavior marked “in our tests” was reproduced in clean batch-mode projects on Unity 2022.3.62f3, 6000.1.15f1, 6000.2.6f2, and 6000.4.9f1.

• Unity 2023.1.0f1 release notes (first import generates sprites in 2D mode) — Unity
• Sprite Mode “Multiple” is set by default when importing images (UUM-34637) — Unity Issue Tracker
• Unity 6000.1.0f1 release notes (Slice on Import) — Unity
• Automatic slicing (Slice on Import) — Unity 6.2 Manual
• Preset Manager — Unity Manual 2022.3
• Set default preset assets — Unity 6 Manual
• Apply preset assets — Unity 6 Manual
• Apply default presets to assets by folder — Unity 6 Manual
• Set your project to 2D or 3D mode — Unity 6 Manual
• Sprite (2D and UI) texture Import Settings reference — Unity 6 Manual
• Cut out sprites from a texture — Unity 6 Manual
• Use the Sprite Editor — Unity Manual 2022.3
• Asset metadata — Unity 6 Manual
• Asset packages — Unity 6 Manual
• Embedded dependencies (package cache) — Unity 6 Manual
• AssetPostprocessor — Unity Scripting API
• OnPreprocessTexture (AssetPostprocessor) — Unity Scripting API
• OnPreprocessAsset (AssetPostprocessor) — Unity Scripting API
• GetPostprocessOrder (AssetPostprocessor) — Unity Scripting API
• GetVersion (AssetPostprocessor) — Unity Scripting API
• importSettingsMissing (AssetImporter) — Unity Scripting API
• SpriteImportMode — Unity Scripting API
• spriteImportMode (TextureImporter) — Unity Scripting API
• spritesheet, obsolete (TextureImporter) — Unity Scripting API 2022.3
• SaveAndReimport (AssetImporter) — Unity Scripting API
• GetTypesDerivedFrom (TypeCache) — Unity Scripting API
• Sprite Editor Data Provider API — 2D Sprite package
• PSD Importer Inspector properties — PSD Importer 8.1 (Unity 2022.3)
• PSD File Importer Override — PSD Importer 9.1 (Unity 6)
• Importer features — Aseprite Importer 1.1
• Introduction to Aseprite Importer — Aseprite Importer 1.1
• PresetManagerPostProcessor.cs (default presets, order -1000) — Unity C# reference source
• AssetPostprocessor.cs (texture preprocessor dependency) — Unity C# reference source