Tessarune 1.4.0: Pixel Art as Code, Now With Godot 4 & Unity Export

On November 6, 2026, indie developer Aurum Nocturne released Tessarune 1.4.0, and the headline feature is the one the tool was missing: game-engine export. Until now, Tessarune produced GIFs, PNGs, frame sequences, and sprite sheets with JSON timing data — useful, but every engine still needed a manual import step. Version 1.4.0 hands you files Godot 4 and Unity can open directly, with frame order, per-frame timing, looping, and direction names carried over. Existing buyers get the update free from the same download page, and the price stays $32.99 as a one-time purchase.

A note on sourcing, stated up front: the facts below come from the author's own channels (the itch release announcement, the itch product page, and the official code examples at tessarune.dev, all verified on the morning of publication). We found no independent hands-on review yet. Where this article says “according to the author,” it means exactly that.

What Tessarune Actually Is: Code In, Pixels Out

Tessarune is a pixel-art drawing language plus a desktop studio, built to be driven by an AI coding agent — the agent itself is not included. You write a production brief, paste the prompt into your agent, and the agent edits a compact JavaScript file and runs the Tessarune CLI. The Studio shows source and artwork side by side and follows every save, so you can refine colours and code yourself or send notes back to the agent. The key idea is that no image-generation model is involved anywhere in this chain: according to the author, same source + seed + settings + engine version = same pixels, and re-rendering costs no AI usage.

Self-made diagram of the five-step workflow described on the product page (usasori-data.itch.io/tessarune, retrieved November 7, 2026).

That determinism is the whole pitch, and it solves three problems that plague AI image generation for games. First, everything stays editable: named parts, palettes, joints, and motions remain code you can change, instead of pixels you have to repaint. Second, a 64×64 design is a real 64×64 grid — no upscaling, no blurry edges, no off-grid artifacts. Third, motion is resampled, not faked: asking for more frames means resampling the motion at more time steps, not duplicating images. The renderer even keeps 3D joints inside small sprites, so arms can reach forward and legs can pass behind each other with correct depth overlap.

The other half of the pitch is privacy and cost: the software runs locally on your machine, never calls an external AI, requires no account, and uses no API keys. Your own coding agent runs the CLI on your PC — any agent that can edit files, run commands, and look at an image works, and the author notes you do not need the most expensive model. What you make is yours to sell, with commercial use and no revenue share, and one purchase covers one person on devices they control.

New in 1.4.0: Engine Export

The export itself is the news. For Godot 4 you get a SpriteFrames resource (.tres) carrying frame order, fps, per-frame durations, and looping, plus an AnimatedSprite2D scene with nearest-neighbour filtering already set. For Unity 2021.3 and later you get a sprite sheet PNG with .meta (Point filter, pixels-per-unit, and pivot options), AnimationClips, and an AnimatorController. Directions and actions keep their names on both sides, so an animation called “walk-left” in the source is still called that in the engine. You trigger it from Export → Game engine in the Studio, from the delivery ZIP, or from the CLI:

render PROGRAM --engine godot|unity

Self-made diagram of the 1.4.0 export contents, based on the author's devlog and product page (retrieved November 7, 2026).

Two details are worth noting. Import and playback were checked automatically in Godot 4.7.2 and Unity 6.0.43f1 — the author is explicit that other versions were not tested one by one, so treat other engine versions as “probably fine, verify yourself.” And the export covers sprite animation only: it does not build game logic or collisions, and looping is infinite or once.

Version 1.4.0 also bundles runtime 0.5.0, which adds rim light and particles and is now the default for new programs. Runtimes 0.3.0 and 0.4.0 ship alongside it, and existing programs keep the runtime they declare — the same version-pinning idea that makes the output deterministic also protects older work from changing under you. The built-in manual gains a new page for the feature: manual show engine-export.

If this sounds familiar, it is the same direction other tools are moving: engine-native export is becoming the baseline for pixel tools, not a bonus. We covered a parallel example earlier this week in SpriteTailor 1.0, which also ships one-click Unity and Godot 4 packages — the difference is that SpriteTailor is a paper-doll character creator, while Tessarune is a programmable renderer. Different input, same destination: a sprite that lands in your engine ready to play.

Reading the Code: A Cauldron in 202 Lines

The clearest way to judge Tessarune is to read a real program. The official site publishes four complete examples from the author's asset packs, and the cauldron from Arcane Curiosities Vol.1 is the baseline prop: a 48×48 sprite, 12 frames at 10 fps, 202 lines, with three brew-colour variants produced by a palette swap instead of a redraw. Here is the skeleton, verbatim from tessarune.dev/code (helper functions omitted for brevity):

// Cauldron over a wood fire — 48x48, top-down 3/4, key light top-left.
// Loop: 12 frames @ 10 fps. Bubbles swell and pop, the brew swirls,
// the sigil pulses, steam drifts, fire flickers.
// Variants: brew colour green / violet / blue (ramp swap — no new colours).
const Cauldron = sprite(pal, (g, t) => {
  contactShadow(g, CX, GROUND, 18, 2);
  g.outlined("ink", () => {
    foot(g, 12, true); foot(g, 36, false);
    g.part("body", () => body(g, t));
    lip(g);
  });
  band(g, t); brew(g, t); bubbles(g, t);
  g.outlined("ink", () => { logs(g); fire(g, t); });
  steam(g, t);
});
submit(Cauldron, {
  size: [48, 48], origin: "top-left", kind: "icon", scale: 1,
  animate: { fps: 10, duration: 1.2, loop: true },
  anchor: { x: 24, y: 45 },
  variants: [
    { name: "idle-green" },
    { name: "idle-violet", repalette: swap("brew", "v") },
    { name: "idle-blue", repalette: swap("brew", "b") },
  ],
});

The API is small enough to hold in your head. palette() defines named colours — the asset packs share a 32-colour palette organized into four-step ramps (iron and stone, wood, brass, fire, green, blue, violet). sprite() sets the drawing function, where g is the brush and t is time progressing from 0 to 1 across the loop. g.part() groups pixels under a name so a person or an agent can inspect and update one component, g.field() computes a colour per pixel inside a box (how the round iron body gets its shading), and submit() fixes the canvas size, frame rate, loop timing, and variants.

The details are where the craft shows. Bubbles use a phase offset with (t + ph) % 1, so the last frame connects to the first without a visible seam. The swirl is two-fold symmetric, so a half turn per loop closes the loop. The brew surface is a field function over an ellipse, with a meniscus along the near edge and a glint where the key light hits. None of this is machine-learned: it is geometry, written down, and every number in it is editable.

The Trailer: Ten Monster Girls, Zero Image Generation

The release also ships a 60-second trailer featuring ten 64×64 monster girls with idle animations: Harpy, Yuki-onna, Lich, Lamia, Jellyfish, Gargoyle, Automaton, Kikimora, and two Goblins. Every sprite in the video was rendered from its own source file in Tessarune 1.3.0, and because each program declares the runtime it was written for, 1.4.0 renders the same pixels — a small proof of the determinism claim, baked into the marketing. You can watch it on YouTube.

The trailer also shows the review workflow the author is honest about. Each body is a small 3D model projected down into pixels, which lets the agent turn a character while the silhouette follows naturally — but faces are pixel maps written directly into the code, because a rotated eye falls apart at 64 pixels. The workflow moves through clear stages (silhouette, values, 8 colours, then 16, then 24, and the final sprite), and built-in review tools let you inspect named parts — head, eyes, lip, torso, arms, fan, book, skirt, legs — individually. Humanoid figures like the ones in the trailer took several review rounds each to reach completion; small props and simple items are much faster.

The Honest Notes

The author's own caveats are worth repeating, because they set expectations better than any review could. Tessarune is Windows 11 only, and the executables are unsigned, so SmartScreen may warn — SHA-256 checksums are included in the download. There is no MP4 export and no FBX/glTF export. Engine export covers sprite animation, not game logic or collision. And it is not a one-sentence image generator: tiles, effects, and backgrounds come out cleanly, but human figures need a few rounds, and the review, history, and notes tools exist for those rounds. An ordinary chat window cannot drive it directly, either — you need an agent that can edit files and run commands, though you can also paste code into Studio yourself.

One more practical note: the box includes the Studio (a local browser app with library, split view, motion editor, frame notes, history, and checks for flicker, missing pixels, and required actions), a JSON CLI for agents with AI-start manuals and structured briefs, three bundled runtimes, and 26 production manuals in English and Japanese, plus templates, style profiles, and editable examples. Future releases are free for buyers of the itch page, with no release schedule or feature promise.

Verdict: A Niche Tool That Respects the Pipeline

Tessarune will not replace a drawing app, and it is not trying to. It is for a specific kind of developer: one who already has an AI coding agent in the loop, wants pixel art that behaves like source code — versioned, diffable, deterministic — and is tired of re-cutting sprite sheets by hand. Version 1.4.0 removes the last manual step between that workflow and a running game: the export now speaks Godot 4 and Unity natively, with the timing data intact.

If that is your workflow, the cheapest way to judge it is the code page: read the four published programs on tessarune.dev and decide whether you would rather edit those 202 lines than redraw a cauldron. If the answer is yes, the $32.99 itch page is where 1.4.0 lives — and if you already own it, the update is free.