Files
AniCraft/docs/roadmap.md
T

33 KiB
Raw Blame History

AniCraft roadmap

Principle: infrastructure first, then high-traffic parity, then the long tail. Every milestone ends with a green tree: build, tests, clippy, a --screenshot check and an updated "Honest status" section below.

Honest status (2026-11-09, v0.1.0 early alpha)

Dimension Status
Architecture M0 skeleton in place: geom → doc → render → engine → cli → shell, layering enforced by cargo test (src/architecture_tests.rs: lower layers only, no UI crates below the shell, and the AGENTS.md map must match).
Rendering CPU oracle with analytic AA, non-zero/even-odd, solid + linear/radial gradients, round-join strokes. Mask clipping: the display list carries nested clips; a clip is the anti-aliased union of its mask fills (strokes and opacity ignored), intersected with any enclosing clip, computed once per render band; an empty mask hides everything under it. Group alpha: a symbol instance below full opacity is a group in the display list; each render band composites the group's run of ops into its own buffer (nested groups stack) and blends it once at the group's alpha, so overlaps don't show through; SVG export writes <g opacity>. Blend modes (Animate's 14, on movie clip and button instances): an instance with one is an isolated group that blends at its close with the W3C separable formulas on premultiplied colour (Alpha and Erase keep or clear the backdrop); SVG gets CSS mix-blend-mode, Lottie the layer bm. Bitmaps: Paint::Bitmap fills (once or tiled) with bilinear sampling in premultiplied space, colour effects per sample; PNG/JPEG import to stage (a rectangle of the image's size); stored in the document as PNG (base64 in .anicraft), decoded once on first use; SVG export embeds each image once as a pattern. Filters: a filtered group is drawn on its own (by the same renderer, recursively, so nested filters work) into a buffer over its artwork grown by the filters' reach, filtered (box-blur passes; shadow and glow from the blurred, offset opacity; bevel and gradient bevel from the difference of the blurred opacity offset towards and away from the light, gradient glow from the glow's intensity, both through a colour ramp whose rest stop is pinned transparent, inner/outer/full and knockout, ADR 0025; colour matrix), and composited back as one image in its group, so alpha and blend apply; clips from inside the symbol apply before filtering and the instance's own clip after. GPU stage, first slice (M3, ADR 0019; --features gpu-stage, off by default): Preferences › Stage › Renderer GPU (preview) draws the stage with wgpu compute from the oracle's own prepared fills (tile binning with per-row backdrops on the CPU, exact area coverage and src-over per pixel on the GPU): solid and gradient fills and strokes, non-zero and even-odd; masks, group opacity, blend modes, filters and bitmaps fall back to the CPU per tile, and the status bar says so. Parity with the oracle: max 1/255, mean < 0.0001/255 on the sample, stress and analytic scenes (tests skip without an adapter). 4K with 1,000 shapes: 8.8–9.0 ms vs the CPU's 17.4–17.8 ms. Not yet: no-readback textures, masks/groups/blend on the GPU, GPU binning, bitmaps and filters, GPU exports; the CPU stays the default and the oracle.
Timeline Frame selection: click, Shift-click or drag across frames and layers; F5/Shift+F5, F6/F7 and Shift+F6 (keys, buttons and right-click menu) act on the whole selection; drag selected keyframes left or right to move them, and up or down onto other layers (the source keeps empty frames, as in Animate) (with a drop outline; one undo step; keys they land on are replaced, and spans fill the frames left behind); removing or clearing selected frames that hold artwork asks first. Cut/Copy/Paste Frames (Ctrl+Alt+X/C/V, and plain Ctrl+X/C/V after clicking the timeline): own clipboard, copies cut exactly at the selection edges (mid-tween state kept), paste inserts like Animate, several layers paste onto the layers below (missing ones are created), fresh element ids, symbols travel with them. Span length by dragging its end (resize cursor, live outline with the length in frames and seconds; later frames move with it). Headless: layers/count on the frame commands, timeline.move_keyframes, timeline.cut_frames/copy_frames/paste_frames. Layers (show/lock/outline), keyframes, blank keyframes, insert/remove frames, classic tweens with 8 easing presets + curve preview, shape tweens (morph between any two shapes: segments made cubic, subpaths paired by size and grown from or shrunk to a point when counts differ, segment counts equalized by subdivision, windings matched and start points aligned; amber spans; classic ⇄ shape keeps the easing; shape hints (ADR 0023): Modify › Shape › Add Shape Hint (Ctrl+Shift+H) adds lettered markers a–z that the artist drags onto an edge on the first and last keyframe (rose until placed, amber placed on the first, mint on the last; right-click removes), the morph cuts both outlines at the hinted points and matches the pieces in order by length; tween.add_hint/move_hint/remove_hint/clear_hints/hints; not yet: View › Show Shape Hints, hints inside symbols edited in place), auto-key when editing inside a tween, frame labels, symbol nesting: graphics keep step with their timeline (loop, play once, single frame, first frame; set in Properties), movie clips loop their own timeline from when the instance appears (continuous across keyframes holding the same instance), buttons show their Up frame, onion skin (±2 frames), looping playback. Mask layers: right-click a layer › Mask turns it into a mask over the layer below (Masked adds more layers to it); masked layers are indented under a stencil icon; the mask applies on the stage and in every export alike, and while the mask layer is unlocked its edge shows in the layer colour so it can be picked and reshaped; masked-away parts cannot be picked; layers moved in under a mask join it, moved out leave it, and a mask moves with its whole group; masks inside symbols nest. Headless: layer.toggle_mask, layer.set_type. Scenes (ADR 0011): the movie is an ordered list of scenes, each its own timeline, edited one at a time (scene menu on the edit bar, Insert › Scene, Modify › Scene, Shift+PageUp/PageDown); add, duplicate (fresh ids), rename, reorder and remove (asks when the scene has artwork; undoable); PNG-sequence and GIF exports play every scene in order. Layer folders: nestable folders (depth ≤ 16) holding layers and masks through Layer.parent, one invariant (Timeline::repair_masks: a child sits below its parent inside the parent's unbroken run; broken links fall back to the nearest valid ancestor); hiding or locking a folder hides or locks its contents (rendering, picking, drawing); folders open and close on the timeline (view state); layers move in and out with Up/Down, a folder moves with its contents; deleting a folder deletes its contents (asks first). Motion tweens (ADR 0016): a span's object animated property by property (x, y, scale, rotation, skew, alpha, tint), each property its own curve of property keyframes with a per-segment ease (presets or a custom cubic Bézier, overshoot allowed); auto-key turns any edit of the object inside the span into property keys (every command, through the session), F6 keys every property, splits and copies keep the motion; sky-blue spans with property-key diamonds; Motion Editor tab beside the timeline: property list with values at the playhead, curve graph with draggable keys and Bézier handles, one undo step per drag. Headless: timeline.create_motion_tween, motion.*. Not yet: motion paths on the stage, retiming keys, rescaling keys with the span, XFL motion-tween import. Motion guides: guided layers (children of a guide through Layer.parent) have their classic tweens follow the guide's first path by arc length, from the point nearest each start keyframe to the point nearest its end (geom::walk::PathWalk), optionally orienting to the path; guide artwork is listed for picking and editing, drawn on the stage as a line, and never rendered or exported.
Drawing Selection (click, shift-add, marquee, drag-move, arrow nudge), Free Transform (Q): scale from corner/edge handles (Shift proportional, Alt from centre), rotate outside corners (Shift snaps 15°), move; one undo step per drag. Rectangle (corner radius), oval, PolyStar, line (45° snap), hand, zoom. Pen (P): click for corners, drag for smooth handles (Alt breaks them), close on the first point, Enter/Esc/last-point click finishes, Backspace takes back a point; one undo step per path. Pencil (Shift+Y): Smooth (Schneider curve fitting with corner detection), Straighten and Ink modes, smoothing relative to the screen. Subselection (A): anchors and handles on selected shapes, drag points/handles (anchors bring their handles; one undo step per drag), point marquee, double-click an edge to add a point, Delete removes points, right-click Make Smooth/Corner; closed shapes' start point and closing edge edit like any other. Cut/Copy/Paste in Center/Paste in Place (the clipboard carries symbols across documents). Rotate 90° CW/CCW, Flip H/V. Align left/centre/right/top/middle/bottom (Ctrl+Alt+1…6; a single element aligns to the stage) and distribute. Convert to symbol / break apart; arrange; duplicate. Headless: draw.path, draw.freehand, path.move_points/add_point/delete_points/convert_point. Paint Bucket (K): click a fill to recolour it, or inside an outline (one shape or several) to fill the enclosed area; gap size None/Small/Medium/Large closes openings; the fill is traced and curve-fitted into a new shape placed under its lines; open areas say so instead of flooding. Ink Bottle (S): gives the clicked shape the current stroke. Headless: paint.bucket, paint.ink. Tool options show first in Properties while a drawing tool is active. Text (T) (ADR 0012): click to type on the stage, click or double-click text to edit it; font (installed families, plus the embedded Inter), size, colour, bold, italic, alignment, letter/line spacing, wrap width; the last style is kept for new text; laid out by anicraft-text (fontdb discovery, harfrust shaping, skrifa outlines) and stored as outlines with the source, so rendering never needs the font; Break Apart makes a shape. Variable-width strokes (ADR 0018): a stroke's width varies along it through width points (position by arc length, a width on each side as a factor of the stroke width, smooth monotone interpolation); built-in profiles (Uniform, Taper both ends, Taper start, Taper end, Bulge, Pinch) in Properties › Width with a picture of each, and in the drawing tools' options for new strokes; the Width tool (U): hover a stroke to see its width points, drag a handle to widen or narrow (Alt: one side), drag the dot to slide a point, drag anywhere on the stroke to add one, Delete removes; one undo step per drag; rendered by the oracle as trapezoids with outer round joins and cross-section caps, written by SVG and Lottie export as the same filled outlines; shape tweens blend profiles; .anicraft keeps them (older files open as uniform). Headless: stroke.set_profile, stroke.set_width_point, stroke.delete_width_point, stroke.width_at, profile on element.set_stroke, the drawing commands and paint.ink. Not yet: width data from or to Animate files, saved custom profiles, pressure. No brush or merge drawing yet.
Plug-ins WebAssembly plug-ins (ADR 0017, docs/plugins.md): sandboxed modules run by wasmi with no imports but the AniCraft ABI (anicraft.call/anicraft.response: JSON requests that run registry commands, read a compact document view or the active layer's elements, and log); fuel (10⁹ instructions), memory (256 MiB), wall-clock (5 s), request, size and log limits, a fresh instance per run; file, plug-in, undo and clipboard commands refused. plugin.install/list/run/remove/reload; a run is atomic and one undo step named after the plug-in. App: Commands menu (Plug-ins, Install, Manage, Reload), palette entries, a dialog generated from the manifest's parameters with a live preview; plug-ins load from <settings>/plugins or ANICRAFT_PLUGINS; CLI --plugins. Samples in Rust (Star Field, Jitter Selection, guest SDK) in examples/plugins. Frame scripts: see Interactivity. Not yet: exporter and easing kinds, background runs with cancel, a binary document view.
Interactivity Frame actions, frame scripts and Test Movie, first slice (ADR 0024): a typed timeline action IR (anicraft-actions: stop, play, go to a frame or label in a scene, next/previous frame and scene, trace, set x/y/alpha/visible/rotation/scale, instance-name target paths) on keyframes and on button and movie clip instances (click, press, release, over, out); a pure, deterministic, budgeted player in anicraft-doc (step(doc, &state, &events); movie clip playheads, button Up/Over/Down states with Hit-frame hit tests, script-set properties) drawn by evaluate_player, while evaluate and exports stay script-free. Actions panel (F9: structured lists, targets/labels/scenes picked from the document; movie clip timelines too), instance name and events in Properties, an "a" on keyframes with actions. Frame scripts on the plug-in host (kind: "frame-script", entry points, player/action ops, 20 M instructions per frame shared, no document access). Test Movie (Control › Test Movie, Ctrl+Enter): the player at the document frame rate in its own window with the pointer, restart/pause/step and an Output panel. Headless: actions.set/clear/list, instance.set_name, control.test_movie (timed pointer events, returns output and state). Not yet: ActionScript (ADR 0013 tiers), HTML canvas export, sound actions, keyboard events, variables, persistent script state, masks in hit tests, a separate OS window.
Headless CLI: info, render, render-seq, gif, commands, exec, run, serve (JSON-lines). MCP server (anicraft-cli mcp, docs/mcp.md): stdio JSON-RPC, protocol 2025-06-18 (and 2025-03-26, 2024-11-05); five tools over the command registry (list, run, run a script, describe the document, render a frame as a PNG picture); confirmation tiers and undo apply as in the app.
Sound Audio layers, first slice (ADR 0020): WAV (own reader), Ogg Vorbis (lewton) and MP3 (nanomp3) import, bounded and crash-proof; sounds live in the library, stored in .anicraft as imported, decoded once in the background. A sound belongs to a keyframe as in Animate (Properties › Sound: name, Sync Event/Start/Stop/Stream, Repeat ×N or Loop); Import to Stage puts one on a new layer spanning its length, Import to Library only adds it, the Library previews, places and deletes sounds. The timeline draws each sound's waveform over its span. Stage playback plays the mix through cpal (default feature sound-output) and the playhead follows the audio clock; stream sounds resync after a jump and scrubbing plays one-frame snippets. Mixing is pure and sample-exact (doc::sound::voices + audio::mix, Catmull-Rom resampling between rates). Headless: sound.place/set/remove/rename/delete, file.import_to_library, file.export_audio (WAV, 16/24-bit or float, any rate), and Export Video carries the soundtrack (Opus in WebM, AAC in MP4, by the user's ffmpeg). Not yet: sound effects (fades, panning, envelopes) and per-layer volume/mute, sounds inside symbols, sounds from XFL, audio in Lottie/HTML, lossless compression of stored WAVs, latency compensation.
Files .anicraft JSON load/save (v3, with scenes; v1 and v2 files open as one scene), PNG frame and sequence export, animated GIF export (parallel render and quantize, exact frame timing, looping), SVG frame export (from the same evaluated frame as the renderer: stage-space paths, renderer-matched stroke widths, gradients under gradientTransform, colour effects baked in, masks as nested clipPaths). Opens Animate documents (.fla, .xfl, XFL folders; ADR 0009): stage, first scene, layers, keyframes, labels, classic tweens with ease, shapes (solid/linear/radial fills, strokes), groups, primitives, symbol instances (matrix, alpha, tint, loop, blend mode, all seven filters), library symbols, shape tweens, layer folders and mask layers (masks inside folders too); imported files are untitled so Save never overwrites them; what isn't supported yet is reported after opening. Every scene comes across. Bitmaps: library items whose image is in the package as PNG or JPEG (the original in LIBRARY/, else the bin/ data file when it is PNG or JPEG), instances, and bitmap fills with their matrix (twips scale removed; repeating unless clipped); Animate's own bitmap encodings are not public and are reported, not decoded. Text (ADR 0014): static, dynamic and input text fields become text blocks laid out by anicraft-text, with face (by PostScript name, family, or the family the name suggests; _sans/_serif/_typewriter), size, colour, bold/italic, alignment, letter and line spacing, margins, matrix, fixed width (wraps) or auto-size, and several lines; runs in different styles become one block per run of same-style lines, stacked as in Animate; a line mixing styles takes its main style and is counted; missing families fall back and are named in the report; dynamic/input fields come across as static text (reported). Shape hints on shape tweens (a tolerant self-authored shapeHints reader, ADR 0023). No per-character styles or motion tweens from XFL yet; frame scripts are counted in the import report but not kept yet (ADR 0013); Import to Stage (Ctrl+R) for SVG drawings: editable shapes on a new layer at the playhead, with groups, use and symbols, transforms, viewBox, styles, opacity and gradients; clip paths and opaque masks (ADR 0021) become mask layers in a folder named after the file (clips that cut nothing dropped, clips inside clips intersected exactly when all but one are convex polygons, curves kept), and text becomes text blocks, one per text chunk (position, anchor, font family list, size, weight, style, letter spacing, fill), with missing fonts named; soft masks, per-character positions, text on a path and dashes are reported, as is anything else unsupported. Sprite sheet export: movie frames on one PNG grid (parallel render, columns/padding/scale, transparent or stage background) with a "JSON hash" frame map (rectangles, sizes, per-frame durations). Video export: WebM (VP9) or MP4 (H.264) by streaming raw frames, in order and rendered in parallel batches, to the user's own ffmpeg (no encoder bundled; ffmpeg from a parameter, ANICRAFT_FFMPEG or the PATH; argument lists, never a shell). Lottie export (file.export_lottie): frame-accurate rather than re-keyed: each frame is evaluated, artwork that persists (same layer, element, occurrence and path structure) becomes one shape layer with outlines baked to stage space, and whatever changes (outlines, colours, gradient points, stroke width, opacity, masks as layer masks) is written as hold keyframes where it changes; one layer order consistent with every frame (topological); checked against the reference web player (matches the renderer). Reported, not exported: bitmap fills, nested masks (innermost kept), group fades (per shape), stretched radial gradients (circles).
Tests 133 tests (adds point editing, closed-path anchors, curve fitting, pen/pencil/subselection commands, the Pen's path data, frame ranges, keyframe moves, range confirmations, frame selection and the frame clipboard): unit, analytic render, band/determinism, robustness fuzz over all commands, round trip (v1 and v2 files), structural sharing and history budget, render-service equivalence, confirmations, clipboard, transforms and align, GIF decode and timing, free-transform maths, UI-guideline enforcement, CLI.
Ease of use & safety Visual language (ADR 0008, revised): graphite palette, corners by role (square structure, softened controls, rounder menus and dialogs with soft depth), borders only between layout regions, flat buttons with a visible focus ring, vibrant timeline blocks (mint artwork, violet tweens), sentence-case headings, collapsible sections with rules (Preferences, Properties, dock, shortcut sheet), Lucide icons stroked as vectors via a new full SVG path reader; click targets ≥ 28 px (tools 40, rows 28, toggles 24); palette contrast, target sizes and "no raw colours or radii" are enforced by tests. Product principles written (docs/product-principles.md). Tiered destructive-action confirmations, enforced in the engine (ADR 0004). Unsaved-changes guard on close/new/open. Crash-recovery autosave (ADR 0015): unsaved work is copied in the background (every minute or 25 changes by default; Preferences › Files › Autosave, with an off switch) to Recovery in the settings folder, atomically and never over the user's file; an OS file lock per running window tells crashed sessions from open ones; the next start offers what was left behind in a non-blocking window (Restore as unsaved work with its original path, Discard with a second click, Later; File › Recover Autosaved Documents… brings it back); saves and clean exits remove the copy; headless file.recovery_list/recover/discard_recovery/autosave. Not yet: several open documents, older copies, the undo history. Overwrite checks for saves and exports. "Ctrl+Z to undo" hints. Command palette (Ctrl+K). Shortcut sheet (F1). Right-click menus on stage, frames and layers. Save As (Ctrl+Shift+S). Shortcut editor (F1): every menu command, tool and view key can be rebound, given extra keys or unbound; recording asks before taking a key from another action, reserved keys (palette, editor, Preferences, quit, play, Esc, Space, Tab) stay fixed, per-action and global reset; only the changes are saved in preferences, so untouched actions follow new defaults; menus, tooltips and the palette show the keys in effect.
Platforms & preferences ADR 0006 platform layer: ⌘ shortcut labels and an AniCraft app menu with a unified title bar on macOS; Exit and Preferences (Ctrl+U) on Windows and Linux; native file dialogs (XDG portal on Linux, with a fallback switch); wgpu with automatic OpenGL fallback; per-OS settings folder. Preferences window: theme (Graphite or High contrast), interface and data fonts (bundled default or any installed font), interface scale (75–200 %), stage render mode, file dialogs, reset confirmations. Edits render live (fixed the missing-repaint bug). Not yet: native macOS NSMenu, macOS/Linux CI runners. Verified on Windows only so far.
Accessibility First pass (ADR 0022, docs/accessibility.md): AccessKit (via eframe) gives every control a name and role, checked by a headless test that walks the tree in 23 interface states (custom-painted tools, layer rows and toggles, icon buttons, Library rows, every Properties field, the Motion Editor, every dialog; the stage is a named canvas; the status bar a polite live region). Ctrl+F6 / Ctrl+Shift+F6 move focus between Stage, Timeline, Properties, Library and Tools (rebindable); focused controls keep Enter/Space/arrows while other shortcuts still work; pointer-only surfaces are not Tab stops. High contrast palette (Preferences › Theme) from the same roles, text ≥ 7:1, controls and focus ≥ 3:1; both palettes checked by the contrast test (the graphite one now meets AA everywhere). Interface scale 75–200 % holds up (stage refits, tools and timeline header scroll, status truncates). Not yet: stage elements and single frames exposed one by one, keyboard menu bar, following the OS contrast setting, manual passes with Narrator, VoiceOver and Orca.
Stage rendering & build Tiled stage (ADR 0007): 512 px cached tiles, batched per frame with one scene evaluation per frame, look-ahead ring and playback prefetch, scaled older tiles instead of blank areas, pixel-aligned (no seams). Space-biased build: debug build 6.9 GB → 1.04 GB, fresh build 44 s, edit rebuild 4–6 s (docs/development.md).
Scale & performance Pulled forward from M2: persistent document with snapshot undo (memory-budgeted history, save-point dirty tracking, History panel), background render worker with frame cache and playback look-ahead, band-parallel renderer with culling, compact streaming file format v2, anicraft-cli bench. Measured numbers are in docs/performance.md. Memory, sharing, file-size and culling budgets are a test on every PR; timing budgets are anicraft-cli bench --check yes (all met; the 1080p render is 15.3–15.8 ms against 16.7 ms).

Milestones

M Theme Exit criteria
M0 Foundations (this version) Workspace + layering; document model; timeline evaluation with classic tweens and easing; CPU oracle renderer; command registry with undo; .anicraft; CLI render + JSON-lines; egui shell with stage, tools, timeline, properties, library; --screenshot.
M1 Authoring core ✅ (v0.1.0) Free transform tool with handles ✅; subselection and Bézier point editing ✅; Pen and Pencil ✅; Paint bucket / Ink bottle ✅; copy/paste ✅, duplicate, arrange ✅, align ✅ (commands and menus; and the dock's Align panel ✅); onion skin ✅ (basic); frame selection ranges in the timeline (multi-frame insert/remove/move keyframes by drag) ✅ (including between layers); PNG sequence + animated GIF export ✅; keyboard shortcut map editor ✅.
M2 Model at scale Arc structural sharing (O(changed) undo) done early (ADR 0001); scenes ✅ (ADR 0011); layer folders ✅, guide and motion-guide layers ✅; mask layers ✅; Movie Clip and Button behaviours ✅ (playback; button states and scripting come with M6); group alpha / offscreen compositing ✅; shape tween ✅, shape hints ✅ (ADR 0023); motion tween + Motion Editor curves ✅ first slice (ADR 0016; motion paths on stage, 3D and XFL import later); MCP server ✅; perf budgets ✅ (machine-independent ones gate every PR; timing via bench --check on a known machine, CI once a benchmark runner exists); layering check ✅ (src/architecture_tests.rs, runs with cargo test).
M3 GPU stage (in progress) wgpu renderer behind a feature flag ✅ first slice (ADR 0019: the oracle's fills, CPU tile binning with backdrops, compute coverage; gradient tables in a storage buffer); per-pixel parity tests vs the CPU oracle ✅ (max 1/255, mean < 0.0001/255); 4K at 60 fps for 1,000 shapes ✅ (8.8–9.0 ms); next: no-readback textures, masks/groups/blend modes on the GPU, GPU binning; becomes the default stage renderer once it covers the display list and is faster everywhere.
M4 Interchange (in progress) XFL import (DOMDocument.xml, symbols, edges/fill styles decoded from the public format descriptions) with a corpus of self-authored files: first slice ✅ (see Files above); SVG import (Import to Stage) ✅, SVG frame export ✅; Lottie export ✅ (frame-accurate; easing curves instead of per-frame keys later); sprite sheet + JSON ✅; MP4/WebM via ffmpeg pipe ✅.
M5 Rich media Text engine ✅ first slice (ADR 0012: harfrust shaping, skrifa outlines, line wrapping, outlines stored with the text; per-character styles, text on a path and input fields later); bitmap import and bitmap fills ✅; audio layers, waveform display, stream sync ✅ first slice (ADR 0020: WAV, Ogg Vorbis, MP3; cpal output; effects, volume and sounds in symbols later); filters (blur, drop shadow, glow, colour matrix) ✅, bevel, gradient glow and gradient bevel ✅ (ADR 0025; SVG export and XFL import; filter presets, reordering, on/off and tweened filter values later) and blend modes ✅ on Movie Clips.
M6 Interactivity & extensibility Plug-ins: the Craft-family WebAssembly system (same host model as PhotoCraft: wasmi sandbox, plugin.* commands; AniCraft ABI for vector/timeline operations and exporters): first slice ✅ (command plug-ins over the registry, ADR 0017; exporter and easing kinds later); frame scripts on the same sandbox ✅ and button states in test-movie preview ✅ first slice (ADR 0024: action IR, pure player, Actions panel, Test Movie); HTML canvas runtime export; command macros. ActionScript compatibility, low priority (ADR 0013), last in M6 and free to slip past M8: tier 1 keeps scripts (XFL frame scripts and class names stored verbatim, Actions panel, script.* commands); tier 2 runs the ActionScript 3 timeline subset (stop, play, go to frame or label, named instances, button events) in Test Movie and HTML canvas export through the same action IR as WebAssembly frame scripts. The full language, the flash.* API and SWF bytecode are not planned.
M7 Advanced animation Bone/IK tool; camera layer with depth; variable-width strokes ✅ first slice (ADR 0018: width profiles, Width tool, exports, tweens) and brush library; asset warp; graph-based easing presets library.
M8 Release quality Installers and signing for Windows/macOS/Linux; web build (wasm) of the editor; localisation; accessibility: first pass ✅ (ADR 0022: screen-reader names for every control, Ctrl+F6 panel focus, high-contrast theme, 200 % scale), next: stage elements and frames for screen readers, keyboard menu bar, the OS contrast setting; crash-recovery autosave ✅ (ADR 0015); documentation book.

Releases

v0.1.0 (early alpha) marks M0 + M1 complete (see CHANGELOG.md). main starts with that one commit; publishing it follows the checklist in docs/release.md.

Parallel tracks (from 2026-11-09)

Milestones whose next task needs no unfinished work from another milestone run at the same time, one agent per track (AGENTS.md › Milestone tracks). Each task is still its own PR to main, titled with its milestone.

Track Next task Depends on (all done)
M2 Motion tweens with property curves and the Motion Editor timeline evaluation, classic tweens
M3 GPU stage: no-readback textures, then masks, group opacity and blend modes on the GPU (first slice ✅, ADR 0019) CPU oracle, tiled stage, GPU stage first slice
M4 Text from Animate files XFL import, text engine (M5 first slice)
M5 Audio layers: import, waveform, playback sync timeline, layers
M6 WebAssembly plug-ins (U2) ✅ first slice (ADR 0017); frame scripts and Test Movie on the plug-in host ✅ first slice (ADR 0024); next: HTML canvas runtime export command registry, plug-in host, action IR and player
M7 Variable-width strokes ✅ (ADR 0018); next: Brush tool and brush library strokes, Pen and Pencil, width profiles
M8 Crash-recovery autosave ✅, accessibility first pass ✅ (ADR 0022); next: installers and signing, or the accessibility follow-ups .anicraft format, session, AccessKit in eframe

Tasks that wait on an open track: XFL motion tweens (on M2's motion tweens); frame scripts and ActionScript (on M6's plug-in host); GPU as the default stage (on M3's parity).

Current focus (after M0 + scale foundations)

The person confirmed that opening Animate files (XFL) is the first interchange priority. The undo/performance foundations it needs are in place, so XFL import (M4) can move up once the authoring core below is solid.

Landed in M1 so far: Free Transform, clipboard, rotate/flip, align/distribute, GIF export, and now Subselection, Pen and Pencil on a path-editing model in the engine (points addressed by command and slot, so XFL edge data can map onto it). The Pen's interaction and the Pencil's curve fitter were borrowed from PhotoCraft and reviewed before porting (see src/pathtools.rs and crates/geom/src/fit.rs for what changed and why). PolyStar no longer has a key (P is the Pen, as in Animate).

Next, in order:

  1. M4 XFL import, next slices: masks (with M2 mask layers) ✅, shape tweens ✅, every scene ✅, bitmaps ✅ (PNG/JPEG data), text ✅ (one style per line; per-character styles with the text model), motion tweens, and a larger self-authored corpus checked by render tests.
  2. SVG import ✅ and SVG frame export ✅, text, clip paths and masks (onto mask layers) ✅ (ADR 0021). Next for SVG: dashes, soft (luminance) masks, per-character text positions and text on a path.

Risks

Risk Mitigation
GPU and CPU renderers drift apart Golden parity tests in CI; CPU stays the oracle.
XFL edge encoding is under-documented Build a self-authored corpus; unknown elements kept verbatim; fail with readable errors.
egui immediate-mode cost with big timelines Virtualise the frame grid (paint only visible cells); cache layer row summaries per revision.
Snapshot undo memory Arc structural sharing in M2; history size cap with a preference.