Kristall: a Qt browser for the small internet protocols

One window for five protocols, most of them old

Kristall is described as a high-quality visual cross-platform Gemini browser, and the project description puts it as a graphical small-internet client for Windows, Linux, macOS and the BSDs.

The protocol list is the point. Gemini is the central one, with HTTP and HTTPS alongside it, plus Gopher and Finger, the latter pointed at RFC 1288. Most of those are not current web technologies, and two of them are decades old protocols whose clients are mostly gone. Kristall exists because the small internet has a client shortage, and a browser that speaks all five in one tabbed interface is a reasonable answer to that.

The tabbed interface and navigation history are the other structural choices that matter. A tabbed browser is the right shape for someone moving between a Gemini capsule, a Gopher hole and an HTTP document, because each is a separate site in the same sense a web tab is. Favourite sites are supported too.

The UI is built on Qt5, which is why the topic list names qt5 and qt5-gui. That choice is what makes the same binary run across Linux, Windows, FreeBSD, NetBSD, OpenBSD, macOS and Haiku from one codebase.

The audience is people who read the small internet. The project also positions itself against the torture suites the community uses to test clients, and it claims to survive both the ConMans torture suite and the Egsam Torture Suite, which is a meaningful compatibility claim in a protocol where clients and servers disagree about edge cases.

TOFU certificates, because the small internet has no public CA

The TLS management section is the part that makes a small internet browser different from a web browser.

Kristall supports client certificates, and it supports TOFU and CA TLS handling for both Gemini and HTTPS. Trust On First Use is the model that matches how the Gemini ecosystem actually works: there is no widely used public certificate authority for most Gemini hosts, so a client pins the certificate it sees on the first connection and complains when it changes. CA handling is offered for the cases where a host does present a certificate from a real authority.

Client certificates matter in a way they do not on the ordinary web. A Gemini server can require a client certificate to authorise access to a private space, which is closer to how a VPN or an intranet works than how a website works. The presence of `finger` in the protocol list reinforces that picture: Finger is a protocol for looking up user accounts on a host, and it belongs to the same era and the same trust assumptions.

The consequence for a user is that certificate errors are part of the workflow rather than a failure. The consequence for someone integrating Kristall into a script is that its TLS behaviour is not going to match a standard web client, and any automation that talks to Gemini hosts has to account for that.

Rendering text documents is the main event, not an afterthought

The document rendering list is where the product's priorities show.

It handles `text/gemini`, which is Gemini's own markup, `text/html` but with what the documentation calls a reduced feature set, `text/markdown`, `text/*`, `image/*`, `video/*` and `audio/*`. So beyond text formats it plays images, video and audio inline.

The feature that stands out is outline generation, shown with a screenshot and a video in the documentation. For a long Gemini or Gopher text document, generating a navigable outline is a real reading aid, and it is the kind of feature that a general purpose browser cannot offer because those formats have no such structure. It is also a good example of a small internet client treating its native protocols as first class rather than as an afterthought on top of HTML.

The rendering stack is visible in the bundled dependencies. BreezeStyleSheets, a Qt style sheet library, comes from Alexander Huszagh and its contributors and is available under an MIT licence. cmark, the CommonMark parser from John MacFarlane and the Cmark contributors, is under BSD-2-Clause and MIT. The gumbo parser from Jonathan Tang and the gumbo parser contributors is under Apache-2.0. And there is a dependency named after its author, luis-l-gist, credited to Luis Lpz.

Those four cover styling, Markdown rendering and HTML parsing, which tells you the rendering is not a thin wrapper but a small stack of its own.

Building it means having Qt5 and qmake ready

The build system is qmake driven with a Makefile on top, and the Makefile at the repository root shows exactly how the platform differences are handled.

The default install prefix is /usr/local, and it can be overridden on the command line with a variable such as `make PREFIX=/app`. Man pages go to /usr/local/share/man by default. The actual build target copies the built binary into place and generates the manual page as part of the build, running `cd doc; ./gen-man.sh`.

The qmake command is the variable that differs by platform. The default is `qmake`, and the comment notes that on Fedora 32 and similar distributions you would use the path to the Qt5 qmake binary instead. On macOS the Makefile appends the Homebrew Qt5 bin directory to the PATH, because Homebrew does not link Qt5 into the system path, and it does that separately for Apple silicon and Intel macs since the Homebrew prefixes differ.

So the practical build requirements are a Qt5 development installation with qmake on the PATH, a C++ toolchain, and the ability to run the generated man page script. The repository also carries a `CMakeLists.txt` at the top level and a `ci/` directory, so the CMake path exists alongside the qmake one.

The documentation points at BUILDING.md for the full instructions, and the credits thank Alex Naskos for providing the Windows build instructions and Vane Vander for the Haiku build instructions, which suggests the platform specifics are documented per system rather than assumed.

The master branch is a nightly, the tags are the releases

The branch policy is stated in a note near the build instructions and it matters for anyone installing this.

The master branch is the latest development status, sometimes called nightly, whereas the tagged versions are the stable releases. If you want a stable experience you should check out the latest version and build that.

The tags are V0.4 named The late release from 2022-09-23, V0.3 named TLS and security from 2020-06-21, and V0.2 named Update from 2020-06-10. So the newest stable artefact is four years old relative to now, while the last push to the repository was on 2026-09-08, which means the development branch is receiving commits that have not been cut into a release.

That gap is the central fact about this project for an evaluator. The README describes a browser that survives two torture suites, and the code is still moving, but the last tagged release predates most of the current work. Whether the master branch is stable enough for daily use is not something the documentation answers, and there is no changelog in the README to tell you.

There is a changelog, just not in the README. It lives at `src/about/updates.gemini`, which is a Gemini document, so the project serves its own release notes over the protocol it implements. The roadmap is a separate file, ROADMAP.md, and the documentation lives in `doc/` with the manual pages generated into it.

Where Kristall is the wrong tool

Three limits are concrete.

The first is that the HTML support is a reduced feature set. Kristall is a small internet client, not a web browser, and the documentation is explicit about it. If your use of a browser involves modern web applications, complex CSS, or anything that assumes a full engine, this is the wrong program regardless of how good it is at Gemini.

The second is that a native application requires a build or a binary per platform. There is no package on a language registry, no container image and no server deployment. You are compiling a Qt application, which means a Qt5 development toolchain on each machine, or hunting for a build for your platform. The credits show that Windows and Haiku instructions exist, which means they are not uniform, and the Makefile shows the macOS case needs a specific PATH adjustment because of how Homebrew installs Qt.

The third is the release gap described above. A 0.x project with a four year old tag and active commits on master means you are running code whose release status you cannot name. That is workable for a personal tool and uncomfortable for a team that needs to say which version is deployed.

The alternative to name is a general purpose browser with a Gemini extension or proxy, which differs in approach in exactly the way the TOFU support implies. A general browser has a full HTML engine, a large extension ecosystem and a much longer release history, and it cannot natively render Gemini's own text markup, cannot generate an outline for a long Gemini document, and will treat a self signed certificate as an error rather than as a trust decision. The trade is between a real browser with a workaround and a real small internet client with a narrower feature set.

Editorial conclusion

Adopt Kristall if you browse Gemini, Gopher or Finger and want one Qt window that handles all of them with a real document outline and per-site theming, and you are comfortable building a desktop client. Do not adopt it as a general web browser, since the HTML support is described as a reduced feature set, and be aware the newest tagged release is V0.4 from 2022 even though commits continue. Verify first which tagged version or branch you want, since the master branch is described as the nightly development status, and read BUILDING.md for the Qt5 toolchain each platform needs.

Frequently asked questions

Official sources

1. ikskuh/kristall on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases