Fission 0.4.1

Fission 0.4.1 is a focused patch release on top of the 0.4 authoring API. It keeps the impl From<Component> for Widget model intact and improves runtime shell routing, server/static rendering, mobile target scaffolding, and package verification.

Source commit: 2f9b0b6d9c777ff421d15b8db29d5419b2f983e8

Highlights

• Added the route/action shell layer built on top of the scoped raw action primitives introduced in 0.4.0.
• Added RouteLocation and ShellRouteChanged for typed shell route-change dispatch.
• Added with_route_handler(...) to desktop, mobile, web, and winit shell builders.
• Added router builder helpers for common route table construction.
• Added server static app mounts, prefix server routes, structured route data, and route response status support.
• Improved SSR/static lowering for forms, links, responsive images, SVG icon coloring, animation output, text output, positioned layout, markdown image rendering, and cache ids.
• Fixed target feature synchronization and hardened generated Android/iOS mobile scaffolds.
• Added executable mobile package script coverage.
• Fixed the desktop notification-response builder so on_notification_response(...) returns the builder for chained configuration.

Scoped Route Actions For Runtime Shells

Fission 0.4.0 introduced the low-level scoped raw action primitives: ActionScopeId, ActionScope, and ActionInput::ScopedRaw. Fission 0.4.1 adds the higher-level route/action shell plumbing that hosts can use alongside that scoped dispatch boundary.

RouteLocation represents browser-compatible route location data, with a required pathname and optional host, hash, hostname, href, origin, port, protocol, and search fields. ShellRouteChanged is a built-in action shells can dispatch when the host route changes.

Shell builders now expose with_route_handler(...), so route changes can flow into ordinary typed reducers rather than shell-specific side channels.

Server And Static Rendering

The server/static path now includes:

• static app mounts;
• SSR environment hooks;
• cache invalidation APIs;
• prefix route matching;
• structured route data;
• response status support;
• server handler execution off runtime threads;
• static form lowering;
• better link/image output and markdown image rendering.

These changes make static and server-rendered apps more predictable when they combine content routes, forms, markdown, metadata, embedded app surfaces, and custom status responses.

Mobile And Packaging

The CLI and package tooling now preserve and synchronize target feature state more reliably when existing projects already contain platform folders. Android and iOS scaffolds were hardened, and generated package scripts gained executable coverage so package-path regressions are caught earlier.

Published Crate Set

All workspace crates under crates/ have been published as 0.4.1, including the fission facade, authoring crates, core/runtime crates, shell crates, rendering crates, command/tool crates, and test crates.

Migration Notes

Most 0.4.0 applications should move to 0.4.1 without code changes.

Applications that need to react to host route changes can register a reducer with with_route_handler(...) and handle ShellRouteChanged. Hosts that mount guest UI can continue using the 0.4 scoped raw action APIs and pair them with route actions where they need route-aware dispatch.

Server-rendered or statically generated sites should prefer 0.4.1 when they rely on route status, structured route metadata, prefixed routes, markdown images, responsive images, static forms, or mounted static app islands.

Mobile projects should regenerate or resync target scaffolds if they need the updated package scripts and target feature handling.

Verification

• v0.4.0^{} resolves to 91cefd180896d64b388ca9b731be8d97ab3cfccb.
• v0.4.1^{} resolves to 2f9b0b6d9c777ff421d15b8db29d5419b2f983e8.
• All 36 workspace crates under crates/ are visible on crates.io as 0.4.1.
• Release preparation ran package verification for the workspace crate set before publication.

Release blog: https://fission.rs/blog/2026-06-17-fission-0-4-1-runtime-shells-and-scoped-actions/

Full changelog: v0.4.0...v0.4.1

Fission 0.4.0

Fission 0.4.0 is the authoring API v2 release. The tag is the merge of PR #63, authoring-api-v2-final, and refactors the framework around concrete component-to-Widget conversion, scoped build handles, provider context, retained local widget state, and WidgetId identity.

This is a breaking authoring release. The commit range from v0.3.0 to v0.4.0 migrates the framework, widgets, shells, examples, tests, and documentation onto the new public authoring shape instead of keeping the old public node/widget-boundary model alive.

Source commit: 91cefd180896d64b388ca9b731be8d97ab3cfccb
Published crate metadata points at crates/authoring/fission in that commit.

Highlights

• Added the widget authoring API v2 RFC and refined the child identity model before landing the implementation.
• Replaced NodeId with WidgetId in the IR and migrated layout/render/runtime paths to the new identity type.
• Added scoped build handles and provider state in fission-core.
• Added base scoped raw action primitives for host shells that need to tag mounted subtrees and inspect scoped raw dispatch.
• Introduced the closed Widget representation used by authored components and framework widgets.
• Updated core interaction internals, runtime state, reducer plumbing, and action binding around the new authoring model.
• Migrated core layout, control, media, text, overlay, navigation, async, form, picker, chart, and 3D widgets to impl From<Component> for Widget.
• Updated desktop, winit, mobile, web, static-site, server, and terminal shells for the new widget representation and identity model.
• Updated CLI command UI, test driver, layout tests, examples, crate READMEs, widget reference docs, Learn pages, cookbook pages, capability docs, chart docs, and release docs.

New Features

Authoring API v2

• Components are now written as ordinary Rust structs that convert into Fission widgets with impl From<Component> for Widget.
• The public authoring surface is centered on Widget, Option<Widget>, and Vec<Widget> child slots rather than exposing node-like internals as the normal application boundary.
• Core framework widgets and fission-widgets components were migrated to the same conversion model, including display/data widgets, forms, pickers, overlays, navigation, async media, text, layout helpers, charts, and 3D surfaces.
• The fission facade exports were updated so application authors can use the new model through the facade/prelude.
• Feature tests were added around the facade and macro exports so the new authoring APIs remain available from the expected public entry points.

Scoped Build Handles

• Added fission::build::current::<State>(), exported by the facade, returning a BuildCtxHandle<State> and ViewHandle<State> during component conversion.
• ViewHandle is the read side for state and view data used while building widgets.
• BuildCtxHandle is the wiring side for action binding, local reducer binding, and runtime-managed behavior.
• Runtime state and reducer plumbing were refactored so component conversion can access scoped handles without threading build arguments through every reusable child component.
• Tests in authoring_api_v2.rs cover typed build handles working during build and generated global state views reading nested fields.

Providers And Scoped Context

• Added Provider and build-scope provider state for typed parent-to-child context during widget conversion.
• Added facade exports for fission::build::{provide, read, try_read}.
• Provider behavior is covered by tests that resolve the nearest scoped value without losing the parent scope and report a clear error when provider reads happen outside a provider scope.
• Documentation was updated to distinguish provider context from durable application state.

Local Widget State

• Added the #[fission_component] macro for v2 authoring components.
• Added #[local_state(default = ...)] and #[local_state(default_with = ...)] support, generating StateField<T> accessors for retained UI-local state.
• Added local reducer authoring through scoped build context, allowing component-local retained state to update without being moved into global app state.
• Local state behavior is covered by tests for authoring shape, persistence across rebuilds, sibling isolation, reordered dynamic children, and pruning removed local state identity after rebuild.

Scoped Raw Action Primitives

• Added ActionScopeId as a stable raw dispatch scope identifier.
• Added the ActionScope widget for annotating a subtree in the lowered semantics tree.
• Added ActionInput::ScopedRaw so runtime and shell code can inspect the nearest action scope and target before recovering the original unscoped input.
• Propagated action scope ids through input lowering and runtime dispatch paths.

Widget Identity And Runtime Model

• Replaced the old IR NodeId file with WidgetId and migrated runtime/lowering/layout tests to use widget identity.
• Added explicit widget identity usage across examples and tests where retained state, animations, inputs, portals, overlays, or dynamic children require stable identity.
• Updated core interaction internals and lowering paths for the closed Widget representation.
• Added guard tests to prevent removed public authoring escape hatches from being reintroduced.

Shells, Rendering, And Tools

• Updated base shell abstractions and the desktop/winit shells for WidgetId and the closed widget API.
• Updated mobile and web shells for the new authoring/runtime model.
• Updated static-site and server shells, including static-site document/build/browser-island paths and server render/artifact paths.
• Updated terminal shell rendering and verification.
• Updated the Fission command UI screens and components to the new widget API.
• Updated the Fission test driver and fission-test regression suites around layout, interaction, media, scrolling, text input, flyout behavior, and UI regressions.

