Everything ALBERT can do and the keys and gestures that do it. This is the manual shown in the application under Help → User Manual, so it stays free of anything that only makes sense with the source code at hand.

Modifier keys are written for Windows and Linux; on macOS, Cmd stands in for Ctrl throughout.

Colors

ALBERT’s everyday controls live on rounded dashboards floating over the drawing area: the tools along the top, and two bars at the bottom – the brush and texture strip, and below it the palette bar with the color slots. The dashboards follow the window as it resizes. Press Tab (or View → Show Dashboards) to hide them for an unobstructed look at the artwork, and again to bring them back.

• Left mouse draws with the primary color, right mouse with the secondary; select them in the palette bar with a left/right click respectively. Options → Pen Width… sets the stroke width (1–32 pixels)
• The number keys pick the primary color without going to the bar: 1 to 8 select the first eight palette colors, Shift+1 to Shift+8 the other eight, in the order the bar shows them. The bar’s selection follows, so it still pictures what the pen paints
• The color slots (right of the palette bar) hold the colors the C64 shares across the whole image rather than per char cell; left-click a slot to assign the primary color, right-click for the secondary. Each slot is drawn as a miniature screen filled with the color it currently assigns, with a light marker showing exactly what it recolors: the bitmap rectangle for the background, the frame or the side bars for the border, a strip along the top or bottom for a border background, and a small sprite for a sprite color (with its companion sprite marked faintly beside it, so the pair reads together). Hovering a slot names it. Background recolors the canvas; the two sprite multicolors recolor both side-border sprite strips. Only the slots the canvas actually has appear: hires has no global background, so it shows the border alone; multicolor adds the background; and a multicolor canvas with side borders shows the background plus the two sprite multicolors; there the frame around the canvas takes the global background color rather than a border color of its own, so the background slot sets it and no border slot is needed. Canvases that are not exactly one screen have no border frame at all (see Files), so the border slot disappears there too; a dual-screen hires canvas shows no slots. A top/bottom-borders canvas adds per-border slots instead: background and two sprite multicolors for the top border, the same for the bottom (hires keeps just the two backgrounds); each recoloring only its own border strip, so the two borders can use fully independent color sets; the global background then covers the bitmap area alone, and the border slot shows the side borders (see below). However many slots a canvas has, they all sit on one row
• The side borders slot (top/bottom-borders canvases, both hires and multicolor) is the color of the plain border left and right of the drawable area, which the sprite strips do not reach; its miniature screen highlights the two side bars. It is the same border color other canvases’ border slot sets, shown for what it colors here; like the border it only sets a color, since the border holds no pixels you can draw on
• Palette → Pixcen/Pepto/Colodore/CCS64/PC64/VICE/Jampal/DeeKay/NTSC/High Contrast picks which RGB values the 16 C64 colors render as; the emulators and tools disagree, so match whichever you compare your work against. It’s a display choice only: the artwork is indexed, nothing in the image changes, and the variant isn’t stored in the project file

Brushes and textures

• Options → Round/Square Brush picks the nib shape; the two buttons at the left of the texture dashboard do the same. On a rotated view the nib stays upright on the screen by default; hold Ctrl (Cmd on macOS) to align it to the canvas axes instead; only observable with the square nib, and previewed live under the cursor. The – and + buttons beside them step the pen width (hold to repeat), the same width Options → Pen Width… sets; from the keyboard , or [ steps it down and . or ] up, a held key repeating just as a held button does
• The texture bar (the strip sitting on top of the palette bar) selects a paint pattern; 16×16, anchored to the canvas so strokes tile seamlessly; the strip’s first tile is the solid pen. The swatches show what each pattern produces and never change: hires and multicolor documents each carry their own drawing of every pattern, made for that mode’s pixel shape, and the bar hands you the right one for the document at hand. The selection returns to the solid pen whenever you start or open a document. White cells paint the stroke’s color; black cells paint the other color (Options → Two-Color Texture, clash-friendly in hires) or stay untouched (Options → Texture Stencil, the default: a pattern then layers over what is already there and touches nothing else)
• Right-click a pattern to select its negative instead: white and black cells swap, so in Texture Stencil the pattern touches exactly the pixels it left alone before, and in Two-Color Texture the two colors trade places. The slot shows the negative while it is selected, so the bar always pictures what the pen paints; left-click the slot again for the pattern as drawn. The first tile is the exception: it is the solid pen, its negative would paint nothing, so a right-click there selects the solid pen like a left-click
• Tablet/stylus pressure widens the stroke live: full pressure adds 16 to the selected pen width, on a quadratic response curve for finer control at light touch; mouse strokes always use the selected width. Options → Pressure- Widened Strokes (on by default) turns this off: unchecked, tablet strokes paint at the selected width too
• Why the toggle: a line whose weight follows the hand is what you want when you are drawing, painting or sketching, and it is quicker than reaching for the width control between strokes. Pixel-level work wants the opposite. There every pixel is placed on purpose, and a width that drifts with how hard you happen to be pressing lays down pixels you did not ask for and have to clean up; a pressure-widened stroke also gives up strict single-pixel rendering, since its width changes as the stroke goes. Leave the option on while you block a picture in, and turn it off for the pass where you are placing individual pixels: the stylus then paints at exactly the selected width, the way the mouse does, and you keep it for pointing accuracy alone

Strokes

• Options → Pixel-Perfect Strokes renders single-pixel lines strictly: exactly one pixel per step, never doubled at row/column crossings (lenient rendering, the default, is faithful to a round 1px nib but can leave chunky spots on shallow or steep lines). Freehand strokes also thin their corners, as pixel-perfect modes in mainstream pixel art editors do: where the stroke turns a right angle, the corner pixel is dropped, so slowly drawn diagonals come out as clean one-pixel staircases. The pixel under the cursor stays provisional until the stroke moves on or ends, so you can watch a corner vanish as you turn; tablet strokes widened by pressure keep the plain strict rendering
• Options → Anti-Aliased Strokes blends the edges of wide pen strokes into the picture on multicolor canvases: each edge pixel takes the palette color nearest to the mix of the stroke color and what was underneath, so the C64 palette itself supplies the in-between shades, just as pixel artists anti-alias by hand (where the palette has no shade between two colors, the edge stays hard). The eraser blends the same way, softening toward the color it erases to. Multicolor only: hires char cells hold just two colors, which leaves no room for blended shades, so the option is unavailable on hires canvases and hires strokes always paint hard-edged. Shape outlines anti-alias too: the choice latches when the shape is created, like its other paint properties, and a filled shape keeps a solid interior with a blended rim. Single-pixel strokes are never anti-aliased either (at width 1 a pixel is either painted or not), so the option is unavailable at pen width 1 too, unless Pressure-Widened Strokes is switched on, which lets a stylus push the stroke past one pixel. Flood fills always paint hard-edged, but a contour from the same tool does blend, being stroked rather than flooded. The color limits still apply: where the blended shades would put too many colors in a char cell or sprite, the extra ones merge into the nearest surviving color. The option is a per-session choice and starts switched off at every launch
• Shift+press rubber-bands a connecting line from the previous stroke’s endpoint: the pending line previews solid while the button is held (adjust the endpoint freely, e.g. to minimize color clashes) and releasing commits exactly the previewed segment. The brush footprint is previewed under the cursor at all times; previews are the exact result a stroke would leave, including any clash recoloring of char cells. Holding Ctrl at the same time suppresses it; Shift+Ctrl is also the Redo chord (Ctrl+Shift+Z), so the connecting-line preview no longer flashes on screen when you press Shift as part of that shortcut

