Pixel Art Blurry in Unity? Sprite Import and Pixel Perfect Camera Settings

Illustration: a blurry pixel-art character sharpening into crisp square pixels

You import a crisp 16×16 sprite and it looks like a smeared photo. Or the pixels are sharp until the camera moves, then they shimmer, wobble and tear. Unity pixel art blurry is almost always a sprite import problem, a camera problem, or both. This guide fixes each layer in order: import settings, Pixels Per Unit, the Pixel Perfect Camera, and the quieter causes like atlas padding and UI scaling.

Quick Checklist

  1. Select the texture. Set Filter Mode to Point (no filter).
  2. Set Compression to None.
  3. Turn Generate Mip Maps off.
  4. Make sure every sprite uses the same Pixels Per Unit.
  5. Add a Pixel Perfect Camera to the main camera.
  6. Use a game view resolution that is a whole multiple of your reference resolution.

Most blurry pixel art is fixed by items 1 and 2. The rest handles shimmer and uneven pixel sizes.

Sprite Import Settings

Click the image in the Project window and look at the Inspector. These are the settings that matter:

Setting Value for pixel art Why
Texture Type Sprite (2D and UI) Makes it usable by Sprite Renderers and the Sprite Editor.
Filter Mode Point (no filter) Bilinear blends neighbouring pixels. Point keeps hard edges.
Compression None Compression blocks smear colours between pixels, especially on small sprites.
Generate Mip Maps Off Mip maps blur the sprite when it is drawn smaller than its source size.
Max Size At least your image size A lower cap silently downsizes the texture.
Mesh Type Tight or Full Rect Full Rect is fine for small sprites and avoids odd outline meshes.

Press Apply at the bottom of the Inspector. Forgetting Apply is a real cause of “I changed it and nothing happened”.

If you have hundreds of sprites, set the defaults once with a small editor script that runs on import:

using UnityEditor;
using UnityEngine;

public class PixelArtImporter : AssetPostprocessor
{
    void OnPreprocessTexture()
    {
        // Only touch files in a folder named "PixelArt"
        if (!assetPath.Contains("/PixelArt/")) return;

        var importer = (TextureImporter)assetImporter;
        importer.textureType = TextureImporterType.Sprite;
        importer.spritePixelsPerUnit = 16f;
        importer.filterMode = FilterMode.Point;
        importer.textureCompression = TextureImporterCompression.Uncompressed;
        importer.mipmapEnabled = false;
    }
}

Put the script in an Editor folder. Every texture you drop into a PixelArt folder then imports with the right settings. If you would rather not write editor code, the Inspector route above works for a handful of files.

Pixels Per Unit and Camera Size

Pixels Per Unit (PPU) says how many image pixels fit into one Unity unit. A 16×16 sprite with PPU 16 is exactly 1×1 units. With PPU 100 (the default) it is 0.16 units wide, tiny on screen and easy to scale the wrong way.

Pick one PPU for the whole project and stick to it. Common choices are 16, 32 or 64, matching the tile size of your art. Mixing PPUs means some sprites have bigger “pixels” than others, which looks like a bug even though it is just maths.

The orthographic camera size is half the visible height in units. For a pixel-perfect view without the Pixel Perfect Camera, use:

orthographicSize = referenceHeightInPixels / (2 * PPU)

For a 320×180 reference resolution and PPU 16, that gives 180 / 32 = 5.625. If the result is not a clean number at your chosen window size, pixels land between screen pixels and blur or shimmer. That is exactly the job the Pixel Perfect Camera automates.

The Pixel Perfect Camera

With the 2D renderer in URP, select the Main Camera and use Add Component > Pixel Perfect Camera. It is part of the 2D Pixel Perfect functionality that ships with the Universal RP, so you do not need to hunt for a package in a standard URP 2D project. Set these fields:

  • Assets Pixels Per Unit: the PPU your sprites use, for example 16.
  • Reference Resolution: the resolution your art is designed for, for example 320 x 180.
  • Upscale Render Texture: renders at the low reference resolution and scales up. Gives a consistent chunky look at any window size, but can add a slight softness if the final size is not a whole multiple.
  • Pixel Snapping: snaps sprite renderers to pixel positions in the final image. Useful if you move things by fractional amounts.
  • Crop Frame: choose letterboxing, pillarboxing or windowbox to keep the reference aspect ratio, or Stretch Fill to fill the screen.

The component shows a Current Pixel Ratio readout in the Inspector. If it shows a whole number such as 4:1 or 6:1, every art pixel is a clean square block of screen pixels. A fractional ratio means you are on a window size that cannot match.