Examples

• Migrated the counter example to the new #[fission_component], local state, build::current, and local reducer pattern.
• Migrated animation gallery, chart gallery, editor, embed examples, field inspector, icon gallery, inbox, mobile smoke, product browser, Pokemon card store, terminal, text lab, todo design system, web smoke, and widget gallery examples.
• Updated example tests where they depend on widget identity, action binding, text/input behavior, browser bridge behavior, visual audit paths, or retained state.

Documentation Site And Reference Material

• Added docs/rfc-widget-authoring-api-v2.md.
• Added the 0.4.0 authoring API release blog post and backfilled release posts for 0.1.0, 0.2.0, and 0.3.0.
• Added the state handles and providers guide.
• Updated Learn/runtime-model pages, app-structure guidance, layout/widget guides, resources/async docs, platform shell/testing docs, theming/i18n docs, and cookbook entries.
• Updated capability documentation and capability reference pages for the new widget API.
• Updated widget reference pages across the catalog and replaced stale node/custom-node references with the new custom-widget authoring direction.
• Updated chart reference documentation and chart gallery material.
• Improved documentation information architecture, nested static-site navigation menus, responsive documentation pages, and blog navigation.

Bug Fixes

• Fixed action binding examples in the widget authoring API v2 RFC.
• Clarified widget child identity rules before landing the WidgetId migration.
• Simplified the minimal widget API example to match the final authoring model.
• Updated stale docs/examples that still referenced old public node/widget-boundary forms.
• Culled off-bounds Vello text glyphs.
• Improved static-site blog navigation after the release-post backfill.
• Refreshed documentation IA and responsive site pages after the authoring API migration.

Testing And Validation Added In The Tag

• Added crates/core/fission-core/tests/authoring_api_v2.rs covering typed build handles, provider scope resolution, provider errors outside scope, generated global state views, local state authoring shape, retained local state persistence, sibling isolation, reordered dynamic children, local state pruning, and public API escape-hatch prevention.
• Updated fission-widgets test suites for display widgets, forms, pickers, overlays, async widgets, markdown, routing, theming, and widget invariants.
• Updated core runtime/layout/input/text/media tests for WidgetId, handles, and the closed widget API.
• Updated shell composition tests, terminal shell tests, test-driver tests, example tests, and widget-gallery visual audit tests.

API Changes And Migration Notes

• Replace old public node/widget-boundary authoring with impl From<Component> for Widget.
• Use let (ctx, view) = fission::build::current::<State>(); inside conversion instead of passing build context through every component signature.
• Use Widget, Option<Widget>, and Vec<Widget> for child slots, with .into() at composition boundaries.
• Use Provider plus fission::build::read::<T>() for scoped parent-to-child context, not durable product state.
• Use #[fission_component] and #[local_state(...)] for retained UI-local component state.
• Use scoped local reducer binding for local retained state updates.
• Use explicit WidgetId values for dynamic retained children that can be reordered, filtered, or recreated.
• Use ActionScope only when shell/runtime code needs a low-level raw dispatch boundary for a mounted subtree; normal application actions should remain typed reducer actions.
• Remove application code that depends on old public NodeId/node-like authoring paths.

Published Crate Set

The tag updates the workspace crate manifests under crates/ to 0.4.0, including the fission facade, authoring/widget crates, macro crate, core/runtime/IR/layout/theme/semantics/i18n...

Fission 0.3.0

Fission 0.3.0 focuses on turning the platform work from 0.2 into more complete application flows. It adds typed async image loading, FutureBuilder/RefreshIndicator widgets, a product-browser example, native capability hosts, GPU-first web/iOS rendering, native app icons/launch surfaces, and the first server-side Fission shell with sessions, signed actions, progressive workers, browser bridge support, Docker packaging, and security controls.

Source commit: d0183e2fa02e09cb383f423debadfb49e63cd235
Published crate metadata points at crates/authoring/fission in that commit.

Highlights

• Added typed image sources and renderer-backed loading for asset, file, network, memory, and SVG image paths.
• Added async UI helpers: FutureBuilder, AsyncSnapshot, AsyncConnectionState, and RefreshIndicator.
• Added the product-browser example using real remote data, async loading, refresh behavior, grid/list presentation, and network images.
• Added native host implementations and generated metadata for built-in capabilities, plus the Field Inspector example to exercise them across platforms.
• Made web and iOS rendering GPU-first, with Canvas2D/software fallback retained where needed.
• Added app icon/native launch surface generation and documented the full fission.toml manifest reference.
• Added fission-shell-server and fission-command-server for server-rendered Fission apps, including signed actions, sessions, server assets, progressive browser workers, island bridge support, cache/security config, and Hyper serving.
• Added Docker image packaging and registry publishing support for server/static deployment workflows.
• Removed the stale Skia renderer crate from the released workspace.

New Features

Images And Async Widgets

• Reworked the Image widget around typed ImageSource values rather than a single path-like field.
• Added image source support for assets, local files, network URLs with request metadata, memory bytes, and inline SVG text.
• Added image loading/cache/error behavior configuration through typed request and policy structures.
• Added renderer loading paths so loaded images are actually available to Vello/display-list rendering.
• Added tests covering source lowering, network image metadata, SVG handling, and renderer image loading behavior.
• Added FutureBuilder so widgets can render loading/data/error states from job-backed asynchronous work.
• Added RefreshIndicator with pull/armed/refreshing/done states and gesture integration.
• Added product-browser documentation and example README updates.

Product Browser Example

• Added a high-quality product browser example using real remote product data.
• Added async loading and refresh behavior using the new async widgets.
• Added image rendering for remote product thumbnails.
• Reworked the example toward grid/list layout instead of a single visible item.
• Added tests and screenshot-oriented checks to catch image-loading and layout regressions.

Capabilities And Native Hosts

• Implemented native capability host plumbing and generated target metadata.
• Added the Field Inspector example to exercise capabilities across desktop, web, iOS, and Android targets.
• Added macOS development-bundle execution so permission prompts and entitlement-style metadata can be exercised through fission run --target macos.
• Added macOS native capability hosts and native notifications.
• Fixed web passkey registration defaults and scheduled notification handling.
• Fixed iOS simulator capability dispatch linkage.
• Documented example learning paths for capability-heavy examples.

Web, iOS, And Rendering Quality

• Made web rendering GPU-first using the WebGPU/Vello path, with the existing Canvas2D/software renderer retained as fallback.
• Added renderer diagnostics so active web renderers can be surfaced by tooling.
• Fixed WebGPU image refresh behavior.
• Made iOS rendering GPU-first where possible and retained fallback handling.
• Fixed iOS safe-area and text layout issues.
• Rendered software frames at device scale to avoid low-resolution/soft output when software fallback is used.
• Added native app icons and launch surface generation.

Server-Side Fission

• Added the server shell RFC and the first implementation of server-rendered Fission apps.
• Added fission-shell-server and fission-command-server crates.
• Added fission server serve style workflow through the CLI command crate.
• Added Hyper-based serving for local server apps.
• Added server-side asset serving for generated CSS/JS/worker/island assets.
• Added revalidated/cache-aware site primitives and runtime integrations.
• Added signed HTTP action/reducer dispatch for server forms.
• Added server-private session state and persistent cart behavior in the Pokémon card store example.
• Added progressive browser worker support and a message bridge for DOM-oriented enhancement work.
• Added browser island bridge support for focused interactive areas.
• Added runtime security controls and configuration for the server shell.
• Added tests around server sessions, signed actions, browser bridge behavior, island worker asset handling, and cache/security paths.

Pokémon Card Store Example

• Added a new server-side e-commerce example selling Pokémon cards.
• Demonstrates static/server-rendered pages, session-backed cart state, signed actions, server assets, progressive workers, browser bridge behavior, and server-side configuration.
• Added documentation using the store as a concrete guide for server-side Fission workflows.

Packaging, Docker, And Deployment

• Added Docker image packaging support for server and static-site deployment paths.
• Added registry publishing support for Docker-style images in the packaging workflow.
• Hardened server build and Docker packaging tests.
• Documented static and server site packaging workflows.

Documentation And Project Metadata