Symmetry draw

• Options → Symmetry mirrors your brush strokes in real time, producing symmetrical designs effortlessly. Every copy paints through the same pipeline as your own stroke; textures, clash rules, and previews included, so the hover preview shows all copies before you click:
  • None (the default) does not mirror your strokes
  • Horizontal mirrors on either side of the horizontal line that splits the canvas into an upper and lower half
  • Vertical mirrors on either side of the vertical line that splits the canvas into a left and right half
  • Quadrant splits the canvas horizontally and vertically, mirroring your strokes to the three other areas
  • Bi-Quadrant further splits each quadrant in two diagonally, with the splitting diagonals serving as additional axes of symmetry; eight mirrored copies in all
  • Kaleidoscope replicates your strokes rotationally instead: eight copies at 45° steps around the axes’ intersection
• Green lines drawn on the canvas serve as a visual guide for indicating the locations of the mirroring; in Kaleidoscope mode the axes of symmetry are drawn in yellow. Angles are true to the emulated display (on double-wide multicolor pixels and under PAL/NTSC emulation a diagonal guide is 45° as you see it) and the square nib rotates and mirrors with each copy, so every copy is an exact counterpart of your stroke
• The axes start at the canvas center, and you can put them wherever your design needs them: Options → Symmetry → Move Axes (press Y) turns drags into axis moves instead of strokes. Grab an axis line, the cursor becomes a splitter over one, and it follows the cursor, landing on pixel boundaries and pixel centers alike; in Quadrant mode grabbing the intersection moves both axes together, and in Bi-Quadrant and Kaleidoscope (whose diagonals hinge on the intersection) dragging anywhere moves it. Clicks never paint while the tool is active. Options → Symmetry → Reset Axes to Center puts the axes back, from any tool
• Options → Symmetry → Apply to Flood Fill extends the mirroring to the fill tool: one click floods every copy’s area; each fill runs on its own from the mirrored click point, so a copy that lands somewhere unfillable simply does nothing while the others proceed, and a single undo removes them all. Off by default: leave it unchecked and fills stay single even while your strokes mirror
• Options → Symmetry → Apply to Shapes does the same for the shape tool: the staged shape keeps its single set of handles, and its mirrored copies appear live in the preview (adjust the shape and watch all of them follow, clash resolution included) then land together at commit as one undoable edit. Also off by default
• Undo treats a symmetric stroke as one edit: a single undo removes all its copies, and the Shift connecting line anchors to your stroke’s endpoint, never to a mirrored copy’s. Symmetry is a drawing aid, not part of the artwork: the mode is not saved with the project, and every session starts with symmetry off

Tools

