Changelog

What changed in the JamChip plugin, newest first. The format is Keep a Changelog and the versions are semantic. The version lives in addons/jamchip/plugin.cfg; pnpm release VERSION gathers changes/ into a dated section and tags plugin/vVERSION. A pull request that earns a line writes it to changes/<branch>.md: a feat under Added, a fix under Fixed, a ! under Changed or Removed; docs/PROCESS.md has the rule.

Unreleased

Added

• About in the app and the web build has Credits and licences: Godot’s licence, every component the engine reports with its licence, and the two fonts’ OFL, read from the engine and the font files so an engine upgrade updates it. In the editor About is as it was, since Godot’s own About carries the same.

• Godot now imports an .aseprite or .ase as a sprite a PixelSprite2D can draw. Save it again in Aseprite and the editor imports it again, and the sprite draws the new file. Open in JamChip on its right-click menu opens it untitled: Save writes a new document, never the Aseprite file.

• A running game follows an .aseprite saved again in Aseprite, as it follows a save in JamChip, when Push To Game is on.

• An .aseprite has two rows in the Import dock: Fallback Palette, for a file with no palette of its own, and Match Style Palette, which moves every colour outside the project’s style to the nearest one in its main palette.

• Every tooltip, hint, status line and dialog is rewritten under docs/VOICE.md: shorter, says the one thing the screen can’t, and gives the plain word next to a music term. Menu items keep their names; three change (“Add PixelSprite2D to Scene”, “Add ChiptuneSfxPlayer to Scene”, “Duplicate frame”).

• The example game runs from a title to a win: it opens on a title card, any key starts it, and the last coin shows an end card. Both cards are Pixel documents, examples/art/title.pixel.tres and end.pixel.tres, on a PixelSprite2D each, so a stroke on one reaches the running game the way a stroke on the player does.

• The example game’s finale is a castle of its own. Behind a stone floor there is a night sky with stars, a wall with its battlements, a tower and a banner, and torches flicker on the wall with no code behind them. Three coins wait on the way to the key and the door. The sky, the wall and the torch are each a document you can open in the dock.

• An echo, rendered by JamChip, so the Tracker tab, the game and an exported .wav sound the same. Each channel of a song sends to the song’s echo, and an instrument can have an echo of its own. In a song its time is counted in rows, so it stays on the beat. ChiptuneSongPlayer and ChiptuneSongPlayer2D ease a channel’s send while the game runs, with set_send.

• A song saved while the game runs reaches the game. It renders on another thread, so the game does not freeze, then the music starts again on the bar nearest where it was. ChiptuneAudioStream.prerender() and ChiptuneAudioStream.prerendered_for(document, loop) do the same for a loading screen: the stream renders on another thread and emits prerendered when it has its audio. Nothing changes for a stream that does not ask.

• sprite board --tiles TILESET[@TILE,...] lays a tileset’s tiles under the board’s cells before the frames go on, taking turns along each row, so you see sprites on the ground they stand on. Name tiles by number or name, or give the tileset alone for all of them.

• sprite cel does several frames of a layer in one run: --dump with --frame 2:5 or --frame all prints each frame under a line like --- frame 2, with --legend one legend for them all, and --from-indices reads a file in that shape and writes every frame it names, so a four-frame effect is one command, not four. A file of one grid works as before.

• sprite cel --outline N --color C draws a line N pixels wide round the drawing on a cel, on the clear pixels around it, or with --inside along its own edge. Corners are square, or round with --round. A select tool outlines only the drawing it holds, and a --frame range outlines each frame. PixelDocument.outline_cel draws the same from a game’s script.

• sprite cel --to and sprite board take --view value,ramps,silhouette,thumb,grid to draw the piece again beside itself: its brightness in grey, lines where two colours meet, its shape alone or with --per-layer a colour a layer, its true size, and pixel rulers. --notes FILE prints your list of what the piece has to show beside the answer.

• sprite lint DOC finds jaggies, lone pixels, doubled lines, banding and touching colours too close in brightness, each with its frame, layer and pixels. --only picks the rules, --banding-rows and --contrast-margin set how strict two are, --to draws what it found, and it exits 1 when it finds something, so a game’s own check can run it.

• palette switch DOC FILE|N switches a sprite, tileset or font to one of the style’s palettes and recolours it, as a tap on a palette’s strip does; a palette from outside the style comes in as Custom, and --custom keeps the colours and drops the link.

• The command line is one short command: addons/jamchip/cli/jamchip palette show art/swamp.hex, or jamchip.cmd on Windows. It finds Godot from GODOT or your PATH, runs it headless on the project the plugin is in, imports a fresh checkout first, and reads paths from the folder you’re in. It never asks a question or opens a window, so an agent or a CI job can run it.

• The palette commands catch up with the palette tab. palette edit --sort hue or --sort brightness puts the swatches in the order the tab’s Sort by hue and Sort by brightness give, and palette default FILE makes a palette the one new documents open on, as Save palette as project default does; --clear takes it back out of project.godot.

• A palette of your style that sprites, tilesets or fonts use isn’t changed from the command line without --force. The refusal says how many use it, the way the tab asks before it saves.

• The command line runs a file of commands in one launch of Godot, run FILE, or reads them from standard input with run -. Every line is checked before any runs, and the first one that’s refused stops the rest. A hundred sprite edits run in about three seconds.

• The sprite commands, and palette switch on a sprite, read and write a sprite outside the project as one .jcsprite that carries its cels, the file the web app’s download gives you, with no blobs/ beside it. sprite create OUT --from DOC copies a sprite out. A sprite whose cels are in a project’s blobs/ is still refused outside it, and now says how to make the copy that opens anywhere.

• sprite paint --polygon 'X,Y;X,Y;X,Y...' draws a shape through three corners or more, its outline at --brush, or with --filled the pixels the lasso selects through the same corners, so a cone, a tent or a face is one call. A script calls paint_polygon for the same.

• sprite paint --ellipse takes --thickness N, drawing the ellipse as a ring N pixels thick, and --arc DEG:DEG, keeping only that part of it, so an arch over the top is one call. A script asks paint_shape for the same with its thickness and arc options.

• sprite paint paints only inside a selection: the --rect X,Y,W,H, --lasso and --wand that sprite cel takes, as the Pixel tab’s tools keep to a selection. --select-layer N makes the selection on another layer, kept to what’s drawn there, so a shape blocked in on one layer is shaded on another without painting past its edge. A script passes a selection to paint_stroke, paint_shape, paint_polygon and paint_fill, and PixelSelection.from_opaque is what’s drawn on a cel.

• --smooth bends the lines between placed points into a smooth curve: a pencil or eraser stroke, a polygon, filled or outlined, and the lasso in sprite paint and sprite cel.

• Palettes and styles from the command line. palette show, create, edit, ramp, nudge, mutate, export (to .gpl, .hex or PNG) and convert (between .gpl, .hex and .jcpalette); style list, show, create, use, edit and check. Run Godot headless with -s res://addons/jamchip/cli/cli.gd; every command takes --json.

• sprite cel runs the Edit menu on the command line, with no editor open: --clear, --flip h|v and --turn left|right, and --move DX,DY, the select tool’s drag, with --all-layers as the bar’s All layers. Each works on the whole cel or on a selection: --rect (the marquee), --lasso or --wand. It works on one frame or a range, and changes the pixels the Pixel tab would. --pick X,Y names the colour under a point and its swatch, on the cel or the frame as it shows.

• PixelDocument.edit_cel and PixelSelection.from_polygon, the same edits and the lasso for a game’s script. Advanced, and open to change until 1.0.

• sprite cel on the command line reads and writes one cel of a sprite whole, with no editor open: --dump prints it as a grid of swatch numbers, --from-indices writes it from such a grid, --from pastes a PNG onto it at --at, and --to copies it to a PNG at --scale. A colour the palette doesn’t have is refused unless --nearest.

• A game’s script can do the same through PixelDocument.cel_indices, set_cel_indices and paste_into_cel.

• sprite export and sprite import on the command line, with no editor open. sprite export writes what the Pixel tab’s Export writes: a PNG of one frame, --sheet for the sprite sheet and its SpriteFrames, --tileset for a tile sheet and its TileSet, or an Aseprite file. The sprite remembers the export, as it does from the tab. --scale N makes a bigger PNG to look at instead. sprite import reads an Aseprite file, a sheet with its .frames.tres, or any sheet cut on --cell, the way the tab’s Import does.

• A save from any command writes the sprite’s exports again, as the tab’s save does, so a PNG or a sheet in a scene follows the drawing, and names each one it writes. It leaves alone, and says so, an export outside the project or inside the addon, and a sheet or TileSet that belongs to another sprite.

• PixelSpriteFiles, the same exports and imports for a game’s script. Advanced, and open to change until 1.0.

• sprite frames, sprite layers and sprite tags on the command line, with no editor open: frames adds, duplicates, moves and removes frames and sets their holds and markers; layers adds, moves, removes, renames, shows, hides, fades and locks layers; tags adds, removes, renames and re-ranges tags and sets their looping, direction, repeats and colour. Each takes its options in the order you type them.

• sprite cel --dump --legend prints a cel as letters, one a pixel, with a legend of the swatches they stand for, and --from-indices reads a grid keyed by a legend of your own, so a grid reads as the drawing.

• sprite paint on the command line, with no editor open: the Pencil, Eraser, Line, Rectangle, Ellipse and Bucket fill tools on one cel, in a swatch of the sprite’s palette, painting the pixels the same drag in the Pixel tab would. The bar’s options come as flags: the brush’s size and round tip, pixel-perfect, filled shapes, the fill’s tolerance and Whole layer, and symmetry about the middle or an axis you give.

• PixelDocument.paint_stroke, paint_shape and paint_fill, the same tools for a game’s script. Advanced, and open to change until 1.0.

• The command line makes and changes sprites: sprite show prints a sprite’s size, palette, layers, frames, tags, grid and exports; sprite create is File ▸ New, or Save As with --from; and sprite resize is Resize canvas, with an anchor or --scale.

• sprite board OUT.png DOC... lays frames of one sprite or several side by side in one PNG, to review an animation or options against each other: every frame, or DOC@2, DOC@2:5, DOC@all or a tag, DOC@fly. --columns N wraps, --strips gives each sprite its own row, --gap N spaces the cells and --scale N grows the board. A board isn’t remembered.

• The command line makes and changes sounds: sfx create is the SFX tab’s Generate for an action and a seed, sfx show prints every setting as text and sfx create --from-text writes a sound back from it, sfx edit sets any of them, sfx nudge and sfx roll are Nudge and a section’s roll, and sfx export writes the tab’s .wav.

• A game’s script can do the same to a sound: ChiptuneSfxSpec.to_text, from_text and set_setting, marked advanced in RUNTIME.md.

• song create and song edit take --echo and --sends, the two lines as options, so a song written on the command line can echo one channel alone.

• song motif FILE NAME --pattern 1 --channel 1 writes one of your style’s motifs into a song from the command line, as the Tracker tab’s Add a tune from the style does: by its name or id, in the song’s own key and scale, from --row, on --instrument, the quote recorded in the song; --key D writes it as if the song were in D. song show --json lists the song’s quotes.

• song create OUT --custom: a new song whose instruments are its own, the Tracker’s New then Detach on each, so it can be written outside the project.

• tiles export and tiles import on the command line, with no editor open. tiles export writes what the Tiles tab’s Export writes: the sheet as a PNG and a TileSet beside it with each tile’s collision, data and terrain. Over a TileSet already there it takes --force and merges, so tiles added in Godot’s TileSet editor keep theirs. tiles import reads an Aseprite file’s tileset, a Godot TileSet, or a sheet cut on --cell, the way the tab’s Import does.

• PixelTilesFiles, the same export and imports for a game’s script. Advanced, and open to change until 1.0.

• tiles tile takes the rest of the Tiles tab’s tile settings: --points for a collision shape, --terrain and --peering, and the Edit menu’s Duplicate, Flipped, Rotated and Wrap-shift, --copy duplicate|flip-h|flip-v|left|right and --wrap-shift.

• tiles terrain adds, renames and removes a terrain, laying its block of tiles as New Terrain does, and tiles grid is View ▸ Grid Size and Offset.

• Tilesets on the command line: tiles create is File ▸ New, tiles show prints the grid and each tile with its cell, name, collision and data, tiles cel draws the sheet or one cell as sprite cel draws a cel, and tiles tile names a tile, makes it solid and gives it data, as the Tiles tab does.

• tiles scratch and tiles layer lay tiles on the scratch or on a PixelTileMapLayer in a scene, by cell, by rectangle or from a grid of text a character a cell, and read the map back as that grid or a PNG; tiles layer --create makes a new scene with the layer as its root.

• PixelTileMapLayer.place_tile(cell, "tree") lays a tile by its name, and tile_at reads one back; PixelTilesDocument has tile_named, cell_image and set_cell_image.

• The command line makes and changes songs: song create is the Tracker tab’s New at a tempo, key, scale and channel count, or Generate Loop’s song or a jingle from a seed; song show prints the whole song as text and song create --from-text writes it back; song pattern --dump and --from-notes read and write a pattern’s notes as a grid; song edit, song instruments, song order and song export are the tab’s fields, Load and Save Instruments and Generate Kit, the order, and Export WAV with its loop. Patterns, rows, channels and instruments count from 1.

• A game’s script can read and write a song as text, ChiptuneSongText, set its order, and replace, resize or remove a pattern, marked advanced in RUNTIME.md.

• song create and song edit take --loop or --once, and a song’s text says loop = yes or no. A one-shot exports once.

• song instruments --palette puts a song on your style’s sound palette, as the Tracker tab’s Use the sound palette does, and --detach NAME or --custom makes one instrument or all of them the song’s own. A song opened by a command takes the palette’s instruments as they are now, and a change to one is saved into the palette and every song and sound that uses it, the same as saving in the tab.

• About links to jamchip.com and Support, and names the licence.

• Each row on the Theme page leads with four chips, the theme’s own surface, ink, accent and playhead, so a theme is picked by its colours.

• Edit and Duplicate turn the Theme page to the swatches, under ‹ Themes / name, which goes back to the list. Edit Theme is no longer a section of its own.

• The theme editor’s eight swatches are named for what they colour, Background, Canvas and lists, Lanes, Selection, Playing, OK, Warning and Danger, with the file’s key under each, and all eight fit without a scroll.

• The line under the themes names your themes folder, and the app’s manual names JamChip’s app folder. Hover either for the full path.

• The example game has two songs in place of the chase: Meadow under the meadow and the gate, and Cavern, the cave’s own, on a second ChiptuneSongPlayer that starts from the top on the way in. Wading mutes Cavern’s lead and its echo, and the gate’s clock still hurries Meadow.

• The JamChip palette has eighteen colours, a pale green and white joining the sixteen, and the JamChip style allows five channels; a new song still starts on four. A palette made from the old sixteen links to a style of eighteen only once it has the same number of colours.

• The example game keeps to the JamChip style: its project names it, and every sprite, sound and song in the game fits.

• Generate loop plays its patterns in one of four orders, A A B A, A B A B, A A B B or A B A C, where C is a new tune over B’s chords, and now and then its tunes jump a few notes, as well as stepping to the next one.

• One Export on every tab and one Import on the Pixel tab, each a dialog: the format first, its options as rows under it, then where it goes, and it opens on the format picked last. The Pixel tab’s six items, Import spritesheet, Import Aseprite, Export frame as PNG, Export animation, Export TileSet and Export Aseprite, are formats in it, and the TileSet’s cell and offset are rows there. In a browser the last row is Download, for any format, and Download on its own is gone: the document’s own format sends the saved file.

• A new song’s grid offers a first song: Generate a loop in one of six feels writes a four-channel loop in a key and a tempo and plays it once, Generate a kit sets the instruments and the key, Start blank takes the offers away. The same generators sit under Song ▸ Generate loop and the Instruments menu ▸ Generate kit once a note exists. A note outside the song’s key gets a band behind it, so it reads.

• A font on one of your style’s palettes holds that palette’s file, so the inspector names it and the glyphs follow when it changes. On Custom, the font keeps a palette of its own. palette switch does the same.

• The Font editor’s glyph sheet groups the set the way a font is drawn: H O n o first, then capitals, lowercase, digits and punctuation, each with a count of what is drawn. Symbols, Latin-1 letters and anything else you add sit below, marked optional and never counted as missing.

• + on the sheet’s title bar adds a group the font lacks, and − on a group’s header removes it, each one undo step.

• The glyph sheet folds and has a grip, so its height is yours.

• The glyph in hand is named in the rack and on the strip.

• The Font editor has the Pixel tab’s Marquee, Lasso and Wand, with their keys. Drag a selection to move it, and one undo puts it back; wide, the bar flips and turns it. Edit cuts, copies, pastes and deletes, so you can copy part of one glyph onto another. Picking another glyph drops the selection.

• The Font editor shows the glyph you’re drawing between H’s and n’s, HHnHH and nnnnn, so you can judge its spacing.

• The font’s preview line moved out of the rack to a strip along the bottom of the stage, which you can zoom, fold and resize.

• A font has a cap height, set in Cell Size and Guides beside the baseline and the x-height. Fonts saved before this get one worked out from the cell.

• The Font editor names its five lines beside the glyph: the baseline, x-height, cap height, and the cell’s top and bottom, each in its own colour and dash.

• Guides is a toggle on the Font editor’s bar, beside Grid.

• Fonts on the command line, with no editor open: font create, show, edit, glyph, import and export. font glyph draws and reads one glyph as sprite cel does a cel and sets its advance, and font export writes the bytes the Font tab’s Export writes as a Font.

• A TTF or OTF imports at a size of its own, apart from the cell: the Font tab’s Import has a Size row, and font import --size. A pixel face imported without --size is drawn at the size its pixels land whole at, in a cell that holds every glyph, and the tab’s Import says that size when you draw it at another.

• PixelFontFiles, the same export and imports for a game’s script, and PixelFontImporter.pixel_size_of. Advanced, and open to change until 1.0.

• The style’s music_db and sounds_db set how loud every song and every sound plays, in decibels: 0 as made, -60 silent, up to +12 to boost without clipping. The SFX and Tracker tabs, every player and an exported .wav all play at them, so what you hear in the tabs is what the game plays, and saving the style changes what’s already playing. A node’s volume_db and bus stay yours.

• The Pixel canvas grid takes a cell of any width and height and an offset, both saved with the document: the cell reads on a button beside the grid toggle and is set in the popover under it, the offset under View, and the square presets stay under View ▸ Grid size.

• A save reaches the running game. Run the game from the editor, draw in the Pixel tab or edit a sound in the SFX tab, Ctrl+S, and every PixelSprite2D, PixelSpriteTexture, PixelSpriteFrames and ChiptuneAudioStream holding that file takes the new document in place, on the animation and frame it was on, with no restart. A document that changes on disk behind the editor reaches the game the same way once the editor has scanned it. The path goes over the debugger connection the editor already holds; an exported build carries the autoload JamChipLive and nothing arrives. Songs wait on streaming playback. The project setting jamchip/push_to_game turns the send off.

• /join/ says what sync will probably cost, about $5 to $10 a month, that it isn’t settled yet, and asks whether you’d pay it: yes, maybe or no, and you can skip it. /privacy/ lists the answer among what’s kept.

• /join/ says what you’re waiting for: a turn before the launch, the launch planned for 8 January 2027, and 1.0, planned for spring 2027.

• A song can name its key and scale, from a Key section on the tracker’s rack, and the grid then tints every note outside the scale; none is set until you pick one, and nothing about playback changes.

• A + above the layer rows adds a layer over the selected one, and so does Shift+N; the rows are taller, so a name reads at scale 1.

• A padlock beside the eye on every layer row locks the layer: the pencil, the eraser, the shapes, the fill, a drag of the selection, Delete, cut, paste, flip and the quarter turns leave it alone and the status line says Locked: and its name. The picker, copy and selecting still work, and All layers moves round a locked layer. Locked is on the row’s menu too. The lock saves with the document, an Aseprite export carries it in the file, and it’s not an undo step, so undo never unlocks a layer. Older documents open unlocked.

• Sounds, songs and palettes can be built and changed from a script at run time, not only in the dock.

• A document built into a scene is editable in the dock and saves where it lives, rather than only a document on disk.

• ChiptuneSongPlayer carries loop and one-shot, and a looped song wraps without a gap.

• LICENSE at the root, MIT, and it ships inside the zip beside plugin.cfg.

• Generate loop gives a different loop each press, not the same tune in a new key: every feel draws from several lead rhythms, one per pattern so the B pattern turns, several kick-and-snare patterns, and a rest chance that varies by song. The same seed still gives the same song.

• Generate loop, on the Tracker’s bar and in the Song menu, gives each seed its own melody shape, bass and chord style and instruments, where a feel’s loops shared one of each. Sad is slower, lower and minor, told from Calm; Big is an anthem, with a power-chord shimmer, a pumping bass and a fill into the turn.

• Every menu item that opens a window, like Open, Export, Preferences, Help or About, has a small window icon beside it, and so do the buttons that open one: Choose in the export and import dialog, Duplicate on the Theme page, and Credits in About. No menu item ends in “…” any more, and one that opens a field in place, like Hold or Opacity, has no icon. The Pixel tab’s grid dialog is Grid settings in the View menu, so it isn’t mistaken for the Grid toggle above it.

• ChiptuneSongPlayer.jump_to_row(order_index, row) moves the music to a row of a pattern at the next buffer, and pattern_row() says which row of its pattern you are hearing, so a game can step the music note to note. A row past the end of its pattern goes on into the next one.

• ChiptuneSongPlayer no longer renders its song when the scene loads. It plays it as it goes, so a scene with music opens without the stall: the example game’s scene takes 0.3 s to load where it took 3. A game can change the music while it plays, and the song file is never written: set_channel_muted, set_channel_solo and set_channel_volume from the next buffer, without a click; tempo, transpose and set_instrument from the next pattern; and jump_to_pattern at the next bar line. position_rows(), position_bar() and pattern_index() say where the music is, and the beat, bar and looped signals fire as you hear them. A song saved in the dock reaches a playing music node at its next pattern, with no render and no restart. seek() and play(from) do not move the music; jump_to_pattern does.

• On a phone, the web app opens the editor, laid out for the phone’s width.

• Every dialog fits a phone’s screen. Where it’s narrower than a dialog wants, each label goes above its field and long sentences wrap. Preferences lists its sections in a drop-down above the page, as the manual does.

• In a side dock or on a phone, the editor buttons sit in a row along the bottom, which leaves each editor the dock’s whole width. A wide dock keeps them down the left.

• There, the Pixel tab starts with the frames folded away so the canvas gets the height. Tap the arrow to open them, and widen the dock to get back how you had them.

• The same narrow layout folds each editor’s menus into one button with three bars beside the document’s name, and the row at the top stays one line. The keys are unchanged, and a wide dock shows the menus as before.

• The Tracker’s rack starts folded there too, leaving the grid more rows, and Rows, the feel and Generate move from the bar to a section at the top of the rack. The SFX tab’s sliders take up to two thirds of the height, so Shape and Envelope show whole.

• The first run’s three screens now fill the whole dock, so there’s nothing to close by accident: it stays on the question until you press Start or Skip, and asks again next time if you quit first. Choose editors on the JamChip menu runs it again.

• The first time you open JamChip it asks what you’re here for (art, sound or both) and shows only those editors, with the leftmost open. The last screen says where Help and Preferences > Editors are, and how to run it again. Skip keeps all five. Choose editors on the JamChip menu asks again.

• PixelPalette has its own API page: a palette’s name, its colours, mapping_to and load_palette, with examples.

• A new Pixel document opens on the project’s palette: the file the project setting jamchip/pixel/default_palette names, else the one your preferences name under pixel/default_palette, else the palette shipped with the addon. Save palette as project default in the Palette rack asks where in the project to put the swatches, saves them there and points the setting at the file, so nothing is written inside addons/jamchip/ and an upgrade cannot take your palette with it.

• The Pixel colour picker is the wheel, the sliders and the hex field. Its own preset and recent rows are gone; the rack’s swatches and its Recent list are where colour lives.

• The Palette section edits the palette. A wheel and a hex field under the swatches edit the selected swatch, a swatch drags to another place, and the menu sorts by hue or by brightness. Every palette edit is a step on the tab’s undo, in Pixel, Tiles and Font.

• Import palette takes a Lospec .hex file as well as a .gpl.

• Saving over a palette the project’s style links asks first, naming the style and how many sprites, tilesets and fonts use the palette, and keeps the style’s palettes the same length.

• Export palette, in the palette’s menu, writes the swatches as a GIMP .gpl, a .hex or a PNG with one pixel per colour. In the web app the file goes to your downloads.

• In the web app, Import palette opens your device’s file picker, so you can import a .gpl or .hex you downloaded from Lospec.

• A palette file has its own icon in the FileSystem dock.

• A style file’s thumbnail in the FileSystem dock shows its main palette’s colours.

• A palette’s name and colours are read-only in Godot’s inspector, with a line pointing to the Palette section in JamChip, where palettes are edited.

• The palette tab’s Check section shows the selected palette as its lightness alone and as someone who’s green-blind, red-blind or blue-blind (deuteranopia, protanopia, tritanopia) sees it, and puts a dot on any slot that’s hard to tell from another.

• The palette tab’s Columns section adds, removes and moves a slot in every palette at once. Sort by hue or brightness sorts every palette by the selected one, so swaps stay paired slot for slot. Dragging a swatch along a row moves its slot in every palette.

• The palette tab has a Harmony section. Pick a base colour on the wheel and a rule, such as Triad or Complementary, and Add as row makes a new palette with a ramp for each hue and a dark and a light grey.

• The palette tab’s Make a swap section imports a .gpl or .hex file, or a sprite’s colours, as a new palette. With a style chosen it joins the style as a swap, each slot matched to the nearest colour in the main palette.

• The Palette tab’s Generate section: lock the slots you want to keep, and Regenerate gives the rest of the selected palette new hues at random, each as light as before and about as vivid.

• The Palette tab’s Ramp section fills the slots between two you pick, stepped evenly in lightness, colour and hue (OKLCH), with a shift that bends the hue of the colours in between.

• File > New Palette makes a palette of greys as a new row, asking how many colours, and File > New Palette from Main copies the style’s main palette.

• A Palette tab. It shows the style’s palettes one row each, main first, with a column per slot, and says whether each is the main palette or a swap and how many sprites, tilesets and fonts use it. A palette outside the style opens as one row. Click a swatch for its slot and hex.

• Double-click a palette in the FileSystem dock to open it in the Palette tab.

• The Palette tab edits palettes. A rack beside the rows, under them in a narrow dock, has a Slot section with the hex field and the wheel for the selected slot. Each edit is one step for Undo, and sprites wearing the palette follow as you edit. File > Save writes every palette edited, and asks first over a style palette in use. Unsaved edits are autosaved and offered back.

• The tracker’s bar has Grid and Roll. Roll shows the pattern as a piano roll, one channel at a time, time across and pitch down: click a channel’s name in the header to switch. Click to place a note, drag right to make it longer, click a note to select it and its Ins and Vol show in the bar; Delete removes it. It’s the same pattern the grid shows, so Grid after Roll has the note and its note-off, and Ctrl+Z takes it away. With a key set, pitch rows outside it are shaded across the roll and the root rows are lined, and the grid’s band behind an off-key note is stronger.

• Dithering in the Pixel tab. The pencil, the line, the rectangle, the ellipse and the fill paint through a pattern picked from one button on the context bar: Bayer 2×2, 4×4 or 8×8 at a density in the matrix’s own steps, or a tile drawn on the sprite, made from a selection with +. A pattern’s off pixels keep what’s under them, and it is read at each pixel’s place on the canvas, so strokes line up. The Tiles editor paints through the Bayer three.

• sprite paint --dither, the same patterns on the command line: bayer4:8, tile:1 for a sprite’s drawn tile, or a tile’s rows typed in, '#./.#'; and dither among the options of PixelDocument.paint_stroke, paint_shape, paint_polygon and paint_fill.

• Flip and rotate are buttons on the Pixel tab’s bar while the marquee or the lasso is in hand: flip left to right, flip upside down, rotate left, rotate right, each acting on the selection. The Edit menu keeps all four.

• The Pixel tab remembers which of Palette, Tags and Frames you folded and how tall you dragged each one, per project, the way the SFX and Tracker tabs already keep their folds.

• PixelFontFile, a font document as a Godot font. Put it in a Label’s font override and the label changes as you paint a glyph in the dock.

• The Font editor’s File menu has Export Font, a PNG and a plain FontFile beside it as name.fontfile.tres for a game that ships none of JamChip, and Use as Theme Font, a theme beside the font that becomes the project’s when it has none.

• The Font editor, the fourth pin on the rail and Ctrl+4. Draw a pixel font a glyph at a time over its baseline and x-height, see every glyph at once under the stage, set each one’s advance, and type a line under the rack to read it set as you draw. Saves as .font.tres, opens from the recents and the FileSystem dock, and comes back after a crash. examples/art/arcade.font.tres is one to start from.

• The Pixel tab’s grid has a colour. Grid settings moved from the File menu to the View menu, right under Grid, with snap in it as before and a colour well for the lines. The colour is kept for you across documents and isn’t saved with any of them.

• The Pixel tab’s hold bar says its unit, 100ms, beside the number. Frames ▸ Set every hold to this rate writes the constant preview rate into every frame, as one undo, and turns the constant rate off, since the frames now play at it on their own. The undo turns the constant rate back on, at the rate the holds were written from.

• PixelSpriteTexture and PixelSpriteFrames have icons of their own in the editor, where they wore Godot’s plain resource icon.

• The onion skin is under Frames in the Pixel tab, with its range and strength, since it’s for animating. Right-click the onion toggle on the frames lane, or press and hold it on a touchscreen, to pick both without leaving the timeline. View no longer lists them.

• A sprite can hold a reference layer: a rough to draw over, a sketch or a photo of one, under every layer in its own colours and shown faint. Right-click a layer row for Add reference layer and Remove reference layer. No tool paints it, and no export, sheet, .aseprite or node draws it.

• sprite layers DOC --reference FILE [--opacity 0.4] [--at X,Y] [--scale N] adds one from a PNG, JPEG or WebP; --opacity and --at alone change it, and --unreference takes it away. sprite cel --to and sprite board draw it under the artwork with --with-reference.

• In the Pixel tab, comma steps to the previous frame and full stop to the next, wrapping at either end.

• Each of Pixel’s export formats says what it makes in its tooltip.

• A PixelSprite2D flashes for a hit. Tween flash from 1 to 0 and the sprite flashes to swatch flash_swatch and back. The swatch is the palette’s it wears, or its own colours’ with no palette set. There’s no shader to write, and its material is left alone.

• The Pixel tab follows its sprite when something outside it writes the file, the command line from a terminal among them, within a second and with the editor in the background. With no unsaved changes it reloads where you were, the same layer, frame, zoom and selection, and the strip says so; with unsaved changes it asks which copy to keep.

• A Size page in the app’s Preferences: everything drawn at 75% to 200% of its size, in quarters, words, icons and controls together, on top of what the screen asks for. It’s display/ui_scale in user://jamchip/preferences.cfg. Inside Godot the page isn’t there; Editor Settings ▸ Display Scale sizes the dock.

• The Pixel tab, after its UX pass. The rack’s sections wear the theme on every tab, with their buttons in the title bar; the wells sit on a checkered plate with the foreground’s hex beside them, and every swatch shows its hex on hover. Brush size, fill tolerance and a frame’s hold are bars you drag or double-click to type, the hold on the lane’s bar; a layer’s opacity opens over its row. A tag’s direction is four toggles, and its row reads name, range, then how it plays. The frame number and the hold sit under the thumbnail, not over the picture. The grid’s cell, offset and snap are one Grid settings dialog under File, and the grid starts off. Fit is on the bar after the zoom steps; the symmetry toggle turns the mode on as well as off; the add thumb adds a frame straight away and Shift-click adds a copy; layers have a minus beside the plus; Play is coloured only while playing; the lane’s bar folds the timeline. Menu items are sentence case and the layout diagnostic has left the File menu.

• Symmetry is set up from one place in the Pixel tab: View ▸ Symmetry holds the four modes, Centre the axes, and Axes, where you type where each line goes, in half pixels. Each line has a grip at both ends, and the pointer over a line shows that it drags.

• The example game is a platformer, and every asset on it came out of the dock: a player, an enemy and a coin as PixelSprite2D documents, the ground a TileMapLayer on a TileSet the Pixel tab exported from a sheet drawn on a grid, three sounds and a song from the SFX and Tracker tabs. pnpm export runs it headless after the probe.

• The Pixel tab’s Palette section fills the rack: the default sixteen swatches show without a scrollbar, Recent appears only once a colour has been painted, and the pair in the header is two wells the size of the buttons beside it. Layer rows in the lane are twenty-two units tall, up from sixteen.

• The pin rail’s Palette glyph is drawn by hand, the same palette as the palette’s class icon at the rail’s 12 pixels.

• The JamChip menu under the jar lists the last ten documents you opened or saved in this project, newest first. Pick one and its tab opens it; a tab with unsaved work asks first. A file you’ve deleted is off the list the next time the menu opens. The list is per project, in user://jamchip/preferences.cfg.

• A palette changed in game code redraws every sprite wearing it on the next frame: set colors, or a swatch with set_swatch.

• A palette ramps, nudges, takes new hues and sorts itself in game code, ramp_between, nudge_swatches, regenerate and sort_swatches, the same maths as palette ramp, nudge, mutate and edit --sort. PixelPaletteMaths ships with your game, for building a palette from nothing.

• RUNTIME.md has “Palettes in code”, and reading the style from a script with JamChipStyle.current().

• An export ships the runtime alone. With the plugin enabled, exporting a project carries the runtime half of each module, runtime model paint format palettes icons from pixel and runtime model synth format icons from chiptune, and the kit scripts they open, and leaves the dock, the editors, the glyphs, the fonts and the suites behind, with nothing to set in the preset. The README’s Install section shows the exclude_filter a preset would carry to say the same.

• jamchip.com/.well-known/security.txt says where to report a security flaw: hello@jamchip.com. app.jamchip.com points to the same file.

• Save As in all five editors, under Save in the File menu and on Ctrl+Shift+S. It always asks where, and the tab then holds the new file; the first file, and any scene using it, stays as it was, and undo carries on. A document built into a scene gets a file of its own this way, and the scene uses that file once saved.

• The SFX and Tracker File menus show Ctrl+S beside Save, as the Pixel, Tiles and Font menus do.

• One sound plays many ways on ChiptuneSfxPlayer and ChiptuneSfxPlayer2D, without a render per shot. play_at(pitch) plays at a MIDI note; pitch_variance moves each play up to that many semitones; variants renders that many variations on the sound once and each play takes the next, with seed picking which. unique, on those two and on ChiptuneSongPlayer, gives a node its own copy of its document, so an edit to it is heard on that node alone; the scene still stores the file.

• Each section of the SFX rack, Shape, Envelope and Motion, has a roll in its title bar that draws new values for that section alone from the action in the picker, and one Ctrl+Z puts them back. Every value in the rack now reads one way, with the nought before a fraction and as many decimals as the row’s step: 0.33, 0.25s, 93.

• The SFX tab explains itself. Every rack row answers a hover with its own sentence, “60 is middle C” among them, over the drag line, and the stage says what Generate does. The strip carries a status line that says a save, an export or a refusal, and an Edit menu with Undo and Redo. The context bar keeps Play, Stop and Loop on one row when the dock is narrow, has no word before either picker, and a separator before Random; the arpeggio’s Steps field is a Custom… chip that opens a row of step spins, eight at most, each two octaves either side; narrow, the stage takes the larger share, and Motion starts folded.

• The example game’s cave is a level of its own and looks like one: a dark sky of stalactites and a bank of rock, each a document you can open in the dock, over a stone floor, a pit of spikes to jump with a coin over it, and two more coins in the pool.

• The example game opens on a village: signs in the pixel font, a notice that names the document to draw on while the game runs, two villagers on one document with the second in a palette of its own, and a sky and houses, each a document in the dock. The meadow, the workshop and the cave open off it by doors, in any order. Each gives you a key on the way out, and the castle’s gate opens once you have all three.

• The example game’s meadow is a level of its own: a sky and hills drawn in the dock behind the grass, flowers that sway, a ledge with a run of coins along it, and two slimes that keep clear of the exit.

• The example game’s walk, room by room from the village on, is a guide page of its own, EXAMPLE-GAME.md, beside RUNTIME.md.

• The example game has a workshop, a level built around sound. A press stamps in time with its own frames, with a clank that pans as you pass and a dash under it for a coin. Five organ pipes play one sound up a scale as you walk through them. Steam hisses on a loop, and the song comes in a part at a time as you go. Its wall, bench, press and pipe are each a document you can open in the dock. The castle’s gate takes a key from each of the three rooms.

• The Font tab’s File > Import makes a new font from a PNG sheet, one cell per character you type, or from a TTF or OTF. Characters the file lacks come in empty; if it can’t read the file, the log says why.

• In the browser, Import on the Pixel, Tiles and Font tabs picks the file from your disk.

• The Tiles rack’s terrain grid draws the tile in hand in its middle, with each matching neighbour lit in the accent, and a loose tile picks its terrain from the ones the sheet names.

• The Tiles lane’s New Tile adds the cell you last clicked on the sheet, and says so when there is none.

• The Tiles rack reads like the Pixel rack: Data’s + sits in its title bar, the collision row is one line, Solid, Clear, Points and the count, and a data value shows as it was typed, its type on hover. Text that starts with a number, 3 coins, stays text.

• The example tileset has a terrain, earth: sixteen tiles, one for each way its corners can be filled. Paint it from the Terrains tab of Godot’s tile editor; each tile’s solid about where it’s drawn.

• The site has a command line page: how to run it headless, each palette and style command with an example, --json, the exit codes, and style check in a CI job.

• Until the free launch, every call to action on the site is Try it early, the waitlist at /join/. The bar, the home page, Overview, Download and Releases carry no zip and no link to the web build.

• The site uses the plugin’s colours and fonts: both themes come from the same palette the dock uses, headings and buttons are Pixelify Sans, code is VT323, and the site serves both itself. The landing page says who JamChip is for, what it does, what it costs and how to install it.

• The site’s Overview and tabs page cover Font, with a picture of it, and Home and About name fonts among what JamChip makes now.

• A new look for Home and About on the site. Home opens on the jar and the name over a shorter line, the cast walks the full width of the page under it, and each part sits in its own panel. About opens on the jar over the name, then each part in its own panel under a label.

• The site shows the three tabs in both themes, rendered by script from the tree, and gains a releases page, a showcase, about and support.

• The site has a page for the Project pin, beside the tabs: what a style is, the presets and No Limits, and how to pick one, in Godot or the app.

• About answers how JamChip was built, in a section that opens on a click.

• A Saving page in Preferences: how many seconds between copies of unsaved work to the recovery file, thirty unless you change it, five at the least, the same for all three tabs. The timers take it as soon as it’s changed. It’s saving/autosave_interval in user://jamchip/preferences.cfg.

• ChiptuneSongPlayer2D, a song from a place on screen: the Tracker’s music on an AudioStreamPlayer2D, panned and quieter with distance, with everything ChiptuneSongPlayer has, from loop and the beat signals to jump_to_pattern, the channel mixer and set_instrument.

• A sound or music node follows its document. Set pitch on a sound or bpm on a song, turn a knob on an instrument or mute a channel on the mixer, and the node renders again on the next frame, once however many fields changed, carrying on from where it was if it was playing. rebuild() renders in the same frame, and document_changed on the stream and the players says the new audio is in. A save in the dock hands every node on the file the saved document, so its document reads what was saved, and a playing song starts again on the nearest bar.

• A style’s sound palette, its shared set of instruments, now reaches the songs and sounds that use it. Saving an edit to one of its instruments changes it in every song and sound on the palette, with a warning that counts them before the first save.

• The SFX tab’s Edit menu has an Instrument submenu: pick one of the sound palette’s instruments, keep the sound’s own, or save it to the palette. The Tracker’s instruments menu can use the sound palette for a song, or detach an instrument from it.

• A song set to play once exports once, and the Tracker’s Loop button starts on the song’s own setting.

• On a sound from the sound palette, Generate, Nudge and a roll of the Motion section keep the instrument and hold the new motion apart, and so does a motion slider moved by hand. A roll of the wave, duty or envelope asks first: this sound alone, or a new instrument on the palette.

• Generate Loop and Generate Kit play each part on the sound palette’s instrument for it, by its role and then its wave, and start in the style’s home key. A new song starts on the sound palette in the home key. An instrument on a wave the style leaves out moves inside it and leaves the palette.

• The Tracker’s instruments menu has Add a tune from the style: one of the style’s motifs, its short tunes, written at the cursor in the song’s own key and scale, in one undo step. A generated loop may open on one.

• A sprite, tileset or font opens on one of the style’s palettes, the first for a new one. Under the swatches is a strip for each of the style’s palettes and Custom: click a strip’s dot to switch, and the drawing changes to its colours as one undo step; hold a strip to see the drawing in it without changing anything.

• Editing a swatch edits the palette, and the drawing follows; reordering moves no pixel. When other sprites, tilesets or fonts use the palette, the first edit asks whether to change it for all of them, recoloured when you save, or to make this one’s colours Custom.

• Custom colours can be added to the style as a new palette or saved over one of its palettes.

• A PixelSprite2D says what it is doing. document_changed fires when a rebuild lands, whatever caused it, and PixelSpriteTexture and PixelSpriteFrames have it too; tag_finished(tag) fires when a tag ends, once a loop for one that loops; frame_event(name) fires when the animation shows a frame with a marker on it. Markers are added and removed from a frame’s right-click in the frames lane, and a marked frame carries a dot. play_then("attack", "idle") and queue(tag) play tags in order with no handler. A node takes a palette of its own and set_layer_visible(name, on) per layer, so two enemies on one document wear two palettes and one hides its helmet, and the document is not touched; palette_changed(palette) fires when a node’s palette is swapped. The example game plays its landing sound from a marker, wears a palette on its second slime, and shows the lantern as a layer on the player.

• A new song opens on the project style’s channel count, and a new sound or a new song’s instruments on waves its chip allows; both waveform pickers offer only those. A song or sound outside the chip opens with a note on the status line and keeps what it was written with.

• Tiles and Font open a new tileset or font on the style’s grid as its cell, and New offers it. One on another cell, or painted outside the style’s palettes, opens with a note and still saves.

• A project with no style is asked for one, once, when the dock first opens on it: the Project page’s preset cards, or Skip. On your first run it comes before the editors’ question.

• New after the presets on the Project pin, and on the first run’s style screen, saves a style of your own on the palette you have.

• The style your project uses has its name, sprite size, grid, channels and waves as fields on the Project pin, saved as you change them.

• In Godot’s inspector the style your project uses has Open in JamChip in place of those rows, and double-clicking its file opens the Project pin.

• No Limits saves no file: picking it sets the project to a blank style with no limits.

• A .jcstyle in the FileSystem dock, and JamChipStyle wherever Godot shows a class, wears the JamChip jar on Godot’s 16 px box, scaling with the editor, where it wore four squares.

• The style’s card on the Project pin has Add palette. New from the main palette copies it as a new swap palette beside the style, and Link a file adds a palette file you have. Every palette in a style has as many colours as the main one.

• Edit palette beside the main palette, and Edit beside each swap, open that one in the Palette tab, or in Pixel’s palette editor when the Palette tab is off.

• Remove beside a swap takes it off the style and leaves its file.

• The colour well in the Palette section is marked in its corner while the colour in hand isn’t in the project’s style, and its tooltip says so.

• Use the style’s colours shows the sprite before and after, each colour moved to the nearest one in the style, and changes nothing until you press Apply.

• Show in, under the palette’s swatches: see the sprite in another of the style’s palettes. The drawing doesn’t change.

• A sprite opened outside the style’s palette offers Use the style’s colours beside the note: each swatch becomes the style’s swatch in the same place, in the drawing too, as one undo step.

• A project can choose a style, a .jcstyle the project setting jamchip/style names: a palette, a grid and a sprite size. New sprites open at its size and grid, and new sprites, tilesets and fonts on its palette. A sprite with colours outside its palette opens with a note and still saves. A project with no style keeps the palette and sizes it had.

• The jar at the top of the pin rail is the Project pin, Ctrl+0, and fills the dock with the project page: the style in use, its palette, sizes and sound chip, Edit palette and Load palette, the presets as cards, and your recent documents. Use on a card copies JamChip, Four Shades, Ink or No Limits into the project and makes it the project’s style.

• A style is a .jcstyle, a small JSON file you can read and edit by hand, and Godot imports it as it does a .jcpalette. The command line’s style verbs write one too.

• The Project pin’s style card reads like a preset’s: the style’s name, its swatches filling the width, one line of colours, sprite size, grid and channels, the waves, its file, and Edit palette and Load palette inside it. The preset the project uses says In use.

• Use on a preset you’ve used before picks up the copy you already have.

• The ≡ on the Project pin has Choose a style, which asks the first run’s style question again.

• A style file has an icon of its own in the FileSystem dock.

• JamChip’s project settings sit together under one Jamchip section and show with Advanced Settings off.

• Every value bar takes the keyboard: Tab reaches it, the arrows nudge it a step, and Shift with an arrow a tenth of its travel.

• The SFX and Tracker tabs are reachable from the keyboard: Tab walks their pickers, buttons, chips and racks in order, as on Pixel, and the rail’s jar and pins lead the chain.

• Outside the editor, the menus hold only what an app can do: no Add to Scene, no README item, no Help under the jar, no Editor theme or Show Folder in Preferences. Inside the editor nothing moves. Every rack scrolls under a finger where a touchscreen is present, through JamChipTouch, which an app asks for and the plugin never does; a drag that starts on a slider and goes up or down scrolls and puts the slider back. The glyphs are kept files the kit rasterises at the scale they are seen at, the editor’s inside it and the window’s content scale outside, so they are sharp on a tablet and unchanged on a desktop.

• Preferences has an Editors page: untick the editors you don’t use and they lose their pin and their key, in every project. Opening one of their files still opens them until you restart. The dock opens faster with fewer editors: Pixel alone builds in about 420 ms where all four take about 760.

• A Pixel tag plays forwards, in reverse, ping-pong or ping-pong reverse, for ever or a number of times, and has a colour. The rack row is where a tag is edited: the selected row opens into its name, range, direction, Loops, repeat and colour, and the popover is gone. The exported SpriteFrames and the live one hold the expanded frames, so play("hop") ping-pongs without the game knowing; Play in the lane does the same. An Aseprite import keeps direction, repeat and colour, and an export writes them. Old documents read unchanged.

• /terms/ covers what the short page left out: who’s old enough, what gets a tester or a waitlist row removed, that the site and the app come as is, what we’re liable for, how a change is announced, and which law applies. It has a “last changed” date.

• /terms/, one short page: who can use JamChip before the free launch, the plugin’s licence, and that nothing is paid for until 1.0.

• Duplicate on the Theme page copies a theme under a name you give it and opens it on the Edit Theme page: eight swatches, surface, surface_alt, lane, accent, playhead, ok, warning and danger, the rest worked out from them. Each change is saved as you make it and the dock follows when it’s the theme in use. A swatch under the contrast floor says so beside itself, and the Theme page greys the theme with the same words in its tooltip until it’s fixed. Edit on a theme file’s row reopens it. The editor writes only its eight keys, so a role set in a text editor stays.

• The Tiles editor, a fourth pin on the rail and Ctrl+4. Draw the sheet with the Pixel tab’s tools and each cell drawn in joins the lane of tiles; the rack names the tile in hand, makes it solid with Fill cell, and holds its custom data and terrain. A scratch map beside the sheet is painted with the tile in hand, and a seam fixed on the sheet shows on the map. New, Open, Save, Resize Scratch and the grid’s size and offset are in the strip’s menus; a .tiles.tres opens from the FileSystem, from the jar’s recents and by double-click, and has a thumbnail there. Nothing reaches a game yet.

• A tileset is a document of its own, .tiles.tres, and the plugin reads and writes one. It holds a sheet drawn as pixels at a tile grid, the tiles declared on it with a name, collision, custom data and a terrain, and a scratch map to try them on; drawing into an undeclared cell declares that tile, and erasing the cell blank keeps it, since a name may be on it. The Tiles editor below is what opens it.

• The Tiles and Font editors wear the Pixel tab’s strip: the title in the accent, and the document chip with its unsaved seed, sized the same way.

• Help on the Tiles and Font editors opens the manual at “Drawing a tileset” and “Drawing a font”, and Keyboard shortcuts, or F1, lists the editor’s keys, C and P among the Tiles editor’s.

• The Font editor says what Export and Use as Theme Font did on its strip.

• File > Import in the Tiles tab makes a tileset from a PNG, a Godot TileSet or an Aseprite file. A PNG asks for the tile size, offset and spacing. A TileSet brings its first atlas with each tile’s collision, custom data and terrain. An Aseprite file brings its first tileset, and its tilemap and image layers are skipped with a line in the Output panel.

• A tile’s collision is drawn on the sheet. Edit beside Fill cell on the rack turns the stage over to the tile in hand’s points: drag one, click an edge to add one, right-click one to remove it, or click in an empty cell to lay a shape a point at a time. Points sit on pixel corners inside the cell, and each press is one undo.

• The Tiles editor keeps a recovery slot like the other three tabs: a killed editor offers the tileset back in the one recovery dialog. A save is sent down the live path to a running game, which holds no tileset until the runtime nodes land, and a .tiles.tres changed outside the editor is followed by a clean tab and asked about by an edited one. examples/art/ground.tiles.tres is the example tileset.

• Hold C on the Tiles tab to move, add and remove collision points the way Edit on the rack does; let go and the tools are back.

• The Tiles editor shows the sheet and the scratch side by side when it is wide, so a tile drawn on the sheet is seen repeating on the map as it is drawn; in a narrow dock the two are tabs over the stage. Where a stroke starts decides what it does: on the sheet it paints, on the scratch it places or, on Paint, draws through into the tile under it. Place | Paint is first on the bar.

• The Tiles sheet outlines each terrain with its name and how many of its slots are drawn; click a dashed slot to make it a tile again, or a terrain’s name and then − to remove the terrain. The lane folds and grows like the Pixel tab’s, and shows every tile as a square with its name under it. Point at − to see what it will remove.

• The Tiles sheet has the Pixel tab’s Marquee, Lasso and Wand, with Cut, Copy, Paste, Delete, Select all and Deselect in Edit. Selections work on the sheet only. Drag or paste a selection into a blank cell and the cell becomes a tile; a cell left blank loses its tile. One undo takes the move back.

• The Tiles editor’s Edit menu makes a new tile from the tile in hand: Duplicate, Flipped horizontal or vertical, Rotated left or right. The new tile goes in the first blank cell outside the terrains and keeps the name, collision, data and neighbours, flipped or rotated to match.

• Wrap-shift tile moves the tile in hand half a cell each way, so its edges meet in the middle where a seam is easy to fix. Do it again to put them back.

• Each blank cell round the tile in hand shows, dimmed, the edge of the tile that would meet it if it repeated, and follows every stroke.

• A PixelTileSet says so in the Output panel, once, when a tile is added or changed in Godot’s TileSet editor, since the tileset holds the tiles and that change doesn’t last. File > Export TileSet... in the Tiles tab writes the sheet as a PNG and a .tileset.tres with every tile’s collision, data and terrain on it. The example game’s ground is a PixelTileMapLayer over examples/art/ground.tiles.tres; the old tiles.pixel.tres and tiles.tileset.tres are gone.

• PixelTileMapLayer, a node for the ground of a level: give it a .tiles.tres and paint with Godot’s tile editor. PixelTileSet is the same set for a TileMapLayer you already have. Each tile brings its art, its collision on physics layer 0, its custom data by key and its terrain, and all of it follows the tileset as you draw, in the editor and in a running game when you save. A collision mask set on the physics layer is kept.

• The Tiles editor makes a set. With the scratch showing, Place | Paint on the bar, or P, lets the sheet’s tools draw through the map into the tiles under it, so a seam is fixed where it shows, in one stroke and one undo. New Terrain under the lane’s + lays out a terrain as 16 corners or 47 blob, the second on Godot 3’s “3x3 minimal” template, with every slot declared and its neighbours set; the rack shows a slot’s terrain and keeps its neighbours read-only. The lane groups the set by terrain, each a grid of its slots with the empty ones still to draw and a count of those drawn, and the tiles in no terrain follow, loose, with no coordinates under them.

• The site’s Overview and tabs page cover Tiles, with a picture of it, and the install steps name all five pins.

• A Pixel tile sheet exports as a PNG with a Godot TileSet beside it, from File > Export TileSet...: one atlas tile per grid cell that has a pixel in it, cut from the document’s grid, and a re-export keeps the collision and custom data a game added to the tiles still drawn. View > Snap to grid makes the marquee, a move and a paste land on the cells.

• A feel picker and Generate on the Tracker tab’s bar, beside Grid and Roll, the way the SFX tab has its action and Generate. Generate writes a new loop in the feel in place of the song, the same as Song ▸ Generate loop, and one undo takes it back.

• On the Tracker’s roll the rows outside the key are two shades darker, and an empty channel opens on the key’s root, or on middle C with no key, rather than on the keyboard’s octave, which the roll hides. The rack’s Key section is titled Key and scale, and in a wide dock Roll on a song with no key opens it.

• The Tracker’s BPM and a roll note’s Vol are value bars, dragged, stepped by the wheel or the arrows, or double-clicked to type, one undo step a drag. Rows, Oct, Step and Ins stay spins, and so do the Saving page’s seconds, all built one way.

• On the Tracker’s roll, drag a note up or down to change its pitch, in one undo step. Its end still stretches it, and a one-row note goes whichever way you drag first.

• The Tracker’s header names each channel’s columns, note ins vol, under its name, with the plain word for ins and vol on hover, and a note left at the default volume reads as the 64 it plays at, dim, so -- in the volume column means no note, or a note-off, with no volume typed.

• The Tracker’s roll has a ruler under the channel names, with the row number at every beat. Roll opens on the row the grid’s cursor was on and lights it on the ruler, and the channel names sit over the notes.

• The Tracker’s strip says the last thing that happened at its right end, the way the SFX tab’s does: what it saved or exported, what couldn’t be done, what’s playing, or that there’s nothing to play. Editing the song doesn’t clear it; opening another song does. In a narrow dock it’s off the strip, as on the Pixel tab.

• On the Tracker, a new song’s empty grid says what to do first: generate a loop, or type notes with Z to M. It goes at the first note.

• On the Tracker’s grid, drag from a cell to select a block, whole cells, as Shift with the arrows does; the Edit menu copies, cuts and deletes it. A click without a drag still drops the selection.

• On the Tracker, a knob turned, a wave or an arpeggio picked in the Instruments section is heard: one note of the instrument, the cursor’s when it is that instrument’s note, else middle C. A drag plays a note at a time and ends on the value it lands on. While the music plays, an instrument it already sounds adds no note.

• On the Tracker, Space plays and stops the pattern on screen from anywhere on the tab, the grid included, and stops the song too. Shift+Space plays the song from the cursor’s row, even over a playing pattern, and stops a playing song. Both are listed under Help ▸ Keyboard shortcuts. In the grid Space no longer steps a row; Down does.

• On the Tracker’s mixer, right-click a channel’s pad to solo it, or Alt+click (Option+click on a Mac), or touch and hold it on a phone or tablet: only soloed channels play, and its pad gets a ring. Do the same again to end the solo. A solo isn’t saved with the song and isn’t an undo step.

• Vary (Edit menu, Ctrl+Right) changes the selected notes a little and keeps them in key. Vary into a new pattern, on a pattern’s menu, plays a varied copy right after it.

• Space plays the animation in the Pixel tab and plays the sound in the SFX tab. It works after a click on a frame or on Generate too. A text field keeps its spaces, and a button you reached with Tab still presses on Space.

• One plugin: the two addons merged into one dock with Pixel, SFX and Tracker as sibling tabs on a pin rail, under the name JamChip.

• Pixel: layers, frames, onion skin, palette, animation tags shaped as Aseprite’s frame tags, and its own undo history.

• SFX: a sound-effect generator over the shared synth.

• Tracker: a pattern tracker over the same synth, with selection, copy, paste and transpose, and an Edit menu naming every key.

• View and Frames menus on the Pixel strip; tags moved to the rack and the grid gained a size.

• Autosave and recovery for the Pixel tab, so a killed editor comes back with the drawing.

• Every tab opens on an untitled document, with each stage’s hint as its tooltip.

• Import and export: Aseprite both ways, spritesheet slicing on import, GIMP .gpl palettes, PNG and SpriteFrames out, .wav out of both audio tabs.

• Runtime nodes and resources that need no dock and no enabled plugin: PixelSprite2D, ChiptuneSfxPlayer, ChiptuneSfxPlayer2D, ChiptuneSongPlayer, ChiptuneSongPlayer2D, PixelSpriteTexture, PixelSpriteFrames, ChiptuneAudioStream.

• JamChip: Copy Diagnostics, which puts plugin and engine versions, platform, what the tabs held and the last recorded failures on the clipboard.

• A theme token layer with the roles held to a WCAG ratio by the suite, and the plugin’s own icon set.

• The web app chooses a style: each card on the Project pin’s page has a Use that saves the style in the browser with no dialog, the first run asks once, new sprites open inside it, a sprite outside it says so, and a reload keeps it.

• Help ▸ README on each tab and Help on the JamChip menu open the manual in a dialog inside the panel, with the README’s sections down the left, on every platform; they opened the file on disk and were hidden outside the editor.

• In the web build, each tab’s File menu carries Download and Open from Disk after Save, and a refresh brings each tab back on its last document. The page is Godot’s loading page with its progress bar, which gives way to “Tap to start”; a refresh or a closed tab with unsaved work asks first.

• The companion has a Web preset. pnpm --filter companion export web exports the three tabs to apps/companion/build/web/, packs the wasm under the Worker’s asset cap, and runs the build check and the browser’s own inside the build in a headless Chrome: a document of each kind is saved to the browser’s storage, survives the tab being closed, downloads through JavaScriptBridge and opens back from a file input or from ?open= on the link. A Worker of its own serves it, .github/workflows/companion.yml deploys it on every merge. Nothing in the plugin changed for it.

Changed

• The sound nodes are named for the document they play. ChiptunePlayer is now ChiptuneSfxPlayer and ChiptunePlayer2D is now ChiptuneSfxPlayer2D, both for a .sfx.tres; ChiptuneMusicPlayer is now ChiptuneSongPlayer, for a .music.tres.

• A new jar: a chip with a face, holding a jar of jam. It’s on the dock tab, in About, and on the site’s favicon, header and link card. The word beside it has a shade and an outline now.

• song create makes a song on every channel your style has, where it started on four, the Tracker’s New; --channels N still asks for fewer, and its answer says the count it chose, “5 channels, the style’s” or “3 channels of the style’s 5”. The tab’s New still starts on four.

• A song’s text, what song show prints and --from-text reads, carries the echo: an echo line, none or its settings in pairs, rows 3 feedback 0.3 damp 0.3 level 0.35; a sends line, each channel’s send to it, 0 to 1; and an echo line in each instrument’s block for its own. What show prints reads back as the same song, and song show --json has echo, sends and each instrument’s echo.

• The song and sound commands read and write a song or sound with its own instruments anywhere on disk, a scratch folder for one render among them, as they already did a travelling sprite: song create --from-text, --generate, --jingle or --custom, song show, song pattern, song order, song edit, song instruments and song export, and every sfx command. A song or sound on your style’s sound palette still stays in the project, since the palette is a file there, and the refusal now says so, naming the palette and the way to a copy of its own.

• style create and style edit take the style’s sound: --instruments SET.instruments.tres makes a set your sound palette, --home-key G:major sets the key new songs start in, and --motif "Bubble=0,0,2;2,2,2;6,4,2,1" adds a tune any song can quote in its own key, each note a row, a step up the scale, a length and an alter, with @N for its rows per beat; a motif named again is replaced, and NAME=none, --home-key none and --instruments none take each off. style show prints the sound palette, the home key, the motifs, the mix, the loudness target and the spaces, and --json carries instruments, keys, motifs, mix, loudness and effects.

• The terms now list what changed on the page itself, under the date.

• ChiptuneSfx.mutate() is ChiptuneSfx.nudge(), the SFX tab’s word for it, with no alias. The arguments are the same.

• A font opens on its first drawn glyph, not the space.

• An empty glyph’s box is dashed, and every box sits on the stage’s checker, so a light font reads on the light theme.

• The character set as text is folded under the glyph in the rack, as Characters.

• Grid and Guides in the Font editor’s View menu no longer show a check mark. The toggles on the bar show whether each is on.

• A TTF import puts the baseline where every glyph’s ink fits in the cell when the face’s ascent would cut some and the cell has room.

• Palettes are now .jcpalette files: a name and a list of exact colours, as plain data that any engine or script can read. Godot imports them like any other resource, and your exported game ships the import. The example palettes and the default palette are .jcpalette files now, and the command line reads and writes them.

• An older .palette.tres still opens. Saving over one keeps its .palette.json beside it, and an export leaves that record behind.

• The style’s mix is in decibels. A style saved before this opens with its levels turned into decibels.

• The jar on the pin rail opens the JamChip menu: Preferences, Help, About JamChip. Preferences is a window with one page so far, Theme. About leaves the three Help menus; they keep their shortcuts and README.

• The inspector shows what a person authors and hides what a hand edit would break, on every document and node.

• A one-frame animation tag does not loop, and the Pixel tab says which tags do.

• addons/jamchip/README.md states the licence and the Godot version the plugin is tested against.

• The built-in palette is JamChip’s own: twenty-four colours in five ramps, dark to light, plum neutrals, reds, warms, greens and blues, where it held eighteen stand-ins. The example art, the ground tiles and the arcade font are drawn in it.

• Palette sits second on the pin rail, right after Pixel, where it was last; SFX, Tracker, Font and Tiles each move down a key.

• The palette tab’s swatches are larger, and the edge between the rows and the sections beside them drags.

• The colour picker for the colour in hand sits at the end of the well’s row, no longer on a row of its own.

• Every button that opens a file in JamChip reads Open in JamChip and wears the icon of the tab it opens in: a sprite’s in the inspector, a sound’s, the chosen style’s, and the FileSystem dock’s menu entry. A palette in the inspector gets the button too, in place of the line that said where palettes are edited.

• The Palette section in Pixel, Tiles and Font has one colour row at the top: the colour you’re painting with, its hex and the wheel. With a swatch selected, the row edits that swatch.

• + and − sit after the last swatch instead of in the section’s title bar.

• One grip, between Palette and Tags, sizes the palette. Tags has no grip of its own.

• The wheel fits the narrowest dock and the web app on a phone. It’s smaller, and where the row of colour modes doesn’t fit, it folds behind Colour modes.

• A style with more than three palettes shows the first three and the one in use, and a button shows the rest.

• The eyedropper selects the swatch of the colour it picks.

• The Pixel guide’s Palette section is shorter: the controls first, then a new sprite’s palette, saving, and import and export, each in a few lines.

• The palette property on PixelSprite2D, PixelSpriteTexture and PixelSpriteFrames says plainly what it does: draws the sprite in another palette’s colours, swatch for swatch, without changing the file.

• The built-in palette is a placeholder of our own until the finished palette lands. Each of its sixteen swatches keeps the role of the one it replaces, and the example art is recoloured in it. Sprites you’ve already made keep their colours, and a palette you’ve saved as the project default is untouched.

• A PixelSprite2D draws crisp by default: its Texture ▸ Filter is Nearest. One in a scene you already have that left the filter alone turns sharp the next time it loads; one you set to Linear stays Linear.

• The Pixel, Tiles and Font editors paint with one colour. The right button erases with the pencil, the fill, the line and the shapes, and the picker and Alt pick only with the left. A right-click on a swatch picks nothing, X no longer swaps, and the rack’s pair is one well with its hex.

• On a touchscreen, a finger held still on the canvas does nothing, where it painted one pixel in a second colour.

• Tiles moves to the fifth pin and Ctrl+5, and a narrow dock’s floor is 180 tall so all five pins fit on the rail.

• PixelSprite2D’s and PixelPalette’s icons are drawn on Godot’s 16 px box, where they were 12 px, and follow the editor’s light theme; PixelSprite2D’s is in the blue of Godot’s 2D nodes.

• A .jcsprite may hold a reference: its picture as an RGBA blob, with its place and opacity, in the project’s blobs/ or inside a sprite that travels.

• The Pixel tab’s canvas size is a budget that warns instead of a wall. Past 262,144 pixels, New and Resize turn amber, say fills and frame changes may lag, and still make the canvas; a PNG opens at its own size instead of being shrunk, and an Aseprite file or a spritesheet past it comes in, each with a note on the strip. The one refusal left is a canvas past 4096×4096, whose single cel would not fit the cel memory. PixelDocument.MAX_PIXELS is now BUDGET_PIXELS, MAX_AXIS is 16384, and PixelDocument.size_verdict says which of the three a size is.

• Every editor has a pin from the first start: Pixel, Palette, SFX, Tracker, Font and Tiles. Hide the ones you don’t use under Preferences ▸ Editors.

• A fresh install’s first start asks what you’re here for, art, sound or both, and shows the editors you pick.

• Saving a file named with a plain .tres, typed or added by the save dialog, gives it the editor’s own ending on every tab: blip.tres saves as blip.sfx.tres in SFX, notes.tres as notes.music.tres in the Tracker, and the same in Pixel, Tiles and Font. SFX and the Tracker used to keep a plain .tres as it was.

• The SFX tab’s Mutate button is called Nudge: it changes every value of the sound a little and keeps its action and wave.

• The SFX tab’s picker holds ten actions, Tick, Confirm, Deny, Pickup, Jump, Hit, Boom, Swell, Warn and Drop, then Random, in place of the seven actions it began with. An action sets the shape of a sound, which way the pitch goes, the envelope, the arpeggio, the length, and Generate rolls its character, so ten Jumps are ten different waves and pitches that all jump. The six feels, Bright, Calm, Tense, Sad, Fast and Big, are the tracker’s: the loop, the kit and the rack’s Generated instruments use them, through ChiptuneSfx.generate_feel. ChiptuneSfx.FEELS is gone and the one list is ChiptuneSongGenerator.FEELS. Old .sfx.tres files open and play as they did, ChiptuneSfx.generate still answers a feel’s name, and an unknown word gives Tick. The example sounds are rolled again from an action each.

• ChiptuneAudioStream.render_document() is now rebuild(), with no alias.

• A ChiptuneSongPlayer or ChiptuneSongPlayer2D plays its song’s own loop until the node sets its own, so a sting plays once with nothing set on the node, and a node already in a scene follows when the song’s loop changes. Set back to the song’s, the node follows it again.

• The strips replace Show in, and Load palette moved from the palette’s menu to Custom’s. Use the style’s colours switches the sprite to the style’s first palette.

• A document opened after its palette changed opens in the new colours, or on Custom with a note when the palette’s length changed.

• Sprites saved before this release still open, and pick up the style’s palette in their colours, or Custom.

• A sprite is a .jcsprite, a small JSON file you can read and diff, and each of its cels is a PNG in a blobs/ folder beside project.godot. Commit that folder. The sprite shows in the FileSystem dock and loads like any resource, and a colour off its palette or a see-through pixel saves as drawn. A sprite with more than 65,535 colours doesn’t save, and says how many it uses.

• A .pixel.tres from before still opens, and saving it keeps it a .pixel.tres; Save As a .jcsprite to move it over. New sprites are .jcsprite, and so are the example game’s.

• On the web, a sprite downloads as one .jcsprite with its cels inside it, and Open from Disk and a ?open= link take one. It opens in any project, and its first save there puts its cels in blobs/.

• A style links its palettes, .jcpalette files all of one length, in place of a copy of one palette’s colours. New work opens on the first, and a sprite drawn in any of them is inside the style. Save palette as project default makes the file the chosen style’s first palette.

• Godot’s inspector no longer shows the palettes of the style your project uses; add, edit and remove them on the Project pin.

• In Pixel, a sprite with colours outside the project’s style gets a bar over the canvas in the warning colour, “Some colours in this sprite aren’t in the … palette.”, with Match the palette right after the words. It was a plain note at the far end of the menu bar.

• Use the style’s colours is now Match the palette, its button, its preview and its undo step.

• Preferences, Choose editors, Help and About moved from the jar’s menu to the ≡ on the project page, and Recent onto the page.

• The first run’s style screen offers the preset cards and Skip; Keep JamChip’s defaults is gone, since JamChip is a card.

• Save palette as over a style’s palette asks first only when a sprite, tileset or font is drawn in it, or a new order changes how another of the style’s palettes swaps.

• A style’s file is version 2. It can name instrument sets as its sound palette, a home key and the keys a game’s songs move between, motifs, the mix of music against sound effects and a loudness target. A style saved by this release does not open in an earlier one.

• In a side dock or on a phone, the Tracker’s bar is always three rows: the playback buttons with Grid and Roll, then BPM, then Oct and Step, or Ins and Vol on the roll. Grid and Roll no longer split across two rows, and a wide dock shows the bar as before.

• A song can have an intro: loop_from on ChiptuneSong is the entry of its order the loop comes round to, song create and song edit take --loop-from N, the song’s text says loop_from = N, and song show --json has it, every one counted from 1 as the order is. A looping ChiptuneSongPlayer, the Tracker’s Play with Loop down and a ChiptuneAudioStream play the entries before it once and then loop from it; a .wav export is the intro and one pass of the loop, and its .import loops from the marker to the end of the file. A song without one loops whole, as every song did; song show prints the new line.

• One word per document suffix: .pixel.tres, .sfx.tres, .chiptune.tres, .instruments.tres, .jcpalette, .frames.tres. The old names are read and never written.

• Chiptune’s rough edges: the mixer saves with the song, songs have a library, and the tracker plays back streaming.

Removed

• ChiptunePlayer3D. For a sound in 3D, put a ChiptuneAudioStream in the stream of Godot’s own AudioStreamPlayer3D and set its document.

• The devlog is gone: /devlog/ and its feed on the site, and the links to it from the footer and About. It never had an entry.

• The login is gone: /login/, /account/ and /invite/ on the site, the footer’s link to your devices, and the login server at api.jamchip.com. The privacy page and the terms no longer cover it. The zip and the app stay open to invited testers through Cloudflare’s gate, as before.

• Load project default and Save palette as project default are gone from the palette’s menu. To go back to the style’s main palette, click its dot. To make a palette file the main one, choose a style and use Load palette on its card.

• Pixel’s File menu no longer has Add PixelSprite2D to scene. Add a PixelSprite2D from Create New Node and drag the .pixel.tres from the FileSystem dock onto its Document. The SFX and Tracker tabs keep theirs.

• The download and releases pages until the launch; their addresses are the 404 until there’s a zip to give.

Fixed

• About’s jamchip.com and Support links start on the line of the text around them in the editor, where they sat a label’s margin to its left.

• Each swatch on the Theme page’s editing state is a square at the top of its row, where it stretched to the row’s height, a tall bar beside a colour under the floor.

• The jar at the head of the pin rail shows the mark in its own colours on the light ramp, where it drew black.

• A release’s zip downloads from jamchip.com, for a tester signed in with their email, where its link was a GitHub page that answered 404.

• The plugin parses in a game that has a global class named like one of its enums, Mode, Tool, Shape, Wave or State among them, where 46 of its scripts failed and the Pixel, Tiles, Font, SFX and Tracker tabs went down with them. The enums a game passes or reads keep their names: PixelSymmetry.Mode, PixelDocument.Verdict, PixelTileOps.Op, PixelTerrainLayouts.Layout, ChiptuneOscillator.Wave, ChiptuneSongText.Problem and ChiptuneSfxText.Problem.

• The plugin parses in a game that has a global class named like one of its own inner classes, Map, Reader, Thumb or Wheel among them, where that game failed with “Class “Map” hides a global script class” and the plugin went down with it.

• The example under PixelPalette.load_palette on its API page compiles when pasted: it used a skin it never declared. The other Pixel examples now keep what $ finds in a typed variable, so you get autocomplete on it and a wrong node fails at that line. Every example is compiled in a test that treats a call or property the type doesn’t have as an error, so a renamed call can’t ship in one.

• The example game’s music sits lower, both songs at −4 dB, and the bat’s flap in the cave is louder, at −6 dB, so it is heard under the song.

• The bat in the example game’s cave flaps on its wing’s downstroke, about four times a second, from a flap marker on its wings-down frame, softer and panned wider than the once-a-lap flutter it replaces.

• The cave’s drip is gone from the example game; the workshop’s steam still shows a ChiptuneAudioStream on a plain AudioStreamPlayer.

• A Bright sound on the SFX tab stays bright. Its pitch now rolls from F#5 rather than C5, and its slide can fall no faster than 20 semitones a second where before it drew from the full range, so a low roll with a steep fall no longer leaves the register the feel promised.

• Readying a style’s sound palette from the command line, or from a generator, keeps the instrument set file’s uid in its header, so a style or a scene linking the set by uid still finds it.

• The JamChip mark shows in an exported app. The kit decoded it from the PNG’s bytes, which an export drops in favour of the imported texture; it now loads that texture when the bytes are gone.

• The SFX and Tracker tabs save outside the editor. Both built their file dialog only inside it, so an exported app could draw but not keep a sound or a song; the kit answers for the dialog wherever the tab runs.

• In a headless run, such as a test suite or a script run with --headless, the Tiles tab’s Export writes the TileSet too, and an export or a merge over a TileSet whose sheet nothing has imported loads it without engine errors.

• Giving a tile’s data a value of another type, kind from wall to 7, no longer stops on a script error.

• A scene with a PixelTileMapLayer keeps its atlas’s id when saved again.

• The companion app’s icon and launch screen show the new jar.

• Pixel’s Open and Save As windows list your .jcsprite files, and the Palette tab’s Import lists your sprites. They only showed .tres files.

• A window the dock opens, Preferences, About or the manual, wears the theme in force. In the app and the web build its panel and frame were Godot’s dark grey, so on a light theme the text in it was dark on dark; the frame, its title and its close button now take the theme too.

• On Linux, Import palette fits a narrow window again: the file picker’s drive button, which names the home folder’s whole path, is trimmed with the picker’s other text.

• On a light theme, a window’s Close button, the manual’s text and a selected name are readable. They were drawn near white on the pale page.

• The manual opens larger, with room for its section titles and the tab table.

• About says the name once, in the logo, and reads “Made by GlitterSnack”.

• An editor button and the jar lift under the pointer, and each editor button’s tooltip names its key, Ctrl+1 for the first.

• The JamChip menu opens beside the editor buttons, so they and their unsaved marks stay in sight, and its tooltip says what’s in it.

• Recent files are listed under Recent by name, then folder, each with the glyph of the tab it opens in.

• Exporting a sheet or a TileSet from the Pixel tab twice in quick succession no longer loses the second export’s reimport, and no longer prints an import error for the PNG.

• jamchip/style in Project Settings has its file picker, held to style files, from every editor start, not only in the session that chose a style. A project that names no style saves nothing new.

• A style’s Grid and Sprite Size read in px in the inspector and hold at 1 pixel; a 0 typed lands as 1, and 1×1 is still no grid. A style file holding 0 or a negative there loads as 1 and is written as 1 on its next save.

• Editing a resource in the inspector no longer prints a typed-array error at each step, and JamChip frames opened there on their own are put back after it, as a node’s frames are.

• The example game keeps coins and lives on the HUD, where a hit or a stomp no longer replaces them.

• Losing the last life in the example game shows a game over card, and the song fades out under it; the end card, won or lost, takes a key and goes back to the title.

• A hurt in the example game’s gate room no longer respawns the player on the spikes, so one fall costs one life.

• The example game’s clock runs ninety seconds across the whole game, and the song goes up a semitone under fifteen in whichever room, heard when the clock says so.

• Esc pauses the example game, and Q quits from the pause.

• The bat in the example game flutters once a lap, quieter, and only in the cave.

• Quick Load offers every example sprite, sound and song, not just the palettes: each file the example generators write carries a uid.

• A scene holding a PixelSprite2D loads without “There is no animation with name” on every sprite, and comes back on the animation it was saved on. The name is stored on the node as saved_animation rather than as animation, which a scene wrote before the script and so before the frames existed to hold it; every scene the editor saved, and every exported one, printed that error and fell back to the first tag.

• A Pixel font saved while the game runs, or while a scene wearing it is open, no longer fills the Output with Parameter "fd" is null: the live font is refilled under the handles its Labels already hold.

• The example game’s clock runs only in a level, the meadow, the cave and the castle, starting afresh on the way into each; the village has none, and the song comes back down there.

• On the web, the example game’s pause no longer offers Q, which had nothing to quit.

• A stroke on the example platformer’s tile sheet shows in the game on the next run, with no export step between. tiles.png is gone from the examples. Export TileSet… is unchanged for a project that wants a file.

• On a phone, the runtime guide’s class table no longer breaks class names mid-word. A table wider than the screen scrolls sideways on its own, and in most browsers fades at its right edge while there’s more to see.

• Clicking the lit arpeggio chip again on the SFX tab no longer adds an undo step that changes nothing.

• PixelSprite2D, PixelTileMapLayer and the three Chiptune players show a warning in the Scene dock while they have no document, saying which file to set.

• The three Chiptune players show Document first in the inspector, before Unique, and Loop on ChiptuneSongPlayer.

• A PixelTileSet’s Tile Size is read-only in the inspector. The sheet’s grid in the Tiles editor sets it.

• A tileset document no longer shows its Tiles, Terrains and Scratch lists in the inspector, and a font document no longer shows its Glyphs. They’re still saved; the Tiles and Font editors edit them.

• The Font editor’s glyph sheet draws each glyph sharp, where the editor blurred it.

• The file name on the Tiles and Font strips sits unframed, as it does on the Pixel, SFX and Tracker tabs.

• A save or an export never overwrites a file the dialog did not confirm.

• A game linked to JamChip from its source no longer packs gdUnit4 into its export: the link to it is left behind, and a project’s own gdUnit4 still ships.

• The manual’s text sits in its own box beside the section list, so its last line no longer spills out under the list on a tablet or a laptop.

• When the manual is narrow, on a phone or opened from a small floating dock, the sections move to a drop-down above the text, and the text gets the full width.

• The manual opened from Help drags larger by its frame and opens again at the size it was left at. Its section list opens wide enough for the longest title, wraps a title it cannot fit rather than cutting it off, and drags wider.

• At the narrowest a dock can be dragged, the Font editor’s Guides button and preview zoom stay on screen. A section title too long for the width ends in an ellipsis and shows in full when you point at it, and Advance’s label moves above its field when they don’t fit side by side.

• The SFX tab no longer runs past the right edge of a narrow dock: Nudge drops under Generate when the row is too narrow for it.

• A new song’s grid is empty cells and nothing else. The card offering Generate a loop, Generate a kit and Start blank over them is gone; Song ▸ Generate loop and the Instruments menu ▸ Generate kit, with the same six feels, are where a first song starts.

• PixelPalette is in the API section of the site’s sidebar, beside the other classes, and its page opens on what a palette is and where you make one.

• The Palette tab no longer pauses each time it’s shown while it counts the sprites, tilesets and fonts on each palette.

• A palette’s count in the Palette tab leaves out documents in a folder holding a .gdignore, which Godot leaves out of the project.

• The rack’s colour wheel opens in the dock’s own panel, not a plain grey one.

• A palette saved with no editor open, from the command line or a script, says so when its import could not be written, and never writes one outside the project’s imports.

• Quick Load on a sprite’s palette slot lists the example game’s palettes.

• A Pixel tab with unsaved strokes keeps them when the editor reloads its file after the tab has already asked about a change made outside, and asks when that reload comes first. It lost them when the editor’s scan refilled the drawing and nothing put the tab’s copy back.

• The eraser on the Tiles editor’s sheet erases, where its first press stopped on an engine error and took nothing off.

• A Pixel document’s export paths sit in an Export group in the inspector, each a file picker for what it holds, labelled in full, with a tooltip saying what a save does with it. Saved documents keep their exports as before.

• The Pixel guide names the Push To Game setting where it is, says what a PixelSprite2D saves with the scene and how it starts playing, and says Aseprite itself opens what the Aseprite export writes.

• The Pixel guide says a recolour saved into a document linked to a palette file is put back in that file’s colours when the Pixel tab opens it, and that document.palette takes the palette’s colors.

• The eye and the padlock on the Pixel tab’s layer rows are the size of every other icon, where they had been drawn larger than the buttons around them.

• The frames lane’s grip sits on the seam between the canvas and the lane, and you drag it up to give the timeline more room. It used to sit at the bottom of the dock.

• A value bar you tabbed to keeps its focus ring while you drag it, and after, until the focus moves on. The click under the drag used to take the ring away.

• The line under Font in the Font editor’s Export dialog names the .fontfile.tres it writes beside the PNG, and says it’s the font to set as a Label’s or a Theme’s Font.

• Under a finger, every grip is three times as deep, so it’s easier to land on.

• Open in the Pixel editor asks about unsaved work only after you pick a file, as Tiles and Font do. A file that isn’t a Pixel document is refused, and the drawing and its recovery copy stay.

• Pixel-perfect is off by default, so a one-pixel pencil or eraser paints every pixel the pointer crosses, including the corners of a slow curve. Switch it on from the brush shape menu on the context bar.

• The brush size bar gives the small brushes room: 1 to 4 px is two fifths of the bar, where it was a tenth.

• The Import dialog’s line for a spritesheet with SpriteFrames beside it says where the frames and tags come from.

• A blank canvas in the Pixel tab is blank: the line of keys drawn across it until the first stroke is gone. The lane’s + and − for layers sit just over the layer rows, one above the eye and one above the lock.

• A frame change, a thumbnail or an onion ghost on a document with a faded layer costs what it does with every layer opaque: the faded layer is kept faded instead of scaled again each time, 21 ms down to 9 at 512×512 on an M2 Max.

• The Pixel tab’s Save asks before writing over a sprite that changed on disk since the tab read it, as Save All already did, and keeps your copy for recovery while it asks, so quitting through the question doesn’t lose it.

• In the browser, exporting an Animation downloads its .frames.tres along with the sheet, and a TileSet its .tileset.tres. Put both files in one folder of your project and the .tres finds the PNG.

• Saving a tileset whose sheet is a sprite file of its own saves the sheet too. Before, what you drew on it in the Tiles tab was lost.

• A font whose palette is a palette file, picked in the inspector, gets its own copy when its colours change: a palette switched, a swatch edited, unsaved work recovered, or another font saved over it. Before, the change went into the shared file, and into the style when the file was one of its palettes.

• A ChiptuneSongPlayer in a web export plays its song without a warning on every play(): the web’s default sample playback cannot hold a streamed song, so the node asks for stream playback there.

• The plugin’s README and the site’s Support page send a bug report or a question to hello@jamchip.com. They pointed at the repository’s issues, which nobody outside GlitterSnack can open yet.

• Other sites can’t show a jamchip.com page inside their own, so nobody can wrap the sign-up form in a fake JamChip page.

• The About page’s LICENSE link opens the licence on jamchip.com. It pointed at the file in the repository, which nobody outside GlitterSnack can open yet.

• Save works the same in all five editors: the dialog opens in the document’s folder with a name that isn’t taken yet, adds the suffix when you leave it off, asks before that replaces a file, and the editor says “Saved” and the name once it’s done.

• The Tiles and Font editors no longer say “Could not save” for a tileset or font built into a scene. They save it into the scene, as the other three editors do.

• A song or sound called “background_music.tres” no longer gets a second suffix in the save dialog.

• With no file browser to show, Save and Open on the Pixel, Tiles and Font editors now say so.

• Opening a file of another kind, or one that won’t open, in the Tiles or Font editor says so on the line, and asks nothing about unsaved work first.

• Save refuses a name that starts with a dot, and a path that leaves the project.

• A document changed on disk from outside the editor, by a git checkout, a copy from a terminal or another tool, now reaches the running game when the editor next scans, as a save in the dock always did. A tab showing the file takes the new copy when it has no unsaved changes, and asks before either copy is lost when it has. Running the game no longer writes a tab’s copy back over a file that changed under it.

• The plugin’s panels load in an exported build. Five scripts named an editor class the export template does not have, so every tab failed to parse outside the editor; the kit now asks for the editor by name and hands out a plain file dialog over the app’s own folder where there is no editor.

• On a phone in the browser, the manual fits the screen instead of running off the left edge.

• On a phone, the runtime guide’s class table shows all three columns, and the API pages don’t scroll sideways.

• The SFX tab’s actions sound less harsh and less alike. Confirm is a short tone that never holds, Jump is shorter, Pickup and Jump hold less, and a noisy Tick, Pickup or Jump plays quieter. Hit rolls four kinds (a fall, a crunch, a thud and a ring), Boom is sometimes a low buzzing tone, some Swells and Drops are short, and Random reaches lower and longer. A sound already saved plays as it did; the same seed may Generate a different sound. The example game’s door, hurt, jump, pickup and splash are rolled again from the same seeds.

• A save in the SFX tab and the Tracker says the name alone, “Saved jump”, without the file’s suffix or a clause about the nodes playing it. The envelope stage loses the A, D, S and R numbers in its corner, which repeated the bars beside it, and the Tracker’s mixer loses the notch cut into its outline.

