ferrite
14.2k Download 0.9.4

v0.9.4 · macOS, Linux, Windows · Rust + wgpu · MIT licence

A terminal that draws every frame on the GPU.

Ferrite is an open-source terminal emulator. It shapes text once on the CPU, then rasterizes every cell on the graphics card, so a gigabyte of logs scrolls past at your display's refresh rate without dropping a byte.

$ curl -fsSL https://ferrite.sh/install | sh
Get Ferrite for your platform Read the benchmarks 12 MB download, no telemetry
zsh · ~/src/ferrite 120 Hz · metal
❯ ferrite --version ferrite 0.9.4 (wgpu 24.0, metal backend) ❯ ferrite bench --suite vtebench --runs 10 running 4 workloads · 3456x2234 · median of 10 scrolling 1,940 MB/s ████████████████████ cursor_motion 1,420 MB/s ███████████████ dense_cells 1,180 MB/s ████████████ unicode_random 612 MB/s ██████ frame time p50 1.2 ms p99 2.9 ms input latency p50 4.1 ms p99 6.8 ms ✓ done in 6.2 s · 0 dropped frames ❯

Benchmarks · measured, not promised

Every number on this page came out of the suite you can run yourself.

Run ferrite bench on your own machine and it prints the same table. Every figure below names its method in the footnote.

  • 1.9GB/s1

    scrollback throughput

  • 2.9ms2

    frame time, p99, at 3456x2234

  • 4.1ms3

    keypress to pixel, p50

  • 38ms4

    cold start to first prompt

Same parser, two renderers.

Ferrite ships a software fallback for machines without a usable graphics driver. Both paths share the same VT parser and grid, so the gap you see below is the renderer alone.

GPU renderer (wgpu)software fallback
  • scrolling
    1,940 MB/s
    software
    310 MB/s
  • cursor_motion
    1,420 MB/s
    software
    280 MB/s
  • dense_cells
    1,180 MB/s
    software
    190 MB/s
  • unicode_random
    612 MB/s
    software
    140 MB/s
  1. 1 vtebench 0.4 scrolling workload, 2024 MacBook Pro (M3 Max, 36 GB), 3456x2234 at 120 Hz, median of 10 runs, warm cache.
  2. 2 Time from PTY read to swapchain present, measured by the renderer's own timestamps during the dense_cells workload, 99th percentile over 20,000 frames.
  3. 3 Typometer 1.4, key event to photodiode-confirmed pixel change, 200 samples, display in low-latency mode.
  4. 4 Wall clock from process spawn to first shell prompt paint, default config, zsh 5.9, mean of 50 launches after the first.

How it renders

Three stages. Only the first one touches the CPU.

Most terminals redraw the whole window whenever anything changes. Ferrite keeps a persistent cell grid on the GPU and uploads only the cells that moved.

  1. 01

    Parse and shape

    Bytes from the PTY go through a table-driven VT parser into a damage-tracked grid. Text is shaped with HarfBuzz once per run, so ligatures and combining marks cost nothing on redraw.

  2. 02

    Cache the glyphs

    Rasterized glyphs live in a GPU atlas keyed by font, size and subpixel offset. A full screen of new glyphs is an upload; a scrolled screen of old ones is a pointer move.

  3. 03

    Draw as instances

    Every visible cell is one instance in a single draw call: background, glyph, underline, cursor. The whole grid renders through wgpu on Metal, Vulkan or DirectX 12.

pty bytes read(2), 64 KiB vt parser damage grid shaper HarfBuzz, once gpu · wgpu glyph atlas cell buffer 1 instanced draw / frame cpu, one thread →

Features

Fast is the entry ticket. The rest is what you use all day.

Splits and tabs, built in

Panes that stay at 120 Hz no matter how many you open.

Each pane is its own grid on the same GPU surface, so a six-way split renders in one draw call. Layouts persist across restarts and can be scripted from the shell.

# ferrite.toml
[keys]
"cmd+d"     = "split:right"
"cmd+shift+d" = "split:down"
"cmd+["     = "focus:prev"

[layout]
restore = true

Ligatures and fallback

->=>!=<=::|>

Shaped by HarfBuzz with per-font fallback chains, so emoji, CJK and Nerd Font glyphs land in the right cell.

24-bit colour, wide gamut

Truecolor everywhere, Display P3 on displays that have it, and 200 bundled themes that can hot-swap with the system.

Images in the terminal

Kitty graphics protocol and Sixel, decoded on the GPU.

Preview a plot from a Jupyter kernel, page through a PDF with fzf, or run chafa on a video frame. Images share the same atlas as text, so they scroll with it instead of tearing.

Search

Regex over 100k lines in under a frame.

Scrollback lives in a compact rope; searching it is a single pass with results highlighted in place.

Shell integration

Jump between prompts, copy a whole command's output.

Marks every prompt with OSC 133 in zsh, bash, fish and nushell. Click any output block to select it.

Config

One TOML file, live reload.

Save ~/.config/ferrite/ferrite.toml and the window updates in place. No restart, no daemon.

Footprint

12 MB binary, 41 MB idle.

Statically linked, no runtime, no Electron. Idle CPU sits at 0.1% with the cursor blinking on a timer, not a render loop.

Install

One command on each platform. Signed builds, reproducible from source.

$ brew install --cask ferrite
$ curl -fsSL https://ferrite.sh/install | sh

Universal binary for Apple silicon and Intel, notarized. The script installs to /Applications and links ferrite into /usr/local/bin. Requires macOS 13 or later.

$ curl -fsSL https://ferrite.sh/install | sh
$ sudo apt install ferrite # Debian, Ubuntu (repo added by the script)
$ sudo dnf install ferrite # Fedora 40+

Wayland and X11, Vulkan 1.2 or later. Also packaged for Arch (pacman -S ferrite), NixOS (programs.ferrite.enable) and as a Flatpak (sh.ferrite.Ferrite).

> winget install Ferrite.Ferrite
> scoop install ferrite

Windows 10 1903 or later, DirectX 12. Uses ConPTY, so PowerShell, cmd and WSL distributions all work out of the box. Binaries are code-signed and checksummed.

$ cargo install ferrite-term --locked
$ git clone https://github.com/ferrite-term/ferrite && cd ferrite && cargo build --release

Needs Rust 1.85 or later. A clean release build takes about 90 seconds on an M3. Release binaries are reproducible; the checksum in the GitHub release matches a local build with the pinned toolchain.

  • Download12 MB, universal binary
  • BackendsMetal, Vulkan 1.2, DirectX 12, software
  • Shellszsh, bash, fish, nushell, PowerShell
  • Config~/.config/ferrite/ferrite.toml
  • TelemetryNone. No network calls unless you enable update checks.
  • LicenceMIT

Before / with

What changes when the renderer stops being the bottleneck.

SituationSoftware-rendered terminalWith Ferrite

Tailing a busy log

Output stalls, the shell falls behind, Ctrl-C lands seconds late.

1.9 GB/s of scrollback; Ctrl-C lands on the next frame.

Resizing a 4K window

Whole window repaints, 14 ms per frame, visible tearing while dragging.

Damage-tracked grid, 2.9 ms p99, resize stays glued to the cursor.

Twelve panes open

Each pane redraws independently and competes for the same core.

All panes are one draw call on one surface; cost grows with visible cells, not pane count.

Editing in vim or helix

Cursor motion feels a frame late on high-refresh displays.

4.1 ms key-to-pixel at 120 Hz, measured with a photodiode.

Laptop on battery

A blinking cursor keeps a render loop alive at 3 to 6 percent CPU.

Idle at 0.1 percent; the GPU sleeps between damage events.

Changelog

Shipped roughly every three weeks. Every release runs the suite before it tags.

  • 0.9.42 September 2026

    Subpixel positioning on Linux, faster unicode_random

    Glyphs are now rasterized at three horizontal subpixel offsets on Vulkan, matching the Metal path. The shaper caches grapheme cluster boundaries, which lifted unicode_random from 540 to 612 MB/s. Fixes a sticky-modifier bug on Wayland when switching keyboard layouts.

  • 0.9.311 August 2026

    Kitty graphics protocol, image atlas

    Inline images via the Kitty protocol and Sixel, decoded off the main thread and stored in a dedicated atlas. Adds ferrite bench --json for CI dashboards and a --renderer=software flag for headless boxes.

  • 0.9.02 July 2026

    wgpu 24, DirectX 12 backend, Windows builds

    First signed Windows release with ConPTY support. Migrates the renderer to wgpu 24 and replaces the per-pane swapchains with one surface per window, which is where the twelve-pane numbers on this page come from.

Full release history on GitHub →

Open source

Read the renderer. File the bug. Land the fix.

Ferrite is MIT licensed and developed in the open. The benchmark suite, the shader sources and the release tooling all live in the same repository, and the maintainers review every pull request within a week.

Star on GitHub Contributing guide Discord

  • 14.2k

    GitHub stars

  • 212

    contributors since 2024

  • 71k

    lines of Rust and WGSL

  • MIT

    licence, no contributor agreement