The Pixel Perfect Camera takes control of the camera’s orthographic size. If your camera follows the player with a script, read the 2D camera follow guide, then move the camera in LateUpdate and let the component handle zoom. Do not also set orthographicSize yourself.

If you use Cinemachine 3, add the pixel perfect extension to the CinemachineCamera object instead of fighting the brain camera. Cinemachine offers its own pixel perfect extension for this reason, and it replaces manual size changes.

Jitter While Moving

If still frames look sharp but movement shimmers, the issue is sub-pixel positions. A sprite at x = 3.0713 lands between screen pixels, so it renders with uneven pixel widths that flicker as it moves.

  • Pixel Snapping on the Pixel Perfect Camera hides this by rounding positions at render time.
  • If your player is a Rigidbody2D, turn on Interpolate. Without it, a physics step and a render frame fall out of sync and the character stutters.
  • Make sure the camera follows in LateUpdate, after the player moved. Following in Update causes the world to wobble against the player.
  • Avoid scaling sprites by non-integer amounts. A scale of 1.5 forces half-pixel results.

Platformer movement code that produces uneven positions can make this worse. The 2D platformer movement guide covers a movement setup that plays nicely with pixel snapping.

Sprite Atlases and Bleeding Edges

Thin coloured lines between tiles are almost always edge bleeding. Neighbouring pixels from another sprite sample into your tile.

  • With a Sprite Atlas, increase Padding in the packing settings. The default of 4 is usually enough, but tight packing can still bleed on some GPUs. Try turning Tight Packing off.
  • Check the atlas’s own texture settings. The atlas has its own Filter Mode and compression. If the atlas is on Bilinear, your sprites blur even though the source textures are Point.
  • If you build tilemaps from one sheet, keep the tiles on exact pixel boundaries in the Sprite Editor. A slice offset by half a pixel produces a one-pixel stripe on tile edges.
  • Extruding the tile edges by one pixel in the source image stops bleeding for good.

Mixing many separate textures also raises draw calls. Atlases fix that, which is covered in the batching guide.

UI and Text

Pixel art in UI follows the same rule: Point filter, no compression. For UI Images, set Image Type to Simple and enable Pixel Perfect on the Canvas only if you use a Screen Space overlay with whole-number scaling. Canvas Scaler modes can scale by fractions and blur sprites, so choose a scale factor that matches your reference size. The Canvas Scaler guide explains the modes.

Fuzzy text is a separate problem with a separate fix. See the TextMeshPro blurry text guide. For pixel fonts, use a font atlas in Point mode and avoid font sizes that are not multiples of the font’s design size.

🔧 Pixel art tooling

Tile painters, palette tools and 2D helpers save hours on pixel projects. See our recommended Asset Store tools.

Troubleshooting

Sprites look blurry even with Point filter

Check Compression (set it to None), Generate Mip Maps (off) and Max Size. Then check whether the sprite lives in a Sprite Atlas with its own filter setting.

Some pixels look bigger than others

Your game view or window size is not a whole multiple of the reference resolution. Use the Pixel Perfect Camera, check Current Pixel Ratio, and pick a fixed resolution while testing.

Thin lines appear between tiles

Edge bleeding. Increase atlas padding, extrude tile edges, and check that the Sprite Editor slices sit on exact pixel boundaries.

Sprites shimmer when the camera moves

Turn on Pixel Snapping, follow in LateUpdate, and enable Interpolate on a Rigidbody2D player.

Pixel Perfect Camera is not in the Add Component list

You are probably on the Built-in pipeline or a non-2D template. Confirm the project uses URP and that the Universal RP package is installed.

The image looks fine in Scene view but blurry in Game view

The Game view is scaled. Set the Game view to a fixed resolution that matches your reference and check the Scale slider is at 1x.

FAQ

What Pixels Per Unit should I use?

Match your tile size: 16 for 16×16 tiles, 32 for 32×32. Pick one value for the whole project and use it for every sprite.

Do I need the Pixel Perfect Camera?

Not for a static image, but you want it for scrolling games. It prevents uneven pixel sizes and shimmer at different window sizes.

Should I use Upscale Render Texture?

Turn it on when you want a consistent low-resolution look and rotation or effects that stay chunky. Leave it off when you want smooth sub-pixel movement and rotation.

Why does my pixel art look different in a build?

Build quality settings, texture compression overrides on the platform tab, or a different resolution. Check the per-platform override in the texture Inspector.

Can I use Bilinear for smoother high-res pixel art?

Yes, if the art is drawn at a higher resolution and you want soft scaling. For true low-res pixel art, use Point.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *