murrtty

How murrtty is built, tested and released

A terminal sits between you and every program you run, so murrtty is checked at every step from source to download. This page says what is checked, where and when, and what isn't covered yet. Numbers are as of 5 November 2026, after release 0.6.0.

  1. Every change builds from pinned sources and passes the unit tests, its GUI scenarios and an ARM64 compile before it is committed.
  2. Every push runs the GUI suite and the unit tests on a desktop with a real GPU, and compiles for ARM64.
  3. Before a release the whole suite runs on GitHub's clean x64 and ARM64 machines, and the on-screen checks on a real display.
  4. The release is built by GitHub from its tag; its installers are installed, upgraded and removed on both architectures.
  5. Before publishing its checksums are signed once the maintainer approves, and every file is scanned and checked.

A build anyone can repeat

Unit tests

About 4,400 unit tests run on Windows: Ghostty's own suite (terminal emulation, fonts, configuration, input encoding) and murrtty's (4,395 passed on 5 November, 69 skipped where they don't apply). They run in a Debug build, with Zig's safety checks on. Some of murrtty's guard things that would otherwise fail only on a user's machine: its hand-written bindings to Windows' COM interfaces (Direct3D 11, DirectWrite, toasts, file dialogs) are tested method by method, since a wrong slot crashes; the configuration editor must save a file it didn't change byte for byte; and the update checker's signature and checksum rules are tested against forged and mismatched input.

The real program, driven from outside

Most of what can go wrong in a terminal is between the program and Windows: keys, focus, windows, the clipboard, the console. So the GUI suite tests the real murrtty.exe. Its harness starts a Debug build on a hidden desktop (Windows lets a program make a desktop that is never shown, so a full run covers nobody's screen), types and clicks into it as Windows delivers input, and reads back what happened: the text in each terminal, the state of every window, tab, pane and dialog through a test-only report that release builds don't contain, and the pixels the renderer actually presented. Each run uses its own settings and state folders, and the user's clipboard is saved and put back.

There are 130 scenarios, from typing into PowerShell and cmd to splits, tabs, dialogs, session restore, keyboard layouts and input methods, links, notifications and the tray. Some examples:

Each feature lands with its scenarios. Stress scenarios run on the hosted machines: 16 panes flooding output, 20 launches quitting right after configuration reloads, commands typed ahead of a slow prompt. Until murrtty's OpenGL renderer retired after 0.6.0, render parity drew seven scenes (colors, attributes, box drawing, fallback fonts, images, a custom shader, a translucent window) with it and with Direct3D 11 on every push, comparing their frames within 1 per color channel; on the test machine they matched exactly.

Some things can only be checked on a real display: transparency and blur over a test pattern, a real toast, tray icon and taskbar button, the touch keyboard. Before a release these on-screen checks run with the maintainer watching, and their captures are compared with golden images recorded earlier on the same setup (Windows build, renderer, GPU, scaling, light or dark): more than 0.05% of the pixels differing by more than 4 levels fails.

Where and when it runs

WhenWhereWhat runs
Before each commitThe maintainer's desktopThe unit tests, the GUI scenarios the change touches, an ARM64 compile.
Every pushThe same desktop as a self-hosted runner: Windows 11, NVIDIA GeForce RTX 2070, 125% scalingThe GUI suite (129 scenarios), the unit tests, an ARM64 compile. The build that passes the GUI suite is installed as the maintainer's own terminal.
Before each releaseGitHub's hosted runners: Windows Server 2025 (x64) and Windows 11 on ARM64, clean machines with no GPUThe whole GUI suite, stress scenarios included, then the unit tests, natively on each architecture (about 45 minutes).
Before taggingThe maintainer's displayThe on-screen checks against golden images.
The release tagGitHub's hosted runnersPackages, installers built and tested on both architectures, checksums, attestations, the signature (below).
With each releaseClean hosted runnersThe Scoop and winget manifests, installed from and checked.

murrtty's GitHub Actions may use only GitHub's own actions, and each hosted workflow starts by checking that none of the workflows inherited from Ghostty is active. The self-hosted runner never runs work from the public repository or from pull requests.

How a release is made

  1. The tag. A release is an annotated murrtty-vX.Y.Z tag; the build refuses a tag that doesn't match the version in the source.
  2. Built by GitHub. The tag starts the release workflow in the public repository: the x64 and ARM64 packages are built on their own architecture's runners from the tag, nowhere else.
  3. The installers, tested. Both installers are built with a pinned Inno Setup (checked by SHA-256 and its signer), then on each architecture installed, checked (the files, the version murrtty reports, the Start menu shortcut, Explorer's Open in murrtty, the uninstall entry), installed again over a running murrtty, run as Restart to Update runs them (silently, murrtty closed and started again), and uninstalled (everything removed but the user's settings).
  4. Checksums and attestations. SHA256SUMS.txt lists every file, and every file gets a build provenance attestation: GitHub's signed record of the repository, commit and workflow that built it.
  5. The maintainer approves. The workflow then waits for the maintainer to approve the release environment. Only then does it sign SHA256SUMS.txt (Ed25519) with a key held by that environment alone, used only for murrtty-v tags. The result is a draft.
  6. Checked before publishing. The maintainer downloads every file, scans each with Microsoft Defender, verifies the signature and an attestation, checks that the build calls itself the release, writes the notes and publishes.

The workflow can rebuild a published release from its tag and compare every file with what was published. A build from the same tag on the maintainer's machine matches GitHub's in every file but murrtty.exe's 20-byte build ID and the debug symbols, which hold the build's paths.

murrtty's own updates rely on the same chain. An update installs only if its checksums carry a signature from a key built into murrtty, name exactly that release's installer for the computer, and match the file; downloads come only from murrtty's GitHub releases, and the installer is checked again just before it runs, held so it can't be swapped. Updates are off until you turn them on.

Checking a download yourself

With the GitHub CLI, a file's attestation:

gh attestation verify murrtty-0.6.0-windows-x86_64-setup.exe -R murr2k/murrtty

Or the signed checksums, with OpenSSL (Git for Windows has one) and murrtty's public key, then the file's hash against its line in SHA256SUMS.txt:

openssl pkeyutl -verify -pubin -inkey murrtty-update.pub -rawin -in SHA256SUMS.txt -sigfile SHA256SUMS.txt.sig
Get-FileHash murrtty-0.6.0-windows-x86_64-setup.exe

Signed checksums start with 0.6.0; attestations with 0.5.0.

What isn't covered yet

Found something the tests missed? Report it with murrtty +version; security problems go to the private vulnerability report or security@murrtty.org.