v3.0.0

AutomataStudio 3.0 adds the automata command line: the app's engine in a terminal, shipped inside the desktop app.

The command line

• Run and test machines: run, test, trace, lint, equiv, diff, convert, minimize, determinize, and an expression language over automata (eval).
• Formats: HOA, BA, Timbuk, JFLAP, SMTF machine codes, SVG, DOT, TikZ, and code generation for several languages.
• Turing machines:
  • halts decides halting with proofs: cyclers, translated cyclers, backward reasoning, n-gram CPS, inductive rules for bouncers, and the busy beaver bound.
  • check-proof re-checks proof files independently.
  • bb-search enumerates machines in parallel.
• Exploring and learning: words, profile, fuzz against an oracle program, grade, generate, learn (RPNI and L*), and play, an animated run in the terminal.
• AI agents: an MCP server (automata mcp) exposes the engine as tools.
• Terminal UI: a coloured interface in the app's palette. Every command has full help with examples, and there are help topics.
• Installation: the Windows installer and the .deb package put automata on your PATH. On macOS, use AutomataStudio → Install 'automata' Command in PATH. See docs/cli.md.

Also in this release

• SMTF: a standard text format for every machine type.
• Machine library:
  • Entries are identified by their machine and listed once.
  • "Recently added" and "Recently updated" views, and sorting in either direction.
  • The website is restyled as the app's catalogue.
  • The library is rebuilt automatically when the engine changes.
• Themes: every theme is rebuilt against the app's colour rules.
• Canvas: a background that responds to the run, and the view re-fits when a panel opens or folds.
• Settings: the dialog is organised by feature, and its phone layout is fixed.
• Fixes:
  • The space-time diagram follows the playhead without lag or jitter.
  • A block can be entered through a nested block.
  • The library's status line no longer has a gap above it on mobile.

v2.9.0

New

A verified library of machines

Browse and share machines other people have built, from More ▸ Library (key 5). Every badge is a result the machine itself produced: the library's CI checks each machine with this app's own engine.

• Discover, Browse, Collections, My Library. Search by words or filters: type:DFA, by:login, badge:minimal, accepts:0110 / rejects:.
• Badges: tested, deterministic, minimal, halts / never-halts (with how the halting proof was found).
• Listings: the diagram with Try it running the machine on it, the formal definition typeset from the machine itself, and a Turing machine's run beside its halting proof.
• Submit from the app. Your submission becomes a PR credited to you; opening one of your own entries and submitting again updates it, and doing the same with someone else's creates a remix.
• Links: #lib=, #library= and #collection= share links, and automata-studio:// links in the desktop app.

Halting proofs for Turing machines

Analyze can now prove whether a Turing machine halts, and say which method proved it: simulation, a cycler, a translated cycler or backward reasoning. When no method can decide, it answers "unknown". The library's halts / never-halts badges are built on this.

What's Changed

• feat(analyze): prove whether a Turing machine halts by @thethinkmachine in #105
• feat(library): a verified library of machines by @thethinkmachine in #106

Full Changelog: v2.8.3...v2.9.0

v2.8.3

What's Changed

• perf(player): keep long runs smooth past a million steps by @thethinkmachine in #102
• fix(spacetime): keep a long run's diagram scrollable past the browser's size limit by @thethinkmachine in #103

Full Changelog: v2.8.2...v2.8.3

v2.8.2

What's Changed

• Panels: VS Code-style tabs, movable tabs and cards, cards organised by job by @thethinkmachine in #99
• perf(canvas): fix dropped frames when dragging states and zooming by @thethinkmachine in #100
• feat(trace): draw each step as a row, with its parts and its verdict picked out by @thethinkmachine in #101

Highlights

Panels organised by job, with a new Run tab (#99) — the sidebar cards are now grouped into three tabs, one per job. Machine (left) holds what you are building: the exercise, parameters, alphabets, states, transitions and blocks. Analyze (right) looks at the machine over all its inputs: Language, Batch Test and Complexity. The new Run tab follows one input step by step: Simulate, Trace, Computation Tree and Space-time. Anything that runs a word from somewhere else (Language's trace link, a Batch row, Complexity's worst case, exercise and machine-card test words) switches to Run first.

Move tabs and cards wherever you want them (#99) — drag a tab to reorder it or onto the other panel, and drag a card onto a tab or into the other panel's stack. Escape undoes a move to the other panel. Right-click (or Shift+F10) a tab or a card header for the same moves and a reset. A panel with no tabs left is hidden, and dragging a tab to that edge of the canvas brings it back. The tab strips now look like VS Code's: compact labels with an underline on the selected tab, shrinking to icons when space runs out. Your layout is remembered, and existing layouts keep working.

A readable trace (#101) — each step in the Trace card is now a row: symbols are drawn as chips, the arrow and the state it lands in are marked, and a verdict (ACCEPT, REJECT, LOOP, NO VERDICT) is a badge instead of text that could wrap onto a line of its own. A transducer's output gets its own line. Click a row to jump the player to that step. Selecting text to copy still works.

Smoother dragging and zooming (#100) — dragging a state no longer rebuilds every sticky note's text on every frame, and panning or zooming no longer restyles the whole diagram on every frame. On the MTM example on a 144 Hz display, the slowest drag frames went from 14–21 ms to 7 ms, and zoom's per-frame style work from about 9 ms to 2 ms. This affected the website as well as the desktop app; it was more noticeable in the desktop app on high-refresh displays.

Full Changelog: v2.8.1...v2.8.2

v2.8.1

What's Changed

• Show every branch of a nondeterministic run, and fit animation to playback speed by @thethinkmachine in #95
• Add a benchmark for the engine, the player and the canvas by @thethinkmachine in #96
• Space-time diagram: linear memory, reset that frees it, a fast overview strip; speed dial on reload by @thethinkmachine in #97
• Long runs: tape runs as columns, checkpoints and undo for jumps by @thethinkmachine in #98

Highlights

Busy beavers, run to the end (#97, #98) — a Turing machine can now run for tens of millions of steps and still be played, scrubbed and drawn. The five-state busy beaver champion runs to its halt at 47,176,870 steps in about 286 MB, space-time diagram included, where it used to need over 10 GB and could not finish in a browser tab. The player keeps a few bytes per step instead of a copy of each step.

Scrub anywhere in a long run, instantly (#98) — stepping back is now as cheap as stepping forward, and jumping to any point costs about the same however long the run is: roughly a tenth of a millisecond anywhere in the busy beaver's 47 million steps. Before, every step back rebuilt the tape from the start of the run, several milliseconds per step on a run of a million steps.

Every branch of a nondeterministic run (#95) — a new Computation Tree card draws the whole search, not just the path the trace follows: every branch, where it forked, and how it ended (accepted, stuck, merged into another branch, or never explored). On the canvas, each live branch is a coloured token that travels the edge its branch took, splits at a fork and fades when its branch dies. Related branches get related colours. Available on the NFA, ε-NFA, NPDA, QA, Counter, 2PDA, PDT, EPDA, NDTM, FST and 2NFA.

Animation keeps up with the playback speed (#95) — the travelling token and the arrival pulse now fit inside each step, so they are no longer cut off at 5× and faster, and from 50× the canvas, tape and space-time view snap instead of fading.

A faster, leaner space-time diagram (#97, #98) — the diagram no longer keeps its own copies of the tape, builds its rows several times faster, and lets go of a run's memory when the run is reset, even with the section folded. The overview strip beside a long run draws in under a tenth of a second where it could take 20.

Fixes — the speed dial shows the saved speed after a reload, instead of 1× while playing at the saved speed (#97).

For contributors — npm run bench measures the engine, the player, the canvas, the space-time diagram and whole long runs against a recorded baseline, and flags a case only when it moves by more than its own noise (#96, #97, #98).

Full Changelog: v2.8.0...v2.8.1

v2.8.0

What's Changed

• chore: remove dead code, and two facts that were stated twice by @thethinkmachine in #76
• perf(geometry): flatten the layout grid, and compile the label stage's inner loop by @thethinkmachine in #77
• EPDA, and a UI audit: focus, notation, framing, labels by @thethinkmachine in #78
• Exercises with automatic grading, a lexer generator, and statechart import by @thethinkmachine in #79
• Exercises decide how much StateMate may help by @thethinkmachine in #80
• Workspace panel: a Machine section, δ as a table, and windows that snap by @thethinkmachine in #81
• StateMate shows its work, talks about its machines, and keeps a run to its tab by @thethinkmachine in #83
• StateMate through your own Claude Code: the CLI provider and an agent bridge by @thethinkmachine in #84
• Space-time diagrams and the complexity profile (re-land #82) by @thethinkmachine in #85
• Floating windows fit their content, and follow it once taken to it by @thethinkmachine in #87
• feat(spacetime): the overview strip is resizable from its left edge by @thethinkmachine in #88
• fix(panels): a section dragged out of its panel no longer collapses by @thethinkmachine in #89
• One field language for both panels, a tile toolbar, and a better batch tester by @thethinkmachine in #90
• Canvas overlays keep one home each; toolbar polish by @thethinkmachine in #91
• Paste a machine onto the canvas; a framed machine stays framed by @thethinkmachine in #92
• Faster player and engine: paint once per frame, index δ, and a speed knob by @thethinkmachine in #93
• Faster searches: name configurations by integers, not by their contents by @thethinkmachine in #94

Highlights

A new machine: the embedded pushdown automaton (#78) — an EPDA's store is a stack of stacks, of which only the topmost is reachable. That is exactly the tree-adjoining languages: more than one stack, less than two independent ones. It reaches every surface a machine has — the editor, the player, StateMate, save files and the export IR — and the Reference gains a Language Classes page for the grammar side of it.

Exercises, a lexer generator, and statechart import (#79, #80) — More → Create Exercise from This Machine… turns the machine on the canvas (or the grammar in the Grammar view) into a hidden reference answer, and a student's machine is graded against it automatically. The author also decides how much StateMate may help: off, hints only, or full help. The lexer generator turns a list of regular expressions into a working tokenizer, and XState / SCXML statecharts written for real applications can be opened as machines.

Space-time diagrams and the complexity profile (#85, #88) — a whole run on one screen: one row per step, time running down and space across, with the head's path drawn through the rows and a resizable overview strip beside it. The complexity profile plots steps and space against input length n.

StateMate through your own Claude Code (#83, #84) — two new providers that need no API key: the desktop app can run the claude CLI directly, and an agent bridge lets a running Claude Code session answer StateMate's requests. StateMate now draws its draft while it is being written, can explain a machine answer alongside it, and keeps each run tied to the tab it was sent from.

Paste a machine onto the canvas (#92) — Ctrl+V now opens a Turing machine in the standard text format (1RB1LC_1RC1RB_…, as used by bbchallenge and the Busy Beaver wiki), a share link anywhere in the pasted text, or a saved file's JSON. A paste never replaces the machine on screen: an occupied tab gets a new one.

A reworked Workspace panel and floating windows (#81, #87, #89) — a Machine section, the alphabets as rows of one section, Blocks shown only once a machine has one, and δ available as the textbook's table of states by symbols. Folded sections summarise what they hold; floating windows snap, anchor, and fit their content.

One field language, a tile toolbar, and a better batch tester (#90, #91) — every field on both panels shares one height, radius and focus style; search boxes clear with Escape; the canvas toolbar shows each tool's shortcut on its tile; and every canvas overlay keeps one home instead of jumping between corners as the toolbar moves.

Faster, especially on large machines (#77, #93, #94) — a step now costs the same on a machine of any size (δ is indexed by source state instead of scanned), playback paints once per frame with a speed knob in place of a 20-steps-a-second cap, and nondeterministic searches name configurations by integers rather than by their contents, so they no longer grow quadratically with their own work. The layout grid is flat and the label stage's inner loop is compiled to WebAssembly.

Fixes — characters draw as themselves rather than as programming ligatures, in the canvas and in form controls; the formal definition typesets the notation's own symbols as math; dialogs take focus when they open; icon buttons are named by an attribute rather than a tooltip; notation keeps its case under uppercase labels; arriving at the phone layout by resizing matches arriving by load; the DPA example's note no longer covers its start state; and 595 lines of dead code are gone (#76).

Full Changelog: v2.7.4...v2.8.0

v2.7.4

What's Changed

• feat(blocks): a block is a thing you can run, ask about, and copy by @thethinkmachine in #74
• docs(readme): describe the app that exists, and show it running by @thethinkmachine in f038110
• feat(header): one plane of chrome, and menus a keyboard can reach by @thethinkmachine in #75
• fix(panels): an unpinned panel opens without its header spilling onto the canvas by @thethinkmachine in af96d9f
• fix(sim): the empty trace log names Σ*, not "a string" by @thethinkmachine in 6e511b7

Highlights

Blocks you can run, ask about, and copy (#74) — drilling into a block used to change what you could see and nothing about what you could do. The run box now offers a run boundary: run one block on its own, or run the whole machine and stop where control first enters it. A block has no verdict of its own, so its run reports which exit control left by. A scoped StateMate turn cuts the machine to the level you are standing in — asking a question about the adder no longer sends the whole processor, and a scoped edit can no longer delete the machine around the block. Copy/cut is the one gesture that crosses machines, so it now asks: a block whose transition shape doesn't match the host machine is refused whole. Notes live on one level; the trace log became its own card with the elided history reachable on demand.

One plane of chrome (#75) — the header's toolbar groups share one ground instead of three separate pills, the model picker moves beside the wizard button, and the Tools dropdown folds into the More menu. Every header menu now closes the same ways (Escape, window blur, outside click) and its rows are real controls: tabindex, Enter/Space, ↑/↓ roving focus, ARIA roles — the <div onclick>s are gone. The tab strip, machine pill and toolbar all stand at 36px.

Fixes — an unpinned panel no longer spills its header onto the canvas mid-open; the empty trace log names Σ* rather than "a string".

Full Changelog: v2.7.3...v2.7.4

v2.7.3

What's Changed

• fix(history): the camera is saved, but it is not an edit by @thethinkmachine in #71
• Revert "fix(history): the camera is saved, but it is not an edit" by @thethinkmachine in #72
• fix(blocks): a run is drawn where the reader is standing, and a note lives on one level by @thethinkmachine in #73

Full Changelog: v2.7.2...v2.7.3

v2.7.2

What's Changed

• fix(files): an opened file outlives the restore by @thethinkmachine in #70

Full Changelog: v2.7.1...v2.7.2

v2.7.1

What's Changed

• feat(grammar): a workbench, where the view was eighteen buttons and one output div by @thethinkmachine in #68
• A versioned document, per-workspace storage, and files on disk by @thethinkmachine in #69

Full Changelog: v2.7.0...v2.7.1