Fission

Fission is a production-focused Rust application framework for building GPU-accelerated apps across desktop, web, Android, iOS, terminal interfaces, static HTML sites, and server-rendered sites.

It gives you the application model, widgets, rendering pipeline, platform shells, testing tools, packaging, and release workflows needed to move from a first screen to a shipped product without stitching together a new toolchain for every target.

Documentation: fission.rs
Repository: github.com/worka-ai/fission

---

Why Fission

Most application projects need more than a widget library. They need a way to create the app, run it on real devices, test it, package it, publish it, and keep the developer workflow understandable as the project grows.

Fission is built around that full lifecycle:

Stage	What Fission provides
Setup	fission init, target scaffolding, setup checks, project manifests, and platform notes.
Learn	A guided documentation site, cookbook pages, reference pages, and examples that use the same public API as applications.
Build	Declarative widgets, typed actions and reducers, design systems, charts, media/embed widgets, 3D scenes, terminal UI, static site rendering, and server-rendered sites.
Test	Unit tests, widget tests, live app tests, device/simulator smoke paths, diagnostics, static route/link checks, and server route checks.
Publish	Package outputs, readiness checks, release content validation, GitHub Pages, GitHub Releases, cloud/static providers, and store distribution flows.

The result is one Rust-first workflow that scales from a counter app to a multi-platform product.

---

See It

These screenshots come from checked-in Fission examples and the Fission documentation site assets. They show the same widget model handling product screens, text editing, developer tools, widget reference work, and data visualization.

Inbox	Editor
Compose flow	Integrated terminal
Widget gallery	Terminal UI
Charts	3D and globe charts

Explore the generated documentation site at fission.rs, or run it locally:

cargo run -p cargo-fission --bin fission -- site serve --project-dir documentation

---

Quick Start

Install Rust first if you do not already have it: rustup.rs.

Install the Fission command:

cargo install cargo-fission

That installs the single fission command used for setup, running, testing, packaging, site generation, and publishing.

Create and run a new app:

fission init my-app
cd my-app
fission run

Add more targets when you need them:

fission add-target web android ios
fission devices
fission run --target web
fission run --target android --device <device-id>
fission run --target ios --device <simulator-id>

Run the terminal UI for the developer tool itself:

fission ui

---

A Small Fission App

Fission apps are ordinary Rust. State is explicit, actions are typed, reducers update local or global state, and components convert into a closed widget tree value.

use fission::prelude::*;

#[fission_component]
struct CounterApp {
    #[local_state(default = 0)]
    count: i32,
}

#[fission_reducer(Increment)]
fn increment(count: &mut i32) {
    *count += 1;
}

impl From<CounterApp> for Widget {
    fn from(counter: CounterApp) -> Widget {
        let (ctx, _) = fission::build::current::<()>();
        let count = counter.count();
        let increment = ctx.bind_local(Increment, count.clone(), reduce!(increment));

        Container::new(Column {
            gap: Some(20.0),
            children: widgets![
                Text::new("Counter").size(32.0),
                Text::new(format!("{}", count.get())).size(56.0),
                Button {
                    on_press: Some(increment),
                    child: Some(Text::new("Increment").into()),
                    ..Default::default()
                },
            ],
            ..Default::default()
        })
        .padding_all(32.0)
        .into()
    }
}

fn main() -> anyhow::Result<()> {
    DesktopApp::<(), _>::new(CounterApp {}).run()
}

Use #[fission_reducer] for compact local actions, or #[fission_action] when you want a named action type that is shared across modules or documented as part of your app API.

---

What You Get Out Of The Box

Application framework

• Struct-based widget composition in Rust, with normal types implementing From<T> for Widget.
• Typed application state, typed actions, reducers, selectors, effects, and explicit environment data.
• GPU-accelerated rendering through the Fission rendering stack.
• Layout, text input, input events, accessibility semantics, portals, overlays, animation support, media/embed widgets, and 3D support.
• Design-system support from Design System Package JSON at build time, including generated themes and bundled presets for Fission, Material Design 3, Fluent 2, Liquid Glass, and Cupertino-style apps.

