Fire UI 0.8.0

Fire UI 0.8.0 makes text rasterization and completed-frame presentation explicit renderer choices.

• Add optional Swash-backed cached glyph masks for ordinary solid OpenGL UI text, while keeping outline fallbacks and the lean outline-only build.
• Upgrade FemtoVG to 0.27 and preserve the framework’s existing shaping positions and explicit font resources.
• Add explicit Cairo direct and retained X11 presentation modes. Direct mode uses no client framebuffer; retained mode copies completed damage to prevent visible clear-then-draw flashing.
• Keep raster text opt-in: core remains dependency-free, default fire-ui-gl excludes Swash, and Studio enables it explicitly.

The opt-in raster-text feature adds about 0.81 MiB to the stripped Studio release binary in the measured Linux build. Glyph masks use dynamically allocated cache atlas pages. Seven verified crate archives and checksums are attached. These crates are not published to crates.io, and Studio is not published as a crate.

This is a breaking prototype release; update consumers directly.

Fire UI 0.7.0

Native hosts no longer require OpenGL, a text shaper, font discovery or unrelated platform services. Applications select rendering, text, font storage and native integrations independently through the public interfaces used by built-in and custom widgets.

• Add X11/Cairo rendering and move OpenGL into an optional crate.
• Share immutable font resources and caller-owned paragraph snapshots; reuse unchanged lines without a persistent document cache.
• Remove redundant scrollbar layouts and excessive gradient painting while preserving Unicode editing, accessibility and uncapped undo history.
• Add isolated native memory, CPU, response, IME/accessibility and editor acceptance tooling.

Seven tested crate archives and checksums are attached. This is a breaking prototype release; update consumers directly. These crates are not published to crates.io, and Studio is not published as a crate.

The full Fire Notes consumer passes its revised balanced 4 MB private-dirty regression gate at 3.51–3.52 MB, with zero swap. Total private resident memory is 10.15–10.19 MB. The original 3 MB target was not met. Native response and idle checks pass; display-server costs and document growth remain separate measurements. Physical scanout and hardware-GPU performance are unmeasured.

Complete Notes binary and native evidence · Changelog

Fire UI 0.6.0

Ambient values keyed by type, a compact instrument theme, and the widget cleanups
that exposed. Breaking throughout; consumers update directly.

Ambient values. A node's environment was a single slot of a single type, so
publishing one type to a child evicted whatever it had inherited and blocked that
type from reaching it ever again. A virtual list publishes selection to each row,
which quietly cost every row its view of the theme: after a theme change, rows that
existed beforehand kept the old one and a list showed two label insets at once.
Values are now a small type-keyed map. Publishing replaces one type and leaves the
rest, inheritance stops per type at the node that publishes it, and nodes share one
map until something publishes its own — so installing a value for a subtree still
allocates once for the subtree rather than once per node.

A second scale. Palette::slate_dark is cool graphite with a signal-blue
accent; Scale::compact halves the rhythm — smaller type, tighter padding, squarer
corners, shorter controls. Theme::compact pairs them. Palette and scale remain
independent axes, so any pairing works, and nothing in the framework prefers a
shipped pair. Changing only the palette repaints; changing the scale relays.

Widgets. VirtualList takes a RowHeight: a number, or a rule read from the
theme so rows tighten with it. Scrollbar geometry takes the strip width rather than
a theme, so a scrolling widget remembers two floats instead of a palette.
Lifecycle::Inherited now reaches every widget whose inherited environment changed,
which is what a widget deciding which children to own needs and cannot get from
layout alone.

Composability, now under test. A custom widget that never mentions a theme; a
shipped control with none installed; and a palette whose surfaces are transparent,
which is how a control is asked for behaviour without chrome. The core itself has no
theme concept at all — theming lives entirely in the optional widgets crate.

Full notes in
CHANGELOG.md.

Known gap: a virtual list publishes itself but not per-row list items, so rows reach
assistive technology as their own content rather than as selectable entries.

Verified: cargo fmt, cargo test --workspace, cargo clippy -D warnings including
each native feature independently, cargo doc and cargo package. The native probe
passes end to end under Xvfb, including AT-SPI activation and all six EditableText
methods. Idle, paused and post-theme-swap CPU all record zero ticks.

Fire UI 0.5.0

Controls, layout policies and a design-token system.

Controls. Checkbox, switch, slider, progress, dropdown, tabs, divider and
surface join the label, button, editor, menu and virtual list. Each carries its own
keyboard handling, focus ring, pointer cursor and accessible semantics rather than
paint alone; sliders and progress publish a numeric range to assistive technology.

Theme. A semantic Palette and a Scale replace the flat theme, with a
six-step type scale and colour roles. Widgets name a role and never a literal value,
so one AppearanceScope swap repaints a whole window correctly — ember dark and
ember light both ship.

Layout. row and column take a Flow carrying gap, Justify for leftover
space and Align across the axis; an Entry claims natural, fixed or weighted
length. stack overlays, grid reflows to a minimum column width, and every policy
has an origin-relative variant so one widget can sequence several without a container
type per combination. A column now measures each child against the space its
predecessors left, so content cannot silently overflow and be clipped.

Composition. Children::bubble makes a decorator transparent in both
directions: commands reach the content and its output passes through untouched.
Overlays anchor to the window as well as to a sibling, and are born anchored through
Update::insert_at — a handle returned by insert is not owned while its callback
runs, so anchoring afterwards was silently rejected. Lifecycle::Inherited tells a
widget to re-derive whatever it published to a child when the ambient value changed.

Painting. Brush::Radial and Brush::Box join the paint contract, carrying
glows, focus rings and drop shadows. One scrollbar serves the viewport, the virtual
list and the editor, each reserving its own strip so content never runs beneath it.

Studio. A seven-section navigable gallery — overview, controls, text, lists,
canvas, a live layout playground and the tokens themselves — containing no literal
colour, font size or panel coordinate. The native probe drives it through the
inspection socket rather than fixed coordinates.

Breaking throughout; consumers update directly. Full notes in
CHANGELOG.md.

Known gap: a virtual list publishes itself but not per-row list items, so rows reach
assistive technology as their own content rather than as selectable entries.

Verified: cargo fmt, cargo test --workspace, cargo clippy -D warnings (including
each native feature independently), cargo doc and cargo package. The native probe
passes end to end under Xvfb, including AT-SPI activation and all six EditableText
methods. Idle, paused and post-palette-swap CPU all record zero ticks.

Fire UI 0.4.0

Fire UI 0.4.0 makes native services and rendering costs explicit app choices, and completes the Linux/X11 editing and agent-inspection work. MIT licensed, Rust 1.88+; experimental API with breaking changes.

• Independent opt-ins for native accessibility, agent inspection, clipboard, file dialogs and bitmap fonts. Core semantics remain available without native services.
• No fonts load by default. Apps provide primary/fallback files and choose whether to retain a framebuffer for partial repainting.
• Bidirectional text geometry, IME composition/selection, stable semantic keys and validated editing actions shared by screen readers and agents.
• All six Linux AT-SPI EditableText methods, Unicode range editing, undo and asynchronous native accessibility clipboard reads. Disabling clipboard support preserves Cut selections.
• Reusable control styling, pointer cursors, richer window actions and X11 passive overlays.

The isolated draw-only demo is 2.66 MiB with minimal features versus 6.34 MiB with optional services compiled in. Both recorded zero idle CPU ticks over two seconds. Measurements include Xvfb/Mesa software rendering; see the performance report for memory figures and limits.

Validation includes 68 framework tests, 14 Fire Notes tests, independent feature builds, strict Clippy, Rust 1.88, documentation and package checks. Real Linux probes cover IBus/XIM, Orca speech generation, AT-SPI editing, agent inspection, resizing and animated text. Wayland is deferred; Windows/macOS native IME and screen-reader behavior still needs desktop verification.

Use the v0.4.0 Git tag in Cargo dependencies. Three verified .crate archives and SHA-256 checksums are attached. These crates are not published on crates.io. See native configuration for the feature flags and explicit font configuration.

All six CI jobs passed on the tagged commit, including Linux/macOS/Windows tests and Linux native probes. A fresh external Cargo app using the Git tag also compiled successfully.

Fire UI 0.1.0

First standalone Fire UI release, licensed under MIT.

Three small crates provide the widget core, optional controls and native desktop hosting. Use the v0.1.0 Git tag directly; the attached crates are ready for registry publication but are not on crates.io yet.

Rust 1.88+. Experimental API: breaking redesigns are expected. Linux native interactions are verified; see the README for platform and implementation limits.

Validation: framework tests and doc examples, strict Clippy, rustdoc, minimum-Rust check, and all three packaged archives passed locally.