Zeal: an offline documentation browser that reads Dash docsets

What Zeal is for, and who ends up using it

Zeal is an offline documentation browser. The README describes it as "your personal reference library, searchable in an instant and available without a connection." The problem it addresses is narrow and real: API references live on the web, and the web is not always there. A train, a locked-down corporate laptop, an air-gapped build machine, or a flaky hotel network all turn a five-second lookup into a stalled task.

The intended user is a developer who looks up function signatures, class members and language syntax many times a day and wants that lookup to behave like a local search rather than a page load. Zeal was originally inspired by Dash and supports the same docset format, which matters more than it sounds: the docset ecosystem is the reason a tool like this has anything to search at all. Without Dash-compatible docsets, Zeal would be an empty window.

It is a desktop application, not a service. There is no server component and no account. That shapes everything else about it, including its limitations.

How the docset library and prefix search work

The mechanism is a local index. After installing Zeal, the README says to open File then Docset Library, select the docsets you want, and click Download. Each docset is fetched and stored on the machine, and from then on searches run against that local copy. The application does not proxy queries to a documentation website; the docset is the database.

Query filtering is the part worth understanding before you adopt it. A query can be scoped to a docset by prefixing it with the docset name and a colon, so `cpp:vector` searches only the C++ docset. Multiple docsets can be combined by separating their names with a comma, as in `python,django:string`. This is a deliberate design choice: instead of a global search box that returns noise from every installed language, Zeal lets you declare the scope inline. The cost is that you have to remember docset names, and a typo in the prefix silently changes what you are searching.

The same query language works from the command line, which is the feature that makes Zeal scriptable. `zeal python:pprint` starts the application with that query already applied. For anyone who wants a documentation lookup bound to an editor key or a shell alias, that is the integration point, and it is the only one the README documents. There is no documented plugin API, no language server, and no editor extension in the README.

Installing Zeal and running a first scoped search

The README points to Flathub and Snapcraft for Linux packaging, and to the download page for Windows binaries and other installation options. Windows builds require Windows 10 version 1809 or later. The README does not spell out a package-manager command, so the Flathub and Snapcraft listings are where the install instructions live.

After the application starts, the first real task is populating the library. Open File then Docset Library, tick the docsets you want, and click Download. Nothing is searchable until at least one docset has finished downloading, which is the most common reason a fresh install appears to return no results.

Once a docset is present, scope a query with the docset name and a colon. Typing `cpp:vector` limits the search to the C++ docset; `python,django:string` searches both listed docsets for the same term. The colon is what separates the scope from the query, and the comma is what separates docsets.

The command line entry point takes the same syntax, so a shell alias or an editor shortcut can open the application directly on a query. The README gives this exact example:

zeal python:pprint

Building from source is a separate path. The README gives a minimal recipe using CMake and Ninja, with Qt 6.4.2 or later plus the Svg and WebEngine modules, libarchive, and SQLite as dependencies:

cmake --preset release
cmake --build --preset release

The resulting binary is `build/release/zeal`, or `zeal.exe` on Windows. The README states that detailed, up-to-date build instructions for each platform live in the project wiki, and that Linux and BSD platforms additionally need `extra-cmake-modules`, while X11 platforms need `libxkbcommon` and `xcb-util-keysyms`. The repository also carries a `justfile` with recipes such as `just configure`, `just build`, `just run` and `just test`, which wrap the CMake presets defined in `CMakePresets.json`.

Where Zeal stops being the right tool

The central limitation is freshness. A docset is a snapshot. Zeal searches what you downloaded, and the README does not document any automatic update mechanism for docsets, nor does it describe a rollback path if a refreshed docset turns out to be worse than the one it replaced. If your work depends on documentation that changes weekly, or on a library that is pre-1.0 and churning, you will be reading stale signatures and wondering why the code does not compile. A browser pointed at the vendor's site does not have that problem.

Scope is the second constraint. Zeal can only search docsets that exist in Dash format. The README says to follow the Dash docset generation guide to create your own, which is a real escape hatch, but it means the tool's usefulness is bounded by an ecosystem the project does not control. If the thing you need documented has no docset and nobody has generated one, Zeal is an empty window with a search box.

There is also a platform gap in the README. It links Flathub and Snapcraft and mentions Windows binaries, and the build instructions cover Linux, BSD and X11 specifics, but nothing in the README describes a macOS distribution. Anyone searching for a macOS build should check the download page directly rather than assume one exists.

Finally, the search syntax has no fuzzy fallback described. Prefix matching on docset names is precise and unforgiving. That is fine for muscle memory and annoying for occasional use.

Zeal against a browser and against Dash

The obvious alternative is the browser you already have. The difference is not speed of rendering, it is the dependency on a network and on a vendor's site staying up and staying structured. A browser gives you the current version of a page, search that spans the whole web, and zero setup. Zeal gives you a fixed corpus, sub-second local lookup, and no connection requirement. The two fail in opposite directions: the browser fails when the network does, Zeal fails when the documentation moves.

Dash is the closer comparison, and the README is explicit that Zeal was originally inspired by it and supports the same docset format. The practical consequence is that switching costs are low in one direction: the docsets are compatible, so the content is portable. The difference is in the surrounding product. Dash is a commercial macOS application, while Zeal is GPL-3.0 and builds on Linux, BSD and Windows. If you are on macOS and want the polished commercial option, Dash is the reference point this project itself names. If you want the same docset format on Linux or Windows, or you want to read and modify the source, Zeal is the one that fits.

A third option is simply keeping local copies of documentation as files and grepping them. That works for a single well-organized docs tree and falls apart the moment you need three languages and a framework, which is the point at which an indexed docset library starts paying for itself.

Maintenance, build cost and the GPL-3.0 question

The repository is not archived, and the last push was on 2026-07-28, the same day as the v0.9.1 release. Recent releases include v0.9.0 on 2026-07-28 and v0.8.1 on 2026-04-04. That is a project with recent activity, though the release cadence shown here is sparse: two releases on one day and one four months earlier. Judging long-term maintenance from three releases is not something the available release history supports.

Upgrade cost depends on how you installed it. Flatpak and Snap handle updates through their own tooling. A source build means re-running the CMake presets whenever you pull, and the dependency floor is not trivial: Qt 6.4.2 or later with the Svg and WebEngine modules, libarchive, SQLite, and on Linux or BSD `extra-cmake-modules` as well. The `justfile` shortens the commands but does not remove the dependencies. Note that the `just lint` recipe depends on `build` because the AUTOUIC, AUTOMOC and AUTORCC headers must exist first, which tells you a clean tree cannot be linted in isolation.

On licensing: Zeal is GPL-3.0 or later, with the full text in the COPYING file. The repository is REUSE-compliant and carries per-component license texts in the LICENSES directory, and the README notes that bundled third-party components keep their own terms. If you only run Zeal to read documentation, the copyleft obligations are not something you trigger. If you plan to redistribute a modified binary, or to link the code into a product you ship, the GPL-3.0 terms apply to that distribution, and the per-component licenses in LICENSES are worth reading alongside COPYING. That is a question for your own counsel, not for this article.

Editorial conclusion

Adopt Zeal if your work happens on machines with poor or restricted connectivity and you want API references indexed on disk, particularly if you already use Dash-format docsets. Skip it if you need always-current web documentation, because docsets only change when you download a new copy. Before committing, verify on your platform that the docsets you depend on exist in the library, that the Qt 6.4.2 build path works for your distribution if you compile from source, and that GPL-3.0 is acceptable for how you intend to distribute anything derived from it.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes