All blog posts

Export a Godot-ready pixel sprite.

Pixel sprites import blurry into Godot when the texture filter smooths them. Export a clean spritesheet, import it as SpriteFrames, and set the filter to Nearest.

The short version: export the Godot preset (sheet + frame metadata), import it as SpriteFrames on an AnimatedSprite2D, switch the texture filter to Nearest, and keep the import scale an integer.

The problem

Sharp in the editor, soft in the engine.

Hard, unblended edges are the whole point of pixel art. Godot's 2D renderer, like most engines, defaults to a linear texture filter that blends neighbouring texels whenever a sprite is drawn at anything other than its native size. That is the right default for photos and smooth UI. It quietly destroys a 16 or 32 pixel sprite the moment a camera, a viewport stretch, or a non-integer scale touches it.

The second culprit is the asset itself. If the sheet was exported at a fractional size, or built from a source that never sat on a clean grid, no import setting can rescue it. So the fix has two halves: ship a sheet that is already grid-true, then tell Godot to stop smoothing it.

Step one

Build the sprite on an exact grid.

Start at the size the sprite will actually be: a tiny item at 16, a character at 32, a chunky avatar at 64. Drawing or reconstructing on that grid means every pixel is already a clean square before it ever reaches the engine. If you are starting from an AI image or a render, reconstruct it onto the grid first rather than scaling the big version down at export time.

Reconstruct, don't rescue

Open the engine at the size you need

Pick the canvas first so the sprite is composed to it, not squeezed into it later. Each size opens the engine ready to draw or drop an image.

Step two

Export the Godot preset.

In the export panel, choose the Godot preset. A single pose comes out as a transparent PNG you can drop on a Sprite2D. An animation comes out as one spritesheet plus a small metadata file describing every frame's position, size, and pivot, ready to become a SpriteFrames resource.

Leave the export scale at 1x, or any whole number. Engines are built to zoom at runtime, so there is no reason to bake a bigger raster into the file. An integer export keeps the source grid intact and lets the node or camera handle on-screen size without resampling.

Three exports, three Godot nodes

One pose

PNG to Sprite2D.

A single still exports as a transparent PNG. Drop it on a Sprite2D or a TextureRect.

Animation

Sheet to AnimatedSprite2D.

Frames export as one spritesheet plus frame metadata you slice into a SpriteFrames resource.

Stretchy UI

9-slice to NinePatchRect.

A button or panel exports as a 9-slice with patch margins a NinePatchRect stretches without smearing the corners.

The right export depends on what the asset is. All three keep the grid exact; only the destination node changes.

Step three

Import it without smoothing.

In Godot, build a SpriteFrames resource on an AnimatedSprite2D and slice the sheet into frames. The exported pivots line up with each frame's anchor, so the animation does not wobble. For a single PNG, just assign it to the node.

Then kill the smoothing. Set the node's texture Filterto Nearest, or set the project's default canvas texture filter to Nearest so every pixel sprite inherits it. Keep the import scale an integer and let the camera do the zoom. If the sprite still jitters, check that it is landing on whole pixel positions rather than between them.

The path from grid to game

01

Clean grid

Build or reconstruct the sprite at an exact size like 32 x 32.

02

Export Godot

Pick the Godot preset: sheet plus frame metadata, integer scale.

03

Import frames

Slice the sheet into a SpriteFrames resource on an AnimatedSprite2D.

04

Filter Nearest

Set the texture filter to Nearest so the engine stops smoothing.

Two of these steps live in the engine and two live in Godot. Miss either pair and the sprite softens.

Pixelpond workflow

Reconstruct, then export to the target.

Reconstruct, don't rescue

Pixelpond Engine exists for the unglamorous groundwork that keeps a sprite intact downstream: a precise canvas, a clean grid, and an export that already knows where every pixel lands. The Godot sprite export preset collects the Nearest-filter import notes and SpriteFrames metadata in one place. Starting from a generated image? Reconstruct it first — the companion guide on reconstructing AI pixel art covers finding the real grid before you export.

Once it is in Godot, the same discipline that keeps it crisp anywhere applies: integer scales and no smoothing. The guide to scaling pixel art without blur covers the four places blur tends to sneak back in.

Godot export checklist

  • Build the sprite on an exact grid like 16, 32, or 64 before exporting.
  • Use the Godot preset: PNG for one pose, spritesheet plus metadata for animation.
  • Export at an integer scale; let the node or camera handle on-screen zoom.
  • Import animations as a SpriteFrames resource on an AnimatedSprite2D.
  • Set the texture filter to Nearest, on the node or as the project default.
  • Test at the real camera scale so nothing lands between screen pixels.