A Swift package that lowers SwiftUI-shaped views through a strict seven-phase pipeline — no global solver, no virtual DOM, no curses. The same App and Scene declarations can run in a terminal executable, through WASI browser deployment, through a native WebHost launch, or inside a host-managed SwiftUI surface.
// add to dependencies
.package(
url: "https://github.com/SwiftTUI/swift-tui",
.upToNextMinor(from: "0.1.0")
)
// add to your executable target
.product(name: "SwiftTUI", package: "swift-tui")Most TUI frameworks invent a new authoring model for the terminal. SwiftTUI keeps the SwiftUI authoring model and reinterprets the substrate. Same View, @State, @FocusState, PreferenceKey, and Layout protocol you already know — drawn as integer-cell glyphs instead of CoreAnimation layers.
Recursive parent-child layout. Graph-scoped state drives rendering, not the reverse. Modifier order matters because modifiers participate in layout and semantics. The terminal target does not bend the authoring story.
The same App and Scene declarations can feed a terminal executable, a WASI browser deployment, a localhost WebHost launch, or a host-managed SwiftUI surface. The framework owns the cells; the host owns the chrome.
Seven phases — resolve, measure, place, semantics, draw, raster, commit — stay visible through DefaultRenderer and FrameArtifacts. Inspect a frame when you need to understand layout, routing, or final cells.
ANSI, sanitized OSC 8 hyperlinks, Kitty graphics, Sixel, truecolor, and mouse reporting are negotiated per session against a live capability profile. PNG and baseline JPEG decode in pure Swift; GIF playback ships in the AnimatedImage peer product.
SwiftTUI builds with Swift 6 language mode, explicit @MainActor authoring APIs, and Sendable frame artifacts. Your app can consume the package without copying those build settings.
The browser path does not embed xterm.js or a DOM terminal. WebHost mounts a scene runtime directly. Tests render frames as integer-cell rasters without spinning up a TTY.
Layout is recursive parent-child negotiation, not a global solver. Graph-scoped state drives rendering, not the reverse. The runtime keeps each phase explicit, and DefaultRenderer exposes FrameArtifacts when you want to inspect or snapshot a frame.
Authored views collapse into the resolved tree.
Parents propose sizes, children choose.
Recursive layout assigns integer-cell rects.
Focus, accessibility, actions, selection, and scroll routes are extracted.
Per-cell glyphs and styles emit as commands.
Draw commands become a styled cell grid.
Lifecycle and handler work are packaged for the runtime.
The same App and Scene declarations flow into terminal-native binaries, browser deployments built with SwiftTUIWASI, localhost browser sessions through SwiftTUIWebHost, and retained native scenes through SwiftUIHost. The framework owns the cells; each host owns its chrome.
RunLoop over the alternate screen. ANSI / sanitized OSC 8 hyperlinks / Kitty / Sixel negotiated against the live capability profile. Unix signal handling, mouse reporting, and pty-backed secondary scenes ship by default.
import SwiftTUI
@main struct DemoApp: App {
var body: some Scene {
WindowGroup("Deploy Dashboard") {
BuildSummary()
}
}
}Build the same target to wasm32-wasi. The WASIRunner emits a scene manifest the host loads through Platforms/Web — no terminal emulator, no xterm.js, no postMessage shim.
// build
swift build --swift-sdk swift-6.3.1-RELEASE_wasm \
--target WebExampleApp
// host
await createWebHostApp({
manifestUrl: "./scene-manifest.json",
sceneRuntimeFactory: createWasmSceneRuntimeFactory(...)
})Retain SwiftTUI scenes inside a native SwiftUI app shell. Theme tokens swap at runtime; the authored TUI does not branch on the host style.
let state = try SwiftUIHostAppState(
app: DemoApp(),
style: .default
)
SwiftUIHostAppView(state: state)Native binaries can opt into --web routing. The runner serves the bundled browser runtime over localhost and carries frames through the shared web-surface protocol.
import SwiftTUIWebHostCLI
@main struct DemoApp: App {
// normal launch: terminal; --web: browser host
}Layout, state, focus, and presentation — plus the runtime and scene types that drive them, and a peer charts product. Terminal-only chrome that would bend the public authoring story stays out of core. The full per-symbol reference lives in the DocC catalogs.
At the lowest public runtime level, you can resolve and render any View into terminal text. Same code path your App takes inside RunLoop, exposed for previews, unit tests, documentation examples, and debug output without opening an interactive terminal session.
import SwiftTUI
struct BuildSummary: View {
var body: some View {
VStack(alignment: .leading, spacing: 0) {
Text("Deploy Queue").bold()
Divider()
ProgressView("Release", value: 18, total: 24)
LabeledContent("Window", value: "staging")
LabeledContent("Owner", value: "infra")
}
.padding(.init(horizontal: 1, vertical: 0))
}
}
let renderer = DefaultRenderer()
let frame = renderer.render(
BuildSummary(),
proposal: .init(width: 40, height: 8)
) Deploy Queue
────────────────────────────────────
Release
18 / 24
Window staging
Owner infra
_ No code generators, no build scripts, no binaries to download — just SwiftPM. Copy the two files below into a new directory and run it.
prereq A Swift 6.3 toolchain on PATH — install it however you already manage Swift.
# build & run — your app owns the terminal until you exit
$ swift run HelloTUI
› alternate screen opens
› resolve · measure · place · semantics · draw · raster commit
› press Ctrl-D to exit — your shell is restored// swift-tools-version: 6.3
import PackageDescription
let package = Package(
name: "HelloTUI",
dependencies: [
.package(
url: "https://github.com/SwiftTUI/swift-tui",
.upToNextMinor(from: "0.1.0")
),
],
targets: [
.executableTarget(
name: "HelloTUI",
dependencies: [
.product(name: "SwiftTUI", package: "swift-tui"),
]
),
]
)import SwiftTUI
@main struct HelloTUI: App {
var body: some Scene {
WindowGroup("Hello") {
VStack(alignment: .leading, spacing: 1) {
Text("Hello, terminal.").bold()
Text("Press Ctrl-D to quit.")
.foregroundStyle(.muted)
}
.padding(1)
}
}
}Targeting the browser? Pass --swift-sdk for a wasm SDK on the same swift build — the authoring code is unchanged. Embedding in a host app? Retain a HostedSceneSession through SwiftUIHost, or add SwiftTUIWebHostCLI for a localhost browser launch. Same App body, every target.