• The tools are one set of radio buttons: exactly one is active at any time, picking one drops the one before it, and picking the one already active changes nothing (so no shortcut can turn a tool off by accident). The pen is a tool like the others, not a state you fall back into: it is the tool every session and every document starts with, and the one to pick when you are done with another
• The tool dashboard at the top of the drawing area carries a button per tool: pen, eraser, fill, shapes, eyedropper, pan, and selection. Each button mirrors its menu entry below (same toggle, same shortcut). The shapes button wears the active shape as its face, with a small dropdown caret in its corner: clicking it activates the shape tool with the shape shown, and resting the pointer on it opens the list of available shapes, hollow and filled, to pick another. Choosing one makes it the button’s face and activates the tool (the current pick is check-marked; hovering names each shape). The selection button works the same way: it wears the active marquee (rectangle or lasso), a click uses it, and resting the pointer on it opens a list to pick the other. How long the pointer must dwell before either list opens is the Hover delay under Edit → Settings → Tool Pickers (half a second by default; the two pickers share the one value)
• Options → Pen Tool (press B) is freehand drawing: strokes follow the pointer, with the brush shape and width, textures, symmetry, clash rules and previews described above. Everything else in this section is a departure from it, and picking the pen is how you come back
• Options → Fill Tool (press G) switches clicks to flood fill: left fills the connected same-color area with the primary color, right with the secondary; the active texture applies (patterned fills), clash rules judge the fill at its starting pixel, and the hover preview shows the exact post-fill result before you click. That preview covers as much of the canvas as the fill would, so moving the pointer across flat artwork can repaint large areas over and over. Options → Disable Fill Preview turns it off: the fill itself is unchanged, you simply click without seeing the result first. The setting is remembered between sessions, and no other tool’s preview is affected. Contours are the one exception: holding Ctrl brings the preview back even with this switched off, because what the setting silences is a whole area flashing on and off as you sweep, and a contour only ever changes a thin band
• Hold Ctrl (Cmd on macOS) while the fill tool is active and the click draws a contour instead of a fill: the same connected area is found, but only its edge is painted, as a band drawn with the current brush width, nib and texture
• Contours are for multicolor canvases. A hires cell allows two colors and a band is a thin thing crossing a great many cells, so on hires the outline would come back chewed through wherever the art it traces is not already monochrome; multicolor’s four colors per cell leave it room. On a hires canvas the chord simply has no effect (you get the plain fill it modifies) and the placement menu below is greyed out
• Options → Fill Contour Placement decides where the band sits, and Ctrl applies whichever is selected: Center (the default) straddles the edge, Outside sits wholly beyond it, Inside wholly within. Outside is how you wrap a shape in an outline without losing a pixel of it. All three are as thick as the brush is wide, so changing the placement moves the band without changing how heavy it reads. At brush width 1 the band is one whole canvas pixel wide, the smallest mark the pen can make, exactly as a width-1 stroke is
• The placement lasts for the session and is deliberately not remembered between launches: it is the only thing deciding what Ctrl does, and every launch starting at Center means the chord never does something you set days ago and have forgotten. Change it while the pointer is resting on an area and the preview re-draws in the new placement straight away, so you can try all three against your artwork before committing to any of them
• Contours obey everything a fill obeys: the texture patterns them, symmetry mirrors them when Apply to Flood Fill is on, clash rules resolve them as they land, the hover preview shows the result before you click (press or release Ctrl and it re-draws without moving the pointer, and it shows even if Disable Fill Preview is checked), and a single undo removes one. Two details are worth knowing: an area running to the edge of the canvas is not traced along that edge, since the canvas rim is a frame rather than an edge of your shape; and clicking the background around a shape with Outside puts the band inside the shape instead, which is the same trick read the other way round
• Options → Eyedropper Tool (press I) switches clicks to color sampling: left picks up the color under the cursor as the primary pen color, right as the secondary, and dragging keeps sampling as you move. Nothing is painted and nothing lands in the undo history; the palette bar follows the sampled colors. While the plain pen is active you don’t need the menu at all: hold Alt and the pen becomes the eyedropper for as long as the key is down; Alt+click or Alt+right-click samples, release Alt and you’re drawing again. Whenever sampling is armed the cursor becomes a dropper and the brush preview hides. (On Windows, tapping Alt without clicking moves focus to the menu bar, as in any Windows program; press Alt again or click the canvas to continue)
• Options → Eraser Tool (press E) draws exactly like the plain pen – the same freehand strokes, and holding Shift erases a straight connecting line from where your last stroke ended, just as it draws one – but instead of a pen color it clears pixels to the mode’s background: in multicolor that is the bitmap’s background color, and in hires (which has no shared background) it is the secondary color. Both mouse buttons erase to that same color. The hover preview shows the exact result before you press, and everything the pen honors (the brush shape and width, textures, clash rules, and the undo history) applies unchanged
• Options → Pan Tool (press H) turns a plain left drag into panning the view, for moving around a zoomed canvas without holding anything down. It is the same pan the temporary gestures give you (hold Space and drag, or drag with the middle button, under any tool); nothing is painted and the artwork never changes
• Options → Shape Tool (press S) drags out shapes that stay adjustable after you draw them. Nothing touches the canvas until you commit: shapes are staged, and the preview shows the exact result, clash recoloring included, the whole time. Because the stage holds every shape you’ve drawn, you can nudge one shape after drawing another and watch their joint clash resolution update live, which is the reason the tool works this way:
  • Options → Shape → Line/Rectangle/Circle/Star/Path picks what a drag creates, and Filled Shapes whether closed shapes fill (a Line and a Path never fill)
  • Corner-to-corner drag creates a shape; left button for the primary colors, right for the secondary, like a stroke. The box follows the screen axes by default; hold Ctrl (Cmd on macOS) to align it to the canvas axes instead. Shift constrains to uniform aspect on the emulated display (a square, a true circle) and previews the shape’s main diagonal while held, so you can see the constraint is on. A Line drag lays a straight segment from where you press to where you release, and a Path drag captures your freehand line instead; both are movable, rotatable, and scalable afterwards like any other shape (the encompassing box carries the corner handles), but never fill
  • Colors, fill, outline width, nib, anti-aliasing, and texture latch when the shape is created, so later tool changes never restyle what the preview already promised. Instead, changing one of those while shapes are selected re-applies it to the selection; drag a rectangle, click a palette color, as in any vector editor. Shape kind is geometry and never re-targets: a staged circle won’t become a star
  • Click a shape to select and move it; Shift+click adds or removes one from the selection; the key above Tab (the backtick ` on a US keyboard, the section sign on an Apple US/UK keyboard) cycles the selection through the staged shapes; clicking empty canvas deselects and starts a new shape. Delete removes the selected shapes. Arrows nudge by one canvas pixel and Shift+arrows by one char cell, the step that matters when hunting for a clash-free placement against the attribute grid
  • Handles appear when exactly one shape is selected: four corner handles scale it (the opposite corner stays put; Shift keeps the aspect uniform, Alt drags that one corner alone and skews the shape into a trapezoid), the pin above the top edge rotates it (Shift snaps to 22.5° steps), and Rectangle and Star get four diagonal handles for the corner radius and the star’s inner points
  • Ctrl+Z while shapes are staged undoes the last stage step (an add, a delete, a move, a property change) and leaves the document history alone; once the stage is empty it walks real history again. Enter (Edit → Commit Shapes) commits the whole stage as one undoable entry however long you fiddled, and switching tools commits too; Esc (Edit → Discard Shapes) throws the stage away and records nothing, so it asks you to confirm first: the stage is not part of the undo history, and a discarded stage cannot be brought back. Esc part-way through drawing or dragging a shape backs out of that one gesture and asks nothing. Pan, zoom, and rotate stay live while staging: rough a shape in, zoom, nudge a handle, commit
  • A staged shape is not saved in the project file, only committed history is, so commit before saving or quitting. Closing the application with shapes still staged prompts you to save, and answering Save commits them for you
• Options → Rectangle Select Tool (press M) and Lasso Select Tool (press L) mark off an area to work on, outlined with marching ants:
  • The modifier held when the drag starts decides how it composes with what’s already selected, on the Photoshop convention: Shift adds, Alt subtracts, Shift+Alt intersects, unmodified replaces. A plain click deselects, and a right-click deselects anywhere on the canvas
  • The marquee follows the screen axes by default; hold Ctrl (Cmd) for the canvas axes, as everywhere else. It composes live, so the ants always show what you’d get; the lasso previews as a dashed guide and composes on release. A selection is an arbitrary region, not a rectangle, so a screen-aligned marquee on a rotated view lands as exactly the shape you outlined
  • Edit → Select All (Ctrl+A), Deselect (Ctrl+D, or Esc), and Invert Selection (Ctrl+Shift+I). Select All switches to the Rectangle Select tool when neither selection tool is on, so the selection it makes is ready to drag, nudge, or undo right away. While a selection tool is active, Ctrl+Z undoes selection changes before it touches the document history, so undoing past a deselect brings the selection back
  • Edit → Cut/Copy/Paste work on the selected pixels. The clipboard is internal to ALBERT and holds C64 color indices rather than RGB, so a paste re-derives through whatever palette variant you’re on, survives starting a new canvas, and clips to it. Cut vacates the area to the blank color: the background in multicolor, and (since hires has no global background) the secondary pen color there. Cutting clears the pixels but leaves the selection outline in place, so you can paste straight back into the same area, refill it, or move it
  • Copy and Cut also place the selection on your system clipboard as a plain image, so you can paste it straight into other applications. This is a one-way hand-off out of ALBERT: pasting inside ALBERT still uses its own color-index clipboard. In multicolor mode the exported image widens each pixel to match its on-screen proportions, and a lasso selection exports with the area outside its outline left transparent
  • Paste (and Paste with Transparency, Ctrl+Shift+V) drops the clipboard at the position it was copied from and leaves it floating: drag it into place, and the canvas underneath is untouched until you commit. A transparent float’s blank-color pixels let what’s beneath show through. If the copied position is scrolled out of view, the paste appears at the center of the view instead, shifted by whole char cells, so the content keeps the same cell alignment it was copied with
  • Dragging from inside the ants floats the selected pixels the same way. Both drags move, the area you lifted from vacates to the blank color when you drop, and Ctrl+drag additionally makes the float transparent, so its blank-color pixels don’t cover what it lands on. Shift, Alt, and Shift+Alt still compose even when the drag starts inside, so every composition mode stays reachable wherever you press (to copy rather than move, use Copy and Paste)
  • Arrows nudge a float by one canvas pixel, Shift+arrows by one char cell. Enter, Deselect, clicking outside, or switching tools drops it as one undoable edit however long you spent positioning it; Esc or Ctrl+Z discards it and leaves no trace, with the canvas underneath unchanged (this is how you remove a floating selection without altering what is beneath it). Clashes under a float resolve in real time as you drag, so what you see is what the drop commits

The view

• Mouse wheel zooms in integer steps anchored under the cursor; Edit → Settings can invert which way it goes; space-drag or middle-drag pans; the View menu has zoom in/out, 100%, and best-fit
• The arrow keys pan by exactly one char cell a press, so the char grid lands back on itself every time and you can step across the artwork cell by cell. The step follows the canvas, not the screen: on a rotated view Right moves the artwork along the canvas’s own horizontal, which is a diagonal slide on screen, the same direction Right nudges a floating selection or a staged shape. Those nudges come first, so while something is staged the arrows move it and the view holds still
• R+drag rotates the view around the viewport center; hold Shift (at the click or any time mid-drag) to snap to 22.5° steps. Rotation is bounded to ±180° so you never wind up whole turns; View → Reset Rotation (Ctrl+R) restores upright without the canvas jumping, and Reset Rotation & Best Fit (Ctrl+Home) does that and re-fits the canvas in one go
• View → Show Reference Grids (Shift+H) overlays the char-cell and sprite boundaries, the units clash rules apply to, so it’s the grid that tells you where a color limit will bite; Show Pixel Grids (Shift+Z) outlines individual pixels, and only draws from 4× zoom up where it would be legible. Pressing Z switches both grids between their normal grey and a lighter one, for when a line is hard to pick out against the artwork under it
• View → Show Safe Frames overlays two translucent frames on canvases with border sprites: the areas of the canvas that VICE’s C64 emulator displays with the VIC-II borders set to Normal (green, 384×272 square pixels) and to Full (amber, 408×293), that is, where it’s safe to set border pixels and still have them shown under each border setting. Both frames are positioned relative to the bitmap area (the entry is disabled on canvases without border sprites, where no pixels exist outside it)
• View → Show Reference Layer shows or hides the reference image imported with File → Import Reference Image…; see that entry for what the layer is; Reference Layer Opacity… opens a slider for the strength it blends over the artwork with, applying live as you drag (Cancel restores the value the dialog opened with). Both entries wake up once a reference image has been imported
• View → Square/PAL/NTSC Pixels emulates the video standard’s pixel aspect by stretching the view vertically; the brush height compensates so the nib keeps its proportions on the emulated display rather than being stretched with it; a round nib stays round, a square one stays square
• View → Bilinear Filtering softens the magnified artwork: zoomed in, pixels blend into their neighbours instead of showing as hard-edged blocks; a quick way to judge how the image reads as a picture rather than as pixels. One toggle for both the main canvas and the preview window, and display-only: no pixel is changed, and grids and overlays stay crisp on top. The preview’s CRT emulation always draws with this softening as part of its look, so while that filter is on the toggle makes no difference there
• View → Show Preview Window (F8, from either window) opens a second view of the canvas in its own window: no grids, tool previews, or selection outlines; just the artwork and its border frame, updating live as you draw. It zooms and pans independently of the main view with the same gestures and shortcuts (wheel, left- or middle-drag to pan, zoom in/out, 100%, best-fit), so whichever window has the focus is the one the keys drive. It stays upright, Reset Rotation & Best Fit (Ctrl+Home) therefore just best-fits here, and follows the pixel aspect: multicolor’s wide pixels and the Square/PAL/NTSC emulation
• View → Preview Stays on Top keeps the preview window above all other windows, ALBERT’s and other applications’, so it works as a live reference while you draw maximized. It steps aside on its own whenever ALBERT shows a message or progress dialog, so a dialog waiting for you is never hidden behind the preview
• View → Mirror Preview Horizontally (W, from either window) flips the preview window’s image left-to-right. It is a drawing aid for judging symmetry, a mirrored view makes a lopsided face or an off-centre shape jump out, and nothing more: no pixel is moved or changed, the artwork is untouched, and the main canvas keeps showing it the right way round
• View → Enable CRT Filter in Preview Window (Alt+F8, from either window) renders the preview window the way a cathode-ray television showed a C64: the red and blue channels smear a pixel either side of the green one the way a composite or RF connection fringed colour, alternate scanlines are dimmed, and the picture is softened rather than shown with hard pixel edges. It is a display filter for that window alone; the artwork is not touched, and the main canvas keeps its crisp pixels for drawing
• The status bar along the bottom reports, left to right, the canvas mode and layout, its size in pixels, the display pixel aspect, the brush shape and width, the zoom, the view rotation, and the char cell and sprite the pointer is over (a dash when it is over neither). The fields keep fixed proportions of the window’s width, so they never shift about as their values change; narrow the window far enough and a field shortens its text, with the whole value in its tooltip
• The rightmost status bar field reports results that leave no other trace in the window: a project opened or saved, an image or sprites imported, an image converted, an export written, a PRG sent to an Ultimate device. It reports a change of mind the same way: closing a file chooser or a prompt without choosing, or cancelling a save, open, export, conversion or send that is already running, leaves a note saying which operation was cancelled. That way a menu entry that ends with nothing visibly different never looks as though it did nothing at all. Each message clears itself after a few seconds. Anything that needs your attention, an error or a question, comes as a dialog instead, so nothing important is lost if you miss a line here
• A handful of shortcuts work the same whichever of the main window or the preview window has focus, rather than being scoped to one: Zoom In, Zoom Out, Actual Size (Ctrl+0), Best Fit (Ctrl+Shift+0), and Reset Rotation & Best Fit (Ctrl+Home) drive whichever window’s view is active; Show Preview Window (F8), Mirror Preview Horizontally (W), and Enable CRT Filter in Preview Window (Alt+F8) toggle the same way regardless of which window you’re looking at. Every other shortcut, including Reset Rotation (Ctrl+R), which only makes sense for the main view since the preview never rotates, is scoped to the main window

Color clashes

• Options → Hires Clash Resolution selects the hires clash victim strategy: replace the overwritten color (default), preserve the border color, or preserve the most-used color. The submenu is available only while a hires document is open; multicolor documents resolve clashes by their own rules
• Everything you draw, paste, import, convert, or transform is kept clash-free as it happens, so a canvas only holds clashes when it arrived with them: a project file written by an earlier version of ALBERT can carry them in. The C64-native exports refuse such a canvas and offer the remedy in the message that says so. Choose Resolve and Export and the clash sweep runs across the whole canvas as one undoable edit, then the export goes ahead: each violating char cell or sprite keeps its most-used colors, and each color that has to go becomes whichever of the surviving colors is closest to it. Choose Cancel and the canvas is left exactly as it was, with nothing written. The same sweep is what the operations below mean when they say they end by resolving clashes

Sprites in the top and bottom borders

• On a top/bottom-borders canvas each border strip shows 13 whole sprites plus an 8-pixel sliver of a 14th across the bitmap width. A border’s two stacked sprite rows share their free color (the display hardware cannot change it between them), so a sprite’s color reaches 42 lines; the reference grid still marks the 21-line hardware boundary through the middle of each strip, with a bracket at each end of the strip linking the two rows it joins. Each border draws with its own shared colors (the T-/B- slots in the color assignment bar) plus that one free color per sprite; the side borders are plain frame here, not drawable
• Options → Border Sprites aligns each border’s sprite grid to the left or right bitmap edge; the truncated 14th sprite sits at the opposite end. Flipping an alignment moves the sprite boundaries the color rules and the reference grid use, so artwork that sat inside one sprite can end up straddling two. The flip therefore ends by resolving the sprites the new boundaries leave over their color limit: each keeps its most-used colors and the rest merge into the closest survivor, exactly as the clash sweep does. That merge is the only pixel the flip repaints, and all of it – the new alignment and the merged colors – is one undoable edit, so a single Undo brings back both
• The C64 has 8 hardware sprites, so at most 8 sprites in each border can hold pixels; a sprite counts as soon as it shows a single pixel in any colour other than its border’s background. For all practical purposes a border’s sprites are 42 lines tall: the display hardware shows the same 8 sprites in both of a border’s 21-line rows, at the same horizontal positions, so a sprite with pixels in either row spends the slot for the whole border. The top and bottom borders are independent, each with its own 8. Enforce 8-Sprite Border Limit and Flag Sprites over the Border Limit (Options → Border Sprites) choose whether drawing into a 9th sprite is blocked or merely flagged; the choice is saved with the project
• Under Enforce, a stroke keeps filling the sprites it already started but simply leaves no pixels in a 9th one; the brush preview shows that before you click. Erasing (drawing in the border’s background color) is never blocked, and pixels already in a 9th sprite are never removed: enforcement only stops new ones appearing
• A red frame around a sprite means the C64 cannot display it as drawn, and it appears under both policies. What it flags in practice is a border holding more than 8 sprites: the excess ones are framed, those with the fewest non-background pixels, the very sprites Reduce Borders (below) would erase, with ties broken toward the border’s aligned edge. An alignment flip can produce this out of artwork that was within the budget, by splitting one occupied sprite across the new boundaries. Erase the flagged sprites, or reduce the border (below). The frame also marks a sprite using more than one free color, but nothing you do here leaves one behind: drawing keeps each sprite within its color limit as you go, and every edit that moves sprite boundaries or colors, an alignment flip included, resolves the sprites it breaks. Such a sprite reaches you only in a project file written by an earlier version of ALBERT, and the clash sweep the native exports offer merges its extra colors away
• Options → Border Sprites → Reduce Borders to 8 Sprites brings each border back within the budget as one undoable edit: the 8 sprites with the most non-background pixels survive, and the rest are erased to their border’s background. When two sprites hold the same number of pixels, the one nearer the border’s aligned edge wins: the leftmost on a left-aligned border, the rightmost on a right-aligned one. Borders already within the budget are left untouched

Editing

• Edit → Undo/Redo (Ctrl+Z / Ctrl+Y) walks every edit (strokes, color assignments, Clear Screen) with unlimited depth back to the first change; edits that end up changing no pixels (e.g. painting an area in its own color) don’t clutter the history, and undoing a stroke also rewinds where the next Shift-connecting line starts
• Edit → Clear History discards the whole record of changes after asking you to confirm. The canvas keeps exactly the content it has on screen; only the record goes: nothing is left to undo or redo, the picture as it stands becomes the only workstage (so there is no sequence left to save), and the next Shift-connecting line has no earlier stroke to start from. This cannot be undone
• Edit → Color Swap (Alt+X) / Color Replace (Alt+A) recolors the artwork between the two pen colors as one undoable edit. Color Swap exchanges the primary and secondary colors everywhere; every pixel of one becomes the other, in both directions. Color Replace turns every pixel of the secondary color into the primary, merging the two; pick the color to retire with a right click in the palette bar and the color to keep with a left click. The shared color slots follow the same exchange: a background, border, or sprite common set to a color being swapped or replaced moves with its pixels (in a swap, in both directions), so background pixels stay the free background color instead of turning into clashes and sprite commons keep matching their recolored pixels. With a selection active, the recolor is confined to the selected pixels, and the common sprite colors are left in place so sprites outside the selection keep their colors. The one exception is a selection that fully covers both side borders (multicolor side-border sprites), or a whole top or bottom border (multicolor top/bottom sprites): there the covered border’s own common colors follow the exchange, since moving them affects nothing outside the selection. Neither operation can create a clash by itself; each still ends with the clash sweep, so clashes already flagged on the canvas are merged away at the same time. Swapping or replacing colors the artwork and slots never use changes nothing and records nothing
• Edit → Transform → Flip Horizontally (Ctrl+J) / Flip Vertically (Ctrl+K) mirrors the artwork. With a selection active it flips the selected content only (the items say so, reading Flip Selection Horizontally/Vertically) and it does that as a floating selection: the mirrored content previews in place with live clash resolution, and you drag, nudge, or flip it again before Enter drops it as one undoable edit (Esc abandons it, leaving the canvas exactly as it was). Flipping a selection you have just pasted works the same way, and flipping twice is exactly the original back, pixel for pixel. The content mirrors about the selection’s own bounding box, so it stays where it is; a non-rectangular (lasso) selection mirrors as a whole shape, and wherever the mirrored shape no longer covers the original, the vacated pixels are left in the blank color. A selection whose bounding box lines up with the char grid and is a whole number of cells across maps cells onto cells and so can never introduce a clash; an off-grid one lands the content at a different phase against the grid and can, in which case the drop resolves it like any other. With no selection the same two items mirror the whole artwork as one undoable edit, ending with the clash sweep so any clashes the mirroring creates are merged away. Bitmap content lands exactly back on the char grid, but the side-border sprite rows sit asymmetrically (their top and bottom rows are cropped), so a vertical flip can land sprite colors across sprite boundaries; the sweep then merges them. On a hires canvas with side-border sprites the mirror covers the editable 408 pixels: the locked 8-pixel border column stays put and the two sprite strips trade places exactly. On a top/bottom-borders canvas the sprite grids and border color slots follow the artwork; a horizontal flip flips both borders’ left/right alignments, a vertical flip swaps the two borders’ alignments and color slots, so legal sprites stay legal
• Options → Clear Screen (Ctrl+L) blanks the canvas to the mode’s blank color; one undoable edit, not a new document
• Edit → Settings… holds the preferences that are set rather than toggled from a menu. The General group carries three view preferences, all off out of the box. Invert Scroll Wheel Direction for Zooming flips which way the wheel zooms (scroll down to zoom in) on the canvas and in the preview window alike, for those who prefer it that way; the Zoom In and Zoom Out entries and their shortcuts are unaffected. Bind Zoom to Canvas: with it on, the point Zoom In/Zoom Out works around is kept inside the drawable canvas, so zooming while the pointer is over the border, or with the canvas off to one side of the window, pulls the artwork back into view instead of magnifying empty space. Smooth Scaling for Imported Images controls how an imported image is resampled when it doesn’t match the canvas: the reference layer and the Convert Image… input. Off (the default for a pixel art editor), a scaled image keeps hard pixel edges, and the reference layer stays blocky when you zoom in, like the artwork under it; on, both are filtered smoothly, which suits photographic sources. It applies as an image is imported, so change it before importing; an image already loaded keeps the scaling it arrived with (re-import to change it); the reference layer’s on-screen sharpness follows the setting immediately. Use OS-Native File Chooser Dialogs, off out of the box, decides which file chooser opens for Open, the imports, the exports and the rest. Left off you get ALBERT’s own, which add a preview pane: Open renders the project you have highlighted, Import Image and Import Sprites decode the file and show it as it will land, with the import’s own options (the target screen on a two-screen canvas, the sprite attribute convention) beside the preview, so choosing the file and its settings is one step. Turn it on for the system’s own chooser, the one your other applications use, with its bookmarks and network places: it has no pane to add any of that to, so those options are asked for in a small dialog after the file is picked instead, and nothing is previewed. On Linux the system chooser is available only on desktops that provide one; where none is, ALBERT’s own opens whatever this is set to. On macOS the group ends with a fourth preference, Use OS-Native Menu Bar, off out of the box: ALBERT’s menus sit in a menu bar inside the window, as on Windows and Linux, where they follow ALBERT’s own appearance and where Open Recent can show its preview bubble. Turn it on to move them to the macOS menu bar at the top of the screen, where a Mac application’s menus are expected; at the cost of that bubble and that appearance, both of which macOS draws its own way, and gaining back the row of window space the in-window bar takes up. The keyboard shortcuts are the same either way, and the menus move as soon as you click OK. The Ultimate Device group sets the host (IP address or hostname, 192.168.0.64 out of the box) and the network timeout in seconds (2.5 out of the box, and anywhere from 0.1 to 60) that File → Export to Ultimate Device talks to the device with. The timeout is how long a send waits on a device that has gone quiet before giving up on it. OK keeps the values across sessions; Cancel changes nothing

Files

• File → Presets → Hires/Multicolor Canvas starts a fresh single-screen project; Hires + Side Sprites and Multicolor + Side Sprites add the side-border sprite strips (two sprites wide each side, with the C64 sprite color rules enforced there; hires sprites share the border color, multicolor sprites the MC0/MC1 commons); Hires + Top/Bottom Sprites and Multicolor + Top/Bottom Sprites put the sprites in the top and bottom borders instead; two 21-line sprite rows above the bitmap and two below extend the drawable area to 320×284 on screen (see Sprites in the top and bottom borders); Dual Hires Canvas and Dual Multicolor Canvas put two screens of the respective mode side by side (640×200 on screen, one continuous cell grid; the seam is cell-aligned and marked by a brighter line in the reference grid). Only a canvas of exactly one screen, with or without sprite strips, is drawn with the border frame: the frame is one C64 screen’s worth of border, and nothing frames a multi-screen or oversize canvas, or a free size smaller than a screen. Where there is no frame the border color slot disappears with it, in the main window, the preview window and the Convert Image dialog alike, and an image export of such a canvas does not offer to include the borders
• File → New Canvas… (Ctrl+N) is the same thing with the choices spelled out: mode, the sprite layout (bitmap only, side borders, top/bottom borders), screens across, and a free canvas size that snaps to whole char cells, with the resulting on-screen size shown as you go. The Presets submenu holds one-click presets for the common layouts. Starting a new canvas either way prompts you to save the current project first, before the New Canvas dialog opens, so the choices you make in the dialog are never thrown away by that prompt
• File → Open / Save / Save As… (Ctrl+Shift+S for Save As) read and write .alb project files: the colormap, the colors, and the full edit history, so a reopened project undoes back through everything you did before saving. Unless you have switched to the system file chooser (Use OS-Native File Chooser Dialogs, above), the Open dialog previews the highlighted project as you browse (the saved image in your current palette, with its mode, on-screen size, and workstage count under it) and reads only the picture itself, so browsing stays quick however long the history behind a file. The picture keeps its true on-screen size, or a whole multiple of it when the canvas is small enough for one to fit, so its pixels stay exact; only a canvas too large for the pane, such as a multi-screen one, is scaled down. Dragging a single .alb from your file manager onto the ALBERT window opens it the same way, prompting to save the current project first if it has unsaved changes
• An installed ALBERT registers itself as the application that opens .alb projects on macOS and Linux alike, so double-clicking one in the Finder or your file manager opens it here, as does dropping one on the macOS Dock icon, and projects carry their own icon instead of a blank-page one. On macOS you can open a project this way while ALBERT is already running; either way it prompts to save the current project first, exactly as File → Open does. On Linux the same registration puts ALBERT under Graphics in your application launcher. Windows keeps whatever association you set yourself, and opens a project handed to it on the command line
• File → Open Recent lists the last ten projects you opened or saved, newest first, each numbered for quick keyboard picking, and two projects sharing a file name are told apart by the folder shown beside it. Hovering an entry pops up a preview of what you’d be opening: the saved picture in your current palette, with its metadata beneath. Like the Open dialog’s pane it sizes the picture the same way and reads only the picture itself, so the bubble is quick however long the history behind a project, and an entry that can no longer be read as a project says why instead. (With Use OS-Native Menu Bar on, macOS draws the menu itself and hovering shows the plain path alone.) Opening or saving a project already on the list moves it back to the top rather than adding it twice. Entries look after themselves: one whose file has been deleted, moved, or renamed is dropped the next time the File menu opens, and one that no longer loads is dropped when you pick it. Below the files, past a separator, Clear Recent File List forgets the lot; it only empties the list, never touching the projects themselves. The submenu is greyed out while the list is empty
• File → Import Image… loads native C64 artwork into the current canvas. Hires canvases take Art Studio, Interpaint, Image System, and Doodle images; multicolor canvases take Vidcom 64, Koala Painter, Artist 64, Advanced Art Studio, and Blazing Paddles. The format is recognized from the file itself (load address and size; no particular extension needed). ALBERT’s own chooser previews the highlighted file as you browse, naming the format or saying why it can’t load. On a multi-screen canvas, pick the target screen beside the preview; through the system chooser, which previews nothing, it is asked for once you have picked the file. The image replaces that screen’s bitmap pixels as one undoable edit, together with the colors the file stores: a multicolor image’s background, and Advanced Art Studio’s border, become the document’s. On a single-screen canvas that is all there is to it, since the image replaces every cell those colors govern. On a multi-screen canvas only the first image you import sets them: the screens an import does not cover keep the artwork you drew against the colors already there, so later imports leave those alone and the arriving pixels are resolved against them instead, the extra colors merging into the closest one each cell can keep. It is the same treatment a selection copied from an image with a different background gets when you paste it, and it means an import never leaves clashes behind on the screens it did not touch. A screen showing a single flat color counts as one you have not drawn on, so you can undo an import and try another until the artwork settles. That first import also carries its background across those screens, so a screen you have not drawn on comes out blank in the new background instead of painted in the old one, which would have cost every cell there one of its three free colors before you started. On a canvas with side-border sprites the strips keep their artwork, but their background pixels – the transparent ones, which the side borders share with the bitmap – take the new background along with it, so nothing there is left painting the old color by hand. The hires image’s rightmost 8-pixel column, covered by the right border’s sprites on the C64, is dropped. Importing into a project you haven’t saved yet also names it after the image: the window title shows the name and Save As proposes it, until a save or open gives the project a real file name
• File → Import Sprites… loads a sprite file (PRG data or Pixcen’s PMAP, the same format either way) into the canvas’s sprite strips (the entry is available on sprite layouts only). With side borders the file holds up to 40 sprites, four per 21-line sprite row: the left strip’s two columns, then the right’s, row by row from the top. With top/bottom borders it holds up to 32: the bottom border’s 8 sprites per 21-line row first, then the top’s, each border’s columns hugging its aligned edge. The import replaces the strips wholesale as one undoable edit (sprites the file doesn’t fill come back empty) and, through ALBERT’s own file chooser, shows the decoded sheet in the dialog as you browse, rendered with the canvas’s own colors. Sprite attributes (beside that preview, or in a dialog of its own once the system chooser has closed) picks what each sprite’s stored attribute byte contributes: Sprite Pad (the Pixcen convention too) takes the sprite’s color from it; ALBERT, offered on top/bottom canvases, additionally reads the sprite’s position, placing it in the strip column the byte encodes (of the 14 sprite columns spanning the border, counted under its current alignment) instead of packing the file’s sprites edge-to-edge, with the preview following; Ignore gives every sprite the primary pen color. A 42-line sprite is stored as two 21-line sprites, each with a color of its own, but the C64 shows a single color down all 42 lines: the import takes the color of the first of the two, the upper one, and draws both halves in it, ignoring whatever color the second one stored. So when you prepare a sheet, give a pair’s two halves the same color and you get back exactly what you stored; give them different colors and the upper one wins. That applies to the side borders’ paired sprites as much as to a top or bottom border, and the sheet in the dialog previews the colors the import will land, so what you browse is what you get. An import therefore always arrives displayable. The one thing it will not fix for you is a border holding more than 8 sprites, which keeps its red frames until you reduce it yourself
• File → Import Reference Image… overlays an ordinary image (PNG, JPEG, BMP; any format Qt reads) on the canvas as a tracing aid. The reference layer draws over the artwork and under the grids, and is never part of the document: it is free of the C64 palette and clash rules, its alpha channel is respected (transparent areas show the artwork through), and drawing ignores it entirely. An image that isn’t the canvas’s on-screen size (multicolor’s double-wide pixels mean twice the colormap width) asks how to scale: Stretch to Fit fills the whole canvas, Keep Aspect Ratio fits the image inside it, centered, with the leftover area empty. The scaling keeps hard pixel edges unless Smooth Scaling for Imported Images (Edit → Settings) is on. Importing switches the layer on; View → Show Reference Layer toggles it thereafter, and View → Reference Layer Opacity… sets how strongly it shows. The reference lives with the open document but is not saved in the .alb file; a new or opened project starts without one
• File → Convert Image… (Ctrl+P) turns an ordinary image into C64 artwork: pick the dither (none, error diffusion, ordered) and how colors are matched (Euclidean or weighted distance), adjust brightness with per-channel curves against a live histogram, and preview the result before applying. The conversion dithers against all 16 colors first and then resolves the color clashes that leaves, so gradients keep the mix of colors the dither chose for them. The conversion runs at the canvas’s on-screen size (multicolor’s double-wide pixels mean twice the colormap width): an image of exactly that size converts 1:1, and any other size asks how to scale: Stretch to Fit fills the whole canvas, Keep Aspect Ratio fits the image inside it, centered, the leftover margins black (they convert like any other pixels, typically to the background). That scaling keeps hard pixel edges unless Smooth Scaling for Imported Images (Edit → Settings) is on; worth turning on for a photographic source, where the softer input usually dithers better. The dialog carries the same color slots the canvas has, the ones for its mode and layout, set the same way (left-click assigns the primary color, right-click the secondary); because the conversion picks colors within them: a sprite gets its border’s shared colors plus one free color of its own, so changing a slot changes the result, and the preview follows. A canvas with no slot of its own, such as hires across more than one screen, shows neither the slots nor the palette bar they are picked from. On a top/bottom-borders canvas the dialog also offers each border’s sprite alignment, for the same reason: it moves the sprite boundaries the conversion picks colors within. Applying it replaces the canvas, the shared colors and those alignments as one undoable edit, and adopts the palette variant you converted against so the canvas matches the preview. As with Import Image…, converting into a project you haven’t saved yet names it after the source image: the window title shows the name and Save As proposes it, until a save or open gives the project a real file name
• Converting a top/bottom-borders canvas can leave more than 8 sprites holding pixels in a border, which the C64 cannot display: those sprites get the red frame like any other, whichever sprite-limit policy is set (the limit blocks drawing, it never discards a conversion’s artwork). Erase or repaint the flagged sprites to clear them
• File → Export to Image As… (Ctrl+Shift+P) writes the canvas out as an image file. When the canvas is a plain bitmap of exactly one or more C64 screens, a small dialog first picks the family: the mode’s native paint-program format (Art Studio, .ocp, for hires; Koala Painter, .koa, for multicolor), which classic C64 software and Import Image… read back directly, or a modern image (PNG and the other formats Qt supports, chosen in the save dialog’s format list). The dialog starts on the family you last picked, so exporting PNGs while working and a native file at the end takes no extra clicks. A multi-screen canvas exports one native file per screen, numbered from the left into the chosen name (name-0.koa, name-1.koa, …). A native export also needs the canvas clash-free: red-flagged cells stop it with a message, and that message offers to sweep them away as one undoable edit and carry on with the export (Color clashes, above); cancelling there writes nothing. The prompt appears before the save dialog, so the canvas is settled before you pick a destination. When native export cannot apply, for a sprite layout, a free-sized canvas, or an active selection, the dialog is skipped and the file is written as a modern image. A modern image keeps the C64’s shape (a multicolor canvas comes out twice as wide, since its pixels are double-wide on screen, the extra columns duplicated exactly with no blurring) while ignoring the view’s zoom, rotation, and the PAL/NTSC pixel stretch, and it always exports, clashes and all, showing the canvas exactly as it is. With a selection active the entry reads Export Selection to Image As… and writes only the selected content, a lasso’s out-of-shape corners left transparent. A modern image can take the borders with it: Include all borders, the checkbox beside the modern image choice, writes the whole picture the way the C64 shows it, the border frame around the canvas and every sprite border in it, instead of the drawable canvas alone. Sprite layouts never see that dialog, so they are asked the same question on its own once you choose the entry; either way the answer is remembered for next time, and Save Workstages… shares it. Borders are a modern-image option only: the native formats describe a bare bitmap screen and have nowhere to put them, a selection export is the selected content and no more, and a canvas that is not exactly one C64 screen is drawn without a border frame in the first place, so it is not offered there. Print… sends the canvas image to a printer. Exporting isn’t saving; only writing the .alb clears the modified marker
• File → Export to Ultimate Device (Ctrl+E) runs a ready-to-run C64 program on real hardware without a file in between: the artwork is sent over your local network to an Ultimate 64, or a C64 fitted with a 1541 Ultimate cartridge, which loads and runs it on the spot, the quickest way to judge the artwork on a real display. Set the device’s IP address or hostname and how long ALBERT waits for it under Edit → Settings (the device’s network services must be enabled); ALBERT checks the device is reachable first and says so if it isn’t, so a wrong address fails with a message rather than a long wait. A progress dialog covers the send in three steps: a third once the program has been compressed, two thirds once the device has answered, and the rest once the program is through. The window stays drawn throughout and takes no input other than that dialog’s Cancel, which stops the send at the next step and reports it on the status bar; the dialog’s close button and Esc do the same. Nothing is left behind on your machine or half-sent to the device. The timeout you set is what bounds each wait, so Cancel is there for the times you would rather not wait it out. The entry is gated exactly like Export to PRG File As… (a single-screen, clash-free canvas within the sprite budget) and like an export it never touches the modified marker. On macOS the first send asks for local network permission; if it was declined, allow ALBERT under System Settings → Privacy & Security → Local Network
• File → Export to PRG File As… (Ctrl+Shift+E) writes the canvas as a ready-to-run C64 program: load it on real hardware or an emulator and RUN it to see the artwork, sprites and all, with the display code adapting to PAL and NTSC machines by itself. The file is compressed on its way out with the bundled Exomizer into a small self-extracting program (should compression ever fail, ALBERT says so and keeps the uncompressed program, started with the SYS address the message names instead of RUN). Compressing one screen takes a fraction of a second and usually passes unnoticed; on a slow machine a progress dialog appears for the wait, and because the compressor reports nothing about how far along it is, the bar runs back and forth rather than filling up. Closing that dialog, with its close button or Esc, abandons the export: the compressor is left to finish the temporary copy it works on, nothing is written where you asked, and the status bar says the export was cancelled. The entry is available while the canvas is exactly one C64 screen, every sprite layout is; a bitmap-only canvas must be the standard single-screen size, so free-sized and multi-screen canvases can’t export. The export also needs the canvas clash-free (red-flagged cells or sprites stop it with the same message the native image export shows, offering to sweep them away and carry on) and, on a top/bottom-borders canvas, each border within the 8-sprite budget: red-flagged extra sprites stop the export with a message (nothing is written or repainted); erase them or run Options → Border Sprites → Reduce Border Sprites to Budget first. The sprite data embedded in the file carries each sprite’s color the way Sprite Pad and Pixcen store it; a top/bottom-borders export additionally records each sprite’s strip column, so re-importing the file with Import Sprites… and the ALBERT attribute setting puts every sprite back where it was. Like an image export, this never touches the modified marker
• File → Save Workstages… replays the edit history and writes the canvas at successive stages as a numbered PNG sequence (name-000000.png, name-000001.png, …, named after the project) into a folder you pick, ready for assembling a time-lapse externally. A workstage is the picture as it stood at one step of its making: the first is the canvas before any of the recorded edits (blank, for a project drawn from scratch) then one stage per edit, so the count is always one more than the edits recorded. Save All Workstages or a Subset of a chosen size, spread evenly (Uniform) or leaning early (Smart, which collects more stages from the start of the history, where the artwork changes most, and fewer from the late refinement). The frames render like a modern image export does, Include all borders and all: you are asked the same question here, it remembers the same answer, and a framed sequence shows each stage in the border color that was in force at that stage, not in the one the canvas carries today, so a color you changed part-way through the drawing changes part-way through the time-lapse. The sequence always ends on the canvas as it stands: edits you undid are not replayed. A progress dialog covers a long sequence, and its Cancel (or Esc, or its close button) stops the run where it is: the frames already written stay in the folder, and the status bar says how many of them there are

Help and version information

• Help → User Manual (F1) opens this manual in a window of its own, so it stays beside the canvas while you work. It is the manual for the version you are running, not a copy fetched from the web, so it never describes a feature your copy does not have
• Help → Online User Manual opens the manual published on the ALBERT website in your default web browser. That copy covers the current release, so it can describe things your version does not have yet, and it needs an internet connection; the built-in manual above is the one that always matches what you are running
• Help → About identifies the copy in your hands: the version, with any pre-release suffix highlighted so a development build is obvious; the two people behind ALBERT; the date it was built and the compiler that built it; and the version of Qt, the toolkit ALBERT is written with, that it is running on. Quote those lines when you report a problem: they say exactly which build you saw it in. The website link at the bottom opens in your browser, and through December the logo wears a santa hat
• Help → About Qt describes Qt itself, which is separate from ALBERT

What ALBERT remembers

• The grid toggles, the reference layer’s opacity, the display pixel aspect, the window geometry, the preview window’s visibility, geometry, stay-on-top, mirror and CRT choices, the Convert Image dialog’s geometry and its dither choice, the Save Workstages dialog’s position and reduction method, the zoom wheel direction, Bind Zoom to Canvas and Smooth Scaling for Imported Images preferences, the file chooser choice, the menu bar’s placement on macOS, and the Ultimate device’s host and timeout (Edit → Settings), and the folders last used for project open/save, image export, PRG export, image-to-convert, image import, sprite import, workstage saving, and reference-image import (eight separate last-folders that never mix) persist across sessions as per-user settings; everything document-related (canvas, colors, history) lives in the project file instead

Keyboard shortcuts

A quick reference to the keys you press with your hand on the drawing area. The menu entries carry shortcuts of their own (Ctrl+S to save, Ctrl+Z to undo, and so on) and every menu shows them beside the entry, so they are not repeated here. The sections above describe what these keys do in full.

• Picking colors:
  • 1 to 8 set the primary color to the first eight palette colors, Shift+1 to Shift+8 to the other eight, in the order the palette bar shows them. The bar’s selection follows either way
  • Hold C to see what the right button would paint: the brush and fill previews swap the primary and secondary colors for as long as the key is down. It only predicts; the buttons keep their meaning
• Choosing a tool. Exactly one tool is active at any time, and picking the one already active changes nothing, so none of these can switch a tool off by accident:
  • B pen, E eraser, G fill, S shapes, I eyedropper, H pan, M rectangle select, L lasso select, Y move the symmetry axes
  • Hold Alt while the pen is active to borrow the eyedropper without leaving the pen: Alt+click samples the color under the cursor as the primary, Alt+right-click as the secondary, and releasing Alt puts you back to drawing. The cursor becomes a dropper while it is armed
  • Hold Space and drag to pan under any tool without leaving the one you are on (the middle button drags the same way), and hold R and drag to rotate the view around the viewport center
• Changing the pen width: , or [ steps it down one pixel, . or ] steps it up; hold a key and it repeats, like holding the – and + buttons on the texture strip
• Z switches both reference grids to a lighter grey, and back on the next press, so a grid line stays findable where the artwork under it is dark. It only changes how they look: which grids are shown is still View → Show Reference Grids and Show Pixel Grids, and Shift+Z is that second toggle
• The arrow keys move whatever is in front of them:
  • with nothing staged they pan the view by exactly one char cell a press
  • with a floating selection or staged shapes selected they nudge that instead, by one canvas pixel, and Shift+arrows by one char cell, the step that matters when hunting for a clash-free placement
• Esc backs out of whatever is in progress. It deselects, abandons a drag mid-gesture, discards a floating selection and leaves the canvas underneath untouched, and throws the staged shapes away without recording anything, asking you to confirm in that last case alone. Enter is its opposite: it drops a float or commits the stage as one undoable edit. Delete removes the selected staged shapes, and the key above Tab (the backtick ` on a US keyboard, the section sign on an Apple US/UK one) cycles the selection through them
• Tab hides and shows the dashboards
• Shift means “the variant of what you are doing”, so what it does depends on the tool in hand rather than being one fixed function:
  • with the pen or eraser it rubber-bands a connecting line from where your last stroke ended, previewing it solid until you release
  • creating a shape, it constrains the drag to uniform aspect on the emulated display (a square, a true circle); on a corner handle it keeps that aspect while scaling, and on the rotation pin it snaps to 22.5° steps
  • during an R+drag it snaps the view rotation to those same 22.5° steps
  • starting a selection drag it adds to what is already selected (Alt subtracts, Shift+Alt intersects), and Shift+click adds or removes a staged shape from the selection
  • with the arrow keys it turns the one-pixel nudge into a one-cell nudge
  • with the number keys it reaches the upper half of the palette
• Ctrl (Cmd on macOS) is the other tool-dependent modifier, and it means two things:
  • everywhere geometry is drawn, align to the canvas, not the screen. Held while a square nib strokes, a shape is dragged out, or a marquee is pulled, the geometry follows the canvas axes instead of the screen axes it follows by default, which is only visible on a rotated view
  • with the fill tool it traces a contour instead of filling, in the placement set under Options → Fill Contour Placement. Multicolor canvases only, and described in full with the fill tool above