• Added a complete fission.toml reference page covering manifest sections, target configuration, metadata, capabilities, icons, splash/launch surfaces, site/server config, packaging, and release settings.
• Added documentation for image and async widgets.
• Added server rendering and security workflow docs.
• Added a two-year video calendar documentation item.
• Added app icon and native launch surface docs.

Bug Fixes

• Removed stale Skia renderer crate/package state so the workspace only publishes maintained rendering crates.
• Restricted PR platform checks so external PRs do not run privileged platform workflows by default.
• Fixed remote image rendering bugs that could leave product-browser images invisible.
• Fixed image overflow/layout issues in the product browser by using appropriate grid/image fit behavior.
• Fixed web image refresh after WebGPU rendering changes.
• Fixed iOS fallback rendering and simulator capability dispatch linkage.
• Fixed macOS capability prompts by running desktop targets from development app bundles.
• Fixed web passkey algorithm defaults and scheduled notification behavior.
• Fixed server static asset 404s by serving generated server shell assets through the server runtime.
• Fixed server action POST behavior so form actions return users to normal app routes instead of leaving them on internal action URLs.
• Fixed cart state loss across requests by adding session-backed server state.

Performance Improvements

• Web rendering now prefers GPU/WebGPU/Vello instead of defaulting to software Canvas2D.
• Software fallback rendering now accounts for device scale to reduce soft output.
• Server pages can use cache/revalidation behavior instead of recompiling/redeploying for every content refresh.
• Browser workers and island bridge work reduce the need for a single large client-side application bundle where smaller progressive enhancement is enough.
• Docker/server packaging paths were hardened to reduce deployment friction.

API Changes And Migration Notes

• Image construction now uses typed image sources and image request structures. Code that assumed a single string/path image field should migrate to constructors such as asset/file/network/memory/SVG source helpers.
• New async widgets are available from fission-widgets and through the fission facade/prelude where exported.
• Server applications should enable the server feature/crates and use the server command workflow rather than treating static-site generation as the only web output path.
• The stale Skia renderer crate is no longer part of the released crate set. Use the maintained Vello/render crates.
• Platform capabilities now require the appropriate fission.toml capability declarations and generated platform metadata for permission-sensitive targets.

Published Crate Set

This release publishes all workspace crates under crates/ as 0.3.0, including the new server command/shell crates and all core, authoring, rendering, shell, command, packaging, release, credential, test, chart, and 3D crates.

Contributors

• zcourts
• Courtney Robinson

Verification

Before publishing 0.3.0, the release was checked with:

• cargo fmt --all -- --check
• cargo test --workspace --no-fail-fast
• cargo run -p cargo-fission --bin fission -- site check --project-dir documentation --release
• cargo publish package verification for each crate in dependency order
• cargo info <crate>@0.3.0 verification for every published crate

Full changelog: v0.2.0...v0.3.0

Fission 0.2.0

Fission 0.2.0 turns the initial GUI framework into a broader application platform. This release adds charts, 3D, web/mobile/static-site/terminal targets, the fission CLI workflow, design-system generation, a major documentation site, packaging/release tooling, desktop tray support, and a comprehensive host capability model.

Source commit: ed8744aaed3994ccd8e09bd643d894e1655d4c82
Published crate metadata points at crates/authoring/fission in that commit.

Highlights

• Added cargo-fission, installed as the single fission command for init, device discovery, running, site generation, packaging, release workflows, and the terminal UI.
• Added first-class target scaffolding and run paths for desktop, web, Android, iOS simulator/device workflows, static HTML sites, and terminal user interfaces.
• Added fission-charts with a broad native chart catalog, chart gallery, animations, datasets, and chart documentation.
• Added fission-3d and Scene3D/embed rendering work.
• Added design-system package support with build-time typed theme generation and widget consumption of generated styles.
• Added Fission static site generation and moved the documentation site onto the Fission static-site shell.
• Added release lifecycle tooling: packaging, signing/notarization hooks, release metadata, credential vault, cloud/static publishing providers, GitHub Releases, app-store metadata/status flows, and Microsoft Store MSIX Partner Center support.
• Added terminal shell support and a Fission-built terminal UI mode for the CLI.
• Added platform capabilities for notifications, deep links, NFC, biometrics, barcode scanning, clipboard, geolocation, haptics, camera, microphone, Bluetooth, Wi-Fi, volume control, and passkeys.

New Features

CLI And Developer Workflow

• Added cargo-fission, exposing the installed fission command.
• Added project scaffolding with fission init, including idempotent behavior for existing projects.
• Added target scaffolding and generated platform folders for web, Android, iOS, and desktop-style projects.
• Added fission devices and fission run workflows with target/device selection.
• Added setup/doctor-style checks and platform smoke runners.
• Added CLI module separation into command crates while preserving one public command for developers.
• Added the Fission terminal UI mode, later renamed to fission ui, implemented as a Fission app with screens, routes, async command execution, logs, settings, and terminal-shell rendering.

Platform Shells And Targets

• Added shared winit shell infrastructure used by desktop and test paths.
• Added mobile shell foundations for iOS and Android, including simulator smoke paths, touch handling, safe-area/input-coordinate fixes, native display scale handling, and Android activity integration.
• Added web shell scaffolding, fullscreen web target generation, browser smoke path, and canvas focus fixes.
• Added static-site shell support with generated HTML/CSS, Markdown rendering, route/link checks, favicon support, optional code highlighting, generated client-side search index, responsive documentation layout, headers/footers, sidebars, and GitHub Pages publishing.
• Added terminal shell backend using terminal rendering and input handling, plus interaction/density improvements.
• Added feature-boundary reorganization so the public fission facade can remain simple while platform-heavy shells are opt-in through features.

Widgets, Text, Embeds, And Interaction

• Expanded the widget surface and rebuilt examples around the public facade and prelude.
• Added PTY terminal widget support.
• Added native Markdown viewer support.
• Added Scene3D and additional embed examples for video/webview/3D-style surfaces.
• Improved scrollbar rendering and input handling, including retained scrollbar fixes.
• Added scoped raw action plumbing.
• Advanced rich text and text input parity: paragraph-aware rendering, IME configuration sync, locale-aware rich text, text selection affordances, inline widgets, hover/span actions, tap-outside actions, and decorated input APIs.
• Reworked text sessions and rendering/hit-testing so renderer and input paths share layout information more consistently.

Charts And 3D

• Added fission-charts and a chart gallery example.
• Implemented layout algorithms for a broad set of chart families, dataset encoding, chart configuration controls, dynamic viewport sizing, geo/hierarchy renderers, and family-specific chart animations.
• Added chart documentation, a chart showcase on the homepage, and reference organization for chart families.
• Added fission-3d with WGPU integration and interactive controls in gallery/example paths.

Design Systems And Theming

• Added DSP-backed theme generation from design-system JSON at build time.
• Added typed generated component styles and widget consumption of DSP styles.
• Added design-system shell builders and standard preset design systems.
• Exposed app window title through Env.
• Updated the website to use the same design-system direction.

Capabilities And Host Integration

• Replaced ad-hoc system effects with typed capabilities and documented the capability runtime.
• Added capability APIs and platform metadata for notifications, deep links, NFC, biometrics, barcode scanning, clipboard, geolocation, haptics, camera, microphone, Bluetooth, Wi-Fi, volume control, and passkeys.
• Added macOS capability usage-string packaging support.
• Added route-filtered static-site page elements for site-specific scripts and metadata.
• Added detailed capability guides, reference pages, and a capability matrix.

Packaging, Release, And Distribution

• Added post-build lifecycle RFC and implementation work for packaging and release workflows.
• Added package icon generation policy and platform metadata handling.
• Added release config parsing while preserving fission.toml formatting.
• Added encrypted credential vault support and interactive auth import.
• Added release content validation, release notes/content sidecar validation, artifact manifests, screenshot capture through test control, and provider status checks.
• Added direct file distribution providers.
• Added GitHub Releases distribution through the GitHub CLI.
• Added static site publishing lifecycle support, including GitHub Pages, Cloudflare Pages lifecycle operations, and Netlify API deploys.
• Added Google Play metadata sync, review operations, beta tester operations, and group sync.
• Added App Store metadata sync, build status checks, review operations, and beta tester operations.
• Added Microsoft Store status polling, metadata sync, and MSIX Partner Center publishing support.
• Added macOS signing and notarization packaging hooks.

Documentation Site And Public Docs

• Added and then replaced the documentation site with a Fission-generated static site.
• Added guided Learn pages, cookbook pages, reference sections, widget pages, chart pages, CLI/device workflow docs, platform smoke prerequisites, terminal shell docs, static site workflow docs, design system guide, lifecycle docs, and capability docs.
• Added local search indexing and GitHub Pages publishing from main.
• Updated README and crate READMEs for crates.io presentation.

Bug Fixes

• Fixed chart-gallery rendering, labels, missing instantiations, viewport sizing, and E2E timeouts.
• Fixed editor regressions around resize redraw, cursor blink, tab bars, context menus, rename flow, stable scroll IDs, caret position, focus routing, rich text hit testing, viewport culling, and custom render object event routing.
• Fixed stale paint-cache behavior, animation invalidation, paused redraw loops, compositor-layer retention, and resize distortion.
• Fixed terminal test reliability and terminal live output checks.
• Fixed mobile smoke target icon paths, iOS software render fallback, Android/iOS touch handling, and web canvas focus/fullscreen behavior.
• Fixed documentation-site typography contrast, responsive layout, generated CSS, markdown media rendering, docs nav, and CI checkout of Android submodules.
• Fixed keyring/dbus dependency leakage for static site builds.
• Fixed package publishability issues for fission-command-core and terminal widget dependencies.

Performance Improvements

• Added retained GPU texture compositor work for the desktop shell.
• Added static-content caching under dynamic compositor layers.
• Added partial root recomposition and retained compositor plans across composite-only frames.
• Throttled low-priority repeating animations and reduced animation churn during resize.
• Improved rich text layout/cache behavior and text-rendering consistency.
• Improved large editor file handling with windowed navigation, sparse indexing, soft wrap defaults, and virtualized file views.
• Tightened resize cadence and screenshot capture settling for more reliable visual tests.

API Changes And Migration Notes

• Applications should prefer the fission facade crate and fission::prelude::* rather than depending directly on internal crates.
• New action ergonomics are available through #[fission_action], with_reducer!, and #[fission_reducer]; manual action structs and reducer binding remain supported.
• Platform-heavy functionality is split behind facade features such as desktop, web, mobile, site, terminal shell, charts, and 3D.
• fission.toml becomes the authoritative project manifest for generated targets, platform metadata, capabilities, packaging, and release workflows.
• The host-access model moves toward typed capabilities instead of generic system effects.
• Static site generation is now driven by Fission widget/static-site shell infrastructure, with generated routes, styles, assets, search, and publishing workflows.

Published Crate Set

