115 KiB
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)
Streaming WAV headers and PCM sample blocks now delegate to craft_audio::wav_stream;
AniCraft retains mixing, frame-range limits, temporary-file cleanup and VFS writes.
This integration depends on craft-libs #1962 and still requires hosted parity validation.
| 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 (with reflect/repeat, focal points, elliptical radials and linear RGB, ADR 0074), round-join strokes. A stroke is covered as one outline (ADR 0110): the stroker builds each run of segments as an outline and unites the loops, so pixels where its pieces used to overlap (round joins and caps, the joints of wide curves, dashes that run together, a line crossing itself) are no longer up to half a pixel too dark, on the CPU and the GPU stage alike; a line with corners, flat or square ends is drawn pixel for pixel as its Convert Lines to Fills fill, a curved or round one within the 0.1 px flattening (not yet: one geometry for both on curves, a per-stroke outline cache, dashes measured along the curve). 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. Soft masks (ADR 0070): a mask layer's mask type is Shape (coverage), Alpha (its artwork's opacity as drawn: gradients, faded shapes, strokes, bitmaps) or Luminance (brightness × opacity, SVG's coefficients), in the CPU oracle (analytic tests), the GPU stage (parity: mean 0.00006, worst 1 step of 255), SVG export (<mask> with mask-type), Lottie (alpha and luma track mattes) and the HTML canvas; Layer Properties › Mask type. 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. Filters apply in list order and may be switched off (ADR 0091): evaluate leaves switched-off ones out, so every renderer and export draws them as absent. 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. Second slice (ADR 0029): on the window's wgpu device the stage tiles are drawn straight into textures egui shows (no readback; a headless device with readback when the window is on OpenGL); masks (nested, united artwork), group opacity and all 14 blend modes on the GPU, same parity (max 1/255, mean ≤ 0.0011/255); 4K: 1,000 shapes in 2.1–2.4 ms, 10k shapes in 10.2 ms as stage tiles, masked scenes 7× the CPU. Third slice (ADR 0032): bitmap fills (textures uploaded once per image and cached under a 256 MB budget, sampled with the oracle's own bilinear filter, colour effect and repeat rules: byte-identical) and all seven filters (each filtered symbol drawn into a layer of its own and filtered by compute passes that run the oracle's resolved steps: max 1/255, mean ≤ 0.007/255) on the GPU; the shaders now build with Direct3D's FXC, so DX12 windows get the GPU stage too (parity suite green on Vulkan and DX12); software adapters are refused (the CPU is faster), the start-up self-test compares with the oracle. The GPU is the default stage renderer: the shell's gpu-stage feature is on by default, Preferences › Stage › Renderer defaults to Graphics card (GPU), and the CPU draws whenever there is no usable card, a tile is past the GPU's limits (more than 16 images, filters nested deeper than 4) or anything fails. 4K: the filtered sample in 3.9 ms (CPU 31.5), 200 bitmap fills in 4.4 ms (CPU 37.2). Fourth slice (ADR 0048): tile binning on the GPU for heavy frames without masks or groups (count, prefix sum, scatter and tile-list passes, no atomics, no readback; the CPU binning stays the reference and does the rest; one tile format for both: an integer backdrop per tile and steps on the tiles' left edges): on Vulkan, 10k shapes at 4K in one texture 21.7 → 4.7 ms, 50k shapes 122 → 22.5 ms, the 50k-shape 4K stage 75 → 37 ms (Direct3D 12 keeps CPU binning: slower there in stage tiles); and hairlines for outline mode in both renderers (coverage by distance, one edge per segment): onion outlines on the 2,000-item stress scene as fast as tinted (GPU stage 73 → 10 ms, CPU stage 34–39 → 17 ms at 1080p). Mid-session failures (ADR 0092): a broken GPU stage hands the stage to the CPU at once with a status-bar notice and a log line, and is retried with a bounded backoff; driver errors on the window's device are logged instead of panicking (the #255 Surface::configure panic), and a lost window device autosaves and reopens the window on a safer way. Not yet: sharing a filtered layer across a frame's tiles, more than 16 images per tile, GPU binning inside masks and groups, flattening and stroking on the GPU, buffer reuse and fewer dispatches across tiles, hairlines for sub-pixel strokes, GPU exports, a GPU runner in CI; the CPU stays the oracle and the export path. |
| Timeline | Frame selection: click, Shift-click or drag across frames and layers; F5/Shift+F5, F6/F7 and Shift+F6 (keys, icon buttons and right-click menu) act on the whole selection; with no frame selection F5 extends every layer with frames at or after the playhead, and F5/F6/F7 move the playhead on as in Animate (F6/F7 on a keyframe key the next frame; all_layers/advance headless); drag selected keyframes left or right to move them, and up or down onto other layers (the source keeps empty frames) (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; a motion tween's keys stretch in proportion, ADR 0083). Side dock tab strips never run under the panel menu (names shrink with an ellipsis, then the strip scrolls). Headless: layers/count on the frame commands, timeline.move_keyframes, timeline.cut_frames/copy_frames/paste_frames. Layers (show/lock/outline), timeline polish (ADR 0061): a per-layer onion skin toggle column (Alt-click solos; left-out layers aren't onion-skinned; Edit Multiple Frames unaffected), the colour square toggles View as Outlines in the layer colour on the stage only (exports, Test Movie and the player draw the artwork as it is), the colour chip opens the layer colour (swatches, hex, More…), onion frames of the parent timeline dimmed around a symbol edited in place, Layer Height 100/200/300 %, Layer Properties (double-click the layer icon; name, show/lock, type, outline colour, outlines, onion, height; one undo step), Frame View (Tiny/Small/Normal/Medium/Large, Short rows) with the frame zoom in the timeline's bottom bar (the header fits at the default window size, tested); headless layer.set_onion/set_color/set_height/set_properties/properties; XFL heightMultiplier. Not yet: folder onion toggles, onion of deeper parent timelines, multi-layer Layer Properties and layer transparency, frame thumbnails (Preview). Layers by drag and all at once (M8, from the issue tracker): drag a layer by its name to reorder it or drop it on a folder (a line shows where it lands; folders, masks and guides move whole; one undo step; `layer.move {before |
| Drawing | Selection (click, shift-add, marquee, drag-move, arrow nudge; across layers, ADR 0044: a selection holds artwork on several visible, unlocked layers, the timeline marks them, Properties shows mixed values), Free Transform (Q): scale from corner/edge handles (Shift proportional, Alt from centre), skew by dragging the line between two handles (the opposite edge stays, Alt about the centre; outside PR #176), 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; pasted raw shapes float, selected, until they are deselected, and Paste takes a picture copied in another app as a bitmap, ADR 0108; not yet: vectors copied in other apps). Free Transform: not yet a transformation point you can move (it is the box's centre) or a box that turns with a rotated object. 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, under or over the artwork, snap accuracy up to Always); Snap to Pixels; one snap engine for every drawing tool, the Selection tool's moves and Free Transform's handles (point › guide › line › grid › pixel, guides and grid per axis); stage only, never exported, on the CPU and GPU stage. Headless: view.rulers, view.grid_show/grid_snap/grid_set, view.guides_show/guides_lock/guides_snap/guides_set, view.guide_add/guide_move/guide_delete/guides_clear, view.snap_pixels, view.aids, moving on draw.snap. Not yet: units other than px, a movable ruler origin, a symbol's own guides, guides and grid from Animate files, Snap Align and Edit Snapping, snapping while rotating. 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. Stroke styles (ADR 0046): Properties › Style (Solid, Dashed with dash and gap, Dotted with spacing), Cap (None, Round, Square), Join (Miter, Round, Bevel) and Miter limit, also in the drawing tools' options for new strokes; drawn exactly by the oracle (butt and square caps, miters bevelled past the limit, dashes by arc length restarting per subpath, round dots, dashes keeping a width profile's widths; sub-pixel patterns solid and faded) and so by the GPU stage; the Ink Bottle carries the style and the Eyedropper picks it; merge drawing keeps it on cut pieces; shape tweens blend miter limits and dash lengths; SVG, HTML canvas and Lottie export write it. Headless: stroke.set_style, and cap, join, miter, style, dash, dash_offset, dot_spacing on element.set_stroke, the drawing commands and paint.ink. Not yet: Animate's ragged, stipple and hatched styles, multi-dash patterns in Properties (kept and editable by command), stroke scale modes and hairlines. Merge drawing (ADR 0031, first slice): with Object Drawing (J) off, the editor's default, the shape tools, Pen and Pencil draw raw strokes and fills that cut and join the raw shapes they touch (a fill on top replaces what it covers or joins the same colour, lines cut each other and the fills they cross, a fill hides the lines under it, points within 0.2 px are one; exact Bézier pieces, anicraft_geom::planar); one element per fill region and stroke run, selected with Animate's dot pattern; double-click selects connected strokes, or a fill with its outline; a dragged or nudged raw shape merges where it lands; arrows move 1 screen pixel (Shift 10). Headless: object on the drawing commands (scripts draw objects by default), draw.object_drawing, draw.drop, element.select_connected. Selection tool on raw shapes (ADR 0041): drag an unselected segment or fill edge to bend it through the pointer (every shape sharing the edge bends with it), an unselected corner or end to move it with every raw shape that shares it, a fill to move only that fill; points and selections snap to points, strokes and fill edges within 10 screen px (snap ring), and arrow nudges join ends within 0.2 px at their midpoint or onto a line that stays put; a corner or curve mark by the pointer shows what a drag does; the marquee selects the parts of raw fills and strokes under it, cut at its edges (taken back if nothing uses them, no undo step), and objects wholly inside; each drag one undo step, merged on release. Headless: path.bend_segment, raw.move_point, raw.select_rect, raw.merge, raw.hit, snap on element.translate. Subselection on raw shapes and merging everywhere (ADR 0042): with Subselection (A), a click on a raw line or fill shows the anchors of everything connected to it (once per shared point; hollow, selected ones solid) and the handles of the selected anchors' curves and of the clicked edge; drag an anchor to move it with the other selected ones and every shape on them, a handle to change the curve in every shape that has the edge, a line or fill to move everything connected; Shift adds or removes anchors; the marquee takes whole shapes on the active layer and selects the anchors inside; arrows nudge 1 screen px (Shift 10); one undo step per gesture, merged on release. Snap to Objects (View › Snapping, a magnet under the tools, the selection tools' options) switches the Selection and Subselection tools' snapping. The Paint Bucket's raw fills are exact (up to the lines and fill edges, from the planar merge) and join fills of their colour; pasted raw shapes cut what they land on; raw shapes from Animate files open raw and merged; gradient and bitmap fills take part in the merge. Headless: raw.subselect, raw.subselect_rect, raw.points, raw.move_handle, with on raw.move_point, draw.snap_to_objects, object on paint.bucket. Width profiles take part in the merge since ADR 0093. Raw points and symbols in place (ADR 0045): add a point on a raw edge (Pen Alt-click, Subselection double-click; every shape on the edge gets it, the curve unchanged), delete raw points (Delete; the shapes on each are joined across it so the drawing stays connected; points where three edges meet are kept), Make Smooth / Corner on raw points, smooth handle pairs (Alt breaks them; drawing objects too); the Line, Rectangle, Oval, PolyStar and Pen tools snap their points within 10 screen px (Snap to Objects, Ctrl+Shift+/); a double-click on an instance (or Ctrl+E, or a double-click in the Library) opens the symbol in place, the stage dimmed around it, the edit bar showing the path back, and every tool and command works on its timeline. Headless: raw.add_point, raw.delete_points, raw.convert_points, draw.snap, smooth on raw.move_handle and path.move_points, symbol.edit, symbol.exit. Not yet: rotated instances in place (they open upright). Onion skin and Edit Multiple Frames work inside a symbol since ADR 0051. Brush (B) (ADR 0033, first slice): paints filled shapes in the fill colour, the exact area the tip sweeps (a distance field traced and fitted with cubics); round or square tip with size, angle and roundness (oval and flat calligraphic tips), pen pressure from a tablet (10–100 % of the size; a mouse paints full size), smoothing relative to the screen, Paint Normal, Paint Fills and Paint Behind; a raw shape that merges with the drawing, or a drawing object with Object Drawing on; a click paints a dab; live preview while dragging; [ and ] change the size; one undo step per stroke. Headless: draw.brush. Paint Selection and Paint Inside (ADR 0080): the paint is clipped to the selected fills' union, or to the fill (or closed-off empty area) the stroke starts in, exactly on the planar map, then merged under the lines; Paint Selection keeps the selection for the next stroke. Not yet: the live preview clipped as it paints. Brush library, pressure curves and the Paint Brush (Y) (ADR 0068, first slice): Window › Brush Library with seven built-in brushes made only of parameters (Pencil, Ink Pen, Flat Calligraphy, Round Taper, Marker, Chalk with a deterministic worn edge, Dotted stamps), each with a stroke preview drawn by the renderer; brushes of your own saved by name in your preferences, renamed, deleted (asks first) and moved between computers as a JSON brush set; a pressure curve editor (Linear, Soft, Firm, or your own points) driving size and, optionally, the stroke's opacity; tapers, dab spacing and a rough edge in Properties; Velocity (mouse speed as pressure, off by default); the Paint Brush draws a width-profiled stroke in the stroke colour that the Width tool edits. Headless: brush.preset_list/save/rename/delete/export/import, preset, curve, as_stroke and the shaping params on draw.brush. Tilt, texture and scatter (ADR 0093): per-sample pen tilt (Pointer Events altitude and azimuth in draw.brush points) turns the tip by the azimuth and widens it up to 2× as the pen leans (Brush › Tilt: Angle, Width, shown once a pen reports tilt; the Paint Brush's width too), a fixed paper grain of holes (Texture) and dabs thrown either side (Scatter), all vector fills; built-in Charcoal and Spatter (nine brushes). Not yet: reading tilt from the pen on desktop systems (winit 0.30 reports it only on iOS), opacity varying along a stroke, bitmap or art brushes, Eraser presets and pressure. Eraser (E) (ADR 0034, first slice): sweeps the Brush's tip and takes what it covers out of the raw shapes on the active layer (the sweep is a fill in the planar merge that comes out empty); Erase Normal, Erase Fills, Erase Lines, Erase Selected Fills and Erase Inside; the Faucet deletes a whole fill or line with a click; drawing objects, symbols and text are kept; a stroke that erases nothing leaves no undo step; live preview, [ and ] sizes, one undo step per stroke; double-clicking the tool (or Erase Everything… in its options) clears the visible, unlocked layers at this frame after asking. Eyedropper (I) (first slice): a click on a fill picks its paint (solid, or a gradient or bitmap kept where it is on the stage, as Lock Fill) into the fill swatch, a click on a line picks its colour, width and profile; with shapes selected it applies the style to them; then it becomes the Paint Bucket or the Ink Bottle; Shift-click picks into the other swatch only. Headless: draw.erase, draw.faucet, draw.erase_all, paint.pick, paint.apply_style. Since ADR 0093: width-profiled lines erase and merge, each piece keeping its widths; gradient pieces keep their gradient where it was; inside an open symbol or drawing object the Eraser erases its shapes, and on the stage the status bar says how. Not yet: eraser pressure, picking text styles, an eyedropper cursor (a bitmap's pixel colour comes from the colour picker's eyedropper, ADR 0109). Modify › Shape, the picker's eyedropper and transformation origins (ADR 0109, M1; #179, #288, #296): Convert Lines to Fills (a line's exact outline as curves, with caps, joins, dashes and width profile, within a pixel of what the renderer strokes; raw fills join the drawing, objects stay objects), Expand Fill (exact offsets in stage pixels: expanding rounds corners, insetting keeps them) and Soften Fill Edges (1 to 50 bands, alpha stepping down, expand or inset, on colours and gradients), each with Animate's dialog; while a colour picker is open a click on the stage takes the colour drawn there (paint.sample: gradients, bitmaps, lines, effects), with a preview chip and Esc to cancel; Free Transform's Transform about (the whole selection, each object's registration point, each object's centre), marked on the stage, followed by Rotate 90° and Flip, with a bindable command to cycle. Not yet: origins with Edit Multiple Frames, previews in the two dialogs, miter corners for Expand Fill, picking from outside the window. The transformation point, a turning box and layer opacity (ADR 0111, M1; #302, #280, #178, #183, #175, #279): Free Transform's white circle is dragged (snapping to the box's handles and centre, free with Alt, also outside the box) and double-clicked back to the centre; a symbol instance keeps its point in the file (pivot, in its own space) and Free Transform, Rotate 90° and Flip, Properties' Scale and Rotation (a Pivot row with Reset) and classic and motion tweens turn and scale it about it (an arm swings on its shoulder); raw shapes, groups, text and several objects have a point for the selection while the tool is held; one selected element shows its own box, turned, scaled and skewed with it, its handles acting along its own axes; layer opacity (Layer Properties, the layer's right-click menu, a percentage beside the name): the layer fades as one group in evaluate, a folder fades its layers, in every export and on the CPU and GPU stage. Headless: modify.transformation_point, modify.reset_transformation_point, layer.set_opacity, opacity on layer.set_properties. Not yet: the transformation point of Animate files' instances, a kept point for groups, text and drawing objects, the point with Edit Multiple Frames and on motion guides, opacity keyed over time, an authoring-only layer transparency. Colour picker and drawing-tool fixes from user reports (M1): every colour swatch (the Tools panel's fill and stroke squares too) opens one picker with Animate's web-safe swatches (216 colours, greys and primaries), the colours mixed or typed this session, a hex field, an alpha (a solid fill's own, and a different one on each gradient stop) and the full mixer; the Tools squares offer No Colour and recolour selected shapes; drawing tools leave nothing selected after a stroke and the Selection tool's box has no handles (they are Free Transform's); Break Apart turns drawing objects into merged drawing; Ctrl-drag on a raw edge adds a corner point; the Pencil and Line show no fill. Swatches panel (ADR 0078): Window › Swatches, the document's saved colours and gradients (in the .anicraft file; a default set for new documents and older files); click applies to the selection and the tool colour, to the stroke or fill that is active (Tools squares, Colour panel or the panel's toggle; gradients always to the fill); + adds the active colour or gradient, Duplicate, Delete, drag (or Alt+arrows) to reorder, names on hover, Clear (keeps black and white) and Load Default Swatches (ask first, undoable); import and export as a JSON swatch file, GIMP .gpl import; the colour picker shows the document's swatches and the fill picker its gradient swatches. Headless: swatch.list/add/remove/move/duplicate/rename/apply/clear/reset/import/export. Not yet: swatch folders, sorting by colour, bitmap swatches, Save as Default, XFL swatch import (no public description), Adobe .aco/.ase/.clr (proprietary). The layer footer is icon buttons (New Layer, Delete, New Folder, Up, Down) that fit at any size and language. Groups and Combine Objects (ADR 0073): Modify › Group (Ctrl+G) / Ungroup (Ctrl+Shift+G), a group element whose members are a one-layer, one-frame timeline, opened in place by a double-click like a symbol (every tool works inside; raw shapes merge only with each other); nested groups; exports, player, sounds and the Library see inside; XFL DOMGroup imports as groups. Combine Objects › Union, Intersect, Punch, Crop on the planar map (analytic area tests). Selection tool: Alt-drag copies, Shift constrains to 45° (Ctrl/⌘-drag corners: #257). Drawing parity leftovers (ADR 0080): PolyStar's Shape (Polygon or Star), sides 3–32 and star point size 0–1 in its options (shape, sides, point_size on draw.star); a double-click (or Ctrl+E) opens a drawing object in place, its raw shapes merging only with each other, and it closes as one object again (a group of the pieces when an edit leaves several); Modify › Transform › Envelope: a Bézier mesh of corner and tangent handles bends the selected shapes and drawing objects, one undo step per drag, baked like Animate's (no Delete Envelope needed), undo restoring the mesh; headless modify.envelope, modify.envelope_move, modify.envelope_close. Not yet: gradient and bitmap strokes (proposed in ADR 0080), envelope handles from the keyboard, an envelope on symbols, text or groups, drawing objects edited without opening them (#181), Combine across layers. Rulers, grid and guides (ADR 0076): View › Rulers (stage pixels, following zoom and pan, pointer marked); guides per scene saved in the document, dragged from a ruler, moved with the Selection tool, dragged back to delete, Show/Lock/Snap/Edit/Add/Clear (Edit Guides lists and adds them from the keyboard); a grid (spacing, Pen parity and Keep area (ADR 0115, #319, #408): the Pen makes its last point a corner on a click, pulls a new handle or redraws the curve (Alt) from it, keeps 45° steps with Shift, previews the next segment as it curves, and on a selected path converts and deletes points, adds them on the outline and continues an open drawing object from either end (path.extend), with a mark by the pointer for each; tweens of any kind take Keep area (timeline.set_keep_area): scale goes geometrically between keys so keys of one area keep it on every frame, an unkeyed scale axis of a motion tween follows the other, the Motion Editor draws the derived curve and exports bake it. Not yet: continuing a merged line as the same stroke, OS pen cursors, Keep area per segment. |
| 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. Exporter and ease plug-ins (ADR 0088): kind: "exporter" declares a format (name, extension, options) and gets evaluated frames (movie, frame: the flattened display list, never the document), returning the file's bytes from ac_export (64 MiB cap, 5·10¹⁰ instructions, 10 min); File › Export lists it with an Export window (options, frames, file, progress bar and Cancel on a worker thread); file.export_plugin, file.export_formats, anicraft-cli export --format <id> and formats. kind: "ease" declares named eases, ac_ease(i, t) sampled into 257 values at load (NaN, unbounded or end-missing eases refused); Easing::Sampled keeps the table in the document, so it plays the same without the plug-in; the ease menus list them under Plug-in eases; {plugin, ease} easing params. Samples: Plain Text Frames and Stepped Eases, built and run in CI. Not yet: plug-in formats in Publish, bitmaps' pixels and sounds for exporters, ease plug-ins with parameters, background runs of command plug-ins, 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. A window of its own on the desktop (ADR 0062): sized to the stage at 100 % (smaller to fit the screen), titled with the document, back where it was last (not on Wayland, where the desktop places windows), with the keyboard when it opens; Esc or Ctrl+W (⌘W) closes it, Ctrl+Enter restarts it in place, and the editor's Ctrl/Alt shortcuts work from it; floating inside the editor in the web build, where the system can't open windows (it says so), or by choice in Preferences › Test Movie. Not yet: full screen, zoom in the movie window, remembering its size. Headless: actions.set/clear/list, instance.set_name, control.test_movie (timed pointer events, returns output and state). HTML canvas export (ADR 0028, file.export_html, File › Export › Export HTML Canvas…): one self-contained page (data, player and drawing code inline; images and sounds embedded) that plays in any browser with canvas 2D; every used timeline baked frame by frame (tweens of every kind exact, identical paths, paints and frames stored once), movie clips, buttons with Hit areas and every action run by player.js, a port of the Rust player checked against it step by step in Boa (state, output and display list); masks and fading/blending groups on offscreen layers; filters and Subtract/Invert in the page (ADR 0072: filters.js, a port of the renderer's filters run over the group's pixels on a layer that reaches past the canvas by the filters' reach, Subtract and Invert composited per pixel, results kept while the group is unchanged; equal to the oracle's pixels within 9.3e-4 in Boa; 3.4 ms a frame for the demo's filters at 1080p while they change); Web Audio for Event/Start/Stop/Stream sounds; bitmap tints, 9-slice scaling and plug-in frame scripts reported. Not yet: 9-slice in the page, keeping a moving filtered group's pixels, filters off the main thread. Kept frame scripts (ADR 0013 tier 1): scripts written in another language (an Animate document's ActionScript) kept verbatim on keyframes with their language, symbol linkage classes and the document class; the Actions panel's Script view (monospace editor with line numbers, language, live and undoable), the same "a" marker, Class rows in Properties; script.set/clear/list/set_class; ActionScript timeline subset runs (ADR 0013 tier 2): a hand-written, bounded lexer and parser (anicraft_actions::as3) lower stop/play/go to/next and previous frame and scene on instance-name paths, mouse listeners (click, down, up, roll over and out; named or inline functions, currentTarget), trace and property settings to the action IR, compiled once per script; anything else is reported with line and column and the script doesn't run (never half-run), navigateToURL and the like are ignored and noted; the player keeps listeners per instance, Test Movie's Output says which scripts run and which don't and why, the Script view lists problems in place, the XFL report and script.list/check say what runs, and the HTML page runs the same steps (player.js checked against the Rust player). ActionScript small logic (ADR 0052): scripts compile to a small typed script IR evaluated by the player with fuel (100,000 per script or listener call, 1,000,000 per step; an endless loop or a run-time error stops its script with an Output line and the movie plays on): typed variables (Number, int, uint, Boolean, String, untyped) kept per timeline instance across its frame scripts, expressions as ECMA-262 has them, if/else, for/while/do, functions with parameters, results and recursion, called from any frame of the same timeline (a timeline-level link step; names that aren't there keep the script from running, said in place), property reads of instances and timelines (x, y, alpha, visible, rotation, scaleX/Y, currentFrame, totalFrames, currentLabel, mouseX/Y, name), removeEventListener, Event.ENTER_FRAME, KeyboardEvent.KEY_DOWN/KEY_UP on the stage with e.keyCode, e.target/e.currentTarget, seeded Math.random(); keyboard in Test Movie and the HTML page, control.test_movie key events and seed; player.js mirrors the evaluator, checked step by step in Boa. Not yet: ActionScript switch, for in, arrays and objects, string methods, closures, event bubbling, mouse listeners on the stage, ActionScript 1.0/2.0, scripts on instances, filters and keyboard focus in the HTML page, sound actions, keyboard events, variables, persistent script state, masks in hit tests, a separate OS window. Buttons, complete (ADR 0057): a button open in place names its frames Up, Over, Down and Hit on the timeline and shows its Hit area translucent over the other states; Test Movie has Show hit areas; sounds on its frames play as its state changes. |
| Headless | CLI: info, render, render-seq, gif, apng, webp, 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. Live control (ADR 0104, docs/control-protocol.md): anicraft --control <port> and anicraft-cli mcp --bridge <port> run the same tools on the open window, on this computer only, with a per-run token in control.json. |
| 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). Second slice (ADR 0039): each frame sound has an Effect (None, Left channel, Right channel, Fade left to right, Fade right to left, Fade in, Fade out, shaped over the time it is heard, or Custom: up to 16 volume points per channel in the Edit Envelope window, drawn on each channel's waveform; the timeline's waveform follows the envelope). Layers holding sounds get a Volume and Mute (Properties, and a speaker toggle in the timeline); volumes multiply down through symbols and muted layers are silent in playback and every export. Sounds inside symbols play: a graphic's on its own frames mapped to the parent's time (loop mode and first frame apply; streams join mid-way and follow the parent playhead), a movie clip's on a loop from when the instance appeared; in the interactive player and Test Movie (which now has sound, the picture keeping time with it) movie clips start theirs as their own timelines reach them. The HTML page carries envelopes, volumes and graphic sounds. Headless: sound.set {effect, envelope}, layer.set_volume, layer.toggle_mute. Sounds on button frames (ADR 0057) play in Test Movie and the HTML page as the pointer changes the button's state (Over, Down, and Up and Hit on leaving and release, as the SWF format keeps them; never in the soundtrack); control.test_movie lists the sounds it starts. XFL brings sounds whose file is in the package (WAV, Ogg, MP3) with the sounds on frames that use them, buttons' included. Output polish (ADR 0095): the playhead follows the sound heard (the device's latency taken off, frames dropped rather than drifting; under a frame off over an hour in tests), event sounds play to their end across a loop and after the last frame (Enter stops all), a monitor volume and mute in the timeline header (Control › Mute Sounds; the listener's, in preferences, never in exports), Control › Audio Scrubbing (a slice of at least 1/20 s), a lost or missing device never crashes (silent playback, one notice, a log line, reopened on the next play; a new default device is followed), and the web build plays sound through Web Audio. The device sits behind an Output trait, so the clock and mixing paths are tested with a fake one. Audio to keyframes and auto lip-sync, first slice (ADR 0114, #332): anicraft_audio::analysis gives a sound's loudness per movie frame (RMS, normalised to the loudest frame, gated by a threshold, smoothed by a centred average) and, for speech, one of five mouth shapes per frame (rest, open, wide, round, closed) from band energies of a short FFT sorted by the vowels' public formant values, with no speech recognition; pure, deterministic and bounded (10 minutes of sound: levels in 19 ms, mouths in 135 ms). Convert Audio to Keyframes (sound.to_keyframes; Modify › Timeline, Properties › Sound) maps the loudness onto an object's scale, alpha, position or rotation offset, or a graphic symbol's first frame, as keyframes or as a motion tween's property curve; Auto Lip-Sync (sound.lip_sync; also beside Looping in Properties) keys the frames of a graphic symbol of mouth poses, found by its frame labels as the mouth chart template names them; sound.analyse reports both headless. One dialog previews everything live (a graph of loudness, threshold, value and key ticks, or a row per mouth; the keys themselves on the stage and timeline), one undo step. Not yet: driving the camera, armature layers or filter values from sound; classic tweens between the keys; more than five mouth shapes (F/V, L and the other consonants are placed by hand) or a script as input; the sound's effect and layer volume in the measured loudness; sounds kept only in Animate's own data format (undocumented; reported), sound effects and in/out points from XFL, sound panning beyond the envelope, audio in Lottie, stream sounds that follow go-tos in the HTML page, lossless compression of stored WAVs, choosing an output device other than the system's default, stopAllSounds as a timeline action. |
| Documents | Several open at once (ADR 0112): tabs above the edit bar, the shown document in App, the others parked whole (session, view, autosave) and exchanged in O(1) (0.2 µs median); the engine and the CLI/MCP stay one document per session. Cross-document paste remaps Library ids (engine::transfer). Not yet: a tab in its own window, another document's Library in the panel, session restore, a shared undo budget. |
| 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), animated PNG and animated WebP export (WebP container writing delegates to shared craft-webp; APNG framing remains app-local; ADR 0063: full colour and real alpha, transparent or on the stage colour; every frame exactly the renderer's; repeated frames merged into longer delays; later frames only the rectangle that changed (APNG blends opaque changes over, WebP replaces); APNG delays exact fractions of the frame rate, WebP milliseconds that never drift; loop forever, once or N times; File › Export, Publish Settings, the web build's downloads, anicraft-cli apng/webp; not yet: lossy WebP (no permissive pure-Rust VP8 encoder exists), dispose-to-background frames, palette or RGB APNG for smaller files), SVG frame export (from the same evaluated frame as the renderer: stage-space paths, renderer-matched stroke widths, caps, joins and dashes, gradients under gradientTransform, colour effects baked in, masks as nested clipPaths). Opens Animate documents (.fla, .xfl, XFL folders; ADR 0009; .fla archives in every common zip layout, ZIP64 included, and hostile ones refused with a readable error, ADR 0054): 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. One damaged bitmap, sound or library symbol is left out and reported rather than refusing the whole file (#226), and a document without a stage colour gets Animate's default white (#163). Archives whose end record overstates the directory's size, as Flash CS5 to Animate write most .fla files, open (#356; until the shared reader does it, storytold/craft-libs#1986). Binary .fla (Flash CS4 and earlier) is not read and says so (#163, #289: a stretch goal in requirements.md, no clean-room reader yet). 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). Colour effects in every style (Brightness, Tint, Advanced, Alpha; ADR 0056), movie clip and button instance names, one-segment custom eases (as cubic Béziers); a symbol without symbolType is a movie clip; frame comments aren't labels. Stroke caps, joins and miter limit, dashed and dotted strokes (ADR 0046; ragged, stipple and hatched are drawn solid and reported). Reported rather than silently changed: gradient strokes, repeating/reflecting, focal-point, elliptical and linear-RGB gradients, reverse loop modes, extra tween spins. A self-authored corpus with golden renders covers all of it (ADR 0035). Shared craft-xfl readers now parse filters, shape hints, tween easing, and frame-sound envelopes; AniCraft retains document-model mapping and validation. The XFL schema audit remains in progress, including per-character styles and motion-tween records; frame scripts are kept verbatim (scenes and every symbol, with the language from the publish settings), with symbol linkage classes and the document class, and the report lists them as kept, not run (ADR 0013 tier 1; scripts on instances and linkage on bitmaps and sounds are reported); 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; stroke caps, joins, miter limits and dashes come across (ADR 0046); soft masks, per-character positions and text on a path 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): each frame is evaluated, artwork that persists (same layer and element, or the same look on the same layer across keyframes) becomes one shape layer, and what changes is written as keyframes with Lottie's Bézier eases (ADR 0089): holds where values stay, eased keys wherever an ease of the document draws the frames exactly (linear, Classic, Bézier, custom curves, Quad/Cubic/Back/Bounce; a key per cubic piece), checked at every frame, and a hold key per frame only where nothing exact exists (Elastic, Sine…, reported once); moving artwork keeps its outline in its own space under an animated group transform (position, rotation, skew, scale), and shape tweens between outlines of one structure are shape keys; a playback parity test plays the file with a Lottie player written from the spec through the oracle at every frame (sample scenes, a movie of every ease, the XFL corpus); files 57–90 % smaller (demo 46.7 → 10.4 kB); 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). HTML canvas export (file.export_html, ADR 0028): one self-contained web page that plays the movie, buttons and actions included (see Interactivity). Drops, Open Recent and the start screen (ADR 0059): files dropped on the window open (documents) or import onto the stage at the drop point on the active layer, or into the Library folder under the pointer, in one undo step (file.drop), with a drop highlight; File › Open Recent (10 recent, pinned favourites, missing files greyed with Remove) kept in the preferences; a start screen at launch with New presets (1280 × 720, 1920 × 1080, 1080 × 1080, 1080 × 1920, custom), Open, the sample and recent files with thumbnails captured on save. Templates, SVG into the Library and drops on the timeline (ADR 0065): six built-in templates made in code (banners 728 × 90 and 300 × 250, social square 1080 × 1080 at 30 fps, storyboard 16:9 panels, character turnaround, lip-sync mouth chart) with guides on a locked guide layer, on the start screen and File › New from Template; File › Save as Template keeps the document with a picture in the settings folder by category (replacing and deleting confirm); an SVG dropped on or imported to the Library becomes one graphic symbol named after the file, in the folder under the pointer; a sound dropped on a layer's frame goes onto that keyframe, an image or SVG onto that layer in a keyframe made there if needed, one undo step, with a highlight on the cell. Not yet: exact drop positions on the desktop (eframe 0.36 and 0.37 are on winit 0.30, which gives none during a drag; a drop waits for the first pointer move, else lands mid-view), user template descriptions and renaming, several documents at once. Publish Settings and Publish (ADR 0060): the formats to publish, with their options and output names, saved in the document; File › Publish (Shift+F12) writes them all in the background with progress, Cancel and one report; presets in Preferences. |
| Library | Library management, first slice (ADR 0050): nested folders (New Folder, rename, drag items and folders in and out, Move to; deleting a folder that holds items asks), inline rename (F2 or double-click the name; names unique per folder, case aside), Duplicate Symbol (fresh ids, same folder, “Ball copy”), Swap Symbol in Properties (keeps transform, colour effect, filters, looping and name), a use count column, Select Unused Items and Delete Unused Items (unused = not reachable from any scene; linkage classes count as used; asks first), deleting used items asks and removes their instances, fills and keyframe sounds, sort by name, type, use count or date added, search (opens the folders that lead to a match), multiple selection, a preview (a symbol's first frame from the oracle, a bitmap as smoothed or not, a sound's waveform with play) and item properties (symbol type and linkage class, bitmap Allow Smoothing, which the oracle, the GPU stage, SVG and HTML honour). Folders are a side table in the document (older files open flat); XFL import keeps folders and Allow Smoothing. Headless: library.items/new_folder/rename/move/duplicate/delete/unused/delete_unused/set_smoothing, element.swap_symbol. Second slice (ADR 0053): drag items onto the stage (symbols and bitmaps land at the pointer on the active layer at the playhead, sounds go onto its keyframe; several at once; one undo step; inside a symbol open for editing too), Place on Stage (button, right-click, or Enter) at the centre of the view, Swap Bitmap in Properties (a placed bitmap keeps its corner and takes the new size; a bitmap fill keeps its shape), a Convert to Symbol dialog with name, type and folder that offers the last folder and type again, and "mixed" on every Properties row for several elements (Scale, Rotation, Alpha, Symbol, Type, Filters, Blending, Looping, First frame, Fill, Bitmap, Stroke, Width, Style; each row compares only the elements it edits; editing a mixed row sets all, and Type sets every selected instance's symbol). Headless: library.place {items, x, y} (and sound), element.swap_bitmap, kind and folder on modify.convert_to_symbol. 9-slice scaling (ADR 0055): Enable guides for 9-slice scaling on a symbol (Library or Properties). Scaled instances keep their corners, stretch their edges one way and the centre both ways, and strokes keep their width. Rotation and skew apply after; nested symbols, text and bitmaps scale normally. Guides are dragged as dashed lines while editing the symbol in place, or typed in Properties. The CPU, GPU, SVG and Lottie output all show it, and XFL scaleGrid* attributes are imported; guides switched off are kept and come back when switched on (ADR 0057). Not yet: 9-slice in HTML canvas export (scaled as a whole and reported), guides in Library previews, snapping guides. Not yet: shared libraries and importing items from another document, linkage on bitmaps and sounds, bitmap compression, dropping files from the desktop, a picture of the item while dragging, Swap Bitmap on a Library item (every use), mixed text style rows, a Colour Effect row with tint. |
| Find & navigation | Find and Replace, and the Movie Explorer, first slice (ADR 0058): Edit › Find and Replace (Ctrl+F) finds text (text fields, frame labels, layer and instance names, frame scripts; match case, whole word, regular expressions on a linear-time engine), fonts, colours, symbols, sounds and bitmaps, in this scene with its symbols or the whole document; results as you type; F3 / Shift+F3 go there, opening symbols in place; Replace, and Replace All as one undo step that asks above 100 places. Window › Movie Explorer (Alt+F3), beside the Library: scenes › layers › keyframes › instances (into their symbols), text, sounds, bitmaps and scripts, symbol definitions, Show filters and search, double-click to go there. Headless find.search, find.replace, find.goto, explorer.tree. Not yet: action parameters, ActionScript strings apart from code, font size and style, colour tolerance, renaming in the explorer. |
| 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. Web editor, first slice (ADR 0036, docs/web.md): the same program built for wasm32-unknown-unknown runs in a browser (WebGL2), built by scripts/build-web.sh/.ps1 with the wasm-bindgen CLI into web/ (8973 KB, 3278 KB gzipped). Open and import with the browser's file picker; save and export as downloads (the engine reads and writes through engine::vfs, memory in the browser). Autosave and preferences in browser storage, with Web Locks so only closed or crashed tabs' work is offered. Leaving with unsaved work asks first. Every crate builds for wasm32 in CI, and the engine's tests run inside WebAssembly in Node. Not yet: a browser-verified run, sound (Web Audio), the GPU stage on WebGPU, video export, plug-in installs, PNG sequence as one zip, IndexedDB for large autosaves, threads, hosting. Preferences window: theme (Follow system, Dark (Graphite), Light or High contrast; ADR 0077), 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). CI on macOS and Windows (ADR 0067): every code PR builds, tests and lints the workspace on macOS (arm64) and Windows (x64) runners besides Linux. Not yet: native macOS NSMenu, Linux arm64 and Windows ARM64 test legs on PRs, a GPU runner. Verified by hand on Windows only so far. Robust start-up (#207): the window opens through a list of ways (the one chosen in Preferences › Stage › Window graphics or `--renderer gl |
| Installers & release | Packaging (ADR 0026, docs/release.md): the Craft family's packaging/ layout behind the shared release workflow. Windows MSI (x64, arm64; per-user by default, everyone on request, upgrades in place), portable and symbols zips; macOS universal DMG with a laid-out window and CLI zip; Linux AppImage, deb, rpm, tar.gz, Flatpak and Arch (x86_64, aarch64; riscv64 deb/rpm/tar). .anicraft opens AniCraft by default; .fla/.xfl offered under Open with. Signed and notarized on the release branch (missing secrets fail it), unsigned elsewhere; ends in a draft release. Packaging lint and a fixture WiX build guard PRs; src/packaging_tests.rs keeps ids and types in step. Opening documents on macOS (ADR 0062): a double-click in Finder, a drop on the Dock icon or Open With opens the document, at launch or while running (the open-documents Apple Event through platform.rs, by fmv-macos-events, so no unsafe of ours), through the unsaved-changes guard; the Dock's Quit asks to save too; Windows and Linux command-line hand-over covered by a test. Portable mode and AppImage desktop integration (ADR 0094): an anicraft-portable marker (shipped in the Windows zip and the Linux tar.gz; also honoured beside AniCraft.app and an .AppImage) keeps preferences, autosave, logs, plug-ins, templates, recent files, brushes, filter presets and workspaces in data/ beside the app, through one switch in platform.rs, falling back visibly when that folder can't be written; Preferences › About shows the mode and every folder; on first start from an AppImage a non-modal card offers once to add AniCraft to the applications menu (desktop.integrate/remove/status: desktop entry with a quoted Exec, MIME types and icons under $XDG_DATA_HOME only, idempotent, removable from About, following a moved or updated AppImage); a store-readiness job checks the Flatpak manifests, AppStream (appstreamcli validate), the desktop entry and any winget/MSIX manifests. Not yet: verified on a Mac (the checklist is in ADR 0062), a single running AniCraft taking a second document on Windows and Linux, store submissions and winget/MSIX manifests, self-update inside a portable copy, video export inside the Flatpak. |
| Documentation | User guide, first slice (ADR 0069, docs/guide/): eighteen chapters for artists (getting started to troubleshooting, and Coming from Animate), a command reference and a shortcut reference (Windows/Linux and macOS) generated from the registry and checked for freshness by tests, every link, anchor and picture checked, eight screenshots from scripts/guide-shots.sh. Help › User Guide opens the book bundled in the app, offline, in the browser; the web build serves it beside the editor; anicraft-cli guide --out <folder> writes it. Not yet: translated guides, search, a PDF edition, context help from panels, macOS and Linux screenshots. |
| Languages | First slice (ADR 0040, docs/localisation.md): every shell string goes through tr!/trn! (keyed by its English; placeholders; CLDR plurals for whole numbers), menus translate the registry's labels when drawn (ids, CLI, MCP and the file format stay English), screen-reader names too. Catalogs are craft-i18n's TSV, read by our own parser and embedded from CRAFT_I18N_DIR (fallback app → shared → base language → English). Preferences › Appearance › Language (system language by default) and --lang. A pseudo-locale (--lang pseudo: accented, a third longer, bracketed) tests layout; checked by a source guideline test and a pseudo-locale accessibility audit; scripts/i18n-extract.sh writes the translators' template and per-locale coverage. Not yet: a real language (craft-i18n has no anicraft.tsv yet), engine messages and confirmation bodies (@msg), default document names, right to left (needs bidi and shaping in egui upstream), CJK and Georgian (need a font), shaped scripts. |
| 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). Second pass (ADR 0064): while the stage has focus its elements are a list box under the canvas (name from the instance name and outline or kind, layer, place and size, bounds, selected; 2,000 at most plus a summary); Tab, arrows, Enter/Space and Shift+Space select on the stage through element.select (new toggle); the active layer's keyframe spans are a list (frames, tween, label, sound, actions; activating one moves the playhead); on the focused timeline the arrows move the playhead and layer, announced through the status bar; the menu bar from the keyboard on Windows and Linux (Alt tap or F10, arrows, submenus, Esc, Alt+letter with underlined access keys); Follow system (the default theme) switches to high contrast with Windows' contrast themes, macOS' Increase Contrast, the portal/GNOME contrast setting and prefers-contrast in browsers. Light theme (ADR 0077, #227): a third palette designed for light (paper greys, near-black text, hairline controls, timeline blocks re-tuned to 3:1 on the panels with 4.5:1 marks), checked by the same contrast test; Follow system now follows the system's light or dark mode too (Windows, macOS, portal/GNOME, prefers-color-scheme). Not yet: names beyond the outline heuristic, per-item menu letters, a light high-contrast palette, a keyboard route to the menu row on macOS (⌘K covers it), manual passes with Narrator, VoiceOver and Orca. |
| Stage rendering & build | Tiled stage (ADR 0007): 512 px cached tiles, over the stage and the visible pasteboard (artwork off the stage shows, on transparent tiles that never cross the stage edge; View › Clip Content Outside the Stage and its edit-bar button hide it, view state), 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) | path.extend), with a mark by the pointer for each; tweens of any kind take Keep area (timeline.set_keep_area): scale goes geometrically between keys so keys of one area keep it on every frame, an unkeyed scale axis of a motion tween follows the other, the Motion Editor draws the derived curve and exports bake it. Not yet: continuing a merged line as the same stroke, OS pen cursors, Keep area per segment. |
| M2 | Model at scale | Arc structural sharing (O(changed) undo)feColorMatrix, HTML canvas and Lottie, XFL Color import with a corpus package, classic tweens across styles, motion tween tint colour, brightness and Advanced tracks; not yet: a colour picker for the Motion Editor's tint colour); bench --check on a known machine, CI once a benchmark runner exists); src/architecture_tests.rs, runs with cargo test). |
| M3 | GPU stage (in progress; the default stage renderer since ADR 0032) | gpu-stage on by default for the app, automatic CPU fallback); |
| 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); .fla variants of the corpus and a hardened zip reader.fla imports in 0.31 s); .fla archives |
| M5 | Rich media | harfrust shaping, skrifa outlines, line wrapping, outlines stored with the text); DOMTextRuns kept in one block, text.style/text.paragraph/text.styles; not yet: justified text, runs on a path's underlines, htmlText in fields, links that click in Test Movie and the HTML page, SVG <text>/<tspan> output, the editor showing the real faces and alignment); textPath; editing the path in place and several lines on a path later); field.text/appendText/length in scripts, typing with caret, selection, max chars and passwords in Test Movie, native inputs in the HTML export, XFL fields kept; htmlText, change events, embedded fonts in HTML and other TextField API later); cpal output); |
| 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); macro.* headless, CLI and MCP; macros call only what plug-ins may. Not yet: Replay Steps without saving, editing a macro's steps, macros that ask for values, the browser build and the command palette). ActionScript compatibility, low priority (ADR 0013), last in M6 and free to slip past M8: script.* commands); if and loops, property reads, functions across frames, enter-frame and keyboard listeners, seeded random, ADR 0052)flash.* API and SWF bytecode are not planned. |
| M7 | Advanced animation | |
| M8 | Release quality | packaging/ layout, MSI, DMG, AppImage/deb/rpm/Flatpak/tar.gz, .anicraft registered everywhere, signing wired to the release environment; packaging/web/package.sh and checked in CI (#210); next: releases carrying it and a hosted copy, once the team decides where, Web Audio, WebGPU stage, verified in browsers); tr! everywhere in the shell, craft-i18n catalogs, Preferences language, pseudo-locale; next: AniCraft's catalog in craft-i18n, engine messages, right to left once egui can lay it out); accessibility: first pass ✅ (ADR 0022: screen-reader names for every control, Ctrl+F6 panel focus, high-contrast theme, 200 % scale), second pass ✅ (ADR 0064: stage elements and timeline frames for screen readers, keyboard selection on the stage, keyboard menu bar, following the system's contrast setting), find.search/find.replace/find.goto over text, fonts, colours, symbols, sounds and bitmaps, scene or document, linear-time patterns, Replace All as one undo step asking above 100 places, going there opens symbols in place; explorer.tree paged, Show filters and search, the Movie Explorer tab beside the Library, lists drawing only the rows in view; not yet: action parameters and ActionScript strings apart from code, font size and style, colour tolerance, renaming in the Movie Explorer); {name}, Shift+F12 publishing in the background with progress, Cancel and one report, overwriting asked once per session, presets in Preferences, the browser's downloads as one ZIP; not yet: Animate's PublishSettings.xml from XFL, more placeholders, outputs outside the document's folder, progress inside HTML, Lottie and audio); docs/guide/, generated command and shortcut references, Help › User Guide offline), anicraft-cli guide search; F1, Help › Help for This and each panel menu open the guide at the section for the dialog, panel or tool, through a map checked against the guide's headings; F1 moves from the shortcut editor, which keeps Ctrl+Alt+Shift+K); next: translated guides, a print edition (PDF through the browser; a native PDF proposed in ADR 0096), help for single fields; |
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: GPU binning inside masks and groups, filtered layers shared across a frame's tiles, more than 16 images per tile (first slice ✅ ADR 0019, no readback and masks/groups ✅ ADR 0029, bitmaps, filters and the default ✅ ADR 0032, GPU binning and hairlines ✅ ADR 0048) | CPU oracle, tiled stage, GPU stage slices 1–4 |
| M4 | Text from Animate files | XFL import, text engine (M5 first slice) |
| M5 | Audio layers: import, waveform, playback sync | timeline, layers |
| M6 | switch, arrays, event bubbling) |
command registry, plug-in host, action IR and player |
| M7 | strokes, Pen and Pencil, width profiles, timeline evaluation | |
| M8 | .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).
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).
Next, in order:
- Raw drawing as in Animate (issue #42, a user's detailed report). Merge drawing's first
slice (ADR 0031, outside contribution #92) makes the shape tools draw raw strokes and fills
that cut and join. Still to match the report, first-party:
Selection tool on raw drawings (ADR 0041)✅: drag an unselected segment to bend it; drag an endpoint or corner to move it, moving every shape that shares the point; snap dragged points to points, strokes and fill edges within 10 screen px, and keyboard moves within 0.2 document px; a marquee that selects the parts of fills and strokes under it (cut at its edges); Shift adds. Not yet: snapping while drawing.Selection across layers (ADR 0044)✅: a selection is a set of (layer, element) pairs; the marquee, Shift-click and Select All work across visible, unlocked layers (raw parts cut and re-merged per layer); move, delete, duplicate, arrange, transforms, colour effects, filters and break apart act on each layer; align, distribute, Free Transform and copy act across them; paste keeps each layer; Convert to Symbol keeps the layers inside and lands on the topmost; the timeline marks layers with selected artwork, and a click on a layer's name selects its artwork; Properties shows mixed values. Not yet: armature instances from inactive layers in a marquee, "mixed" on every Properties row.Subselection on raw drawings, and merging everywhere (ADR 0042)✅: hollow anchors on connected raw shapes, handles on curves, point marquee on the active layer, dragging a segment or fill moves what is connected, arrow keys; Snap to Objects (View › Snapping, the magnet); the Paint Bucket's fills (exact, up to the lines) and pasted raw shapes merge; raw shapes from Animate files come in raw; gradients take part in the merge. Not yet: width profiles in the merge.Raw points and raw shapes inside symbols (ADR 0045)✅: add a point on a raw line or fill edge (Pen Alt-click, Subselection double-click), shared by every shape on the edge; delete raw points (the shapes on them joined across, the drawing kept connected; a line's last points remove it); Make Smooth / Corner on raw points; smooth handle pairs (Alt breaks them; drawing objects too); the Line, Rectangle, Oval, PolyStar and Pen tools snap while drawing; Snap to Objects is Ctrl+Shift+/; symbols open for editing in place (double-click an instance or a Library symbol, Ctrl+E; the edit bar's path back), where merge drawing, Selection and Subselection work as on the stage. Not yet: in-place editing of rotated instances (they open upright), deleting a point where three edges meet. (Onion skin and Edit Multiple Frames inside a symbol: ADR 0051 ✅.)
- 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, anda larger self-authored corpus checked by render tests✅ (ADR 0035).- Shared wire-schema work in progress: filters, shape hints, tweens/eases and frame-sound envelopes now read through craft-libs views; AniCraft keeps validation and mapping into its document models. Audit any remaining native document wire parsing before declaring the full XFL format cutover complete.
SVG import✅ andSVG frame export✅,text, clip paths and masks (onto mask layers)✅ (ADR 0021).dashes✅ (ADR 0046).soft masks (luminance and alpha), text on a path (✅ (ADR 0070). Next for SVG: booleans between two curved clips, multi-line blocks from stacked chunks, images and style sheets.textPath) and per-character positions where simple
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. |