Newest first. The acceptance checks for each part are in DESIGN.md §7.
Versions follow Semantic Versioning ↗ as Cargo reads it: before 1.0, a change to the second number (0.1 → 0.2) may break code, and a change to the third (0.1.0 → 0.1.1) does not. The crate and the amenui npm package (web/) always carry the same version, because the page side must match the module that web_app! generates. The minimum Rust is the one CI builds with (rust-version in Cargo.toml); raising it is a breaking change before 1.0 only in the second number.
Parts of a stage that change alone
El::steps()inside a stage marks a part of it that changes alone (a lens over a page that stays): a step (Ui::on_step) that names the stage views and draws only those parts, by their keys throughUi::stage_view, and the rest of the stage is the last frame's. A partstage_viewdoes not give, or laid out otherwise, and the stage is viewed whole as before. The page naming the step no longer needs to name what in the stage moves.
Bloom in a region
El::bloom()marks what the look's bloom glows over: once any element is marked, the bloom glows only inside the box round what marked elements draw, and only from what is drawn there (Post::bloom_region). With none marked it covers the whole frame as before.
The default theme's colours
- The default theme (
DARK,LIGHT) takes the AA.9 table: new grounds, ink and accents (the accent is#f47a3cdark and#b23f0dlight;#ff6b2bis retired), and four greys of its own (Theme::greys: raised, hairline, dim, text).Paint::DIM,TEXTandFAINT(nowHAIRLINE, andRAISEDnew) are drawn as those colours exactly, not as the ink mixed toward the ground; a tone between two greys is drawn between their colours. Their tones moved to whole 255ths (dim 0.66 → 168/255, text 0.86 → 219/255). Other themes take their greys mixed as before (Greys::mixed); **a theme built fromDARKorLIGHTwith its own ground and ink keeps their greys unless it setsgreys: Greys::mixed(ground, ink)** (orGreys::mixed_dim(ground, ink, 4.5), which takes dim toward the ink until it reads 4.5:1 on the ground). Paint::EXTREME: white on a dark scheme, black on a light one (Theme::extreme). It is the ink image's fourth hue code (0.45, which the unused glyph-height code held).El::fill_hoverandEl::fill_held: a fill under the pointer and while held or dragged;El::border_hover: a border under the pointer or with focus.Variant::Primary: an ink plate with a ground label, the extreme under the pointer, for the one main action of a group.Variant::Accentstays for an explicitly coloured action. Badges takePrimarytoo.- The default controls rest in ink: a switch that is on (ink track, ground knob; off a hairline track and a dim knob), a slider (ink run and thumb, a hairline rest; the thumb is the accent while dragged), a radio's dot, a checkbox's outline and tick, a toggle that is on and a choice's current option (ink plates with ground labels). So are a pagination's current page (an ink plate), a current tab's rule, a progress bar's fill and the label of a selected list row or menu option;
widgets::SELECTED, the plate of a selected or keyed row, is the raised grey (it was the accent at 0.12), the hairline grey on a raised surface (widgets::selected_on). Hot rows of the command, context and nested menus are that plate with an ink label, a skip link an ink plate. Outlines of interactive controls stay dim at rest and turn ink under the pointer or with focus, and while a select or menu is open or a number is typed into (they were the accent then); panel frames (menus, dialogs, sheets, popovers, toasts, tooltips) are hairline. A switch's knob is the accent while pressed. The hover and focus marks are ink (Fx::marks_accentis 0 by default). - The recipes' and samples' main actions are
Primary; the components' button page shows it.
Display type in its own material
nearhas ink bands (墨带, 1 to 3, and带宽, px; 0 by default, the bands as before): only that many bands outside the ink, in the ink at 0.5, 0.3 and 0.15 (two: 0.5 and 0.25), each the width with as much ground before it, square round the ink's pixel corners, for pixel type on whole pixels and on the lattice.carvrnever cuts deeper than its band (刻带), the knife's wander included.- A glyph 32 px or more each way set in
nearorcarvrtakes all the ground its quad covers, padded by the spread once more, so what the material draws round the letter is drawn; text at reading sizes keeps the override just round its ink.
Cached subtrees
- A cached subtree (
El::cached) in which nothing it draws from changed is passed by when the page is painted: it is neither drawn nor hashed, and its plate is laid on as it was (Counters::keptcounts them). It was drawn and hashed instance by instance on every paint (about 9 ms for 11,000 glyphs natively).
Shaders in Chrome
fs_ink's code test no longer mixes||and&&without parentheses, which Chrome's WGSL compiler rejects (the ink, nearness and clearing passes were invalid there). A test now holds every WGSL source the renderer compiles to the expression rules Chrome enforces and naga does not.
Fast scrolls under dottr and charr
- The frame in which a fast scroll's trace starts or stops holding the rows to the lattice moves the last frame by what it shows, instead of shading the whole viewport (the readout's
latch on/off). - A lattice material used only outside the scrolled viewport (a bar in dottr over a list in charr) no longer stops the last frame from moving (the readout's
latch: mixed lattices).
3D elements that come and go
- A 3D element that comes on the page or goes (scrolled into view, a section opened) draws the frame again only where it is or was, not the frame whole (the readout's
meshes); the 3D elements after it are not drawn again.
Pictures that arrive
- A picture given after its page is drawn (
Renderer::set_picture) is drawn on the next frame where it is, with the cells that read it, not by a frame drawn whole: a page need not turnRenderer::partialoff for it.
Flows
- What a new page lays out only after a flow began (a label shown once what it follows is in view, a drawing's new marks) comes in as what was new when the flow began: over a growing picture once it has landed. It was drawn at once where it is, outside the part of the picture that shows.
- An element keyed the same on both pages that rode on the growing picture on the old page and is outside every flow on the new one (a layer over the page's frame: a pointer's box and its label) is carried by the picture to its new place. It was drawn at once there, outside the part of the picture that shows.
Stage scale
- The stages' scale steps up only when the frames' cost there, by the level up's pixels, would be under 85 % of the display frame; a step down within 5 s of a step up holds the lower level, and a route's visit has at most two steps up (
perf::STAGE_UPS,StageScale::held), in place of the waits of 5, 10 and 20 s and three returns a level.
Morphs from a stage
- A morph from what a stage draws (
El::stage; posed glyphs stepped every frame) starts its tiles where the frame before it drew them, also when the morph is asked for by a command with a new view that poses them elsewhere or hides them; it took them as the new view put them.
Marks in the ink
Fx::marks_accent(1 by default, the accent as before): how much of the accent the hover and focus marks are drawn in; 0 draws them in the ink.
Frame rate
- Scrolling under the automatic level is not softened on a frame that can move the last one (
dirty::Move): that frame shades only the strip scrolled in, sharp. - From a renderer's second frame, one a frame, the material passes for the page's materials (hidden elements', one waiting for a morph, included:
Scene::mats) are made ahead and kept by material; a morph's frames count the materials of its tiles. With one built-in global material and no override, the material pass (and its upsample) is a pipeline of its own for that material (the WGSL override constantMAT):Renderer::specialise,Renderer::specialised,render::SPECIALISE_AFTER. - Marks changed in place (drifting motes, a turning body's glyphs) are each their own box, not one box round them all; many boxes are gathered by where they are, and the final frame is shaded in up to 32 boxes grown from what changed (
dirty::MAX_SHADE_BOXES; the G-buffer keeps 8). - A fast scroll with its trace showing moves the last frame too, and shades again only the pixels the trace can reach (
fs_trace,Cost::trace); under dottr and charr the frame moves by the lattice's steps (dirty::Move::frame,trace,way,latch). Not under glitchr or a material from source. El::local_messages: the messages a subtree's handlers send change only it and theEl::stepselements, so it is restaged after them (Ui::stage_view) instead of viewing and laying out the page; for a stage dragged by hand.- Inside
El::cached, a pixel face asked for under its native size is set and drawn at the size asked, by its outline's coverage (text::FINE,Text::fine). - A renderer made after the page was painted (
Offscreen::newin a render tool) draws it: it sends the whole glyph atlas on its first frame, and a cached subtree its plates do not hold is drawn again (Ui::plates_lost). A scene drawn twice with no paint between inks its plates once (Scene::paint). - An element moved by its offsets in a restage stays where it was moved through a view of the page that lays nothing out; it had gone back to where the last layout put it.
Perf::path(perf::FramePath): how the last frame was drawn, for a readout: whether it moved the last frame and the first reason it did not or was drawn whole, whether the material pass was specialised and why not, the share shaded at full resolution, and the soft, stage and reduced scales;FramePath::line, shown by the full overlay.dirty::parts_why,Parts::refused.- A scroll with its trace showing over stages shaded at their own scale moves the last frame (it was drawn whole every frame); the stages in the viewport are shaded again where they are, slow or fast.
dirty::meet,Move::bx. Renderer::spec_force: force the material pass made for the global material on (from the next frame, even over overrides, for measuring) or off. Off, a pass already made is not used either. The trace pass is made for the material too (fs_tracewithMAT).- A page of several built-in materials (up to
render::GATED_MAX) is drawn by a material pass for each, each drawing only its own pixels (the WGSL overrideONLY), once the same materials have held forspecialiseframes; an override in the global material no longer keeps the page from the pass made for it.FramePath::gated. - A step of the stages' scale shades only the stages again, not the whole frame (and not the frame after either).
Ui::stage_governor,StageScale::set_level, for checks.
For Kern
pair::Facesresolves a role as the page's root does (itsEl::fonts), and the faces kept follow it; a Lab page whose theme sets display to mono measured Noto Sans.Faces::face_of.Experiment::faces: a cell made alone (experiment::ui, the contact sheet) is handed the faces.GlyphAttells a pose each glyph's pen as laid out (pen,base,advance), so a pose can put a kerned glyph's pen exactly;GlyphAtisDefault.
Drawn once
El::cached(): a subtree drawn once onto a plate and laid on from it while it draws the same, so a large page of small text costs no instances; drawn again when it changes and after a new window size.el::cached_view(over, from, ink): part of a cached subtree, scaled into an element, read as coverage nearest (a magnifier's pixels).El::clip_round(radius): a clip with round corners, or a circle.- A stage's absolutely placed element that moves by its offsets alone is restaged with no layout, so a chip dragged about a stage costs no page view or layout.
- A pointer move asks for a frame only when something shows where the pointer is, the hover or the cursor changes, or a drag, touch or selection is under way; hovering a still page draws nothing.
- An experiment's formula and label are selectable.
Fixes from the website: controls at rest
- A front pushes text to read and controls about the centre of the control they are in, and a surface that holds them is not that control: an element that follows the pointer (
on_point,on_move) or one larger than a quarter of the window. A full-window stage withon_pointoron_keymade its whole page one piece, so every commit's front shoved everything on it sideways at once, when the front crossed the window's centre. - A commit inside
El::commit_scopeis over once its front has reached the scope's farthest corner, not the window's, and its scope takes in what the material draws round the box (the nearness spread and a front's push). A card that switched tonearkept the old outline round it for two seconds and then swapped it in one frame, and every frame until then was drawn whole. The commit's own front stays in the scope too, as the fronts of other presses there did. neardraws no bands round text with strokes under 3 px. Only the shapes' nearness takes a label's surroundings into an element's own material, so round a label in a control its bands showed as stray dashes over the ascenders and a hook under a descender. Titles keep their bands.- The hover and focus marks are drawn over the material, exact, in the accent, and on a segment or a tab they stay inside the control's border. Drawn by the material,
nearoutlined each bar twice, and on a segment the bars sat on the control's own border, which looked broken. - The performance readout keeps its width: every field keeps its width whatever its number (
idleis as wide as the rates), and its plate does not narrow while it stays open in a window of the same size. Its corner's inset no longer counts on both sides, so a wide inset (a stage's edge) leaves it the room beside it. Its edge used to jump about 70 px each time the page went idle and woke.
A stage at its own scale
- When frames are missed, the stages' device scale steps down (2 → 1.5 → 1 → 0.75) and back up after a wait that doubles each time; text, panels, the chrome and whatever is drawn over a stage stay at the device's scale (
perf::StageScale,Ui::reset_stage_scale,Perf::stage_label).Look::qualitybelow 1 pins it. A slow stage is held under input only once its scale is as low as it goes. - Automatic quality goes by the intervals between frames drawn while something moves, not their CPU time, so a machine slow on the GPU steps down too (
perf::AutoQuality::feed(t, cost, moving)). - Under the automatic level, scroll areas are shaded at it while they scroll (no lower than the material's floor,
render::soft_floor); the ink's edges, overlays and the rest of the page stay sharp, and 100 ms after the last delta one frame is drawn sharp (Ui::scroll_soft,render::SOFT_SCROLL).
Between letters
pair: the distance between two glyph outlines and the white between them, and where to set a pair for a gap or an area, from the page's faces handed to the state (Ui::faces,Ui::on_faces), not the text system.
Stages, from the site
- A slow stage holds with input coalesced (
Ui::coalesce, as the web and desktop hosts run): the input of a frame waited for the frame's layout, and the tick had spent it before, so the stage drew every frame of a drag. El::stepsmarks an element beside a stage that changes with it (a formula, a label):Ui::on_stepreturns its key with the stage's andUi::stage_viewgives it, so an experiment's own page no longer lays out every frame. Text whose words changed but measures as before counts as laid out the same.
Flexbox only
- taffy is built with flexbox alone (no grid, block layout or calc), about 170 KB less in a web module. A
StylewithDisplay::GridorDisplay::Blocknow lays out as flexbox; amenui itself used grid only forstackandlayers. stackkeeps its meaning: as wide as its widest child, as tall as its tallest, each child centred. It is a row whose children lie over one another by their margins (set from the widths they took), so a margin you give a child of a stack still counts, and a percentage margin there becomes a length.layersplaces each child absolutely at the top left of its box unless the child is placed already; the box does not grow with its children, as documented (a box with no height of its own grew with the grid before; give itfill_heightor a height).
Fixes from the website, the way back
- A ramp stroke (
Drawing::ramp) fades as a whole: its far and middle stops follow the element's opacity as its start does. Coming back to an index, a window waiting for the picture to land no longer drew its rays at full size. - A picture in a layer (after something that stirs, or a modal) is a picture for what is drawn over it, so a drawing's own colours (
Drawing::palette) stay its own while its picture fades in, not the accent; a picture under 0.01 of its opacity no longer marks its area as a picture.
A stage that steps alone is drawn alone
Ui::on_step(f)andUi::stage_view(f): a stage (El::stage) whose piece changes by itself is viewed and drawn again alone, in the boxes the last layout gave it, while the rest of the page keeps its last frame; the frame is the one a whole view of the page gives. A step that lays the stage out otherwise views the whole page (DESIGN.md §1.35). The website's Lab index with one cell running takes 2.9 ms a frame on the CPU, from 6.9 ms.perf().counters.restagescounts those frames.- The experiment cell's stage (
experiment::frame) is anEl::stage. - Text to read over other ink finds that ink by a grid over the window, faster.
The state hears where the focus is
Ui::on_focus(f): the state is told which element has the keyboard focus whenever it moves (Tab, a press,focus_key,clear_focus, a modal layer opening or closing), ason_hovertells it where the pointer is;freturns whether the view changed. A Lab cell can run while one of its controls has the focus.
A stage that holds while the hand works
El::stage(): the live piece of a page. When its draws take more than 0.6 of a frame it holds its last image on frames that answer input, so the controls beside it answer in that frame, and draws again on the first frame without input, after a release, and during a long drag everymax(100 ms, 6 draws)up to 500 ms (DESIGN.md §1.35). A stage that draws in time is drawn every frame as before.Ui::slow_stage(ms)andUi::stage_state(key), for checks;stageholds the numbers.Propshas a new public field,stage.
Fixes from the website
- Pixel type set at its face's native size because a fitted box zoomed it under that size (the Lab's formula on a docs stage) has its lines as much further apart: the lines no longer overlap and the text's box holds them.
ViewProblem::OwnColourOffPictureandViewProblem::RampHuelook at what is drawn of a mark, cut by its clip: a ray that runs out of a band holding its picture is no longer reported.- Posed text (
El::pose) whose box is outside its clip draws the glyphs its pose puts inside the clip.
One GPU for every off-screen renderer
- Every
Offscreenin a process shares one wgpu instance, adapter, device and queue, made on first use; each keeps its own renderer, target and read-back buffer. Tests that ran in parallel made and dropped Vulkan instances on several threads at once, which crashed lavapipe (a segmentation fault in a different GPU test each run on CI). A failure to start is kept and returned again to every laterOffscreen.
Paint that does not grow with the square of the page
- Drawing only what changed matches instances in order rather than by place, so a drawing whose strokes change in number redraws its own box and not everything after it, and redraws up to 8 boxes a stage instead of their union (
dirty::parts,dirty::MAX_BOXES,Scene::cuts;dirty::Inputshas a new public field,cuts). - A fitted box (
El::fit) whose subtree changes only what it draws is one view and no layout a frame (it was three views and two layouts): the scales found last time stand until something layout reads changes. - What text to read holds (
holds) finds the ink drawn before it through a 64 px grid instead of testing every earlier instance, and the islands of loosened controls (islands) walk up each node's parents once instead of searching every earlier node. The scene is the same; on the website's Lab index (about 7,000 instances and 420 nodes, 1440 × 900 at 2×) a frame's paint goes from about 16 ms to about 4 ms natively.
Widgets built once per message type
widgets::number,captionandexperiment::framebuild their controls once, with their own messages, and map them to the application's;segmented,choice,sliderandinputbuild their body once per message type rather than once for every closure passed to them. Nothing changes in what they show or send. The website's full module is 11,819 bytes smaller gzipped (2,832,825 to 2,821,006).
How selected text looks
Look::select(style::Select { halo, alpha, ink }, 3 px, 0.34, on by default): the selection halo is opaque, the accent mixed into the ground as one colour (#5f2d18 on the dark theme), so halos that meet across glyphs and lines show no box and no darker band; selected glyphs are drawn in the ink. The halo comes and goes in one frame.Lookhas a new public field,select: code that builds one with every field named needs it.
Number controls that keep their steps inside
widgets::number: never narrower than its steps and field; a width that leaves the label no room beside them puts the steps on a line under it, and a label wider than the control ends in an ellipsis, read whole. A caption's and the Lab's numbers no longer run into each other.experiment::frame: the formula wraps to the cell instead of being cut.El::clamp: a word wider than the line is cut too.
A drawing's own colours
Drawing::palette([...]): a drawing's own colours, which its marks name asPaint::hue(3 + k), so it looks the same under any theme; exact over a picture (a ramp between two in OKLab), hue 0 and reported off one (ViewProblem::OwnColourOffPicture, DESIGN.md §1.26). A frame's drawings have at most 32 between them.Drawinghas a new public field,palette: code that builds one with every field named needs it. Outside a drawing, aPainthue of 3 or more is hue 0.El::mapmaps an element's children in a plain loop rather than collecting them in place, which is built once for every pair of message types: with grain in a region, labels shown while clear, keyed elements, drawings that ride and their own colours, the website's full module is 4,605 bytes larger gzipped than before them (2,826,385 to 2,830,990).
Labels shown while clear and elements keyed across a growing picture
El::show_clear(inset, rank): a label shown only while it is clear, checked every frame against its view (El::view_scale, or the window) and the labels of lower rank, coming back with 4 px more to spare and fading linearly over 150 ms; hidden, it takes no pointer and is still read (DESIGN.md §1.2). A view of more than 64 is reported (ViewProblem::ShowClearMany).Cmd::Flow: an element keyed the same on both pages of a picture that grows goes from its old place to its new one with the picture instead of fading out and in, its size on the picture's cubic (DESIGN.md §1.10). Own-size type at another size on the new page is reported (ViewProblem::FlowOwnSize) and cross-fades once the picture lands. A picture with the same flow id whose box changed now grows.Cmd::Flow: a drawing's marks that ride on a growing or shrinking picture go with the picture's transform, their pen kept, instead of at their own size by parts, so a drawing shrinks into the window with its picture; under a view scale everything that rides does, own-size labels apart.ViewProblemhas two new variants, andPropsa new field,show_clear.
Grain in a region
El::grain(): once an element is marked, the look's grain is drawn only over what marked elements draw (their box, following a flowing picture), the same grain as over the whole frame; with none marked it covers the frame as before (DESIGN.md §1.21).Posthas a new field,region, which the runtime sets.
Smaller web module
El's fields that do not depend on its message type are inEl::props(Props), which anElreads and writes as its own fields (el.style,el.key,e.childrenare as before).El::map,El::zoomandEl::newmove them as one, and each leaf is measured outside the generic code, so an application that embeds others' views builds less per message type: the website's full module is 13,937 bytes smaller gzipped (2,840,450 to 2,826,513). Code that builds or takes apart anElby naming all its fields namespropsinstead.- Web: a canvas resized by its stage is drawn again at its new size in the same refresh, so a route that changes the stage's size shows no empty refresh (
web/amenui.js).
A view scale
El::view_scale(s): what a container holds is scaled bysexcept the pen: line, border and trace widths and a trace's dashes stay as at 1, own-size labels keep their size, and a dot is never less than one whole device pixel (DESIGN.md §1.2).El::zoomis unchanged.Elhas two new public fields,penandview_scale: code that builds one with every field named needs them.
Labels at their own size
El::own_size(ax, ay): an element that keeps its own size when it is zoomed (El::zoom,El::fit) or rides a growing picture (Cmd::Flow): its anchor point goes where the zoomed box would put it, on whole device pixels; in a row or column it takes its own room, and one that then overflows its parent is reported (ViewProblem::OwnSizeOver, P1 in the audit).El::fitmeasures subtrees with one in two passes (DESIGN.md §1.2).- Pixel faces are never drawn smaller at a higher device pixel ratio than at 1: at 2, 7 px of a 12 px face is two device px a face pixel, as at 1, not one (DESIGN.md §1.6.3).
Elhas a new public field,own_size: code that builds one with every field named needs it.
Strokes with a ramp
Drawing::ramp(a, b, w, paint, mid, far): a stroke whose colour and opacity go frompaintatatofaratb, through an optional middle stop, still one instance. Over a picture the colours mix in OKLab; off one it keeps its first hue, and a ramp across hues there is reported (ViewProblem::RampHue, P1 in the audit) (DESIGN.md §1.26).Mark::Linehas two new fields,farandmid(Nonefor a plain line): code that builds one with every field named needs them.
Islands under labels
- Flow: what rides on a growing picture moves by whole parts (a word; strokes that touch, as a box of lines), so a box drawn as four lines stays one box at one size while the picture grows or shrinks (DESIGN.md §1.10).
Ui::ambient_fps(30)on a 60 Hz display draws every second refresh: a paced frame is due within half a refresh of its time, andweb/amenui.jswakes a refresh early for it (in Chrome it was 20 a second).- Web: when the WebGPU device fails, the full build starts on WebGL2 before it reports
device; the canvas is given a WebGPU context only once a WebGPU device is there. - Flow: cells that read a picture (
el::cells) are not taken for the subtree's picture, so they are not drawn a second time as one that grows. What rides on a growing picture stays whole until it lands, and the new subtree's notes are there at once then: each note is drawn once every frame (DESIGN.md §1.10). Blade::lean_fromandBlade::lean_full: the blade's colour (and its head's) goes tolean_paintfrom the one lean to the other on a smoothstep; both 0 (the default) keep the mix linear overmax_lean, byte for byte (Blade::mix, DESIGN.md §1.26). Code that builds aBladewith every field named needs the two new ones.
- The ink under text to read is held at looseness 0, not at
legible_cap: a label reads on its ground's colour at rest (DESIGN.md §1.15). - A filled control whose own fill is loosened keeps one island: its content's ink box grown by
max(5, 0.36 × size), rounded, within its outline at rest, with a hard edge. Text on others' ink keeps its glyph island, with the gaps inside a word held too.Scenehasislands. Under scribblr such a control's fill becomes a thread round its outline, with the island whole at rest fill.
Blades, gusts and pacing
- The
webglfeature (on by default) carries the WebGL2 backend on the web. Without it a web build has only WebGPU, and a browser without WebGPU fails to start:Host::startreturnsapp::web::StartError(AdapterorDevice; it was aString), the module'sstart_failure()export says which, andweb/amenui.jscallsopts.onFail(kind, message).
Drawing::blade(Blade)(Mark::Blade): a rooted stroke the field map bends from the flow at its root, worked out on the GPU every frame; its lean is its tip's tangent, its root leans 0.35 of that and it bends above its stiff part (Blade::tangent,Blade::shape), drawn in 10, 6 or 2 segments by its length; it keeps its length, tapers to half its width and can carry a head glyph on its tip, turned with it and going tolean_paintwith the stroke; its own lean and the map's add, within ±max_lean(DESIGN.md §1.26).MarkhasBlade, so exhaustive matches need the new arm.Cmd::Gust { gust, scope }(fieldmap::Gust): a band that crosses a scope with a wake behind it, worked out from the clock and laid over the map, never put into it: once it has passed, the map is as it was and nothing is asked for (DESIGN.md §1.29).CmdhasGust.El::map_life(energy_life, flow_life): what is put in the map within an element's box is back at rest after these lives, however much and however wide: nothing spreads there, and each node goes down the look's curve slowed to end at the life. A stir narrower than a cell is put in a cell wide.- The warm-up goes on in idle time (
Renderer::warm_idle; the web module'swarm_idle, whichweb/amenui.jscalls fromrequestIdleCallback): a page that draws nothing after its first frame is still warm soon, and its pieces no longer land in the frames of the next input. A warm-up step no longer asks for a frame of its own. A page shell of its own callswarm_idlethe same way, asking for the next idle callback whatever a call did (a pipeline compile that blocked, a call that threw or found the module busy) untilwarm()is empty. - The field map's ink for
creepis read again only for instances that changed since the last scene, and not for blades or what lies inside a box with lives of its own, where nothing creeps. Cmd::Flowgrows a subtree with a picture on both pages: the picture is one, in a box and a visible part that go from the old to the new on whole pixels; the rest of the old subtree rides with it at its own size and fades, the rest of the new one and what is new outside the flows comes in once it has landed, and the old page's ground stays around it until then (DESIGN.md §1.10). The growing picture and its riders are drawn in the page pass over what dissolves, so the notes keep their colour and size and no other window is drawn over it; a frame along the window's edge fades under it; a picture that shrinks back takes the old page with it, the new page's ground around it from the first frame. A flier's clip goes from the old to the new one instead of covering both.Ui::ambient_fps(n): frames for what moves by itself at mostna second; input and what it starts are not paced until a second after the last input.
Ink over pictures and character marks
- Text and shapes drawn over a picture are their own colour there, blended with the picture by their coverage and opacity, in the page and in a layer (DESIGN.md §1.6.1). Before, their edges (or the whole text, in the page's own layer) were read as the picture's colours and showed red; a site no longer needs a layer of its own for ink over a picture. Text to read over a picture stays as it is while the picture loosens.
el::cells(Cells, cols, rows)draws the picture under it as character marks at a pitch of its own (7 × 14 px by default) from a ramp the caller gives, each cell in its own colour mixed toward an ink: one instance and one draw, nothing laid out when it moves, nothing drawn while it is still (DESIGN.md §1.6.1).ContenthasCells, so exhaustive matches need the new arm.
Fitting, clamping, faces that come later and plates
- Breaking:
FlowSpechasfade_msandLookhasoverlay_keepandoff, so struct literals of them need the new field or..Default::default();CmdhasClearFocusandClearPlate,ViewProblemhasFitShort,ClampAround,PlateOverandOnPlate,Offhasground, andFontErrorhasBad, so exhaustive matches need the new arms. Every element is now the box its absolutely placed children are pinned in (its padding box), not the window: a page that placed anabsolutechild against the window from inside a padded parent moves it. - Lengths are laid out on a 1/64 px step, so a wrapping row in a box as wide as its content stays on one line.
- Text to read and controls hold the looseness under and around them to the legibility cap (DESIGN.md §1.15): a label on a loose shape reads as at rest. Sites no longer need a ground-coloured patch or band under labels. Each material meets the island in its own way: whole cells and an island that follows the glyphs in charr, dots that join it in dottr, separations that close up by whole dots in halftonr, no copies of the label in glitchr, a crisp fill in scribblr.
- An element that clips, clips inside its border.
El::fit(Fit)zooms a subtree to fit its box in the same layout (pixel type is set smaller, the scale is kept; atminwhat overflows starts at the box's start, and only what is cut is reported);FitMode::Reflowlays it out at the box's width first, with its type at its own size, and zooms it down only if it still does not fit;El::clamp(lines)ends text in the face's own ellipsis (three full stops where the face's floats off the baseline), copies what it shows without it, and brings the rest in from the next frame when the clamp is taken away, keeping the ellipsis until the text after it has come, withUi::clamped;El::preview(true)draws sheets, menus and dialogs where they are written, without a layer (a skip link over what is beneath it and still where it is written in Tab order, a docked sheet inside the border);Ui::line_inksreads each line's box and ink;Ui::clear_focusandCmd::ClearFocustake the focus off.- Faces that come later (§1.6.5):
Ui::declare_face,text::with_declared,Ui::add_face,Ui::faces_wanted; resources by name withUi::add_asset,Ui::asset,Ui::assets_wanted. Text stands in until the face comes, then each line sweeps over in 240 ms; with a material each glyph comes apart a little as it changes (a heading up to 0.6). The web module carries only the three main faces;web/amenui.jstakesopts.faces,opts.assetsandopts.preloadand fetches what is wanted. - Plates (§1.33):
El::plate(Plate { fade_s })keeps the ink a subtree draws, ageing it out overfade_s;Cmd::ClearPlate { key }empties it. Ageing ink fades as its coverage, with no pattern; a new stroke makes new only the old ink under its own outline; an empty plate is not laid on; text to read inside a plate is reported. - A decode held at a step draws once and then the page rests (it asked for frames for good before).
Look::overlay_keepkeeps the readout in its corner; the readout wraps to fit a window 390 px wide.- With less motion a flow fades in place over
FlowSpec::fade_ms(150 ms by default). With or without it, what is new on the page fades in overfade_ms, so a route change is never the new page drawn whole over the old one. Look::offturns each effect off (close, fronts and commits, flows, morphs, ripples, loosening, recompose, decode, material motion, bloom, the field's dots), each going straight to its end state and asking for no frames (§1.34).- A box whose last child was absolute no longer keeps the child's layout after it goes (it could panic in taffy).
Coalesced input, cached word pieces, and a web page that survives a panic
- Breaking:
el::Pointandel::Draghavet, when the event happened on the runtime's clock, so struct literals of them need it.experiment::Pointer::hearmeasures speed between the events' own times. Ui::coalesce(on in both hosts): pointer moves, wheels and ticks lay out and paint once a frame, before it is drawn (Ui::settle, called byRenderer::draw); every other input lays out what waits first. Eight moves in a frame cost one layout instead of eight.- The words and lines of a text drawn by
El::reveal_byare found once per text and width, not on every paint (Counters::reveals); each glyph's word is looked up in its own line. - The renderer reuses the lists it compares frames with instead of copying the scene into new ones.
- Web: a panic in a call no longer leaves every later call failing with "already borrowed": the application goes on as the panic left it (
app::slot). GPU errors are logged, not panics, and mesh vertices go in buffers of at most 256 KB (render::MESH_CHUNK).
Controls that hold under effects, the warm-up in the hosts, opacity and scoped commits
- Breaking:
Cmd::Commithas ascope: Option<String>(Noneis the old behaviour);MorphSpecisClone, notCopy, and hasfrom_last;Lookhasoverlay_atandoverlay_inset, andGazehasechoandecho_ms, so struct literals of them need the new fields or..Default::default(). A drive file'scommitwithoutscopereads as before. - Both hosts warm the renderer up a piece a frame within 6 ms (
Renderer::warm_frame,WARM_MS): the first frame is the plain page.Ui::warmandUi::on_warmsay how far it is; the web exportwarm()gives[done, total], andweb/amenui.jssetsaria-busyand callsopts.onWarm. - A frame drawn while something moves owes one more, so a motion that ends between frames ends on the settled page; a host no longer needs to redraw by hand after one.
- An element that leaves with its page takes its field map and decode with it; one taken away alone decodes out with its own spec inside its clip.
audit::off_palettecounts colours no theme makes. - Controls inside a subtree marked
legible(false)keep their fill and label as at rest; a tab list's heads and rule are the control. El::passlets the pointer through to what is under it;El::opacityfades a subtree as one (at 0 it takes no pointer);El::commit_scopekeeps a commit inside one element's box.Ui::morph_from_lastandMorphSpec::from_lastfly an element's glyphs, each whole, from where they were drawn last frame to the new element's, across a route change, in every material.- The readout goes in
Look::overlay_at's corner and moves on clockwise rather than cover text to read. - The INK leader is dashed and routed round text to read;
Gaze::echokeeps fading earlier INK boxes. - With reduced motion, what comes and goes fades over 150 ms.
- Looks: the thread's clearances move its control points, so the curve stays smooth; a thin accent rule under
charris one unbroken row; the Crack's pieces start to leave at 0.28; a press's flash inplainkeeps a filled control's label at 4.5:1.
Materials named for what they do, and as source
- Breaking: the six printing materials are named for what they do:
dot→dottr,halftone→halftonr,ascii→charr,print→smudgr,lino→carvr,glitch→glitchr(theMaterialvariants and their strings);plain,nearandscribblrkeep theirs.PicFxisMarkr(El::markr), the finishing pass'sDitherisDithr(post.dithr,DithrKind),Cmd::Front/Cmd::FrontAtareCmd::Ripplr/Cmd::RipplrAt, andEl::ripple,El::ripple_scopeandEl::wipeareEl::ripplr,El::ripplr_scopeandEl::wipr. No aliases: an old material name is refused and the error names the new one, andLookErrorgives the closest name for any other. Look recipes start withlook:v2:; alook:v1:recipe is refused with the renames listed.Materialhas a variant for added materials, so cast withMaterial::id(), notas. - Materials as source (§1.6.4): each material is
src/materials/<name>.wgslwith its name and numbers in a header;amenui add material <name>copies one into a project, andLook::material_source(name, wgsl, params)adds one back under a name of its own (ids 9–15,Material::Custom).Look::numbers(m)reads the numbers a material is drawn with. El::effect(Effect { material, response, scope })puts a material, a response and a scope on a subtree in one line, andel::wrap_textturns plain text or Markdown into a page to read.- The thread (§1.30): one large lopsided knot and smaller ones (
knot_fall), a few chords escaping (escape), long flat tails with a few gentle bends (tail_turns) at half the line's tone (tail_tone), all instrand::ThreadShape; it no longer lingers between a half-drawn title and a thread when it draws back (strand::shown), and it passes behind pictures without changing colour. - Sample sheets that check themselves (
amenui::sample,sheet --material <name> --loose … --arrival). - The audit finds text a material wears away at rest (
Eroded, P1 under 85 % of plain's ink); a clipped finding names the side, the distance and what cuts it. Annotation tags andINKreadouts keep off text to read and off each other. nearkeeps a label in the ground's colour on a solid button whole. Text on a form fades its rim fromedge0.6 (range 0–0.8), and inform3dthe pointer's light falls off smoothly.- The warm-up (§1.23): the material arrives on the page at rest, then over 120 ms (
ui::RAMP) the page loosens to its caps and condenses, so the arrival no longer jumps. - Every public item of
strand,fieldmap,field,hit,audit,formandmaterialshas a doc comment.
Text on a form, the warm-up and the audit
- Glyph poses have a depth and a facing (
Pose::z,Pose::facing; the defaults draw as before), and a text element's glyphs are drawn far to near.El::form(FormFx { back, edge, overlap, fog })keeps text on a form legible: what faces away is left out, what is edge on fades, a glyph mostly covered by nearer ones is not drawn (measured on the true ink), the far side is dimmer (§1.26). amenui::form:Formwraps a block of text onto a sphere, a surface function or a mesh seen by amesh::Camera(Form::pose_of), andForm::hitfinds the pointer on the surface. The recipeform3d.El::reveal_by(Reveal::Word | Line): clips, poses and the window show words and lines whole.- Hits follow what is drawn:
Ui::glyph_at,Point::glyphandPoint::z;El::turnturns an element and its subtree, and it is pressed where it is drawn;MeshHithaspoint,normal,tanduv, andMesh::raycasts a ray at a mesh. - A button or link inside an element that drags (a scene with
on_point) takes its own press. - The warm-up (§1.23):
Renderer::begindraws plain at once,Warmup::step/Renderer::warm_stepmake the rest a piece at a time, and the page condenses into its look when it is ready;Offscreen::try_warming.Ui::prepare,Ui::readyandUi::readinessrun an application's own work in the frames' spare time; the annotation layer readsREADY. - The audit (§1.31):
amenui::audit,drive::audit,render --audit(with--strict, a P0 or P1 fails): text cut off, contrast, glyphs over each other, text too small, a page that never settles. The annotation layer'sINKkind draws the same measured ink box. - What the audit found:
Paint::DIMis 0.66 (it was 0.5, 3.2:1 on light); the light theme's accent is darker (5.6:1) and the selection tint 12 %;nearkeeps text's ink whole; the loading recipe no longer asks for a frame every tick.
Running applications
amenui::app: the framework runs applications itself.app::native::runopens a winit window (featurewindow, on by default) with the system clipboard, the input method, touch, frames on demand, and--shot/--exit-afterfor checks under Xvfb.app::web::Hostand theweb_app!macro generate a wasm module's exports from an application's state and message types. TheApptrait is how a shell routes, reads the route, takes clipboard requests, and sets the look, the language and reduced motion; every method has a default.- Native screen readers:
app::accessbuilds an AccessKit tree from the accessibility mirror for the window (UI Automation, NSAccessibility, AT-SPI) and turns Focus, Click, Increment and Decrement into the runtime's focus, activation and arrow keys. - The mirror says more:
El::expanded,El::description,El::live(Role::Statusis polite by default),El::invalid,El::required. The accordion, select and popover reportexpandedinstead ofchecked. - Fonts beyond the bundled ones:
Face::fallbackfor faces tried after the bundled ones, andFace::system()for the system's installed fonts (featuresystem-fonts, on by default; the native window adds it).Text::missing_glyphs. Thecomplex-scriptsfeature for Thai, Lao, Khmer and Burmese line breaking. - Any language:
Locale::Other(Tag)for any BCP 47 tag, falling back to English, with CLDR plural rules, right-to-left direction by language or script, and its ownlocale.nameandlocale.date. Arabic ships (Locale::AR,assets/i18n/ar.txt).Locale::ALLlists the three shipped locales;i18n::installed()lists the application's.Locale::namereturns aString. - Focus:
El::tab_order(positive first, 0 in document order, negative out of Tab),El::skip_toandEl::focus_shown, and theskip_linkcomponent. App::set_appearance(Appearance { dark, high_contrast }),App::files_hoveringandApp::files_dropped(Droppedwith a path natively, name and bytes on the web), from both shells.- The native window draws with the bundled faces compiled in (
text::embedded), so a shipped binary finds its fonts anywhere.WindowError::Fontis gone. amenui addwrites from the sources compiled into it (sources::file,add::writereplacesadd::copy), so an installed command works without the repository.- Crate metadata for crates.io (description, keywords, categories,
rust-version); the package leaves out CI (8.7 MiB compressed, under the 10 MiB limit). - The native window recovers from a lost GPU device: new device and renderer,
setupagain, theUiuntouched.native::run'ssetupis nowFn. web/amenui.js, theamenuinpm package: the page side of the web entry (mount,stage,css).offscreen::read_back: one frame drawn into a texture of a given format and read back.error::WindowError.- CI: clippy for native and web, rustdoc, the tests on lavapipe, and the website's tests against each framework commit.
The framework and the website in two repositories
- The site (the gallery shell and its pages, the skeleton demo, Body and the Lab, the site documentation, the web shell, the native window, and the sample, acceptance and timing tools) moved to amenui-dev/website ↗, with its history.
i18n::install: an application installs its own message catalogs, looked up before the framework's. The framework's catalogs keep only the components' own strings (widget.*).amenui::pictures: sample pictures computed in code (formerly indemo.rs).amenui::sources:AGENTS.md,llms.txt,registry.json,CHANGELOG.mdand every component's source, compiled into the library.text::ASSETS: where the fonts are on disk.drive::render_withtakes an application's own pages;drive::openopens recipes only, and so does therendertool.- The library is no longer a
cdylib. The web entry point (wasm-bindgen),winitandarboardmoved to the website repository with the native window.
The field map and trails, the thread material, small type, Loose Thread
- Body is English only, whatever the interface language. Its language marking reads
LANGUAGE EN / ZH, and pressing it changes the language of the rest of the gallery. - The field map (
src/fieldmap.rs): a coarse grid over the window whose nodes hold energy and a flow direction. It steps at a fixed 1/60 s, spreads, decays by lifetime, meanders (meander) and creeps along ink (creep), returns to exactly zero within a bounded time, and needs no frames at rest. - Trails: an element with
El::stirrstirs the map along the path it moved.Cmd::Stirstirs a point, an element or a stretch of a path. The floating box, the bottom sheet and the card stack trail by default; the preset sets how strongly (Normcore has none). - Reading the map: in the G-buffer stage it is one more source of looseness (still bounded by the legibility cap and each element's response), and instances that can be pushed drift along its flow (pictures and 3D elements loosen in place). The
dotmaterial's ground dots andglitch's ground read it;Ui::loosenessuses the same value. An element that trails and has a ground fill is drawn on a layer above, so loose decoration it passes over does not show through it. - The
#stirrpage, with twelve numbers as number controls; one more line in the F2 readout;checkitem 19 (the former item 19, effects, is now item 17),bench … mapandcraft <dir> stirr. - The
scribblrthread material (src/strand.rs). At rest it is byte-identical toplain. Loosened, the fill fades and the ink becomes one continuous thin line: it first follows the glyphs' true outlines, bridged into one stroke (clean outlined letters); looser, it drops vertices step by step and merges into long polylines across several glyphs that wander off. The one to three places with the most energy knot into large stars, one long tail enters from the scope's edge and another leaves through the opposite edge, and it writes itself back in reverse. Text to read and controls never turn into thread, fade or move. Eight numbers are in the material parameters (reach40,knot_r48,tail480,angular0.9), andLook::hold_msholds the thread's pose for a beat. - Long paths with
El::trace: a polyline drawn by progress, solid or dashed (dash,gap, by arc length from the start), bent by the flow, stirring the map at its head. "Draw a line" on#stirr. - The thread starts from the outline as the G-buffer stage drew it, plus the offset by which the map pushed the instance. Vertices are ranked by one Ramer–Douglas–Peucker pass, slide onto their chord and are then removed, so the line follows its chords and nothing jumps on the way back. Knots are long chords through a center. Tails are cut at the scope's edge and stop before text to read.
strand::figuredraws a tangle from a fixed seed as page content. - The
#material-scribblrpage;checkitem 20,bench … strand,craft <dir> scribblrandtests/strand.rs. - Letter spacing with
El::tracking. Quiet type withEl::whisper(): lowercase, 0.6 em tracking, in a serif (Source Serif 4 at its 8 pt optical size, Latin only, 82 KB, OFL). - Three new readouts in the annotation layer: edge notes
EDGE(a hairline, ticks and a pointer mark at the scope's right edge, with the scope size, the pointer position, the material and theme, the loosest element and the number of non-zero map nodes set vertically), a waveformOSC(the energy of one row of nodes as a one-device-pixel polyline) and a level barLEVEL(the mean energy). The annotation layer honours instance transforms, used only to turn the edge notes by 90°. The exported tree gainsfield: { level, nonzero }. - The tenth preset, Loose Thread: white thread on black (or paper white), one accent,
scribblr, only edge notes and corner marks on hover; the map meanders, creeps along ink and lives two seconds (a title the pointer sweeps loosens past 0.8 and comes back within three seconds); the thread holds every other beat; a 700 ms transition loosens into thread and then draws the outline. Its style page is English only: a lowercase serif title, one picture, one sentence, three controls as one line of small type in the footer, and a drawn tangle at rest. - The finishing pass gains black and white only (
binary: a black-and-white palette, no dither, line widths rounded; text, thread and annotations are thresholded by coverage rather than brightness, and pictures get a two-level ordered dither) and invert (invert:1 − colourat the end). - Annotation corner marks sit 6 px outside the element's rect, off its own text.
- Fixed theme ids and style-page descriptions that had drifted after themes and styles were removed.
checkitems 7.2 and 7.3 (edge notes, waveform, level bar, edge notes at 1080p) and 20.6 and 20.7 (black and white only, invert), three tests intests/gaze.rs, the Loose Thread page intests/i18n.rs,craft <dir> loose-threadandcraft <dir> thread-ref.
Foundation leftovers, the Lab as a wall, Body
- Sampling follows transforms:
morph::cover_atmaps points back through each instance's own transform, andcellsandink_boundsuse the turned bounding box, so a posed or turned glyph loosens from where it is drawn, and masks and decode work there too. - Hover and focus corner marks land on their target in the frame the pointer arrives (they used to chase it every frame and trail behind), with only a 70 ms close-in and fade.
- The lens touches only pictures and 3D elements that may loosen and that the pointer is not operating, added per instance in the G-buffer stage as fronts are. Looseness belongs to the instance's own ink (its ink wins over another's distance band) and no longer spills onto neighbouring decoration.
- Dragging, throwing and settling the floating box joined
check's partial-redraw comparison (every material, two at 2× scale). - Decode counts coverage of the outline, not colour, so a dialog filled with the ground colour is covered too at the finest level.
- DESIGN.md no longer mentions the removed chrome, liquid and collage materials.
- The Lab: each stage takes over 70% of its cell and the piece fills it, the formula is one line and the numbers fold into
[ params ]. Cells that can be seen keep running and stop when scrolled away (they rest with reduced motion). Every cell was redone to fill its stage, with the blue under the pointer; decode's exploded view became planes seen at an angle, each with a leader and a label. - Removed the film (the prologue and chapters, the slate, the timeline, before-and-after, each chapter's caption), the xray material and its preset (Transparent Electronics), and the tests, checks, docs and strings that existed only for them. The exploded scene no longer uses xray.
- Body (
#body) is the new full-bleed landing page. A page of readable text appears, then gathers into a slowly turning, luminous body made of its own glyphs (the skin, glyph count conserved) and more than ten thousand volume marks, with a key light, rim light, fog, bloom, a reflection and halo on the ground, three layers of dust, parallax and a breathing lens. Small markings in the picture (form, seed, gather / release, language, Lab, components); an opening at the pointer shows the original text. - Bloom samples at a per-pixel noise angle, so text no longer shows ghost copies.
Pose::huegives one glyph an accent colour.
Fields, the Lab, decode, a narrower scope, the frame budget
- Per-instance transforms (
Instance::xf: turn, scale and shear about the instance's own center) and glyph poses (El::pose), so text can follow a path, wrap a sphere and be lit while its outlines stay true. - Drawings (
el::canvas(Drawing): dots and strokes are shapes with true outlines) andEl::on_point(move, press-drag and leave in one handler, in the canvas's coordinates). - Fields (
amenui::field): noise, bumps, metaballs, curl, grids, marching-squares contours, vector flows, advected swarms and masked Gray–Scott. El::on_visible(run only while seen) andEl::on_outline(an element's true outline handed to the state as a mask).- The frame budget (
amenui::budget): morph tiles, shed marks, flow fields, swarms and drawing marks all draw from one budget, which shrinks when a frame runs over and recovers when there is room; the readout shows it. - The Lab (
#lab): ten experiments (lit text, contours, silk, grown shapes, mercury, text on a path, text on a sphere, orbits, a spring, the card stack), one example file each, each with its own page. - The decode transition (
El::decode): an element resolves from coarse to fine over its true outline and disappears by the same backwards; its documentation page has an exploded 3D view and a timeline. - Removed the chrome, liquid and collage materials, the Neo-Y2K and Mixed media presets, and film chapters 11 and 12 (with the finale).
Interaction craft
- Gesture physics (
amenui::gesture): an analytically stepped spring with velocity hand-off on release, a rubber band, throw projection and velocity tracking. - A bottom sheet (detents, dismissal by projection, rubber banding, a scrim, hand-off from scrolling) and a floating box (the corner picked by projection).
- The formula caption: a line under a demo that prints its real parameters, each editable.
el::layers: children stacked in one box.- English text around obstacles: Liang hyphenation (en-US) and up to 0.08 em of letter spacing; pieces that are not justified fall below 15%.
- A dot chart: a dot's size and brightness are the area under the curve, a sweeping line, draggable control points.
- The zine chapter's toner halved and kept off the text (
Shed.clear), with a one-line caption. - A fanning card stack: angle0 × falloff^n, delay_ms × n, three looks that follow the material.
- Skeletons:
El::skeleton()draws the real tree as a skeleton (bars are measured line widths), the twoLoadingnumbers, zero layout shift, and a comparison of four ways to load. - Nested menus: a safe-zone triangle, two delays, the keyboard, and a triangle that can be drawn (
El::on_move,El::guide).
The prologue, display not slogans, guidance, wrap, the readout, look recipes
- The film's prologue: one small interface, as it is on the left and in a material on the right, with a draggable divider and a row of material names.
- No slogans: a chapter's title is one element that recomposes glyph by glyph across cuts; chapters 9, 10 and 11 redone.
- Guidance in the bottom bar: previous and next chapter, autoplay progress, hints shown only until the first input, bracket hints, invisible edges.
- Text around obstacles follows the true distance, leaves no slivers and does not hop while dragged; body text never condenses glyph by glyph; nothing is cut off at 330 px wide.
- The F2 readout: one line or every number, with a sparkline, and no frames at rest.
look:v1:recipes (in a URL or a PNG text chunk); eight new mark sets grouped by family; five Geist Pixel faces; the<amenui-view>custom element.
Scrolling, the sign and the mechanism, languages, components and docs
- Slow scrolling moves a picture by whole pixels; fast scrolling leaves each material's own trace (§1.8.3,
checkitem 18). - The film's third actor is a flat sign; chapter 13 is a real 3D mechanism (gears, a cam, a follower).
- Message catalogs,
t!, plurals, a fallback chain and right-to-left rows (§1.20). - Eighteen new components,
amenui add, and a documentation site laid out after shadcn/ui.
Fixes and the film
Bounded recomposition, particles emitted from mesh surfaces, local clocks, and the twelve-chapter film.
3D, GPU particles, dirty boxes, presets and transitions
Ripple rules, recomposition, the model-facing surface
Interaction and performance
Drawing only when something changed, the frame-time readout, text input, incremental layout and long lists, touch, and the accessibility mirror.
Annotation, every material, twelve presets, scenes
Transforms: particles and flows
Components and the gallery
Marks, pixel type, themes and materials as data
The skeleton
The element tree, taffy, parley, scrolling, clicks, focus and the number control.
The vertical slice
Two-stage drawing, waves that follow outlines, and one codebase for native and web.