• The example game’s bat flaps where it warned, a soft whoosh that is a little different each lap. The cave’s splash is louder and the room doors shut with a low fall rather than a chime of success.

• The SFX tab’s Jump and Pickup stop climbing before they squeal, so the steep ones are shorter and easier on the ears. A Confirm wobbles as a quick trill or not at all, and no longer sags at the end like a failure. A Tick on a pulse is thin, so two Ticks at one pitch sound apart. A Boom that fades fades over its whole length instead of trailing a whisper, and a Boom’s low tone is louder. A sound already saved plays as it did; the same seed may Generate a different sound.

• The example game’s cave drips: a sharp high blip about once a second where it hissed. The gate the key opens plays its own sound.

• Saving a sound while another node plays a plain WAV, the SFX tab’s own preview among them, no longer prints an engine error.

• The example game guide said the bat’s flutter loops. It plays once a lap, and the drip is what loops.

• The site’s sidebar lists Tiles under The tabs, beside Pixel and SFX.

• On the site’s docs pages, the sidebar’s section bars run all the way to its edge on Windows and Linux. They used to stop a scrollbar’s width short.

• The reference’s Limits section says which limit only warns: a canvas over its pixel count gets a warning, and the rest are refused. It used to say every one was refused.

• A typo in the description of ChiptuneSfxPlayer2D: “a AudioStreamPlayer2D” is now “an”.

• The site says the free launch is planned for 5 February 2027. Home, Download, Releases, Try it early and the terms used to say January.

• Support says the plugin’s version is listed under Project → Project Settings → Plugins. The tabs page says the Tracker has four channels.

• The reference lists the Font and Tiles editors’ keys, and the files they save and export: .font.tres, .tiles.tres, .fontfile.tres and .tileset.tres.

• A white font reads in the Font tab on the light theme: the stage, the spacing lines, the preview and the glyph boxes sit on a mid-tone checkerboard, so white letters and black ones both show on either theme.

• The site’s Home says what’s in the box under its claim, heads its install section “Try it early” until there’s a zip, and says the plugin costs nothing, so it no longer argues with the waitlist’s price for sync.

• The waitlist page sits in the site’s own frame, with no guide sidebar and no contents box of one entry.

• Overview draws the bat where it drew an enemy the example game doesn’t have, outlined so it shows on the dark theme, heads its tracker CH1 to CH4 as the Tracker does, and runs its tabs in the pins’ order.

• The reference’s tables are as wide as their columns, and a page’s contents box says “Top” where it said “Overview”.

• The guide and the API pages read plainer: the folder lists sit under Shipping, Pixel’s guide is headed Pixel and lists the tiles and font folders, and the class pages leave out what only the plugin calls.

• The changelog page doesn’t link Download or Releases until the launch.

• Search results and shared links for the site’s home page and the tabs page mention tiles and fonts, as the pages do.

• The site’s home page leads with the line JamChip stands behind, and the line under it says what the plugin does in Godot today.

• Try it early no longer guesses at a price for sync or asks whether you’d pay it, and its sync box says what sync is.

• The site’s About, Overview and footer no longer say what isn’t true yet: the app comes later, and the iPad takes one finger for now.

• The site doesn’t show a version number until there’s a release with that number. Home’s install button, Download’s box and the footer just say JamChip.

• Home’s install steps match Download’s: unzip at your project’s root.

• A missing page says “Page not found.” with links to Home and the docs. It used to tell you to search, and the site has no search.

• The Pixel screenshot’s alt text no longer gives a count of its frames, which was wrong.

• A playing ChiptuneSongPlayer or ChiptuneSongPlayer2D renders its song on a worker thread, so a frame pays almost nothing for the music, and two or three songs at once no longer slow the game. In the editor and in a web export without thread support, the song still renders on the main thread, as before.

• A game that quits while a ChiptuneSongPlayer or ChiptuneSongPlayer2D plays no longer ends with “ObjectDB instance was leaked at exit”.

• A ChiptuneSongPlayer or ChiptuneSongPlayer2D turned down to a volume_db of -80 or below, or a volume_linear of 0, stops rendering, so a song a game keeps playing silent costs almost nothing, on the web too. It still sends beat and bar on time. Turn it back up and it picks up where the song has got to; a note that was already sounding stays out until the next one starts.

• Every tab’s keyboard shortcut list fits the window and scrolls inside it, and its descriptions line up in one column, Redo’s too. On a phone the keys and descriptions wrap to the page.

• On the web, the loading page and Tap to start are set in the app’s own font.

• The web app’s start screen is one button, Tap to start.

• The manual in a browser no longer says where files are kept.

• Export’s hints are shorter, and PNG and Aseprite have none.

• Each tab’s keyboard shortcut list sits on the same dark ground as the manual’s text.

• Saving over one of the style’s palettes asks plainly: “Main is one of Bright style’s palettes, and 14 sprites, tilesets or fonts use it. Do you want to change the palette anyway?” It names the palette as you named it, and no longer promises a note.

• A stroke, an undo or a palette worn from the Palette section’s strips now says when it leaves the sprite outside the style, and the bar goes when one brings it back inside. It only said so when the sprite opened.

• On a narrow strip, the note about colours outside the style stays beside its Use the style’s colours button.

• A sprite, tileset or font open when the project picks another style says it steps outside the new one then, not only the next time it opens.

• Picking a style in Project Settings stores its path, and a style named by its uid there still opens.

• A sprite already open when a style is chosen, as the app’s first sprite is under its style screen, wears the style’s palette once it is chosen, and the Palette section lists the style’s palettes with that one ticked, where it stayed on Custom with the style’s rows missing until it was opened again.

• Escape on the layer opacity bar closes it and gives the keyboard back to the canvas, where it used to leave every key dead until a click.

• Ctrl+2 and Ctrl+3 bring a tab forward with its own keys live: SFX lands on its first control, the Tracker on the grid or the roll. Ctrl+1 on the tab already forward gives the canvas the keys too.

• Tab no longer lands on the piano roll, which answered no keys of its own.

• What draws itself shows focus: the canvas, the Tracker’s grid and roll, a value bar, a frame and an order chip wear the accent border when they have the keyboard, so Tab no longer lands on a frame with no mark.

• Escape leaves the Tracker’s pattern grid for the next control, once any selection is cleared; Tab inside the grid is still the next channel.

• A saved PixelSpriteTexture or PixelSpriteFrames no longer carries a copy of the artwork beside the document it follows. Both are rebuilt from the document on load, so the file holds the document and the frame, and a scene with a seven-frame animation in it is kilobytes smaller.

• A colour under the contrast floor on the Theme page’s editing state shows a warning sign at the end of its row, where there was a line of words that made the row taller. The words, then the keys and ratios, are the sign’s tooltip, and pressing the sign shows them too, for the keyboard and for a tablet with no hover.

• A colour under the contrast floor on the Theme page’s editing state says so in one line, in the words over the swatches: “Too close to Background, and to Lanes: selections are hard to see.” The keys and the ratios behind it are its tooltip, where there was a line per pair in keys and numbers.

• Exporting a TileSet from the Tiles tab twice in quick succession no longer loses the second export’s reimport, the same fix the Pixel tab’s two exports had.

• A refusal on the Tiles strip stays until your next action. Moving the cursor no longer clears it.

• The tileset’s sheet and the font’s glyph open fitted and centred.

• The tile in hand on the Tiles sheet keeps its own colours: its collision is an outline, filled only while Points is on.

• Undoing a stroke that erased a tile on the Tiles sheet puts the tile back where it was on the scratch.

• A Tiles stroke on the scratch that is still held when a new tileset opens, the file reloads from disk, or an undo runs is let go. Before, it kept autosave waiting, and its release could put an undone placement back as a new step.

• Everything a mouse reaches in the three tabs, a finger reaches in the app. A finger held still for half a second is the right button: the second colour on a swatch and on the canvas, the menus on a layer row, a frame, a tool group, an order chip and the arrangement lane. About JamChip opens in the app. Frames ▸ Hold opens its field above the on-screen keyboard. The grip under a rack section drags instead of scrolling the rack. A menu’s words end inside its edge, where a submenu cut them off by four units in the editor and in the app alike.

• In the Tracker, Shape, Envelope and Motion no longer fold inside Instruments. They’re three titled groups under it now. The SFX tab keeps its folds.

• A sounding channel’s pad in the mixer is the same green as its dot in the header, where it was orange, the colour of a note off the key.

• A pattern with no notes shows a bare chip in the song lane, where four stubs read as loading, and a chip’s bars follow a note as it is typed.

• The Tracker’s grid and roll fill the whole stage. On a wide dock the channels spread out and a short pattern’s roll stretches to the edge, so there’s no empty strip past the last channel.

• The grid marks the beat with a line, the same one the roll draws.

• Grid, Roll and the two Plays each have their own tooltip, so you can tell the pattern’s Play from the song’s.

• The Help tooltip on the Tracker names what’s on its menu, the shortcuts and the README. About JamChip is on the JamChip menu.

• The mixer’s master row reads Master, where it read MST.

• The key’s tooltip says the roll shades notes outside it too.

• A song exported from the Tracker as a .wav into the project loops when Godot imports it, from the end of its last row back to the top. The file is now the loop the Tracker’s Loop plays, with the notes still ringing at its end carried over its start. A loop set in the Import dock is kept on a re-export.

• The Tracker’s add-to-scene item read Add ChiptuneSfxPlayer to scene though it adds a ChiptuneSongPlayer; it now says so.

• Discard reloads from disk into the instance the scene holds.

• Both chiptune tabs measure unsaved changes against the last save.

• A layout reload opens into an empty panel only.

• The oscillator clamps at Nyquist.

• The 2015 Aseprite palette chunk has the modern one’s ceiling.

• A first save takes the path over.

• An exported PNG remembers its frame.

• PixelSprite2D no longer shows a Sprite Frames row in the inspector, and an edit in Godot’s SpriteFrames panel on a sprite drawn from a document is put back at once with a warning, rather than lost at the next rebuild.

• PixelFontFile no longer shows a Base Font row, which kept nothing put in it.

• Godot’s TileMap and TileSet panels name a PixelTileSet’s atlas after its document, ground for ground.tiles.tres, instead of “Unknown Type Source”.

• The Export and Import dialogs no longer explain each format in a line under it. A line shows only when a setting has something to say.

• Pixel’s TileSet export shows “Set the cell to your tile size” quietly now, since every sprite starts on a 1 by 1 grid. It turns red only when the cell and offset leave no whole tile inside the frame. Export stays greyed in both cases.

• On a phone, the previous and next links at the foot of a guide or API page no longer break a class name mid-word. When they don’t both fit on one line, the next link moves under the previous one.

• About JamChip in the browser says which version it is and who made it, where it read “unknown” on every line.

• The Pixel strip’s Use the style’s colours shows its words whole, and on a narrow dock the note beside it shows too, on a row of their own.

• On a slow computer or phone, the web app no longer loses a stroke made in the last half minute before a refresh or a closed tab. It keeps unsaved work in the browser every couple of seconds while the page is open, instead of trying to save it as the page closes.

• The web app keeps unsaved work across a refresh or a closed tab. Every tab autosaves, and again as the page is hidden or left, and the next visit offers it back in the same recovery dialog the plugin shows.

• With the web app open in two tabs, the second one no longer deletes what the first saved. It says JamChip’s open in another tab and saves nothing itself.

• In the browser, exporting a sprite or a font no longer leaves it unsaved, so a refresh after a download does not ask about work you already saved.

• In the browser, the Tiles and Font tabs download what they export: a TileSet sends the sheet and its .tileset.tres, a Font the PNG and its .fontfile.tres, and the tileset or font document the saved file. Both tabs have Open from Disk there too.

• The Tiles and Font tabs export through the one Export dialog the other tabs have, and the Tiles tab’s Import picks PNG, TileSet or Aseprite inside it, with a PNG’s grid as rows.

• On the web, Pixel’s Animation and TileSet, the Tiles tab’s TileSet and the Font tab’s Font now download as one zip, the PNG with its .tres, so Chrome doesn’t ask to allow several downloads. Other exports download as before.

• Opening app.jamchip.com a second time uses the engine the browser already has, instead of failing once and downloading all 6.9 MB again.

• Play in the Tracker while a song or pattern is already playing, a second Generate loop among them, no longer frees the sound still fading out under the engine, which crashed Godot on Windows; closing the tab mid-song keeps it a moment longer for the same reason.