Deluxe Pixel

A modern Deluxe Paint for retro game developers.

Deluxe Pixel brings back the tools and the feel of Deluxe Paint III and makes them aware of the machine you're drawing for. Choose a ZX Spectrum, a Spectrum Next, a Commodore 64, an Amiga or another classic, pick a screen mode, and your palette, pixel shape and colour rules follow the real hardware. What you draw is what the machine can show.

This guide covers version 2.19.

Getting started

Deluxe Pixel is a single program file, DPixel.exe, a free download. There's no installer: save it anywhere (your desktop, a USB stick, your project folder) and double-click it.

You'll need Windows 10 or 11 (64-bit) and a graphics card with Direct3D 11, which means almost any PC from the last ten years.

"Windows protected your PC"? The first time you run it, Windows SmartScreen may show this, because Deluxe Pixel is new and Windows doesn't know it yet. Choose More info, then Run anyway. To be sure your copy is the real one, compare its checksum with the one on the Deluxe Pixel page: in a command prompt, certutil -hashfile DPixel.exe SHA256.

When it starts, the splash screen shows for a moment (click or press any key to skip it). Then:

1. Press Ctrl+N for a new image.
2. Choose a system (the machine you're drawing for), then a screen mode. A line underneath describes the result in plain words.
3. If you need something different, open Customise to change the width, height, pixel shape or number of colours. Each has its own Reset button.
4. Press D for freehand, pick a colour in the Palette panel, and start drawing.

The left mouse button paints with the left colour and the right button with the right colour, just as in Deluxe Paint. Painting with the transparent colour erases.

The demo and registering

DPixel.exe is a free download. Until it's registered it runs as a demo: every tool works, so you can learn the program properly, but with limits that are tight for a real project.

Your work is never held hostage. Registered or not, you can always open and save your files, autosave and recovery always work, and you can edit anything already in a file. If you try something the demo doesn't allow, Deluxe Pixel explains and offers to register or buy; "Not now" carries on. The demo shows "(unregistered)" in the title bar and a note in the status bar when it starts. There are no nag screens.

To register, buy a registration code: the digital edition's code is emailed to you, and the boxed edition's is on the card in the box. Then:

1. Open Help > Register and enter your email address and the code. (Typing is forgiving: case, spaces and dashes don't matter.) If you'd like occasional news from Kage Games, tick the box; it's off unless you do.
2. We email you a link. Click it, and Deluxe Pixel unlocks by itself. You can close the Register window while you wait: "Registration: waiting for the email link" in the menu bar reopens it.

Not online? Register on our website instead. After you click the emailed link, the page shows your unlock code (and we email it to you too). In Deluxe Pixel's Register window, choose I have an unlock code and paste it in.

A personal or education licence is for life, and once registered it never contacts us again. Once registered, Help > Registered to … shows your details.

Organisation licences (Studio and Company) are one code for the whole organisation, tied to its email domain: each person registers it in the same way, with their own work address. Copies registered this way check in with kage.games about once a month, to confirm the licence is running and to tell you about updates; About shows "(subscription)". If a seat is removed or the licence ends, or a copy can't check in for 90 days, it goes back to the demo, saying why, and nothing you've made is affected.

The machines

Every image remembers its machine and screen mode, so files stay self-contained.

Wide and tall pixels are shown at their real shape, and circles stay round on screen whatever the pixel shape.

The newer machines (from the Dragon on) export their own screen memory too (see The machine formats). Their palettes are the ones emulators commonly show, since these machines put out a TV signal rather than exact RGB.

Your own systems

Every machine Deluxe Pixel knows is a system. As well as the built-in ones, you can make your own, customise a copy of a built-in one, and share them.

File > Systems (or the Systems... button in the New image dialog) lists the built-in systems and yours. Built-in systems can't be changed: Duplicate to customise makes your own copy. For each system you set:

• The machine: its maker or family, its name, and which native exports suit it (none, ZX Spectrum screens, ZX Spectrum Next, Commodore 64, or Atari ST Degas). The Export menu follows this, so your own machines can use those formats.
• The colours: either any colour, from a number of levels per channel (1 to 8 bits each), or a fixed table of swatches you can edit, add to and remove. Import palette file reads JASC .pal, GIMP .gpl, Lospec .hex, Adobe .act, or the colours of a PNG.
• The screen modes: for each one, its name, size, pixel shape (square, wide, tall or your own), the number of colours on screen, and any colour cells: their size, colours per cell, a shared colour, and BRIGHT-style colour groups.
• Export formats, one by one: under Native exports, tick exactly the formats this machine should offer; they head the Export window's list, under For this machine. With none ticked, it offers the formats made for its family.
• A colour table for a screen mode, for machines whose modes offer different colours: tick it on the mode, edit its swatches (or take the current image's colours), and images made in that mode use those colours (up to 256).

Save stores it (anything that needs fixing is shown in red); Export writes a .dpsystem file to share, and Import reads one. Deleting a system is safe: images made with it keep working, because each image carries its own copy.

File > New system (guided) walks you through five plain steps (a name; where the colours come from; the screen's size, pixel shape and colours; whether parts of the screen are limited to a few colours; then a summary), and Create opens the New image dialog with your new system chosen.

Your systems are kept as .dpsystem files in the Systems folder inside your settings folder (or UserData in portable mode). They're plain text, so you can read them, though you never need to edit them by hand.

The canvas

• Zoom with the mouse wheel or + and -, from 1/16 (6%) to 6400%. Zooming centres on the pointer.
• Images go up to 4,096 × 4,096 pixels. Bigger pictures (up to 16,384 × 16,384) shrink to fit as they open, keeping their shape, and Deluxe Pixel tells you; to keep a huge level at full size, cut it into tiles with Tiles > Make tile set from a picture file (see Sprites and tiles).
• Ctrl+0 fits the image to the window; Ctrl+1 shows actual pixels (on a map, Ctrl+1 to Ctrl+9 keep quick stamps instead, so use View > 1:1). A new image fits itself to the window until you zoom or pan.
• Pan by dragging with the middle button, or by holding Space and dragging.
• G shows the pixel grid (from 600% zoom). T shows transparency as a checkerboard.
• View > Wrap around makes the picture repeat in every direction on the canvas, and paint going over an edge comes in at the other side: strokes, lines, shapes and every paint mode, so seamless textures, backgrounds and tiles are painted as if they had no edges. Fill and the colour picker work in any copy; the picture itself is outlined among its copies, and the setting is saved with it. (Fills don't yet flow over an edge, and selections stay inside the picture.)
• The pointer is a precise crosshair with the pixel under it outlined. The status bar shows its coordinates, the colour under it, the zoom, the image size, the active layer, the palette and whether colours are cycling.

Drawing tools

Esc cancels a shape, curve or polygon in progress.

The Tools panel lists the tools by name in four groups (Select, with undo and redo beside it; Draw; Fill and pick; Shapes). Right-click the panel (or View > Appearance) to show them as compact icons instead, which reflow as you widen the panel (hover over one for its name and key), or to put the left and right colours under the tools instead of over them. Beside Left and Right, each mouse button's last few colours are kept: click one to swap it back in.

Paint modes

Choose a paint mode in the Paint options panel (docked under Tools, with the colour range, fills, attribute cells, symmetry and brush settings). Every tool's preview shows exactly what the mode will do.

• Colour: paint normally.
• Shade: steps each pixel along the colour range: the left button up the range, the right button down. Pixels outside the range are left alone.
• Cycle: like Shade, but wraps round the range.
• Behind: paints only where the layer is transparent.
• Blend: mixes with what's already there, as translucent paint: its Strength (5–95%) sets how much shows, 50% being an even mix. The mix is in real light, and the result is the palette colour that looks nearest.
• Smear: with freehand, pushes the colours under the brush along the stroke, like wet paint.

The colour range is a from–to pair of palette entries in the Paint options panel. Shade, Cycle and gradients use it.

Smooth edges (Paint options, 0–100%) anti-aliases lines, curves, polygons, shapes and freehand strokes: palette pictures use only the palette's own colours for the in-between shades (the nearest mix), and true-colour pictures the exact mix. At 0, edges are hard pixels, as always.

Pixel-perfect (Paint options, under Smooth edges) cleans up freehand lines as you draw with the 1-pixel built-in brush: wherever three pixels make an L, the corner pixel goes, so hand-drawn curves come out as clean one-pixel stairs. It works with every paint mode but Smear, the stencil, symmetry and colour cells, and the stroke is still one undo step. (With another brush, or smooth edges on, the panel says why it's off.)

Texture (Paint options, under the paint mode) is the surface paint lands on, so strokes break up like chalk on rough paper, with every tool and paint mode: Paper (a fine grain), Canvas (woven threads) or Chalk (coarse, broken clumps), with a coverage (how much of the surface takes paint). It's fixed to the picture, not the brush, so overlapping strokes share the same grain. With Blend and a gradient fill, filled shapes can also fade from one strength to another.

The stencil

Ctrl+click a swatch to lock that colour: locked colours show a cross and can't be painted over. The Stencil checkbox in the Palette panel switches the stencil on and off. It's saved with the image.

Fills, dithering and symmetry

Flood fills and filled shapes can be:

• Solid.
• A gradient through the colour range: horizontal, vertical, radial (from the click or the shape's centre), or contour, from the area's edge to its middle, following its shape.
• A pattern: the current brush, tiled. Patterns line up across the canvas, so neighbouring fills join seamlessly, and holes in the brush leave pixels alone.

Gradients can be dithered: ordered (8 × 8 Bayer) or noise.

Symmetry mirrors everything you paint: left–right, top–bottom, both, or rotational with 2 to 16 copies, centred on the canvas with guides drawn over it. It works with every painting tool, including fills and the airbrush.

Colour clash: attribute cells

Some machines colour the screen in cells: the ZX Spectrum's 8 × 8 attributes, for example. Deluxe Pixel knows their rules:

Clashing cells are tinted and outlined in red, and the cell grid appears once you've zoomed in far enough. The Paint options panel shows the number of clashes as you work, and switches the overlay on and off.

Choose how painting behaves in Paint options > Attribute cells:

• Clash like the hardware (the default): a new colour takes over a cell colour for the whole cell, exactly as on the real machine. Painting green INK over red INK turns all of that cell's red green, and a BRIGHT colour makes the whole cell BRIGHT.
• Keep cell colours: your paint snaps to colours the cell already has. A new colour can join only while the cell has room.
• Paint freely: anything goes; clashes are only highlighted.

Fix colour clashes (the Fix button with the cell settings) makes a picture legal for its machine, every cell keeping only the colours it's allowed. Choose no dithering (each pixel to the nearest allowed colour), ordered (a fine pattern mixing the two nearest allowed colours) or diffusion (kept inside each cell, so it never spills into a neighbour), with a strength. The fix shows on the canvas as you change it, with how many pixels in how many cells will change; hold Show original to compare, then Apply (one undo step).

Fix gives every clashing cell its best legal colours, choosing the ones that change the picture least. Only clashing cells change, and the whole fix is one undo.

Brushes

• Built-in brushes: round or square, 1 to 32 pixels. Ctrl+[ and Ctrl+] change the size; . (full stop) goes back to the built-in brush.
• Pick up a brush: press B and drag a box over any part of the picture. Pixels in the transparent colour become holes. A brush can paint with its own colours, or as a shape in the left or right colour.
• Flip with X (horizontally) and Y (vertically); Z rotates 90°.
• O adds a one-pixel outline in the left colour; press it again for a thicker one.
• Brush > Transform stretches the brush to any size, shears it and rotates it by any angle. Double size and Halve size are quick versions. Everything stays crisp.
• Bend and Perspective, also in Brush > Transform, as in Deluxe Paint: Bend slides the rows along an arc (or the columns, with Down), the middle most and the ends not at all; Perspective lays the brush on a plane seen at an angle, with tilt (like a floor or ceiling), turn (like a wall going into the distance) and distance (nearer exaggerates it). The pixels stay crisp, with no gaps.
• Brush > Morph... turns one brush into another, as an animated brush, Deluxe Paint IV style: set the Start and End brushes, choose the steps (2–64) and how it dissolves (Ordered, even and calm, or Scattered, organic), then Make animated brush. The size changes smoothly between them.
• Brush > Handle sets the point under the pointer: the centre or any corner.
• Text as a brush: in the text dialog, Use as brush turns your text into a brush you can flip, rotate, transform or use as a pattern.

Selections and the clipboard

Selecting is undoable too: box and lasso selections (and changes to one), Select all, Select none, Invert and Alt+click on a tile are each an undo step, in order with your painting.

• M selects a rectangle; L draws a lasso.
• Adding and taking away, with every select tool: hold Shift to add to the selection, Alt to take away from it, or Shift+Alt to keep only where the new one and the old one overlap. (Alt+drag starting inside the selection still copies its pixels, so to take away, start outside it.) A plain click deselects.
• The magic wand (Shift+M, or Select > Magic wand): click a pixel to select it and the pixels like it, with Shift, Alt or Shift+Alt as above. Its settings: Tolerance (0% means the same colour only; on palette pictures, two colour numbers that look alike stay apart unless you allow some tolerance), Joined pixels only (turn it off to take that colour anywhere), and Look at all visible layers (instead of the active layer alone).
• Select > Select the left colour selects every pixel in the left colour: the magic wand with joined pixels off.
• Ctrl+A selects everything, Ctrl+D or Esc deselects, Ctrl+Shift+I inverts.
• While there's a selection, every tool paints only inside it.
• Drag inside the selection to move its pixels; Alt+drag copies them. The arrow keys nudge it by 1 pixel, or 8 with Shift.
• With the Pointer (P), a selection gets a frame with handles: drag inside to move the pixels, an edge or corner to stretch them, or just outside a corner to rotate them (clean rotation, with no new colours, by default). It's always redrawn from the original pixels, so nothing wears away; Enter applies it (one undo step) and Esc puts it back.
  • The rotation centre is the round mark, in the middle at first: drag it to turn about another point (Shift snaps it to the middle, the corners and the edge middles), or double-click it to put it back.
  • While dragging, the pointer shows the size ("120 × 75 (148%)"), the angle or the move. Shift while moving keeps it straight across or up and down; the arrow keys nudge it (Shift: 10 pixels).
  • Paint options shows Transform the selection: width and height in percent (with Keep proportions), the angle and the move, to drag or type; Flip across and Flip down (lossless); Turn −90° / +90° (pixel-exact); Clean rotation or plain; and Apply, Cancel and Reset.
• Del clears the selected pixels; Ctrl+X cuts; Ctrl+B turns the selection into a brush.

Ctrl+C copies the selection (or your brush, or the whole picture) to the Windows clipboard, with transparency, ready for Aseprite, Photoshop, GIMP or a browser. Ctrl+V pastes as a brush, with colours matched to your palette. Ctrl+Shift+V pastes as a new image, and you can also paste as a new layer.

Layers

Up to 32 layers: add, duplicate, delete, move up and down, show and hide, and lock. Double-click a layer to rename it. One palette colour is the transparent colour on every layer. Everything can be undone, step by step or from the History panel (see "The undo history" below).

• Opacity and blend modes: each layer has an opacity and a blend mode (Normal, Multiply, Screen, Overlay, Add, Subtract, Darken, Lighten or Difference), set in the Layers panel, where the layer's name shows them ("Shadow Multiply 60%"). Shade a sprite with a Multiply layer, or light it with Screen, without touching the pixels beneath.
• On palette pictures, each mix is drawn in the nearest colour of the palette, so the picture keeps to its colours. True-colour pictures mix exactly.
• What you see is what you get: exports, Merge down, onion skins and every frame show the layers blended just as the canvas does.

Object layers: editable text, shapes and 3D models

An object layer holds editable objects (text, and rectangles, ellipses and lines) instead of painted pixels. Its pixels are always drawn from the objects, so the canvas, exports and frames treat it like any other layer, but you can change the words, font or look at any time, and nothing ever degrades.

• Adding text: + Text layer (or + Object layer) in the Layers panel, or the text tool: on an object layer the text joins it; on a painted layer, a new object layer is made just above, so your painting is never touched.
• Adding shapes: the rectangle, ellipse and line icons beside the T in the Layers panel's objects section. A shape's settings are its size, whether it's filled, its outline thickness (always even, inside its box), smooth edges and colour; a line runs corner to corner of its box (flip it for the other diagonal). Everything else here (moving, transforms, the Pointer's handles, which resize the box so outlines stay crisp, merging, saving) works for shapes as for text.
• Editing, in the Layers panel: with an object layer active, its objects are listed under it, to select, reorder, hide and delete. The selected text's settings are right there: the words, the font (a built-in pixel font at a whole-number scale, or any Windows font, with smooth edges), letter and line spacing, alignment, colour (a palette colour, or any colour in a true-colour picture) and position. Every change redraws straight away, and a run of changes to one setting (typing a word, dragging a slider) is one undo step.
• Transform (in the same panel): stretch, flip, rotate, shear, bend and perspective, kept as settings and drawn from the original text each time, so they never blur or wear away. Clean rotation (on for new text) rotates pixel fonts the pixel-art way, with no new colours; Windows fonts are drawn by Windows at any angle.
• The Pointer tool (P): click an object to select it (its layer becomes active) and drag to move it. A frame turns with it: drag an edge or corner handle to stretch it (Alt from the centre, Shift keeps the proportions), or drag just outside a corner to rotate it (Shift in 15° steps). Each drag is one undo step.
• Merging: an object layer merged into another keeps everything editable; merged into a painted layer, its objects become pixels (Deluxe Pixel says so first). Painting on an object layer asks whether to turn it into a painted layer, or to paint on a new layer above.
• Live 3D models: a 3D model can be an object too (see 3D models to sprites). It's drawn from the model in the picture's colours, and stays 3D: in the Layers panel, change how it's turned, how far you look down on it, the zoom, the light, its animation and the moment in it, perspective, dithering and an outline, and it's drawn again straight away. With the Pointer, drag it, resize its box by the handles, or turn it round with the round handle. Paint over it on a layer above; flatten the layer to make it pixels. The model is saved inside the .dpx, so the picture opens anywhere.
• Posing a live 3D model: in the Layers panel, under the model object, Pose its parts > Pose on the canvas. Hover to see each part outlined, click one to pick it, and drag: across turns it, down tips it; Shift moves it, Ctrl rolls it, Alt scales it. Each drag is one undo step. The panel has the same as numbers, and sets what a part turns round: its middle, its top (a shoulder or hip, so an arm swings from it) or its bottom. Unpose this part and Unpose all put it back. Each animation frame keeps its own pose, so posing frame by frame makes an animation.
• Frames: objects belong to the frame they're on, as pixels do. Everything is saved in the .dpx, still editable when you reopen it.

Adjustment layers

An adjustment layer has no pixels of its own: it holds one colour adjustment, applied to everything beneath it, and never baked in. Add one with + Adjustment in the Layers panel: brightness and contrast, hue and saturation, colour balance, levels, curves, posterise, invert or greyscale, or one of the Photo adjustments (see Photo styling, below), including a colour look-up from a .cube file.

• Its settings are edited right there in the Layers panel, live on the canvas, with a Mix to apply it partly. Levels has its channel choice, with a histogram of what's beneath; Curves has the curve editor (click to add a point, drag it, right-click to remove one; Straight line and Gentle S to start from). A whole drag is one undo step.
• On palette pictures, each colour becomes the palette colour nearest its adjusted colour; on true-colour pictures it's exact.
• Only what's beneath is adjusted, and hiding the layer turns it off. Exports, the HAM view, storyboards and camera moves all show it.
• Layer > Merge down bakes it into the layer just below, in every frame. Painting on an adjustment layer explains that it has no pixels.

Sprites and tiles

The sprite and tile grid

Tiles > Show sprite and tile grid (or Shift+G) lays an orange grid over the image, at any size. Presets cover the common sizes: 8 × 8, 16 × 16, 24 × 21 (a C64 sprite), 32 × 32, 8 × 16 and 16 × 32, or choose your own. The grid is saved with the image, and sprite exports use it to cut the image into frames.

Making a tile set

Tiles > Make tile set cuts the picture, as the canvas shows it, into tiles the size of the grid (8 × 8 on attribute screens), keeping one copy of each different tile. It can store far fewer tiles than the picture has tile-sized cells: each saving is a separate checkbox, and afterwards the Tile set made window shows what it saved: the picture and tile sizes, how many cells became how many tiles, and how many were repeats, mirrored, turned, shared in other colours or nearly the same, plus the palettes used (Copy as text copies it all).

• Mirrored: a cell that's another one flipped shares its tile; the map cell remembers the flip.
• Turned 90° (square tiles): a cell that's another one rotated shares its tile too. With mirroring as well, all eight orientations are covered (the rotation comes before the flips, as on the Spectrum Next).
• Same colours, other colour numbers (on by default): cells that look exactly alike share a tile even if their colour numbers differ, such as a palette with the same red at 6 and 7, or the same colours in another palette bank. It never changes what you see.
• Nearly the same (off by default): a tile that differs from a more used one in at most 1 to 4 pixels (2 by default) uses that tile instead, so a solid area with the odd stray pixel shares one tile. No cell ever changes by more than the number you choose. It's meant for pixel art; photos gain little.
• Fit into at most N tiles (off by default): when the hardware only holds so many tiles, the tiles that look most alike are merged until there are no more than N. Presets: the Spectrum Next (512), the SNES (1,024) and the Mega Drive (2,048), or any number. Tiles that are kept are never changed: cells that used a merged tile use the closest kept one instead (with its palette bank, so they show what it looks like), and see-through areas stay see-through. The Tile set made window says how much the picture changed. For example, a 12-megapixel photo's 245,000 tiles fit into 2,048 in about 20 seconds.
• The same pattern in different colours, using palette banks: runs of colours (16 by default, each bank's first colour being transparent), with each map cell choosing its bank.
  • Use the image's own banks, for art already arranged in banks (colours 0–15, 16–31 and so on). Each cell's colours must come from one bank; a cell that mixes banks, or uses a bank's first colour, is reported.
  • Build banks from the colours: Deluxe Pixel makes the banks for you, and they become the tile set's palette. With Prefer fewer tiles (the default), the same shape in different colours shares one tile, its colour schemes sharing banks wherever they fit; turn it off for as few banks as possible, even if that means more tiles.
  • The colours per bank and the number of banks are set in the dialog, starting from the machine's own: 16 banks of 16 on the Next, 4 of 16 on the Mega Drive, 8 elsewhere.

The tiles open as a new image, 16 to a row, in the same machine and palettes, with the grid on. It remembers how the tiles make up the original picture: Tiles > Export tile map saves that map (see below). Tiles at the edge that aren't complete are filled out with the transparent colour.

Tile map files. Tiles > Export tile map writes one entry per cell, row by row, low byte first, as a binary file, a C array (.h) or assembler data (.asm), depending on the file type you choose. There are two formats:

Rotation is 90° clockwise, applied before the flips (as on the Spectrum Next). The 16-bit format can't hold rotation or palette banks: if your map uses them, the export warns you first, saying how many cells are affected, with Export anyway or Cancel. Tile numbers too big for a format's field are refused (above 16,382 in the 16-bit format, 65,534 in the 32-bit one), rather than written wrongly. The Spectrum Next's own tile map export uses the machine's layout, rotation and bank included.

Tile sets from very large pictures

Tiles > Make tile set from a picture file... reads a picture straight from disk, up to 16,384 × 16,384, without opening it as an image, and cuts it into a tile set and a map: ideal for a whole game level. It reads PNG, BMP, PCX, TGA, PPM / PGM, and through Windows JPEG, TIFF, WebP and HEIC, then opens the usual Make tile set dialog, with all its savings.

• One palette for the whole picture: true-colour pictures are reduced to the number of colours set in File > Opening true-colour pictures, without dithering, so repeated tiles stay identical and are shared. (Dithering one test level turned its 40 tiles into 131,068.)
• A palette for each tile, the way tile-based consoles show far more colours than one palette allows. Deluxe Pixel finds a set of small palettes and gives each tile the one that suits it best; each tile's palette becomes its cell's palette bank. It's suggested when the picture has more than 256 colours. You choose:
  • A preset: SNES (8 palettes of 16, RGB555), Mega Drive (4 of 16, RGB333), Spectrum Next 4-bit tilemap (16 of 16, RGB333), or 256 palettes of 16 (4,096 colours, RGB555), all with 8 × 8 tiles; or your own number of colours per palette and palettes (up to 256 palettes and 4,096 colours, the colours past 256 becoming bank colours).
  • Colour 0 of every palette: transparent, as on the SNES, the Mega Drive and the Next, or a shared backdrop colour, as the NES does.
  • The colour depth (24-bit down to RGB222), and dithering within each tile, which never crosses a tile's edge, so identical tiles stay identical.
• Limits: a map more than 4,096 tiles across is refused before starting, and the tile set can hold as many tiles as fit a 4,096 × 4,096 image (262,144 at 8 × 8), checked as tiles are made; either way you get a suggestion (bigger tiles, sharing mirrored or turned tiles, or palette banks).
• Big pictures take a while (a 12-megapixel photo cut into nearly 245,000 tiles takes under a minute): a Working window shows each step, a progress bar and the time, and Cancel (or Esc) stops it within a few seconds, leaving everything as it was.

Tile maps

A tile map is a grid of cells, each showing a tile from a linked tile set. Because a tile used in many places is stored once, editing it in the tile set changes every cell that uses it, live, while you paint. A map can be any shape that fits in map memory, 16,777,216 cells a layer (4,096 × 4,096, or 65,535 × 256, or 10 × 100, as the Amiga editors allowed), up to 65,535 cells either way; the New map window shows how much a size uses. It zooms, scrolls and changes palette like any other canvas. Even on the biggest maps, painting stays instant, using the tricks that made Tame, the Turbo Amiga Map Editor, turbo (see Amiga map editors): only the cells you change are remembered for undo and sent to the screen, and the brush preview is drawn into the map itself, so a tile brush of any size costs the same.

• Make one with Tiles > Make tile set from this image, leaving "Also open a map that uses the tiles" on: you get the tile set and the map that rebuilds your picture. Or start an empty map from a tile set with Tiles > New tile map from this tile set: the dialog lets you pick the tile set from your open pictures, shows which maps already use it, and takes the tile size and the map's size in cells.

• One tile set, many levels: several maps can share one tile set, so editing a tile changes it in every level. On a map, Tiles > New map with the same tile set (or New map from these tiles in the Tiles panel) starts another level from the same tiles. On a tile set, Tiles > Maps using this tile set lists the open maps drawn from it, one click to each. Tiles > Change this map's tile set points the whole map, or just the active layer, at another open tile set (optionally taking its palette), and warns if the map uses tiles the new set doesn't have.

• Pick up tiles: right-click a cell to pick up its tile, or right-drag to pick up a group of cells as your brush. For a clear brush (an eraser), hold Shift while you right-drag a group, or Shift+right-click for one cell; Clear in the Tiles panel makes the brush clear at its current size. The Tiles panel (with Layers) shows every tile, and an Empty slot for erasing; click one to make it your brush, or right-drag across it to pick up several tiles as one brush.

• Paint with the left button. Fill and the rectangle tools cover an area with your brush, tiled.

• X and Y flip the brush, and Rotate in the Tiles panel (or Z) turns it 90°, its layout and every tile (on hex maps, 60°: see Map shapes). Palette bank in the Tiles panel sets the brush's bank, for tiles that share a pattern in different colours.

• Alt+click a cell to open its tile in the tile set, zoomed in and selected, ready to edit. J swaps between a map and its tile set.

• Selections on a map are in cells, on the active layer: Select rectangle takes a box of cells, Select lasso the cells you draw round, and the magic wand the cells showing the same tile (flipped the same way, in the same palette bank; attributes don't matter), joined side by side or, with Joined pixels only off, every cell of that tile. Shift, Alt and Shift+Alt add, take away and overlap as on pictures, and Select all, Deselect and Invert work too. Painting, fills, rectangles and scripts then change only the selected cells (a fill stops at the selection's edge); Select > Fill the selection covers it with your tile brush, tiled from its top-left corner; Del empties the selected cells; and Ctrl+B makes the selected block your tile brush (cells outside the selection left empty).

• Cell attributes: every cell has 8 bits of its own for your game to use (solid, ladder, damage, whatever you decide). The Tiles panel sets your brush's attributes, can show them on the map in hex, can paint attributes only, or paint tiles keeping the cells' attributes. Picked-up brushes carry them, and undo keeps them.

• Properties: named, typed values your game reads ("spawn = true", "speed = 1.5", "music = level2.mod", "boss = Door"), on the map (or a picture), on each map layer and on each tile. A tile's properties are kept with the tile set, so every map using it shares them.

  • Types: true / false, whole number, number, text, colour (with alpha), file, object (another map object, chosen from a list of the map's objects by name, with Go to jump to it), and your own enums (one of a list, or with flags, any of them at once, as bits) and classes (named members with defaults, classes inside classes). Make them in Property types (Types... in the panel, or Window > Property types); they're kept with the map or picture.
  • The Properties panel (with Layers; Window > Properties) has a section for the map, the active layer and the tile in your brush (pick one up to see its). Each type gets its own editor: a tick, a number to drag or type, a colour picker, a file box, a list for an enum, a box for each flag, a class's members nested. + Add property takes a name and a type, and x removes one. Every change can be undone.
  • Naming the attribute bits: a flags enum can name a map's 8 cell attribute bits (Property types > Cell attribute bits), and the Tiles panel then shows a named box for each ("solid", "ladder", "water") beside the number.
  • Scripts: prop.list, prop.set, prop.remove, types.enum, types.class and types.remove (see the scripting reference).

• Terrains (auto-tiling): paint "grass", "sand" or "road" on a map and the right edge and corner tiles are chosen from what's round each cell; erasing puts the neighbours right too. Terrain sets belong to the tile set, so every map using it shares them, and work as Tiled's terrain (Wang) sets. There are three kinds:

  • Corners: the 16-tile transition sets, such as grass to sand. Painting a cell sets its four corners.
  • Edges: paths, roads, pipes and fences, 16 tiles. Each cell takes the terrain, joined to the same terrain beside it.
  • Corners and edges: the 47-tile "blob" set, for walls, cliffs and platforms.
  • The Terrains panel (with Tiles; Window > Terrains) holds the tile set's terrain sets (+ New set, Remove, name, kind) and their terrains, each with a colour, a name and how often its tiles are chosen. Paint with chooses a terrain, Erase terrain, or Tiles (terrain off) for ordinary painting. Set up tiles from a layout sets up 16 corner tiles, 16 edge tiles or 47 blob tiles in one go, from the first tile, terrain a over b (or over nothing). The tile in the brush shows its eight places round it: click one for the next terrain, right-click for none, or Take it out of the set.
  • Painting: with a terrain chosen, freehand (joined from cell to cell), lines, boxes and fill paint it, inside a map selection if there is one, and each stroke is one undo step. The right button still picks up tiles. Where several tiles fit, one is picked by the cell's position, weighted by how often each should appear, so variants mix and painting the same cells again gives the same tiles. Cells with tiles outside the set are left alone unless you paint them.
  • Scripts: terrain.list, terrain.new, terrain.remove, terrain.layout, terrain.tile and terrain.paint (see the scripting reference).

• Automapping (rules maps): for the details terrains don't choose, such as a stone edge under every grass area or a wall top over every wall, Deluxe Pixel applies rules maps the way Tiled's automapping does. A rules map is another open map with the same tile set, whose layers say what to look for and what to put:

  • input_Ground is what the map's "Ground" layer must hold, inputnot_Ground what mustn't be there, and input2_... and so on are alternatives.
  • output_Ground is what's put there every time; output1_Ground, output2_Ground... are alternatives, one chosen at random each time, weighted by each layer's Probability property.
  • Each rule is a group of touching cells on those layers. Besides ordinary tiles, the Tiles panel has rule tiles to paint with, shown on the rules map as coloured letters: Empty (an empty cell; as an output, it erases), Ignore (no condition, to join a rule's parts), NonEmpty (any tile), Other (a tile the rule doesn't name) and Negate (the opposite of the cell's condition).
  • The rules map's properties are Tiled's (MatchOutsideMap, OverflowBorder, WrapBorder, MatchInOrder, AutomappingRadius, and defaults for ModX, ModY, OffsetX, OffsetY, Probability and Disabled), and rectangles on a rule_options object layer set those options for the rules they cover.
  • In the Tiles panel, Automapping picks the rules map; Apply the rules runs them over the map as one undo step, and While drawing runs them after each stroke around what it changed. It shows how many rules matched and how many cells changed. Locked layers aren't touched, cells keep their attributes, and a layer the map doesn't have is mentioned.
  • Terrains and automapping stay two tools, as in Tiled: paint the terrain, then let the rules add the details. Scripts can do it too (map.automap, and map.set with rule).

• The status bar shows the cell under the pointer and its tile, and every stroke, fill and rectangle is one undo.

• Saving: the map remembers where its tile set is, and opening the map opens the tile set too. If the tile set has never been saved (one you've just made, or a picture opened from a PNG), saving the map saves it beside the map first, as "map name tiles.dpx", and the status line says so. If you move or copy the folder (to another PC, say), the map finds its tile set beside it. Or tick Keep the tile sets inside this map's file (in the map layers panel): the map and every tile set it uses are saved in one .dpx, to keep or send as one file, and come back with it.

• Priority: on the Mega Drive and SNES, a high-priority tile draws in front of sprites and of low-priority tiles on other layers. Priority in the Tiles panel gives your tile brush priority (picked-up brushes keep each cell's own), and Show priority marks high-priority cells with a yellow corner. (The Next's tiles have no priority bit of this kind, so its export doesn't use it.)

• Exporting: on a map, the Export window offers the tile, map and palette formats: the tile map files below, the Next's .map and .til, and the Mega Drive's and SNES's (see The machine formats). Map exports write the active layer, or for the Mega Drive and SNES every visible layer as a file each if you choose. Before a Next, Mega Drive or SNES map export, Deluxe Pixel checks the map against the hardware (tile and map sizes, tile counts, palette banks, rotated tiles, colours the machine can't show) and warns about anything that may not work on the real machine, with Export anyway or Cancel.

• A map as an image: with a map in front, the Export window's first format is Map as an image (PNG), for a level overview, a screenshot for a wiki or store page, a print-out, or a background in another tool.

  • What part: the whole map, the selected cells (their rectangle, with cells outside the selection left empty), or a rectangle of cells typed in.
  • Which layers: the visible ones, only the active one, or the ones you tick, each at its scroll as drawn; or Laid flat (unscrolled), each layer from its own top-left, for the level's real layout.
  • Scale 1x to 8x (each pixel a crisp block), and empty places see-through or filled with the see-through colour.
  • It shows the size the picture will be, and whether it's in the map's palette or full colour: a palette PNG when one palette holds everything drawn, otherwise full colour, so maps with layers in their own colours, see-through layers or palette banks past colour 255 save too. Always full colour forces it.
  • Any size: the picture is written a strip at a time, so even a map far bigger than any canvas (up to a million pixels each way) saves without needing the whole picture in memory, with a progress bar and Cancel. As a new picture opens it as a canvas instead.
  • Tiles > Map to picture (a new picture to paint on) uses the selected cells when there are some, otherwise the whole map, up to 4,096 × 4,096 in one palette; for anything bigger, use Map as an image. Scripts have both too (map.save_image and map.to_picture).

• Tiled maps: File > Open opens maps made in Tiled (mapeditor.org), .tmx or .tmj, and Tiles > Save as a Tiled map (.tmx / .tmj) writes them, for Tiled itself and the engines that read its maps (Godot, Unity through SuperTiled2Unity, Phaser, LibGDX, MonoGame and more).

  • Opening: tile sets inside the map or in .tsx / .tsj files beside it come across as one tile set picture, in one palette of up to 256 colours (more colours are fitted to it, and you're told). Tile layers keep their names, visibility, opacity, offsets (as scroll) and parallax, and the map's, layers' and tiles' properties come across with their types, tile animations and collision shapes come across (even with frames from another of the map's tile sets) (Tiled keeps its enums and classes in its project file, so they're worked out from what the map uses), and so do terrain sets; layers inside groups come across with the group's settings applied, named "Group/Layer". Every way of storing the cells opens (CSV, XML, base64 plain or zlib, gzip or zstd), infinite maps are put together round what's painted, and every flip and turn comes across exactly.
  • Tiles of other sizes: a tile set whose tiles aren't the map's size (16 × 32 trees on a 16 × 16 map, say) opens as a tile set picture of its own, named "map tiles 16x32", and the cells using it go on a layer of their own just above the one they were on, named "layer (16 × 32 tiles)", as tall tiles (see Map shapes), standing on their cells as in Tiled. A tile set made of separate pictures (a tower, a tent) is opened the same way: each picture becomes a tile the size of the largest, standing at its cell's bottom-left. Saved back, each of those layers keeps its tile set's own size.
  • Object layers come across both ways, every shape with its name, class, properties and turn (see Objects on maps below).
  • Image layers come across both ways too, each picture opened beside the map (see Image layers below).
  • What's left out is listed once the map opens: Tiled's oblique maps (they open as square grids). Isometric, staggered and hexagonal maps open in their own shape (see Map shapes below).
  • Saving: every layer, with its name, visibility, opacity, scroll and parallax, the map's, layers' and tiles' properties, terrain sets, tile animations, collision shapes, and each layer's tile set as a PNG beside the map. Cell attributes and palette banks have no place in a Tiled map, so saving says so; they stay in your .dpx.

• Grid and tile numbers you can see: View > Map grid and tile numbers sets how the grid looks over your tiles: each layer's own colour, dark, light, the accent, outlined (shows on anything) or your own colour, 1 to 4 pixels thick, from faint to solid, with heavier lines every few cells (a screen or a room, say). Ctrl+G steps through six ready-made styles. Shift+N shows each cell's tile number, in decimal or hex, in the colour and style you choose; they hide when the cells are too small to read. Gap between cells (0 to 16 screen pixels) spreads the cells apart on screen when zoomed in, so each tile stands alone; painting and picking still line up, and the map itself is unchanged. The tile set picture a map is painted from is spaced apart the same way (untick it there if you'd rather not).

• Animated tiles: a tile can show other tiles of its set in turn, each for its own time, round and round, wherever it is on any map, as water, torches and conveyor belts do. Choose the tile, then Animation in the Tiles panel: Animate tile n starts it off with that many tiles from it on, each for the same time. Its frames are shown (each tile with its number and time): drag a time to change it, move frames earlier, take them out, add more with + Frame, or give them All the same time; Stop animating makes it an ordinary tile again. The animation belongs to the tile set, so every map painted from it animates, live on the canvas, and so does the brush. Play on maps turns playing on or off, and Restart starts every animation from its first frame. Animated tiles have a corner mark in the panel, with their frames in the tooltip; every change is one undo step, and rearranging tiles in the panel takes their animations with them. Scripts and AI assistants can do it too (tiles.animate, tiles.animation_remove, tiles.animations, tiles.animation_play).

• Random tiles: for grass, floors or rock without a repeating pattern, tick Paint random tiles under Random tiles in the Tiles panel, and every cell you paint is one of a set of tiles, chosen by weight, and (on square tiles) mirrored across or down or turned a quarter at random if you ask. Ctrl+click tiles in the panel to add them to the set or take them out (they're framed there), and set each one's weight (its share is shown as a percentage); or pick up a patch of the map and use From the brush, which weights each tile by how often it's in it. Clear empties the set. It works with the brush, quick drags, boxes, outlines, fill and Fill selection, and the brush's palette bank, priority and attributes still apply. The preview shows the very tile a click will put down, going over a cell again in the same stroke never changes it, and each new stroke chooses afresh. The panel shows Brush: random, n tiles while it's on; picking another brush turns it off. Scripts can do it too (tiles.random, and map.set with random = true).

• Collision shapes: each tile can say which parts of it are solid, for your game's physics, as Tiled's collision editor and Godot's physics layers do: rectangles, ellipses, polygons (slopes), polylines and points, in the tile's own pixels. Choose the tile, then Collision in the Tiles panel: the tile is drawn big with its shapes, and dragging on it adds a box. Ready shapes (Full, Top, Bottom, Left and Right half, Slope /, Slope \, Platform) set it in one click (Shift adds one to what's there); Copy and Paste carry shapes from tile to tile, and None clears them. Each shape's place and size, or a polygon's points, can be changed as numbers. The shapes belong to the tile set, so every map painted from it has them, turned and mirrored with each cell; rearranging tiles takes their shapes with them. Show on maps draws the active layer's shapes over a square map and marks the tiles that have them in the panel. Every change is one undo step.

  • Into your game: Tiled maps keep each tile's shapes both ways; Godot scenes get a physics layer, each tile's shapes as polygons (points and lines, having no area, are left out, and you're told). Or map.collision_layer turns the active layer's collision into an object layer above it, solid runs of cells merged into as few rectangles as possible, for a game (or Unity) that reads a map's objects. Scripts can set shapes too (tiles.collision, tiles.collision_clear, tiles.collisions).

• Stamps: keep a brush you've picked up (a right-drag on the map, or a block of tiles) under a name, in Stamps in the Tiles panel, for every map. + on a stamp adds the current brush to it as another variation: wherever the stamp goes down, one of its variations does, at random, so three kinds of rock or bush mix naturally. The preview shows the one that will land, and flipping or turning the brush turns every variation. Quick stamps: on a map, Ctrl+1 to Ctrl+9 keep the brush and 1 to 9 bring it back (for this session; also as nine buttons in the Stamps section). Scripts can use stamps too (tiles.stamp_save, tiles.stamp_use, map.set with stamp, and the rest).

• Zoom in the Tiles panel: - and + (1x to 16x), Ctrl+wheel over the tiles, Fit or Auto, kept with each tile set, so small tiles are easy to see and pick. Numbers here shows the tile numbers on the panel's tiles too.

• Map overview (Window > Map overview, or Tiles > Map overview (condensed)): the whole map at a glance, each area one dot in its most common colour, so you see the layout of a level (platforms, rooms, water) without the tiles turning to mush. A dot can be a quarter tile, half a tile, a tile, or 2 × 2, 4 × 4 or 8 × 8 tiles; all visible layers combined, or one alone. Your view is outlined on it: click or drag to go there. Make a picture of it gives a new image, a pixel a dot. View > Map overview on the canvas draws the map condensed in place. It follows your painting as you go.

The spare page isn't available on a map (J goes to its tile set instead): paint the tile set to change what the tiles look like.

Map shapes

A map doesn't have to be a square grid. Its shape can be:

• Square, as before.
• Isometric: diamonds on a turned grid, so the whole map is a big diamond.
• Isometric staggered: every other row or column shifted by half a tile, so the map stays a rectangle.
• Hexagonal: pointy-topped hexes with rows shifted, or flat-topped hexes with columns shifted, odd or even ones shifted, with the length of the straight edge set too.
• Brick: rectangles with every other row (or column) shifted half a tile, as Godot's half-offset squares. Tiled sees these as hex maps whose straight edge is the whole tile, which is what they are.

These are Tiled's shapes and conventions, so Tiled's maps open looking as they do there, and are saved in their shape.

• Choosing it: Tiles > New map offers the shape, with a few cells drawn so you can see it. To change a map's shape, use The map in the Map layers panel: it changes every layer, and can be undone.
• Everything works as on square maps: painting, brushes, boxes, fills, the magic wand, selections, layers, undo, and the cells' flips and attributes. Each tile is drawn inside its cell's own shape. The grid, the brush under the pointer, boxes being dragged and the selection's outline follow the shape, and tile numbers sit in the middle of each cell.
• Fill and the wand follow the shape's neighbours: six for hexes.
• Brushes keep their shape on staggered, hexagonal and brick maps: a group of cells picked up on one row and put down on another lands in the same arrangement, instead of coming out sheared, and the preview outlines just its cells. Flipping keeps the rows' shift too.
• Turning on hexes: Z (or Turn 60 in the Tiles panel) turns the brush's arrangement 60 degrees on the hex grid; the tiles themselves stay as drawn, as tiles can't turn 60 degrees. Square maps keep their quarter turns.
• Tile set templates: Tiles > New tile set for this map's shape makes a picture of tiles at the map's tile size, each with its cell's shape (diamond, hex, brick or square) outlined in the left colour and the corners outside it see-through, ready to paint into.
• Godot 4 scenes: Tiles > Save as a Godot scene writes a .tscn for Godot 4.3 and later, with a TileMapLayer for each layer and a TileSet using the tile set picture (a PNG beside the scene), in the map's shape, with each cell's flips and turns and each tile's collision shapes on a physics layer. Layers keep their visibility, opacity and position. What Godot can't hold (parallax, column scroll, cell attributes and palette banks, animated tiles, and hexes whose straight edge isn't half the tile) is listed when you save.
  • Opening them: File > Open opens Godot 4 scenes (.tscn), from TileMapLayer nodes (Godot 4.3 and later) or the older TileMap node's layers (4.0 to 4.2). Each layer comes in with its name, visibility, opacity and position; tile sets are read from the scene or a .tres beside it, their pictures found through the project folder; and Godot's tile shapes and layouts become the matching map shape. Tiles bigger than their cells come in as tall-tile layers. Anything not read (other nodes such as sprites and cameras, animated tiles, custom data, terrain sets, Godot 3 scenes) is listed once when the scene opens.
• Tall tiles: a layer's tiles can be bigger than its cells, for walls, trees and buildings on an isometric map, or tall scenery on a square one. Set the tiles' size for the layer in the Map layers panel (This layer). Each tile is drawn whole from its cell's bottom-left, overhanging the cells behind it, back to front as Tiled draws them, so nearer tiles cover farther ones and see-through pixels show what's behind. The Tiles panel, the brush, the overview, flattening and exports all use the tall tiles, and Tiled and Godot maps are saved to look the same. Setting the size back to the cell's makes them ordinary tiles again. Tiles on the top row (or the last column) that overhang the map's edge are shown whole: the map grows to make room, without anything moving on screen, and shrinks back if the tiles are made ordinary again. Saved for Tiled or Godot, which draw over the edge themselves, the cells start at the top-left as usual.
• Map to picture and exports draw the map in its shape too.
• Scripts: map.shape, map.save_godot, tiles.shape_template and map.tile_art, and map.new takes the shape too.
• Wrap (repeat in every direction) works on every shape: isometric maps repeat along their diamond's two sides, and staggered, hexagonal and brick maps repeat seamlessly when the number of shifted rows (or columns) is even (with an odd number, the copies meet half a cell out of step). Tall tiles reach over the edges from the next copy, on square maps too. You can paint, pick and select on any copy. Scripts set a layer's wrap and scroll with map.layer.
• Not yet: column scroll, the condensed overview and gaps between cells on other shapes, and terrains on staggered and hex maps (they work on square and isometric ones).

Block maps

A map layer can be a block map: built from blocks, each a small piece of map of any size (2 × 2 metatiles, 4 × 4 or 16 × 16 blocks, bigger chunks), as Sonic, Mario and many Amiga games were. Each place a block is used (a placement) can be mirrored, can add to its cells' palette banks (the same block in other colours), and can have spot changes: a few cells of its own that differ from the block. Blocks can be grouped into chunks in turn, as Sonic did (tiles in blocks, blocks in chunks, chunks in the layout). A map made this way takes far less memory, which is the point on a small machine.

The layer's cells are still the map as you see it, so every other tool, export and Tiled work on it as before.

• Making one: Window > Block map, then Make block map, cuts the layer into blocks of the size you choose. Alike areas become one block, mirrored ones too; with Spot changes allowed, so do areas differing in up to that many cells, the differences kept as spot changes; and with Blocks in other palettes are the same block, an area whose palette banks are all moved by the same amount is placed as that block with a palette add. Empty areas get no block. Find blocks again recuts it, and Ordinary layer forgets the blocks (the map looks the same).
• Painting with blocks: choose Paint with: Blocks, pick a block from the panel's grid (each drawn from its tiles, with how often it's used), and the map tools place it: freehand (joined from placement to placement) and boxes (filled or outlined), with flips and a palette add. The right button picks up the placement under the pointer, and Erase (no block) turns placements back into plain cells. Each stroke is one undo step.
• Spot changes: paint tiles over a placed block and those cells become spot changes of that placement only. Each one shows an orange corner on the canvas.
• Editing a block everywhere: with Edit blocks in place (every copy changes) on, painting tiles over a placed block changes the block itself, and every copy follows, except where a copy has its own spot changes. Undo once and the stroke is left as spot changes; undo again and it's gone.
• Placements' attributes: every block or chunk placement can carry your game's own bits (Sonic's solidity, its second path, a chunk's loop flag), set with Attributes on the brush.
• Chunks: in the panel's Chunks part, Group blocks into chunks (size in blocks) makes alike areas one chunk, mirrored and recoloured ones too when allowed; Find chunks again and Ungroup chunks do what they say. Finding blocks again forgets the chunks. Paint with: Chunks places a chunk from the panel's grid with freehand, lines and boxes; the right button picks one up, and Erase (no chunk) takes it away. With Edit chunks in place (every copy changes) on, placing a block inside a placed chunk changes the chunk, and every copy follows. Chunk edges show in gold, thicker than blocks', and a block that differs from its chunk gets a cyan frame.
• From the selection: New block from the selection makes a block of the cells at the selection's top-left, and Break into cells turns the placements under the selection back into plain cells.
• Seeing it: Show block edges and spot changes (a View option) outlines each placement with its block number (X and Y for flips, +p for a palette add). The panel's overview counts the blocks, placements and spot changes, and compares the bytes they'd take in a simple machine layout with the flat map.
• Machine formats: the panel's Machine list picks the format the blocks are for, and every option stays editable (change one and it becomes Custom). It's kept with the layer.
  • Free: anything goes, exported as JSON.
  • Sonic 1, Sonic 2 and Sonic 3 & Knuckles (Mega Drive): 16 × 16 blocks of Mega Drive tile words, in 256 × 256 or 128 × 128 chunks, with their layouts, solidity bits and the empty block 0 and chunk 0 the games expect, as SonLVL (the Sonic Retro community's level editor) writes them. Files are compressed as each game keeps them: Kosinski, Sonic 3 & Knuckles' moduled Kosinski, Enigma for Sonic 1's blocks and Nemesis for its tile art.
  • NES metatiles (Super Mario Bros. style): 16 × 16 metatiles of four tiles, one palette each, no flips.
  • NES 32 × 32 (Mega Man style): the same metatiles in 2 × 2 structures.
  • SNES Map16 (Super Mario World style): 16 × 16 blocks of four SNES tile words.
  • The Legend of Zelda (NES overworld): 16 × 16 squares of four tiles, stacked in columns 11 squares high, 16 columns to a screen, written as the game keeps them: packed columns, the column directories, screens (alike ones once) and the screen layout.
  • Metroid (NES rooms): 16 × 16 macros in rooms of 16 × 15, built from structures as the game builds them. The structures are found from your map (alike ones kept once), each room lists where they go and in which palette, and the 32 × 32 world map says which room is where (alike rooms once).
  • Custom: tile, block and chunk sizes, the most tiles, blocks and chunks, the layout's size, palette banks, which flips and priorities are kept, palette adds, spot changes, the cell and block words, the layout's order and byte order, whether block 0 and chunk 0 are the empty ones, each file's compression (none, Kosinski, moduled Kosinski, Enigma or Nemesis), and whether the tile art and palette are written too.
  • Your own formats: Save format as (in Format options) keeps a format with all its options under a name, listed under Saved in the Machine list for every map; Forget it takes it out.
• Check against the format lists everything that won't fit, with a count for each: sizes, too many tiles, blocks or chunks, flips or priorities the machine can't keep, palette banks past its limit, attribute bits the words can't hold, spot changes on formats that don't keep them, and a layout that's too big. Zelda and Metroid add their own: a layout that isn't whole screens, too many screens, structures or rooms, or a world bigger than 32 × 32.
• Exporting:
  • Tiles > Export block map (JSON) writes the blocks, chunks, layouts and spot changes, with the format explained in the file, for your game's code.
  • Tiles > Export block map for the machine writes the machine's own files: name.blocks.bin, name.chunks.bin and name.layout.bin, plus name.palettes.bin for one-palette blocks (Zelda's add name.columns.bin, name.column_dirs.bin and name.screens.bin; Metroid's are its structures, rooms and world map, with their pointer tables). Formats that include them also write the tile set's art (name.art.bin: Mega Drive 4-bit tiles, NES 2-bit or SNES 4-bit planes) and its palette (name.palette.bin: Mega Drive or SNES colour words, 16 to a line), compressed as the format says. A background layer (as Sonic has) is written with it, and Share blocks first makes that layer use this one's blocks and chunks, so the two go together.
  • Reading a level back: Import in the panel (or Tiles > Import block map from the machine) reads a level's layout file, with its blocks, chunks and NES palettes from beside it, decompressed as the format says, into the active layer: its blocks, chunks, placements and cells, the layer sized to fit. A Sonic level's background goes into the background layer you choose. The map's tile set should hold the level's tiles, in order. It's one undo step.
  • File > Open a game level opens a level's machine files as new pictures: choose the format (or one you've saved) and the layout file, and its blocks, chunks and layout, with its art and palette if they're there, open as a tile set picture and a block map drawn from it, ready to paint with. A level's background comes in as a second layer. Without art, each tile is a plain square; without a palette, the colours are grey ramps.
  • The flat map exports as before.
• On other shapes: isometric, staggered and hexagonal block maps show their block and chunk edges and spot changes too.
• Scripts: block.make, block.clear, block.info, block.place, block.break, block.from_cells, block.set, block.export, block.chunks, block.unchunk, block.format, block.check, block.export_format, block.share, block.import_format, block.open_level, block.format_save and block.format_forget (see the scripting reference).

Objects on maps

A map can have object layers: game objects placed over the map, such as spawn points, triggers, doors, patrol paths, enemies placed as tiles and signs. Each has a name, a class (what kind of thing it is) and typed properties. They're never drawn into the cells: they're data for your game, saved with the map. (They're not the same as a picture's editable shapes, which become pixels.)

• Making one: + Objects in the Map layers panel adds an object layer, listed as "(objects)". It's a map layer like the others: order, visibility, opacity, scroll, parallax, properties and undo all work.
• The shapes, as Tiled's: rectangles, ellipses, points, polygons, polylines, tile objects (any tile, anywhere, stretched to any size and mirrored), and text (with size, colour, wrapping, alignment and bold). Any of them can be turned.
• On the map: objects are drawn in the layer's colour, shapes faintly filled with their names over them. The chosen one shows in the accent colour with its handles.
• Placing and editing (with an object layer active, the pointer works on objects instead of cells): the panel's Clicking on the map picks what a click does.
  • Choose: click to choose, drag to move, drag the corner to size, or drag a polygon's points.
  • Rectangle, Ellipse: drag one out, or click for one cell's size.
  • Point, Tile (your brush's tile) and Text: click to place.
  • Polygon and Polyline: click the corners. Double-click, Enter or right-click finishes; Backspace takes the last point back; Esc drops it.
  • Turning: drag the circle above the chosen object to turn it about its middle (Shift: in 15° steps).
  • Points: double-click a side of a polygon or polyline for a new point there, then drag it; Alt+click a point to take it away (a polygon keeps at least 3, a polyline 2).
  • Snap to the cells keeps them on the grid; hold Ctrl for the other way. Del removes the chosen object, the arrow keys nudge it (Shift: 10 pixels), and Esc lets it go.
• In the panel: the objects are listed top first, with the chosen one's name, class, place, size, turn, visibility, and its tile and mirrors or its text settings; Delete, Duplicate and To the top. Its properties are in the Properties window, under Object.
• Tiled: object layers open and save both ways (see Tiled maps above). On isometric maps, places are converted to and from Tiled's own, and rectangles, ellipses and text come in upright. Tiled's templates (.tx, .tj) come in as templates, their objects as linked copies, and are written back the same way, as .tx files beside the map (copies of tile templates are written whole). Godot has no map objects, so its export leaves them out and says so.
• Templates: Make a template of it turns the chosen object into a template, and it becomes the first copy. Choose a template in the panel's list and clicks place copies of it. Change the template and every copy changes with it, except for anything a copy has changed itself: each copy keeps only its own differences (its place is always its own). A copy shows which template it follows and what's its own, with As the template to drop its changes and Cut loose to make it an ordinary object. Delete the template leaves its copies as ordinary objects.
• Objects pointing at objects: give an object a property of type object (a switch pointing at its door, say) and an arrow is drawn from it to the one it points at, in the accent colour when either is chosen.
• Scripts: map.object_layer, map.object, map.object_delete, map.objects, map.object_go, map.template_make, map.template_place, map.template_set, map.templates, map.object_reset and map.object_detach, and the prop.* commands work on objects too (see the scripting reference).

Image layers

An image layer is one picture as a background or foreground on a map: a sky, distant hills, a foreground of leaves. + Image in the Map layers panel makes one from any open picture, listed as "(picture)".

• It's a map layer like the others, so it scrolls, follows another layer for parallax, fades, flattens, exports and saves as they do. It isn't painted on: change the picture itself, or move the layer with its scroll.
• Repeating: across, down, both or neither, so a strip of cloud can repeat across the sky only. (Any square layer can now wrap one way only, too.)
• A true-colour picture is copied into 256 colours for it, and the copy opens beside it.
• It's always drawn square, whatever the map's shape.
• Tiled: image layers open and save both ways, with their offset, opacity, visibility, parallax, repeats and properties. Godot: saved as a Sprite2D of the picture (without its repeat).
• Scripts: map.image_layer.

3D cubes from tiles

Tiles > 3D cubes from tiles... puts each tile on the top and sides of a cube and renders the cubes into a new picture, one cube a cell, in the same order as the tiles: isometric (2:1), three-quarter (top and front) or your own angle. Choose the cube's height, and whether its sides use the same tile, the tile below it in the set (grass on top, earth down the sides) or plain colour, plus light, dithering and an outline. The top stays exactly as you drew it, only the sides are shaded, and a palette picture keeps its colour numbers. The new picture's grid is set to the cube size, ready to use as a tile set.

Map layers

A map can have up to 16 layers, drawn bottom first: a foreground and backgrounds, say. Each layer can draw from its own tile set, at its own tile size (8 × 8 tiles in front of a 16 × 16 background, for instance); all of them share the map's palette. On a map, the Layers panel becomes the map layers panel: add, duplicate, delete and move layers, and for each, show or hide it and its grid (each layer's grid in its own colour). Click a layer to make it the active layer, which painting, picking, fill, rectangles, Alt+click and the tile brush all work on. Empty and transparent pixels let the layers below show through.

New layer with another tile set... adds a layer using a different open tile set, sized to cover the map, and the active layer's settings can change which tile set it uses. The active layer's tile set is the one you paint and pick with: the brush preview, Alt+click, the Tiles panel and tile exports all follow it. Saving the map remembers each layer's tile set file, and opening the map opens them too.

For the active layer you can set:

• Scroll X and Y, or turn on Scroll by dragging the map and drag: it moves the topmost visible layer under the pointer (which becomes the active layer). Reset puts it back.
• Wrap: the layer repeats in every direction when scrolled, and painting on a repeat paints the cell it repeats.
• Link: the layer follows another at a ratio across and down: 1 moves with it, 0.5 half as far (a distant background, for parallax), 0 stays put. Links can chain.

Sizes and offsets: a map is its layers. Each layer keeps its own size in cells, and the map is always just big enough to show every layer where its offset puts it, worked out as you go (wrapping layers don't count). This layer in the map layers panel sets the active layer's offset in whole cells and its own size (cells beyond it are dropped, new ones empty, as one undo step), and the panel shows how big the layers make the map. Drag a layer in any direction and the map grows or shrinks on that side as you drag, while the other layers stay still on screen. The checkerboard behind is the map's area where no layer has a cell, so it always fits round the layers exactly. Each layer's grid stops at its own edges.

Empty space (where no layer has a tile) shows as a grey and white checkerboard, or, with View > Empty map space > Nothing, as nothing at all. A tile's own see-through pixels still show colour 0, the machine's background, unless Show transparency (T) is on.

Its tile set's own colours: a layer with its own tile set can be drawn in that tile set's palette and see-through colour instead of the map's (the panel's Its tile set's own colours).

Opacity: each layer can be made see-through (the bottom layer is always solid), so only its tiles blend over what's below.

Locking: the lock on each row of the Map layers panel protects a layer. You can still look at it, pick tiles up from it, select and scroll it, but painting, filling, Fill and Delete selection, automapping and scripts leave it alone, and the status line says why. Locks are saved in the .dpx and in Tiled maps, both ways.

Focus: Ctrl+H on a map (or Focus on the active layer in the Map layers panel) dims every other layer to 30%, so you can see what's on the one you're working on, as Tiled's "highlight current layer" does.

One map over another: with a map in front, Ctrl+click another map's tab. Deluxe Pixel asks whether to show it over this one as an overlay (it follows the other map as you edit it, and isn't painted on) or to copy it in as layers (one map, painted and saved as one; Close the other map afterwards is ticked, since its layers are now this map's), with how see-through it should be, or the other way round. Its visible layers are added on top in the map layers panel, each with its own tile set, scroll and parallax, with its top-left at the cell you choose (the top-left corner unless you say otherwise). Each keeps its own size: a 10 × 100 map over a 100 × 10 one stays that shape, and the map shows both whole. Not sure what it will do? Hover over another map's tab for a moment and a tip says what Ctrl+click does there. It's handy for comparing two versions of a level or lining up a foreground. Make it this map's own turns an overlay into an ordinary layer. It keeps its own colours and see-through colour, so it looks just as it does in its own window.

Shift+G on a map shows or hides the active layer's grid. Undo remembers which layer each change was on, and Tiles > Map to picture combines every visible layer at its scroll.

Column scroll

The Mega Drive's vertical scroll by column, for water, heat haze, and wobbling or tilting platforms: each layer can have a table of vertical offsets, one per column of a chosen width, so each column of the layer is moved up or down by its own amount. It's in the map layers panel, under This layer > Column scroll.

• Switch it on, and choose the column width (the Mega Drive's 2-cell mode uses 16 pixels). A table shorter than the map repeats.
• The strip shows a bar per column: drag across it to set the values (one undo step a drag), or fill it with a Sine wave (height, wavelength and phase), a Slope, or Flat.
• What the columns follow: the screen (the default, and the Mega Drive's way: the wave stays put while the layer scrolls under it), this layer (the columns travel with the layer, like a ripple painted on its tiles), or the map (they travel with the level, so layers set this way line up whatever their parallax).
• Animation: a speed in columns a second turns the table along, as games do for water; Play animates every layer's column scroll on the canvas.
• Everything follows it: painting and picking use the offset under the pointer, so you paint where you see; the brush preview, the grid, Map to picture and the sprite scene preview all include it. Wrapping layers stay seamless.
• Export the table... writes it as signed 16-bit words, little-endian or big-endian (Mega Drive, Amiga), as binary, C or assembler.
• The Mega Drive's rules are checked when you export its planes: columns must be 16 pixels (2 cells) and follow the screen, only planes A and B can have column scroll, and its table holds at most 20 columns (H40). Anything outside them is listed before you export.

Amiga map editors: Ame, Tame and KagePro

Deluxe Pixel opens and saves the maps of three Amiga map editors: Ame (1991, written for Mercs and compatible with Tiertex's Atari ST editor), Tame (Turbo Amiga Map Editor, 1992–93, used for Superhero) and KagePro (1993–94, AGA). They were written by Deluxe Pixel's author and used in many Amiga games, and Tame was given away free with Amiga Format magazine for anyone to use, so there are plenty of their maps out there. Tame's own speed tricks live on in Deluxe Pixel: on the Amiga it redrew only the cells that changed, and treated brushes as tile numbers drawn into the map's own grid; Deluxe Pixel does the same for undo, for what it sends to the graphics card, and for the brush preview.

• Opening: open any of a map's files (File > Open, Explorer, or drop it on the window). The tiles (Tame calls them blocks) become a tile set picture, 20 to a row like the editors' own screen of them, and the map a tile map that uses it, on the Amiga. Painting keeps the cells' attributes, as the editors' brushes did.
• What's read: Ame and Tiertex ST maps (Map?.chr, with tiles from Chr?1–Chr?9 screens as .iff, .pc1, .pi1 or .raw, or from Chr?.chr); Ame's own Ame?.map, .blk and .inf; and Tame's .map, .blk and .dat, in its 2048 or 4096 mode. KagePro uses Tame's files. Tame's second palette becomes palette bank 1.
• Tame's two modes: the files don't say which mode they were saved in, so Deluxe Pixel works it out from the cells. If it guesses wrong, Tiles > Open the Tame map again as... reads it the other way.
• Crunched files and shared sets: files packed with PowerPacker (as many were, to fit on the disk) are unpacked as they're read. Encrypted ones can't be opened, and you're told why. Where a game's maps share one set of tiles and colours (World01 to World17 all using world00's .blk and .dat, say), a map without its own files uses the set's, and the map's notes say which files it used.
• Saving back: File > Export, "Amiga map editors": Tame 2048 or 4096 (.map, .blk, .dat), or Ame / Tiertex (Map?.chr, named from the file name, with Chr?1.iff onwards as screens of tiles). Each checks first that the map fits the format: 16 × 16 tiles in colours 0–15, no flipped or turned cells, and the format's attribute bits, palettes and tile counts.

Exporting

File > Export... (Ctrl+E) is the one way to export. It lists every format Deluxe Pixel can write, whatever the image is, in groups: first For this machine (the formats made for the image's machine, or those its system has chosen), then Pictures and Animation (free), then each machine's own formats (ZX Spectrum, ZX Spectrum Next, Commodore 64, Atari ST, Amiga) and Data. Each format is marked:

• Ready: the image can be written as it is.
• Converts first (~): a machine format the image doesn't suit yet (its size, colours or colour clashes), with the reason. Convert and export writes a converted copy: fitted to the machine's screen (scaled to fit, keeping its shape, centred), converted with the dithering you choose, and with clashes fixed. Your image itself isn't changed. For more control, convert first with Image > Convert to another machine.
• Not available: for example a sprite sheet without frames; the reason is shown.
• (registered): the machine formats the demo doesn't export.

Every export writes the picture as the canvas shows it: its visible layers and its palette set. File > Save as offers all the same formats; choosing one exports a copy, and your image stays a .dpx project, so its layers and frames are never lost to a flat format. The window remembers the last format you used, so a quick PNG is Ctrl+E, then Export.

The machine formats

The 8-bit machines' screen files can also be written as C arrays or assembler data (.h, .asm). Colours become the machine's own numbers: matched by colour where the machine has a fixed set, or as the palette registers your program sets.

Exports are saved as safely as your projects: a failed export never damages an existing file.

Palettes and colour cycling

• Left-click a swatch for the left colour, right-click for the right colour. [ and ] step through the colours, and Shift+X swaps left and right.
• The colour editor has these tabs, and every one snaps the colour to what the machine can show:
  • RGB (or Machine): sliders that move in the machine's real hardware steps, or, on fixed-palette machines, the hardware's own colours to choose from.
  • HSV: hue, saturation and brightness. They stay where you put them while you drag, even when snapping nudges the colour.
  • Picker: a colour square with a hue bar.
  • All colours (machines with up to 4,096 colours, such as the Next, ST, Mega Drive, Amiga and CPC Plus): every colour the machine has, laid out in blocks by red level with green down and blue across. Hover for its hardware value (such as "RGB333 5,0,3") and hex, and click to set it.
  • Under the tabs: hex entry (#RRGGBB or #RGB), Copy and Paste, and ramps, which fill the colours between the left and right colours smoothly, straight or round the hue for richer ramps.
• The Mixer (in the Palette panel, folded away until you open it) is a small canvas to mix colours on, like a painter's palette. Left-drag paints with the left colour and right-drag with the right, as soft wet dabs; Ctrl+drag smudges; Alt+click picks. Choose how colours mix: as light (a real mix of light), as the eye sees (perceptually even), or like paint (as pigments do, so blue and yellow make green). Hovering shows the colour and the nearest one already in your palette (with "too close to see" for near-twins); a picked colour can go into the colour being edited or be added as a new one, snapped to the machine. Shift+drag a line across the mix to fill a ramp (between the left and right colours' numbers), with Even steps for a ramp that looks evenly spaced. The mix is saved with the project.
• Palette sets: keep up to 256 palettes for the same pixels (day and night, say, or alternative colourways) and choose which one each view shows.
• Bank colours, for tile maps: a map cell's palette bank (0–255) picks its colours from further along the palette, so a tile set can have far more colours than a picture's 256, up to 4,096 (256 banks of 16, like the Neo Geo). Those extra colours are bank colours, listed in the Palette panel's Bank colours section once a palette has 256 colours (click one to edit it; add or remove 16 at a time). Pixels never use them: they exist only for map cells' banks, and a palette for each tile makes them for you.
• Palette files: Load JASC .pal, GIMP .gpl, Lospec .hex, Adobe .act, a Next .pal, or the colours of a PNG (snapped to the machine); Save as JASC, GIMP, hex or ACT.
• The palette library (Library...): built-in palettes, previewed on your picture before you choose: artists' (PICO-8, DawnBringer 16 and 32, Sweetie 16, Endesga 32), machines' (ZX Spectrum, C64, Amstrad CPC, MSX, CGA / EGA, BBC Micro, Game Boy, Amiga Workbench) and generated ones (greyscales, web-safe, RGB332), plus your own in the Palettes folder in your settings folder. Use replaces the palette; As a new palette set adds it.
• Arrange...: sort the colours (by hue, brightness, saturation or how much they're used), swap the left and right colours, gather the used colours at the start, remove unused colours, or mark them. The pixels in every layer and frame follow, so the picture looks exactly the same, and so do your palette sets, the stencil and your colour cycling.
• The colour-blind check (in the Palette panel): about 1 in 12 men and 1 in 200 women see colour differently. Choose a kind of colour blindness, and it lists the pairs of colours your image uses that look clearly different normally but alike with it, the hardest first. Click a pair to make them the left and right colours, ready to adjust one. See the canvases like this then shows every picture, map and tile set as someone with that kind of colour blindness sees it (also View > See colours as).
• Colour depth (in the Palette panel, and in File > Systems): the colours the target machine can make. Choose the bits for each of red, green and blue (together or separately: 3-3-2 for RGB332, say), or hue, saturation and brightness steps for machines that work that way, starting from common choices like RGB444 (the Amiga), RGB333 (the ST, the Next, the Mega Drive) or RGB332. In the Palette panel it applies to this image only, so you can try another target, and Snap the palette moves every colour to the nearest the new depth can make. File > Reducing colour depth chooses how a colour is brought down to fewer bits: Nearest value (each of red, green and blue rounded on its own: the default), Nearest as seen (all three together, choosing the colour that looks closest; about 20% closer on average at 2 to 4 bits), or Mask (the low bits simply dropped, as some hardware does). Everything that reduces colours follows it, including the colour words the exports write, so the files match what's shown.
• Locking the palette: Lock to the N loaded colours (in the Palette panel, under the stencil; Lock to these N colours for a picture that wasn't opened with a palette) keeps the picture to the colours the file was opened with. While it's locked, no colour can be added: Add colour and the mixer's Add as a new colour are refused, and loading or dropping a bigger palette fills only those colours. The colours themselves can still be changed. Locking after colours were added takes them off again, and pixels in them become the nearest loaded colour (never the transparent one), as one undo step. On a true-colour picture, the left and right colours snap to the locked colours, and Convert to a palette and palette exports use exactly those colours instead of making a new palette. Scripts: palette.lock.

Colour cycling

Colour cycling moves colours through the palette while the pixels stay put: waterfalls, lava, glowing lights, the classic Deluxe Paint effect. Each palette set can have any number of cycles, made and edited in the Colour cycling panel (docked with Layers, Tiles and Frames). They act on whichever palette set the canvas shows.

What a cycle moves:

How it moves, for any kind: Bounce goes back and forth instead of wrapping round; Reverse runs the other way; Smooth blends between steps instead of jumping (lovely for show and GIFs, though real hardware steps); Start sets a phase, so cycles don't all begin together; and a Name ("Waterfall", "Lava") labels it in the panel. Where two cycles cover the same slot, the later one wins.

Timing: in steps a second, or every N frames at 50 Hz (PAL) or 60 Hz (NTSC), which matches exactly what a game's vertical-blank code will do. Switching between them converts the speed, and each cycle shows its steps, its rate and how long it takes to loop.

Previewing: Cycle in this canvas (or Tab) plays and pauses, each canvas with its own clock. Speed previews from a quarter to four times the real speed without changing your cycles; Step moves on one step at a time, and Reset goes back to the start. Bake into palette makes the colours as they are at that moment the palette's own (and can be undone).

In files: your .dpx keeps everything. IFF files keep range cycles as Deluxe Paint does, and opening an IFF reads Deluxe Paint's and Graphicraft's cycling back in. Degas Elite keeps the simple ranges it can describe, and File > Export colour cycling as GIF understands every option.

For games

The For games section at the bottom of the Colour cycling panel turns your cycling into something a game can use. It plays the cycles at your game's frame rate (50 or 60 Hz) for one complete loop, until every cycle is back where it started together, and shows how many distinct steps that takes, how long the loop is, and how big the export will be.

• Export palette tables... writes the palette at every step of the loop, as binary, C or assembler, in one of six colour formats: 24-bit RGB, Spectrum Next 9-bit, Amiga 12-bit, Atari ST, Mega Drive CRAM or SNES CGRAM. Each step is led by how many frames it lasts, and you can write only the colours that change (Deluxe Pixel works out the range) or the whole palette.
• Cycle definitions... writes each cycle as one line of numbers (its kind, frames per step, reverse and bounce, and its slots or colours), for games that run the cycles themselves. Hue shifts and smooth blends can't be described that way, so they're listed as skipped; use palette tables for those.
• Make frames from cycling makes a new image with one animation frame per step of the loop (up to 256), the palette fixed and the pixels changing instead, for machines without palette animation. Ranges and chosen slots come out exactly; colour lists, hue shifts and blends use the nearest palette colours, and the status bar says so.

Seeing it as others will

Two views change only what you see, never the picture, with a label on the canvas while they're on:

• View > See colours as: normal, protanopia, deuteranopia (the most common), tritanopia, or monochrome: the canvas as players with that colour vision will see it, while you carry on painting.
• View > Show as Amiga HAM: HAM6 (16 base colours) or HAM8 (64, AGA). The canvas shows the picture as a Hold-And-Modify screen would, fringes and all, the base colours being the palette's first 16 or 64, so you can paint in HAM as in Deluxe Paint IV.

Amiga HAM pictures

A HAM picture keeps every pixel's full colour, with the palette's first 16 (HAM6) or 64 (HAM8) colours as its base colours, as on the Amiga. The canvas always shows it as HAM, fringes and all (labelled "Amiga HAM6 picture"), so painting on it is painting in HAM.

• Image > Pixel art > Amiga HAM picture...: HAM6, HAM8 or not HAM; base colours chosen from the picture, or the palette's first colours as they are (snapped to the hardware, as in Deluxe Paint IV); dithering for smoother skies. The preview shows how many colours appear and how close the result is (hold to compare).
• Opening: HAM IFF files open as HAM pictures, exactly as they are. File > Settings > Opening true-colour pictures can also open photos straight As Amiga HAM6 or HAM8.
• Exporting: HAM6 and HAM8 IFF write a HAM picture exactly as it shows. Each line is planned as a whole, so colour changes can start a pixel early where that makes shorter fringes.

True-colour (24-bit) pictures

A picture is either a palette picture (as everything above: up to 256 colours, the way the machines work) or a true-colour picture, with any of 16 million colours in every pixel and real translucency, for painting freely, photos, and artwork you'll fit to a machine later.

• New images: the New image dialog offers palette or true colour.
• Opening: 24-bit files open as true-colour pictures (see Files); File > Settings > Opening pictures changes that.
• Converting: Image > Convert to true colour (24-bit) (exact) and Image > Convert to a palette (to the screen mode's number of colours, at most 256), each one undo step.
• Back to the palette it was opened with: a picture remembers the palette it had when it was opened (kept in the .dpx). Image > Machines > Convert to the palette it was opened with (nearest colours, or dithered with Floyd-Steinberg, ordered or Atkinson) puts every pixel back into exactly those colours, in the same order and numbers as the file, after painting in true colour or changing the palette. Transparency stays transparent, and it's one undo step. It's greyed out for pictures that were never opened with a palette. Scripts: picture.convert.
• Painting: every tool and paint mode works in colour, with full-colour brushes (animated ones too), smear, translucent Blend, textures and selections; painting with see-through erases.
• Choosing colours: the left and right colours can be any colour: in the colour control, left-click sets the left colour and right-click the right, with a hue strip, hex fields and See-through for each. The mixer, swatches and the picker all give exact colours.
• Exporting: PNG, JPEG, TIFF and HAM are written in full colour; other formats use a copy fitted to a palette, and the Export window says which.
• Palette-only features: tiles, attribute cells, colour cycling, the colour-number filters and the machine exports need colour numbers. On a true-colour picture they use a converted copy, or say that the picture needs converting first.

The Image menu: filters

Every filter in the Image menu opens a small panel and shows its result on the canvas live, as you move its controls; most previews are instant, worked out on the graphics card exactly as Apply will do them. Colour filters work on true-colour pictures too, exactly. On a palette picture, colour adjustments can also Apply to the palette instead of the pixels: instant, lossless, and snapped to the machine. Apply (or Enter) makes it one undo step; Cancel (or Esc) leaves the image as it was. Hold Show original to compare, and the panel shows how many pixels will change. Filters work on the active layer, inside the selection if there is one, and transparent pixels stay transparent.

The menu has five submenus:

• Fitting to the palette: colour and blur filters work in full colour, then fit back to your palette, with dithering (none, ordered, Floyd–Steinberg or Atkinson), Only colours from … to … to keep to a range of the palette, and Mix to blend with the original. Pixel art filters work on the colours directly, so they never invent new ones.

Photo styling

Image > Photo is for photos and paintings, to style them before they become game graphics (before Convert to a palette or a machine export):

• Instant previews on the canvas, at any size, matching what Apply does.
• On palette pictures, all but grain and vignette can Apply to the palette (instant and lossless), as the colour adjustments can.
• As adjustment layers, all but grain and vignette: + Adjustment > Photo, so the look stays editable. A .cube look is kept inside the picture, so it still looks the same if the file moves.
• Recipes: Save as recipe... keeps a filter's settings under a name, and Image > Recipes brings them back, so a chain of them gives a repeatable "photo to game graphics" look. Ctrl+F repeats the last filter straight away; Ctrl+Shift+F opens it with its options.

Artistic styles

Image > Artistic flattens detail but keeps edges sharp, so a picture then reduces to fewer, cleaner colours. Each previews instantly, matching Apply exactly.

Pixel art tools

• Resize: Shrink, keeping edges and outlines (the first choice): shrinks a drawing or photo while keeping its outlines and thin lines unbroken, with Keep dark lines to say how much; or nearest neighbour to any size, or Scale2x, Scale3x and Scale4x, which round off staircase edges without adding colours. It works on true-colour pictures too, and shows the whole result when shrinking. Every layer of every frame is resized, in one undo step.
• Extract outlines to a layer: copies dark lines, edges (for art with no drawn outlines) or a sprite's shape edges to a new "Outlines" layer above, in their own colours or the left colour, optionally taking them off the original. With a preview.
• Punch for few colours: Contrast, Saturation and De-mud (near-greys to clean grey, dull colours clearer), so colours survive being reduced to a few. It also works on the palette and as an adjustment layer.
• Convert to another machine: choose a machine and screen mode, a dither, and, for machines with colour cells, Fix colour clashes. The result appears in its own canvas, rebuilt live as you change the options, and your original isn't touched. Keep keeps the converted image; Discard closes it. It works on true-colour pictures directly, and has the same three Before converting settings, so the converted canvas beside the original shows before and after live: photo to machine in one step.

Animation

Every image can have frames, each with its own timing. The current frame is simply your layers, so every tool works on it as usual.

• The Frames panel (with Layers and Tiles): Previous, Play / Stop and Next, and "Frame n of m". + Copy adds a frame after this one, starting as a copy of it; + Blank adds an empty one; Delete removes it, and the arrows move it earlier or later. The frame strip shows a picture of every frame with its number: click one to go to it, or drag one onto another to move it there.
• Timing: set each frame's time in milliseconds, or give every frame the same with All frames. The panel shows the animation's total length.
• Keys, as in Deluxe Paint: 1 and 2 step back and forward through the frames (wrapping round), and 4 plays and stops.
• Onion skin: neighbouring frames show faintly while you draw, so you can line up the next pose. In the Frames panel, choose 0 to 3 frames before and after, the strength (further frames are fainter, and fainter still over painted pixels), Tint (frames before in red, after in blue, instead of their own colours), and Wrap (for loops: the first frame's "before" is the last frame). It hides during playback.
• Animated brushes, as in Deluxe Paint: Brush > Pick up animated brush, then drag a box. The brush takes that box from every frame, starting with the current one, and each stamp moves it on to its next frame: dotted freehand and single clicks show it plainly, and a shape steps once. Turn on Each click goes to the next frame in the Frames panel and the image moves on a frame after every stroke too, so clicking along a path lays down an animation one frame at a time. X, Y and Z flip and rotate every frame of the brush; any other brush change, or Make the brush still, makes it an ordinary brush again.
• Animated move, Deluxe Paint III's Move: pick up a brush, then Animated move... in the Frames panel carries it across frames from the current one, drawing it into each, travelling, turning and changing size as it goes. Set the number of frames (missing ones are added as copies of the last, so the background carries on), the start (its centre), how far it moves, how far it turns, its size from and to, ease in and ease out (starting from rest, coming to rest, or both), and Reach the end (turn it off for loops, so the last frame doesn't repeat the first's position). The canvas shows an outline of the brush at every step, along its path, before you Apply; it's one undo step, added frames included. Quarter turns are exact and the brush stays crisp, so it suits pixel art.
  • Key frames: turn on Use key frames to set the brush's position, turn and size at chosen frames, with a straight path between them or, with Smooth path, a curve through every key; Add key puts one halfway. Keys show as diamonds in the preview.
  • Fade from / to: the brush dissolves in or out across the move.
• Per-frame palettes (Deluxe Paint V): tick This frame has its own palette in the Frames panel, and that frame has colours of its own, for fades, day to night, or colours that change as it plays. Other frames share the main palette. Playback, thumbnails and animated GIFs (a colour table per frame) all show each frame's own colours.
• Camera move... (Frames panel) makes a new animation of what a camera sees as it pans and zooms over the picture: choose the frame size, the number of frames, a start and end (each a centre and a zoom), easing, and Wrap for endless scrolling backgrounds. The path and both frames show on the picture first.
• Storyboard sheet... (Frames panel) lays every frame out on one new image, to plan, review or print, as Deluxe Paint V's AnimBoard: frames per row, a whole-number scale, a gap, and frame numbers and times beneath each in the pixel font.
• Anim paint along a line or curve, with an animated brush: in the Frames panel, turn on a stamp every N pixels (1 to 512), then draw a line or a curve. A stamp goes down every N pixels along it, evenly spaced even round curves, each the brush's next cel. Turn on each stamp into the next frame as well, and every stamp lands on the next image frame (frames are added as copies of the last if needed), so one stroke walks a character across the screen, Deluxe Paint's classic anim paint. It's one undo step, and afterwards the brush carries on from the cel after the last stamp. (Into frames, the brush is written as it is, so paint modes and symmetry don't apply.)
• Layers and frames: a layer added later is empty in the other frames; duplicating a layer copies it in every frame.
• Undo covers adding, deleting, moving and timing frames. Undoing a stroke takes you back to the frame it was on first.
• Exporting:
  • File > Export animated GIF saves every frame as the canvas shows it, with each frame's timing, looping forever (the transparent colour follows your PNG transparency setting).
  • File > Export frames as sprite sheet saves the frames side by side in one PNG, wrapping onto more rows if it's very wide.
  • File > Export colour cycling as GIF turns a still picture's colour cycling into a looping GIF: one step of the fastest range per frame, for one full turn of the slowest (up to 256 frames). Ranges with very different speeds may not meet exactly at the loop.
  • Next sprites from every frame (8-bit or 4-bit), in the Export window: each frame cut into 16 × 16 sprites, frame after frame.
  • Every other export uses the current frame.

Frames are saved in your .dpx file. Tile maps don't have frames.

Sprites

A sprite is a game object made of cels (rectangles of your image, on any of its animation frames) and animations that play them. Sprites are kept in your .dpx, and every change can be undone.

The Sprites panel

• The sprite list: + adds a sprite; delete, choose and rename them here.
• Origin: the sprite's hot spot, measured from each cel's top-left. A new sprite's first cels set it to their bottom centre (where a character stands); drag the numbers to move it.
• Adding cels:
  • Add from grid cuts the current frame into cels of a size, left to right and top to bottom, optionally skipping empty ones: ideal for a sprite sheet.
  • Add each frame makes one cel per animation frame, from the whole image.
  • Add the selection makes a cel from the selected rectangle, on this frame.
  • Remove cel removes it, and any animation steps that used it.
• The cel strip shows each cel as a thumbnail. Click one to choose it; double-click it to add it to the selected animation.

The Timeline

The Timeline (Window > Sprite timeline; it opens by itself when you make a sprite) is where animations are built and played. A new layout docks it across the bottom of the canvas area.

• The preview plays the selected animation at your game's frame rate (50 or 60 Hz), with the origin as a red cross. It has play / pause, restart, zoom, onion skin (the step before, faint) and a frame count.
• A track for each animation: its name (click to choose it) and how it repeats: Loop, Ping-pong (there and back, without repeating the ends) or Once (holding the last step). Its steps are blocks as wide as they last, each showing its cel, and the play head is a red line.
  • Click a block to choose it (the preview pauses on it), drag a block onto another to move it, and drag a block's right edge to change how long it lasts.
• Buttons: new, delete and rename animations, the frame rate, and add (the chosen cel), duplicate and delete steps.
• The chosen step: its cel, its duration in frames (the tooltip shows milliseconds), and an offset, which draws it shifted (for bobbing or recoil) without new art.

Joined sprites

Most machines' hardware sprites are small (8 × 8 to 16 × 16, or 32 × 32 on some), so a big character is drawn as several of them moving together. In Deluxe Pixel that's a pose: a set of pieces, each a cel (one hardware sprite's worth of pixels) at an offset from the sprite's origin, and optionally mirrored. An animation step shows either a single cel or a pose.

• Splitting (the Sprites panel's Joined sprite section) turns cels into poses for you:

  • choose the piece size (8 × 8, 8 × 16, 16 × 16, 16 × 32, 32 × 32, 64 × 64, or any);
  • Skip empty pieces, and Reuse identical and mirrored: a piece that matches one already made, or its mirror image, uses that cel flipped, saving sprite memory;
  • split the chosen cel, or every cel the animations show; their steps then show the poses.

  It tells you how many poses and hardware sprites it made, the new cels, and how many pieces reuse one; a symmetric 4-frame walk in 8 × 8 pieces needed only 4 new cels for its 16 pieces. A pose always rebuilds its cel exactly, pixel for pixel.

• Poses by hand: make an empty pose, rename or delete it (its steps go back to showing a cel), set each piece's cel, offset and flips, add the chosen cel as a piece, and use it in the chosen step.

• In the Timeline: each step's shows menu chooses a cel or a pose. The preview draws the pieces, outlines them (Pieces), and counts the hardware sprites the step uses and the most on any one line, so you can keep within the machine's limits. Drag a piece in the paused preview to move it in the pose, for every step that shows it; with Drag in this step only, it moves just in this step (a head bobbing on a body), and Clear this step's piece moves puts it back.

Hardware and scene

In the Timeline, under Hardware and scene.

Hardware: choose the machine your sprites are for (it's saved with them), and Deluxe Pixel checks every step of every animation against it: each piece's size, its colours (and, where sprites take a palette, that they all come from one), the sprites on each line, and the total. Each kind of problem is listed once, with where it first happens and how many steps have it; click a problem to go there. Lines over the limit are tinted red in the preview.

Each piece is checked on its own: modes that apply to every sprite at once (the NES's 8 × 16 mode, the SNES's two sizes a screen) are up to you.

Scene: play your sprite over any other open image or tile map (all its visible layers, at their scrolls), with its origin at a point you choose. Only the visible part is drawn, so big maps stay quick, and transparent pixels and empty cells show the backdrop colour, as the hardware does.

Exporting sprites

Export sprites... in the Timeline writes every sprite in the image as game data: its patterns (the pixels), its tables (poses and animations) and its palette. The format starts as your chosen machine, the dialog shows what will be written (or why it can't be) before you export, and the machine's hardware check runs first.

• Patterns are written once each, for every cel a pose or step uses, as the machine wants them: NES, Game Boy and Game Boy Color, Master System, Mega Drive (down each column, as its multi-cell sprites need), SNES, PC Engine, C64 hires and multicolour (24 × 21), Amiga, Spectrum Next 8-bit and 4-bit, or raw bytes. Pixels are colours within the piece's own palette; a cel whose colours span two palettes, or that uses its palette's colour 0 (kept for transparency), is refused with the reason.
• Tables, as 16-bit words (big-endian for the Mega Drive and Amiga, little-endian otherwise): the sprite count; each sprite's origin and its numbers of poses and animations; each pose's pieces (offset from the origin, pattern number, flips and palette); and each animation's loop mode and steps (pose, duration in frames, offset, and any piece moves). A single-cel step becomes a one-piece pose, so every step is a pose.
• The palette in the machine's own colour format (none for the NES and C64, whose colours are fixed: a note says so).
• Files: binary writes three (name_patterns.bin, name_tables.bin, name_palette.bin); C or assembler writes one file with the three labelled, and the layout described in comments.

Packed sprite sheets

Many engines want sprites of different sizes packed tightly onto one image, with a data file saying where each one is. File > Sprite sheets reads and writes them in TexturePacker's formats (JSON hash, JSON array and its .tps projects), Gideros', Aseprite's JSON (with frame times and tags), libGDX's .atlas, Phaser 3's multi-atlas, Unity (TexturePacker's .tpsheet, which its free Unity importer slices into sprites, pivots kept) and Godot 4 (a SpriteFrames .tres for an AnimatedSprite2D, with your animations and frame times).

• Open a sheet with its data: the sheet opens with each region as a sprite in the Sprites panel, its trimming, rotation and pivot kept, so it saves back exactly as it came. Frames named like walk_0001, walk_0002 become one sprite, "walk", with an animation in number order, lined up and timed from the data; Aseprite's tags become animations too. Turned frames show upright in the timeline. A .tps project also opens with File > Open or by dropping it on the window.
• Pack a sheet... from the picture's frames, its shown layers, its sprites, or a whole folder of pictures: trimming of see-through edges, padding, a border, extruded edges (against bleeding), identical sprites stored once, a power-of-two or square sheet, and a largest size. Turn sprites to fit better stores some turned 90° when that packs tighter, and if they don't all fit one sheet, it makes as many sheets as needed ("sheet 1", "sheet 2"...). Pack by outlines (polygons) places each sprite by its outline instead of its rectangle, as TexturePacker's polygon packing does, so slanted and round sprites nest into each other's corners and the sheet is smaller; the outlines are saved in TexturePacker's JSON (formats that can't describe overlapping sprites say so). Palette pictures that share one palette pack as a palette sheet. The result is a new picture with its regions as sprites.
• Save the sheet's data as Gideros, JSON hash, JSON array, Aseprite JSON (frame times, and animations as tags), a libGDX .atlas, a Phaser 3 multi-atlas, Unity .tpsheet or Godot .tres, with the sheet saved beside it as a PNG. Sheets packed together (or opened together) stay a set: saving any of them saves them all, and Open a whole multipack set... opens every sheet of one at once from any of its files. Save > TexturePacker project writes a .tps with the packing settings and sprites, so TexturePacker can carry on with it.
• 9-patch (9-slice) sprites: give a sprite borders in the Sprites panel and its corners stay as drawn while the edges and middle stretch: buttons, panels and speech bubbles at any size, with a preview you can stretch. The borders are saved in TexturePacker's JSON (as Phaser's NineSlice reads them), Aseprite slices, libGDX splits and Unity's sprite borders. Packing a folder reads Android's name.9.png files, borders and all, and Save as Android .9.png... writes one.

Drag and drop

Most things can be dragged where they should go. While dragging, a tooltip says what's moving and what letting go will do; letting go anywhere else cancels, and every drop is one undo step. Everything can still be done with buttons and menus.

• Layers and map layers: drag one onto another to move it to that place.
• Palette colours: drag a colour onto another to move it there (the colours between close up), or hold Ctrl when dropping to swap the two. The picture looks the same: its pixels are renumbered.
• The mixer: drop a palette colour on the mix for a dab of it; drag the picked colour (Alt+click the mix) onto a palette colour to make it that colour.
• Objects: drag the Add icons (text, rectangle, ellipse, line) onto the canvas to place a new object there; drag an object in the list to change the drawing order, or onto another object layer to move it there, still editable.
• Tiles: drag a tile from the Tiles panel onto the map to place it. Drag a tile onto another in the Tiles panel to move it there (Shift: swap them): every open map using that tile set is renumbered to match, so they look exactly the same.
• Selections between pictures: drag selected pixels onto another picture's canvas, side by side, to copy them there as a new layer.
• Files from Explorer, several at once: a palette file (.pal, .gpl, .hex, .act) anywhere loads its colours; a picture dropped on a canvas becomes a new layer where it was dropped; a picture on the Palette panel gives its colours; anywhere else, or a .dpx, opens as its own image.

The copper: per-line changes

Window > Copper changes things from a screen line down, as the Amiga's copper and raster interrupts on the C64, ST, Spectrum Next and others did. Changes show live on the canvas, with a mark at the canvas's left edge on each line that has some.

• Colours (palette pictures and tile maps): a colour number given a new colour from a line down, until it changes again: sky gradients, water, colour bars. Gradient ramps a colour down a run of lines, a change every N lines, optionally snapped to the machine's colours.
• Layers (tile maps and pictures): a layer's scroll across or down from a line, and a layer hidden or shown from a line: split screens (a fixed status bar over a scrolling level), wavy water, heat haze, road effects, parallax bands. Scroll wave sets a sine wave of scroll across a run of lines.
• Machine limit: the most changes a line your code can make; lines with more are listed.
• Show the copper turns it off without losing the changes.
• In what you make: "PNG with the copper", JPEG, TIFF, printing and Map to picture all show it.
• Exports (registered): a table of every change (line, kind, colour or layer, value), or an Amiga copper list (WAIT and MOVE words, colours only), as binary, C or assembler.
• From scripts and AI: the copper has its own commands (copper.colour, copper.gradient, copper.wave and more), so scripts, macros and AI assistants can build it too.

Printing

File > Print... (Ctrl+P) prints, or saves as a PDF: this picture, every frame, the tiles (numbered), the storyboard sheet, the whole map, the map overview, or the palette (swatches with colour numbers and values). A preview shows each page.

• Paper: A4, A3, A5, Letter, Legal or Tabloid; portrait or landscape; margins.
• Size: fit to the page, or a set size a pixel (0.1 to 10 mm). Pixels always land on whole printer dots, so they stay crisp and square, with the pixel shape kept.
• Big pictures are split across pages that overlap, each captioned ("part 3 of 6: row 2, column 1"), with assembly marks to line them up.
• Show: labels, a header (name, date, page numbers), a pixel grid and the tile grid.
• Print... uses the Windows print dialog (any printer, or Microsoft Print to PDF); Save as PDF... writes the pages at 300 dpi.

3D models to sprites

File > 3D model to sprites... turns a simple 3D model into pixel-art sprite frames, the way many classic games pre-rendered theirs. Opening a model with File > Open, or dropping it on the window, goes straight there.

• Reads STL, OBJ (with its MTL colours and textures), glTF 2.0 (with its textures) and MagicaVoxel .vox (.gltf and .glb), and writes STL and OBJ. From Blender, use its glTF 2.0 export (File > Export), which keeps the colours.
• The model: "Z is up" (for STL), and each colour can be changed (a textured colour is tinted).
• Textures: models keep their own textures, drawn pixel-crisp, lit and dithered into the palette. Or paint one in Deluxe Pixel: + texture by a colour puts the picture in front (or its selection) on that part of the model, or an image file. A texture painted in a palette picture keeps its colour numbers, so changing or cycling the palette recolours the model. Models with no texture coordinates (STL, say) get the texture from each side, the right way up.
• The sprite: its size; 1 view, or 4, 8 or 16 directions from a starting angle; looking down (0 to 90°); zoom; perspective or straight on. Every frame uses the same fit, so they line up.
• Light: direction and height, ambient light, ordered dithering between shades, and an outline (none, the darkest colour, or the left colour).
• Palette: the active picture's, or one made for the model (a see-through colour, black, then each colour from shadow to light).
• Animation: glTF and GLB files' animations play, both moving parts and skinned characters (Blender armatures, Mixamo). Choose Still or an animation, how many frames for each direction, and Loops (so a looping animation doesn't repeat its first moment at the end). The preview shows a row for each direction, and the whole animation keeps one scale and place, so frames line up as the model moves.
• Each part on its own layer (optional): glTF's mesh parts and OBJ's objects and groups are each drawn to a layer named after it, ready to adjust separately.
• Make the frames: a new image, a frame for each direction (and each moment of the animation, with its timing), ready to animate or export as sprites.
• Put on a live 3D layer: puts the model itself into the picture in front, on a layer of its own, where it stays 3D and can be turned, lit and animated from the Layers panel (see Object layers).
• Voxels as layers: File > Voxels opens a MagicaVoxel .vox as a picture with a layer for each slice (bottom layer lowest, up to 32), saves a picture's shown layers as a .vox (keeping the colour numbers), or shows the layers straight away as a 3D model, ready to turn, light, make frames from or put on a live 3D layer. So you can build a voxel model by painting its slices.
• By command: everything here is also a command (model.open, model.view, model.light, model.pose and the rest), so scripts, macros and AI assistants can do it too. They can also pose a part (raise an arm, turn a head, scale it), which goes along with any animation, and stamp the model into a picture: rendered in that picture's colours onto a new layer, a 3D object placed in a scene as one undo step. See the scripting reference.

Commands, macros and scripts

Almost everything Deluxe Pixel does is also a command: a name like layer.add or draw.rect, with settings. The menus, keys and panels use the same commands, so a command does exactly what the menu does, and every change it makes is an ordinary undo step.

The command palette

Edit > Command palette (Ctrl+Shift+P) finds any command as you type. Choose one with the arrow keys to see its help, fill in its settings, and press Run (or Enter). If it can't run now (no picture open, a locked layer, a tile map), it says why. The palette also shows the exact line a macro or script would use for it: click to copy it.

There are commands for drawing (pixels, lines, rectangles, ellipses and fills, with lines and outlines any thickness from 1 to 64 pixels, in a round or square pen), the palette and colours (including which colour is see-through), tools and brushes, files (new, open, save, export in any format), undo, selections, layers, frames, every filter and colour adjustment (filter.apply), tile maps (setting tiles and cell attributes), 3D models (from opening one to posing it, making frames, and turning and animating a live 3D layer), voxels, 3D cubes and packed sprite sheets and running scripts, plus questions that change nothing, such as info.picture and info.layers.

Macros

Edit > Record a macro writes down what you do: commands, menu actions and painting strokes (freehand, lines, rectangles, circles, fills, airbrush, selecting, picking up a brush, and the tile tools on maps). Stop recording saves it as a .dpmacro, or as a .luau script to edit into loops. Edit > Play a macro runs it again, stopping at the first line that can't run and saying which. Polygons, curves and text aren't recorded yet.

Luau scripts

Scripts are written in Luau (the fast, safe Lua that Roblox uses). Every command is dp.<group>.<name>{ settings }:

for y = 0, dp.height() - 1, 8 do
  for x = 0, dp.width() - 1, 8 do
    if (x + y) % 16 == 0 then
      dp.draw.rect{ x = x, y = y, w = 8, h = 8, colour = 1, filled = true }
    end
  end
end

• Helpers: dp.width(), dp.height(), dp.colours(), dp.layers(), dp.pixel(x, y), dp.colour(i) and print. For speed, dp.pixels() gives the whole active layer as a buffer to work on, and dp.set_pixels(buf) writes it back as one undo step: far faster than a command a pixel. A command that can't run stops the script with its reason and line; dp.try(...) gives you the result instead.
• One undo step: everything a script does to the picture is undone with a single Undo.
• Safe: scripts can't open files or use the network, and are stopped after 30 seconds, or when you press Escape.
• Scripts that keep running: a script can respond to things as they happen, with dp.on("key", ...), "mouse", "frame" (every frame, for animation and little games), or a change to the picture, layer, colours or selection, and run tasks alongside with dp.spawn and dp.wait. dp.key(name) says whether a key is held, for smooth movement, and game controllers work too: dp.pad() reads an Xbox-style or other USB pad's sticks, triggers, buttons and d-pad, and the pad event says when a button is pressed or a pad is plugged in. Window > Game controllers shows each pad live, with its buttons named as scripts use them. While one runs, the menu bar says Running: and its name; Escape, Edit > Stop running scripts or running it again stops it. Everything it changes is one undo step, and plugins can use events too.
• Your level in 3D: while a script plays, it can show the map in first person, as Wolfenstein 3D did (cells with a tile, or a chosen attribute bit, are walls, each drawn with its own tile; the floor and ceiling from the open cells' tiles; fog by distance), with sprites standing in it, doors that slide open and push walls that move when pushed; raised in 3D, each cell a stack of cubes as high as its height (from attribute bits, a height per tile or per cell), seen isometrically or from above at an angle, with sprites standing on top; or flat, seen from above at an angle as Mode 7 did. With a graphics card, the first-person view is drawn on it, so it can fill the window (up to 3840 × 2160) and stay smooth. Scripts can also turn 3D models into live sprites, facing the way they move and animated. Examples: Walk round the map in 3D, Doors and push walls in 3D, The map raised in 3D, Fly over the map and A 3D character on the map.
• Playing a level: a script can show things over the canvas without drawing into the picture: sprites cut from any open picture or tile set (dp.image, dp.tile_image, shown with dp.show), boxes and text. It can move the view with dp.camera and read the map's cells and attributes (dp.cell, dp.cell_at) to find what's solid. Scripts can also use your own animated sprites from the Sprites panel (dp.sprite, dp.show_anim) and turn on the level's colour cycling. So you can try your level as it's being made: on a map, Tiles > Play this level runs the Platform game example (or any of your own scripts), which runs and jumps a hero over your map with the view following, using the keys or a pad. If you've made a sprite called "Hero", it uses that, walking as it moves and facing the way it goes. F9 plays again, and Escape stops. When it stops, everything it showed goes, the view is put back, and the picture or map is exactly as it was.
• Running them: Edit > Script console to write and run one, Edit > Run a script, or Edit > Scripts for the ones in your settings folder's scripts folder, one click each.
• Examples: the console's File > Examples has 65 ready to run, from shapes and patterns to palettes, a Mandelbrot, a maze, the Game of Life, animation, filters, tile maps and little games, plus a set for learning Luau itself.
• The full reference: every command with every setting, the dp helpers, exactly what this build of Luau includes, and all the examples: see the scripting reference.

The script editor and debugger

The script console is a full code editor: Luau colouring, line numbers, bracket matching, find and replace (Ctrl+F), several cursors (Ctrl+D), commenting lines (Ctrl+/), and Ctrl+S / Ctrl+O to save and open. Its toolbar's icons (new, open, save, run, debug, step, stop, breakpoint) show their keys when you hover over them.

• Checks as you type: mistakes are underlined before you run anything, with suggestions: dp.draw.rec (did you mean dp.draw.rect?), a setting the command doesn't have, a value out of range, a misspelled global. They're also listed under Problems: click one to go there.
• Autocomplete offers the groups after dp., the commands after dp.draw., a command's settings inside its { }, and the libraries' functions (Ctrl+Space asks). Hover over a command or setting for its help.
• Debugging: click left of a line number (or press F9) for a breakpoint. Debug (F5) runs, stopping at breakpoints; F6 pauses a running script, even an endless loop. While paused: F5 continue, F10 step over, F11 step into, Shift+F11 step out, Shift+F5 stop. The Variables and Call stack panels show where you are, and hovering over a name shows its value.
• Errors highlight their line in red, with the call stack in the Output (click a line to go there).
• Layout: the editor and the Output, Problems, Variables and Call stack panels are docked windows inside the console: drag the splits, reorder the tabs, or drag a panel out (Options > Reset the console's layout puts them back).
• Speed: Run compiles scripts to native code, several times faster for heavy loops (Options > Native code turns it off); debugging uses the interpreter.

Plugins

A plugin is Luau that adds to Deluxe Pixel itself. Each is a folder in the plugins folder (in your settings folder) with a plugin.json (its name, version, author and description) and a main.luau. A plugin can add:

• Menu items in the Plugins menu. Each is also a command, so the command palette, macros, scripts and AI assistants can use it, and each run is one undo step.
• Panels: dockable windows with text, buttons, check boxes, sliders, a palette colour picker, lists and text boxes. Plugins > Panels shows and hides them.
• Filters, under Image > Plugin filters and Plugins > Filters: a dialog with the filter's settings and a live preview on the canvas, applied as one undo step.

Plugins > Manage plugins turns each one on or off, reloads it, or opens it in the script console to edit (saving reloads it). Add the example plugins installs three to learn from: Star tools (a panel and a menu item), Retro filters (scanlines and a colour shift) and Layer tools (mirror the left half, colour usage). New plugin starts one from a template. Plugins run in the same sandbox as scripts: no files, no network. The scripting reference explains how to write one, with the example plugins in full.

AI access

Edit > AI access lets an AI assistant use Deluxe Pixel: Claude Code, Claude Desktop, or any assistant that supports MCP (the Model Context Protocol). The assistant uses the same commands as scripts and the command palette, and can look at the picture as it works, so you can ask it to draw, rearrange layers, set up a palette, run filters or fill in a map, and watch it happen on screen.

• Off until you turn it on, and only in a registered copy.
• What it may do is your choice: look only (it can ask about the picture and see it, but change nothing), edit pictures (the default: no files), or also files (open, save and export, macros and scripts). Anything it isn't allowed to do is refused, with where to change it.
• Undo takes back what it did: a run of changes made in quick succession (each within 2 seconds of the last, with nothing of yours in between) is one undo step, such as "Undo AI: 45 changes". A single change keeps its own name ("Undo AI: Draw an ellipse"). The status bar shows each call as it happens, and the AI access window lists them all, failures in red.
• Connecting: the AI access window gives the line to paste for Claude Code, and the address and key for any other assistant. For Claude Desktop, quit Claude, then press Add Deluxe Pixel to Claude Desktop in the AI access window: it adds Deluxe Pixel to Claude's settings for you, keeping everything else there and saving a backup first, and Claude then starts Deluxe Pixel by itself whenever it needs it. (If you'd rather do it by hand, the window shows exactly what to add. Claude's settings file must stay one { ... } block, so don't paste a second one at the end. If that has already happened, the button joins them back into one.)
• Private to your computer: it only answers on this computer, and only to an assistant with its key (New token makes another). Nothing goes to kage.games. What the assistant sees of your picture goes to the AI service you use, under its own terms.

The commands an assistant can use are listed, with every setting, in the scripting reference (where they're written group_name, such as draw_rect).

AI assistants inside Deluxe Pixel

You can also ask an assistant from inside Deluxe Pixel, with your own account: Anthropic (Claude), OpenAI, Google (Gemini), or a local model on your own computer (Ollama, LM Studio, llama.cpp).

• Setting up: Edit > AI assistants adds accounts, chooses the default and the model, and Tests it. Refresh models fetches the provider's own list of models, so you can pick one from a list (or still type one in). Your key is kept in Windows' Credential Manager, never in Deluxe Pixel's settings or files, and only ever sent to that provider over a secure connection. You choose what it may do, as for AI access: questions only, change pictures, or files too.
• Asking: Window > AI assistant is a conversation: type what you want ("make colour 1 red and colour 2 orange", "name these layers"), and it uses Deluxe Pixel's commands to do it, showing each one and how it went. Ready-made requests suit what's in front. Answers appear as they're written. Show it the picture (off unless you tick it) lets it see the picture as well, and see it again after its commands have changed it, so it can check its own work. The window shows the tokens used this session; give an account the provider's prices and it shows what each request and the session cost, and roughly what the message you're about to send will add.
• AI buttons in the Palette, Layers and Map layers panels, Frames (in-between frames, a smooth loop), the Copper (a sky gradient, wavy water) and the Export window (why a picture won't export, and which format suits) offer ready-made requests limited to what's there, once an assistant is set up.
• Undo: everything one request changes is one undo step, "AI: your request".
• Privacy: your requests, a short description of what's in front, and the picture if you choose, go straight from your computer to the provider you chose, under its terms. Nothing goes through kage.games. It's part of the full version, as AI access is.

Reference images

The References panel (with Layers) holds pictures to look at while you draw: a photo, concept art, a sprite sheet to copy from. They're never part of your picture: not a layer, not exported, not merged.

• Adding one: the panel's Add a picture... button opens any picture Windows can read (PNG, JPEG, GIF, TIFF, BMP, WebP...) up to 8,192 pixels a side; Paste (or Edit > Paste as reference image) takes one from the clipboard. Window > Reference images brings the panel forward.
• Where it goes: beside your picture (to its right, as tall as it) or fitted over it to trace, at any size (100% for a sprite sheet, pixel for pixel) and opacity. Tick Move on the canvas to drag them about instead of painting. Several can show at once, in an order you choose, each shown or hidden.
• Picking colours: Pick colour takes the colour from a reference image where one shows; on palette pictures, the nearest palette colour.
• Kept with the picture: they're saved inside the .dpx, so they come back when you open it.

The undo history

The History panel (with Layers; Window > History brings it forward) lists every undo step of the current picture or map, oldest first: its number, what it was and the layer it touched ("3 Fill (Background)"), and how long ago. Hover over a step for the clock time and the memory it holds. The current step is marked, steps you can redo are greyed after it, and Start of the history comes before them all.

• Going back or forward: click a step to go to just after it. It's ordinary undo and redo, so you can undo the jump too.
• The timeline: every step is a mark along the time it was made, with the playhead after the current one. Click or drag along it and the picture follows. Pauses over 30 seconds shrink to a dashed break, the zoom spreads the steps out, and the clock times show at the ends.
• Changing the history itself: these can't be undone, so each asks first. Forget older... drops the steps before the current one and frees their memory (the picture stays as it is); Clear redo... drops the steps Redo would bring back; Branch opens the picture as it is at the current step as a new picture, leaving the original and its history alone. Right-click a step to do the same from that step.
• Memory: the panel shows how many steps there are and how much memory they hold.
• While the picture is open: the history isn't saved in the .dpx, so it starts afresh when you open the picture again.
• Scripts: history.list, history.goto, history.forget and history.clearredo (see the scripting reference).

Several images and views

• Each open image is a tab, and the Window menu lists them all.
• Ctrl+T opens a new view of the same image beside the current one. Each view has its own zoom, its own palette set, its own colour cycling, and can show its own choice of layers. Paint in one and watch the result in another palette.
• J jumps to the previous canvas. With only one open, it makes a spare page with the same machine and palettes, just like Deluxe Paint's.
• Ctrl+W closes a canvas. Closing the last view of a changed image asks whether to save.
• File > Remember canvases in projects (off by default): saving a .dpx keeps every canvas open on it (zoom, position, palette set and layers shown), and opening it puts them back, as tabs.

Files

• .dpx is Deluxe Pixel's own format: layers, palette sets, cycle ranges, the stencil, the selection and the full machine settings.
• Exporting (Ctrl+E): every format, PNG included, through the Export window: see Exporting, above. A PNG is exactly as the canvas shows it, with its palette set and layers, optionally with the transparent colour see-through.
• Drag and drop any picture or retro file below onto the window, or onto DPixel.exe itself.
• File > Open recent lists your last ten files.
• Saving is safe: a failed save never destroys the old file.
• Autosave: changed images are saved every minute. If Deluxe Pixel didn't close properly, it offers to recover them the next time it starts.

Picture formats

Pictures with up to 256 colours open with exactly those colours, palette pictures keeping their palette in order. Fitted to a palette, pictures with more colours (photos, JPEGs, most TIFFs) have their colours snapped to the machine's colour depth first; if they then fit, they're kept exactly. If not, the most alike colours are merged (twins you can't tell apart first, then whatever changes the picture least) until they fit, and a notice says how much changed. File > Settings > Opening pictures chooses how pictures open: As the file is (the default: 24-bit files such as JPEGs, most PNGs, TIFFs and HAM files open as true-colour pictures, and palette files such as GIFs, IFFs and the machine formats as palette pictures), Always a palette, or Always true colour. When a picture is fitted to a palette, File > Opening true-colour pictures sets how many colours to fit (256 down to 16) and the dithering (none, ordered, Floyd–Steinberg or Atkinson), which smooths gradients that would otherwise show bands. An alpha channel becomes the transparent colour.

Opening retro files

Everything Deluxe Pixel exports can be opened again and edited: File > Open, drag and drop, or the command line. Each opens as a new, untitled image in the right machine and screen mode, and Save keeps it as a .dpx project.

Next palette files (.pal) can be loaded like any palette file. 24-bit IFF pictures (and HAM files with an unusual number of bitplanes) aren't supported, and files of the wrong size, or damaged ones, are refused, with the reason. Pictures bigger than 4,096 × 4,096 shrink to fit as they open.

Settings and portable use

• Theme: light, dark, or follow Windows, using your accent colour. View > Show splash screen at startup turns the splash off.
• Panels dock wherever you like and are remembered. View > Reset panel layout starts afresh: every panel goes back to where it was the first time you ran Deluxe Pixel, and any window that floats (the copper, the AI assistant, the script console...) comes back to the middle of the screen, so none is left off it.
• View > Appearance > Panel tabs on several rows: where panels are docked together, their tabs wrap onto more rows when they don't all fit, so every tab shows its whole name instead of being squeezed and scrolled. It's off until you turn it on, and remembered.
• The title bar: Deluxe Pixel draws its own by default, with the menus in it and the title centred, and it still behaves like any Windows title bar (drag, double-click to maximise, snap layouts on Windows 11). View > Deluxe Pixel title bar switches back to the standard Windows one, straight away.
• Text: View > Sharper text (FreeType) draws the menus and panels with FreeType, crisper at small sizes (on by default); turn it off for Dear ImGui's own text.
• Help > Deluxe Pixel guide (or F1) opens this guide.
• Help > About lists the components Deluxe Pixel is built with, and their licences.
• If Deluxe Pixel ever crashes, it writes crash.txt in your settings folder (or UserData in portable mode) first. Please send it to us with what you were doing: it tells us exactly where the problem was.
• Your settings are kept in %APPDATA%\DeluxePixel.
• Portable mode: put an empty file called DeluxePixel.portable next to DPixel.exe, and everything is kept in a UserData folder beside it instead. Ideal on a USB stick.

Keeping up to date

Deluxe Pixel can update itself. Help > Check for updates checks now, and it also checks once a week when it starts (File > Settings > Check for updates once a week, on unless you turn it off). The check sends nothing about you or your licence.

When there's a new version, Update to 1.38 available (say) appears on the right of the menu bar. Click it to see what's new, then choose Download and restart, Later or Skip this version. The download is checked against a signature only we can make before anything is replaced, so a tampered file is refused. Deluxe Pixel then closes (asking to save any changes) and starts the new version, which tells you what's new.

If DPixel.exe is in a folder Windows protects (such as Program Files), the update window says beforehand that Windows will ask your permission to replace it. If it still can't, it explains how to swap the files by hand. Earlier versions are on the past versions page.

Keys

All of these, and the mouse shortcuts from the rest of this guide, are on one printable page: the Deluxe Pixel keys cheat sheet.

Tools

Brush

Colours

Selection and clipboard

View and canvases

Files and editing

Single-key shortcuts are ignored while you're typing in a text box, or while a menu or dialog is open.

Coming next

Deluxe Pixel keeps growing. Planned next:

• More for plugins: painting tools of their own, importers and exporters, scripts that respond to events, and folders a plugin may use once you've approved them.
• More for scripts and AI: more commands (sprites, tile sets, export settings), polygons and curves in macros, an AI reading the pixels and maps as data, and type definitions for outside code editors.
• More AI assist: AI buttons for sprites and sprite sheets, cheaper long conversations where providers offer caching, and attaching another picture to a request as a reference.
• Tutorials and demos: guided tutorials (a tour of the window, a picture from a blank page, palettes, animation, a tile set and a map from scratch, terrains, sprites, exporting for a machine) run by your AI assistant through the program's own commands. Watch it work, with a pointer that moves to each control and clicks it as a person would, captions saying what it did and why, and the view following the action; or follow along while it checks each step and helps if you get stuck. Pause, undo or take over at any time. Each tutorial also comes as a recorded run that works offline with no account, can be saved as a video (MP4 or WebM, with captions or a subtitle file), and can be spoken: Windows' own voices, a free offline voice, or your own subscription to a cloud voice service.
• 3D models to sprites, next: shape keys, and rendering a model's parts as joined sprites.
• More 3D while playing: a map remembering its 3D settings, and the raised and Mode 7 views on the graphics card too.
• 3ds Max files: reading .max scenes' meshes, texture coordinates and common materials (collapse them to editable meshes first).
• Speed: quicker smooth edges on palette pictures; big jobs using your processor's fast vector instructions, still working on older PCs; the heaviest filters (blur, sharpen and colour adjustments on big pictures, and their live previews) on the graphics card; and big brushes, strokes and fills drawn on the graphics card where it pays.
• More from the Amiga map editors: Tame's masking (stamping a see-through tile over the map makes the merged tiles, reusing any that already exist) and its tile reduction (no repeats, remove unused, shuffle) as one Tiles command.
• More map shapes: column scroll on every shape.
• More for map pictures: the extras (objects, the grid, tile numbers, collision shapes, the copper's colours, and which frame of animated tiles), saving just the part showing in the view, and BMP and IFF as well as PNG.
• More from Godot: tiles' custom data as properties, terrain sets, animated tiles (both ways: for now they're left out when saving a scene), tiles spanning several atlas cells, reading tiles' physics shapes back, and Godot 3 scenes.
• More for tile maps: auto-tiling beyond terrains (override sets, and terrains on staggered and hex maps), animated tiles for machine exports (frame lists or tile swaps), line brushes, a tint and named values per cell, collision shapes shown over isometric, staggered and hex maps, polygon points moved with the mouse, scripts asking whether a point is solid, isometric cubes with height, and getting maps into Unity.
• A font editor: bitmap fonts drawn on a grid, with kerning, in and out as machine character sets, Amiga and GEM fonts, BDF, PSF, Windows fonts and BMFont; TrueType / OpenType and colour fonts, and converting between bitmap and outline.
• Icons: an icon set holding one design at every size, with the small sizes redrawn by hand, saved as Windows .ico and cursors, macOS .icns, web, Android and iOS icons, and Amiga .info and Atari ST GEM icons.
• Vector (SVG) editing: paths with editable points, combining shapes, and SVG in and out, with pixel-art extras: colours from the palette, pixel-exact drawing, gradients as dithering, and animation. The files stay plain SVG that opens anywhere, and the extras will be fully documented here.
• TV and monitor display: first a quick View > Scanlines, then see the picture as a PAL or NTSC TV or monitor would show it (artifact colours, colour bleed, scanlines), paint in artifact colours where a machine relies on them, and an easy raster bars tool on top of the copper, checked against each machine's limits.
• More block maps: NES palettes for the NES formats.
• More from Tiled and tIDE: group layers of our own, layer tints and blend modes; objects shown in the overview and map pictures; more automapping (opening Tiled's own rules maps and rules.txt, outputs to object layers, NoOverlappingOutput, and ignoring flips per layer); properties on objects and on single cells; worlds of maps side by side; tile sets that reload when their picture changes; opening and saving tIDE's .tide / .tbin (for Stardew Valley mods) and Mappy's .FMP; exports for GameMaker, Defold, CSV, JSON and Lua; and a small runtime library for games to read and draw our maps.
• The rest of Tiled's maps: what a .tmx or .tmj brings that's still left out, opened and saved back: Tiled's oblique maps.
• More from Krita: pen pressure and tilt, stroke smoothing, brush presets; groups, alpha lock and clipping on picture layers; more selection shapes; drawing assistants (perspective, isometric grids, rulers); snapshots and a time-lapse recorder; normal maps from height maps; and PSD, OpenRaster and Krita files with their layers.
• More undo history: the history kept with the picture in the .dpx if you like, and a step-by-step replay of a picture being drawn, to export as an animation.
• More kinds of object: layer effects and placed pictures, kept editable like text and shapes.
• Accessibility: screen reader support, and full keyboard use of the panels and dialogs.
• On Steam: Deluxe Pixel on Steam as well as here, licensed by owning it on Steam (no code to enter) and kept up to date by Steam, with a free demo there too; later, the Steam Workshop for sharing palettes, stamps, machine settings, scripts and block formats. Organisation and education licences stay here at kage.games.
• Mac and Linux versions: Deluxe Pixel on the Mac (Apple Silicon and Intel) and on Linux (and so the Steam Deck), from the same program, with Windows still first.
• Translations into other languages, once everything else is settled.