This release includes new or substantially expanded crates such as cargo-fission, fission-charts, fission-3d, fission-shell-site, fission-shell-terminal, `fission-sh...

Fission 0.1.0

Fission 0.1.0 is the first public crates.io release of the framework. It establishes the core Rust-first application model: typed actions, reducers, widget trees, semantic lowering, layout, rendering, desktop shell integration, examples, and test infrastructure.

Source commit: 92780259bb7dc359946bd922349417bb84108dcd
Published crate metadata points at crates/authoring/fission in that commit.

Highlights

• First public fission facade crate for application authors.
• Core runtime model for AppState, typed Actions, reducers, BuildCtx, semantic input handling, and widget lowering.
• GPU-oriented rendering stack with display-list primitives, renderer traits, Vello renderer work, text rendering, image rendering, shadows, anti-aliasing, and retained rendering experiments.
• Desktop shell path capable of running real Fission examples end to end.
• Initial widget catalog covering layout, text, buttons, inputs, scroll, overlays, navigation, feedback widgets, and data/application UI surfaces.
• Test harness and live test-driver foundations for headless/widget tests and shell-driven end-to-end tests.
• Example applications, including counter, inbox, editor, and widget-gallery style coverage.
• crates.io packaging metadata, README files, license metadata, and internal path dependency versioning prepared for publishing.

New Features

Application Model

• Added the fission facade crate so applications can depend on one public crate instead of wiring every internal crate manually.
• Added fission-core, fission-ir, fission-layout, fission-semantics, fission-theme, fission-i18n, fission-diagnostics, fission-widgets, and related framework crates.
• Implemented typed action/reducer support with action envelopes and stable action identifiers.
• Added BuildCtx for ergonomic binding of actions to UI events.
• Added semantic input handling so widget behavior is driven through structured semantics rather than raw renderer-only hit testing.
• Added theme and internationalization foundations through environment-driven app context.

Widgets And Authoring

• Added core layout primitives and a broad first widget set: text, buttons, rows, columns, boxes/containers, stack/z-stack style composition, spacers, positioned content, scroll containers, lazy lists, sliders, checkboxes, radio controls, dropdown/select controls, menus, tooltips, progress indicators, skeleton loading surfaces, breadcrumbs, tree views, drawers, modals, alerts, forms, number inputs, data tables, routers, overlays, portals, popovers, and gesture handling.
• Added rich text and advanced text-input work: multiline editing, selection, clipboard integration, IME-oriented infrastructure, undo/redo foundations, caret placement, styled runs, tab capture, auto-indent, and input affordance tests.
• Added media/embed foundations including image rendering, video primitives, webview/browser mechanisms, and macOS video backend wiring.
• Added #[derive(Action)] through fission-macros.
• Added widget IDs, stable lowering keys, and retained-mode cache foundations needed for rebuild and animation correctness.

Rendering, Layout, And Shells

• Added display-list structures and renderer traits.
• Built out Vello/WGPU rendering work, Parley text layout integration, font fallback, image drawing, shadows, transparent surfaces, and alpha handling.
• Implemented a desktop shell path with window/event handling, pointer and keyboard input, hit testing, focus, scrolling, resize handling, and screenshot/test control foundations.
• Added layout engines and then refined them toward deterministic constraints, intrinsic sizing, flex behavior, stable child ordering, and layout invariant validation.
• Added scrollbar, animation, repaint, resize, and retained rendering work to reduce unnecessary rebuilds and CPU usage.

Testing And Examples

• Added fission-test and fission-test-driver foundations.
• Added test harness support for widget/runtime integration tests.
• Added live E2E control-channel foundations for desktop shell testing and screenshot capture.
• Added regression coverage for layout ordering, hit testing, animation invalidation, resize behavior, paint cache behavior, and display-list text bounds.
• Added and expanded examples demonstrating counter interactions, inbox-style app UI, editor-style rich text/code surfaces, widget-gallery coverage, media, scrolling, overlays, and input behaviors.

Documentation And Packaging

• Added comprehensive crate-level documentation and README files for the first publishable crate set.
• Added open-source project metadata and crates.io package metadata.
• Added version requirements to internal path dependencies so the workspace could be published to crates.io in dependency order.
• Reduced package size by limiting theme/font package contents.

Bug Fixes

• Fixed rendering order, root traversal, stable layout ordering, intrinsic sizing, flex shrink/stretch behavior, text measurement, and layout overlap issues.
• Fixed hit testing across scroll offsets, overlays, absolute fill nodes, portals, popovers, and text input caret placement.
• Fixed keyboard input handling, copy/paste matching, focus routing, tab handling, and caret positioning.
• Fixed stale paint-cache entries, repeating animation CPU burn, paused redraw loops, and resize-driven rendering issues.
• Fixed video playback surface visibility, scroll-aware video layer placement, precise seek/stop behavior, event polling, and a macOS video shutdown crash.
• Fixed inbox/editor visual regressions, scroll behavior, flyout sizing, modal layout, button padding, and large-file/editor rendering issues.

Performance Improvements

• Added retained rendering/cache foundations and repaint-without-rebuild work for animations.
• Added rich text layout caching and faster node hashing in lowering.
• Reduced high CPU usage from event loops, repeating animations, cursor blink, and resize redraw behavior.
• Added windowed and sparse-indexed editor data structures for large file navigation/editing.
• Added pixel/screenshot checks to catch resize and paint regressions.

API Notes

• This is the first public API baseline for Fission.
• The preferred application entry point is the fission facade crate.
• Action types are defined with #[derive(Action)]; later releases add more ergonomic action/reducer macros.
• Several internal crates are public because the framework is still early and modular, but application authors should generally start from fission.

Verification

• Published crate VCS metadata confirms this release was built from 92780259bb7dc359946bd922349417bb84108dcd.
• The release included package metadata and versioned internal dependencies needed for crates.io publication.

Full changelog: https://github.com/worka-ai/fission/commits/v0.1.0