PAS7 Studio
Editorial illustration for Why Your Pixel Art Looks Blurry in Godot, Unity, and Unreal — and How to Fix It
Technology21 Nov 2026··10 min read·Updated 21 Nov 2026

Why Your Pixel Art Looks Blurry in Godot, Unity, and Unreal — and How to Fix It

Fix blurry pixel art, uneven scaling, tile seams, and camera jitter in Godot 4, Unity, and Unreal Engine with practical settings and checks.

Overview

You draw a crisp 32 × 32 sprite, import it into a game, and suddenly its edges look as if someone smeared them with a finger. Or the sprite is sharp while stationary, but its pixels shimmer when the camera moves. These symptoms look related, yet often come from different stages of the rendering pipeline.

Start with texture filtering. If that does not fix the image, check compression, the way the game scales its output, and the position of the camera. A seam between two tiles is yet another problem: it can come from sampling the wrong part of an atlas, even when the original files are perfectly sharp.

The 30-second diagnosis

What you seeFirst thing to inspectWhy
Soft edges around every enlarged spriteTexture filteringLinear filtering blends neighboring texels; nearest/point selects one.
Sharp pixels, but some columns are wider than othersOutput scalingA non-integer enlargement cannot give every source pixel the same number of screen pixels.
Discolored blocks or damaged small detailsTexture import/compressionLossy compression can change colors and fine edges.
Thin lines between tilesAtlas padding, texture sampling and alignmentSampling near a frame edge can pick up a neighbor or transparent space.
A stable scene that jitters when the camera movesCamera and object positionsFractional movement relative to the render grid can make pixels jump unevenly.

Quick starting points: Unity: select the sprite texture and set Filter Mode → Point. Godot 4: set the relevant CanvasItem's Texture → Filter → Nearest, or change the project's default canvas texture filter. Unreal: right-click the texture and choose Sprite Actions → Apply Paper 2D Import Settings. Then test the actual game view, not just the asset preview.

Filtering: why a sharp PNG becomes soft

A sprite is a grid of source pixels, or *texels*. When the game draws it larger than the source image, the renderer must decide which color to show at each display pixel.

With nearest/point, the renderer picks the closest texel. A red texel beside a blue texel stays a hard boundary. With bilinear/linear, it blends nearby texels, creating intermediate colors along that boundary. The second approach is useful for photographs and smooth artwork; it can be exactly the wrong look for a deliberately hard-edged sprite.

A useful controlled test is to place the same sprite twice at the same position and scale, once with point/nearest and once with linear filtering. Compare the game output at 100% display zoom. If the hard edges return with nearest, filtering was at least part of the issue. If only one object stays blurry, look for a per-node, material, UI, shader, or platform override that defeats the project default.

Compression: look for changed pixels, not just fuzzy edges

Texture compression and filtering solve different problems. Filtering changes how a texture is sampled; compression changes how image data is stored for the target platform. Depending on the format and settings, compression may alter a small sprite's colors and edges even if point filtering is enabled.

In Unity, set Compression → None for a diagnostic comparison, click Apply, and examine a build on the target device. The Unity pixel-perfect guidance recommends uncompressed sprites, but uncompressed textures consume more memory: measure the trade-off in your actual project. Also check platform-specific overrides and the imported maximum size. A large atlas silently resized during import can lose detail before filtering enters the picture.

In Unreal, the documented Paper 2D import action configures filtering, mipmaps and a compression setting for that workflow. Inspect the resulting texture settings and the target platform rather than assuming that one universal compression preset suits every project. For Godot, examine the imported resource and its compression mode when the source image and rendered sprite differ. Keep the original PNG unchanged so you can compare.

Integer scaling: sharp is not always even

Nearest filtering can preserve hard edges while still producing uneven pixel widths. Suppose the game renders at 640 × 360 and the window is 1366 × 768. A fractional scale of roughly 2.13 fills the window, but a source pixel cannot occupy 2.13 physical pixels: some columns end up wider than others. With a 2× integer scale, the image occupies 1280 × 720 and its pixels remain even, leaving unused space that can become bars depending on aspect settings.

There is a design decision here: uniform pixel sizes can mean bars or a different visible area. Filling every screen edge can mean uneven scaling, cropping, or showing more of the game world. Pick the trade-off deliberately, and test window resizing and aspect ratios. Integer scaling also does not make a low-resolution sprite magically gain detail.

Unity: match sprites, camera and reference resolution

  1. Import the PNG as a Sprite (2D and UI). Select it in the Project window and choose Filter Mode → Point; for the initial diagnostic use Compression → None, then apply.
  2. Set a consistent Pixels Per Unit (PPU) for sprites that should share the same world scale. A 32-pixel sprite at 32 PPU is one world unit wide; at 16 PPU it is two units wide. PPU controls world scale, not monitor resolution.
  3. Add a Pixel Perfect Camera to the camera using the package appropriate for your project and Unity version. Match its asset PPU to the sprites and choose a reference resolution suitable for the art.
  4. Test the game at multiple window sizes. Inspect cropping, scaling and the selected camera options in the version you actually ship; rendering pipeline and package UI differ across Unity versions.