Targets and shells

• Desktop apps for Windows, macOS, and Linux.
• Web/WASM apps that run in the browser.
• Android emulator/device and iOS simulator/device workflows.
• Terminal user interfaces built from Fission widgets.
• Static HTML sites generated from custom widget routes plus Markdown/MDX content routes.
• Server-rendered sites for request-time HTML, sessions, signed actions, jobs, cache policy, workers, and islands.

Built-in product features

• A broad widget catalog for layout, text, buttons, forms, navigation, surfaces, overlays, media, and embeds.
• Fission Charts for dashboards and data-heavy applications.
• Platform capabilities for notifications, deep links, NFC, biometrics, passkeys, barcode scanning, camera, clipboard, geolocation, haptics, microphone, Bluetooth, Wi-Fi, and volume control where the host platform supports them.
• Static-site features including sidebars, table-of-contents links, favicons, generated CSS, optional code highlighting, client-side search, sitemap, robots output, JSON-LD, route-filtered page elements, and internal-link validation.
• Server-site features including route modes, session-private state, signed actions, server jobs, cache policy, Docker packaging, progressive workers, and focused islands.

Developer workflow

• fission init for new and existing projects.
• fission add-target for platform support files.
• fission devices and fission run for attached local development.
• fission doctor and readiness checks for actionable setup diagnostics.
• fission package, fission release-content, and fission distribute for production artifacts and release flows.

---

Platform Status

Target	Status	Entry point
Windows, macOS, Linux	First-class desktop app targets	fission run --target macos, fission run --target windows, fission run --target linux, or cargo run
Web/WASM	Browser host and smoke path	fission run --target web
Android	Emulator/device workflow	fission run --target android
iOS	Simulator/device workflow	fission run --target ios
Terminal UI	Widget-based terminal shell	fission ui and examples/terminal
Static HTML site	Build and serve static content	fission site serve --project-dir documentation
Server-rendered site	Run dynamic Fission HTML routes	fission server serve --project-dir examples/pokemon-card-store

Some host APIs depend on platform support. The capability matrix in the docs shows where each built-in capability is available and which app-store or platform configuration files are generated.

---

Examples To Try

cargo run -p counter
cargo run -p widget-gallery
cargo run -p chart-gallery
cargo run -p animation-gallery
cargo run -p fission-editor
cargo run -p terminal

Static site workflow:

fission site check --project-dir documentation --release
fission site serve --project-dir documentation
fission site build --project-dir documentation --release

Packaging and release workflow:

fission readiness package --project-dir . --target windows --format msix
fission package --project-dir . --target windows --format msix --release
fission release-content validate --project-dir . --provider microsoft-store
fission distribute --project-dir . --provider github-releases --artifact target/fission/release/windows/msix/artifact-manifest.json

---

Repository Layout

Path	Purpose
crates/core	Core runtime, layout, text, theme, 3D, and IR crates.
crates/authoring	Public facade crate, widgets, charts, icons, and macros.
crates/shell	Desktop, mobile, web, terminal, static site, and server-rendered site shells.
crates/tools	fission command modules, diagnostics, credentials, packaging, release, and test tooling.
examples	Runnable apps that exercise real framework features.
documentation	The Fission documentation and product site, built by the Fission static site shell.
docs	RFCs and design documents for deeper implementation work.

---

Documentation

Start at fission.rs:

• Quickstart
• App structure
• Widgets and layout
• Design systems
• Charts
• Platform capabilities
• Static sites
• Server-rendered sites
• Terminal user interfaces
• Build and package
• Release and distribute

---

Contributing

Fission is MIT licensed and open to practical contributions: bug fixes, tests, documentation, examples, platform hardening, and focused feature work.

Read CONTRIBUTING.md before opening larger changes, and keep examples aligned with the style we want application developers to copy.

License

Fission is available under the MIT license.