A pixel-perfect camera helps coordinate a consistent grid; it cannot correct a sprite imported at the wrong size or a material that applies its own smoothing. Check those separately.

Godot 4: nearest filtering and viewport scaling

  1. Select the sprite's CanvasItem node and set Texture → Filter → Nearest, or set the project-wide Rendering → Textures → Canvas Textures → Default Texture Filter to Nearest. A node-level override can supersede the default.
  2. In Project Settings → Display → Window, choose a base viewport size appropriate for the art, such as 640 × 360.
  3. For a traditional low-resolution pixel-art presentation, use stretch mode viewport and stretch scale mode integer. Choose keep aspect if preserving one aspect ratio and accepting bars is appropriate; expand can show more area on other aspect ratios.
  4. Run the scene at several window sizes. Check UI anchors as well as sprites: a low-resolution viewport affects the whole rendered result, including UI in that viewport.

Godot also documents canvas_items as an alternative when subpixel movement or a high-resolution 3D viewport matters. It is a different presentation choice, not a universal upgrade. Nearest filtering applies to texture sampling; it does not by itself pixelate every lighting or post-processing effect.

Unreal: apply Paper 2D settings to the texture

  1. Import the PNG into the Content Browser as a texture. Make sure Paper 2D is available in the project.
  2. Right-click the texture and select Sprite Actions → Apply Paper 2D Import Settings. Epic documents this action as setting the filter to Nearest, removing mipmaps, and applying its Paper 2D compression setting.
  3. Create or update the Sprite asset from that texture, and inspect the material and final game view. If the result is still soft, compare the texture preview with the rendered scene; material effects, post-processing and output resolution can introduce changes later in the pipeline.
  4. Test in a packaged build and at the target resolutions. The Paper 2D texture preset alone does not guarantee pixel-perfect camera movement or uniform display scaling.

Tile seams: why a one-pixel line appears between sprites

Spritesheets and atlases place many images next to one another. A sample taken near the edge of one frame can include an adjacent frame or transparent pixels, especially with filtering or mipmaps. Fractional positions and scaling can also expose gaps between geometry. These causes look similar on screen, so isolate them before rebuilding the whole tileset.

Try this sequence:

  1. Display the same tiles as separate images. If seams disappear, investigate atlas frame rectangles and sampling.
  2. Check that frame coordinates and tile dimensions match the source image; an off-by-one crop can include transparent space.
  3. Add sufficient padding between atlas entries and extrude edge colors into that padding when creating the atlas. Padding is empty spacing; extrusion repeats edge pixels so neighboring samples have compatible colors.
  4. Check filtering, mipmaps, camera positions and scene transforms. Padding helps texture bleeding, but it will not repair actual gaps in tile geometry.
  5. Re-test at the camera zooms and resolutions you ship. If you rely on mipmaps for distant or minified assets, padding needs to work at those mip levels too.

Camera jitter: preserve motion without mixing grids

If the sprite looks correct when the camera is still but appears to wobble during scrolling, pause the game and inspect positions. A camera moving by a fraction of a source pixel can cross display-pixel boundaries unevenly, especially when the scene, camera and final output use different grids.

As a diagnostic, move the camera by whole source-pixel increments. In a Unity scene using 32 PPU, one source pixel corresponds to 1/32 world unit before additional transforms. Compare that with the normal camera motion. Godot offers 2D pixel-snap settings; Unity's Pixel Perfect Camera offers grid-related options. Verify each option against your version and scene rather than turning every snap setting on blindly.

Snapping is a trade-off. It can make the render stable but make slow movement visibly step between pixels. You may choose to keep physics and camera logic continuous while snapping the rendered presentation, or accept subpixel movement for smoother animation. Fast camera tracking, physics interpolation, screen shake and UI layers all deserve separate tests.

A repeatable test scene

Make a tiny scene before tuning a full game: one stationary sprite, a tile strip, a moving character and a slowly scrolling camera. Use a fixed reference resolution, then run at a native integer multiple and at an awkward window size. Change one setting at a time and capture both the editor setting and the game output.

Record the engine version, renderer, target platform, asset dimensions, filter, compression, viewport and window sizes. This gives you evidence when a mobile build looks different from the editor and prevents a correct setting in one place from hiding a conflicting override elsewhere.

For sample images, the free 2D game assets collection includes packs for different use cases. ARSENAL 254 contains 254 ammunition sprites and atlas mappings; Archiforge contains 173 UI and architect icons. Use an image whose intended look suits the test: not every 2D icon is designed as pixel art. Check the download's own licence and credits before use; the asset licence guide explains what to look for.

Original CAN_b sprite from ARSENAL 254 v1.0.0. Use the same sprite to compare filters in your engine; this image is not a before-and-after test. The enlarged preview uses nearest-neighbor display.

Section section-7 screenshot