GoldenDict-ng: a Qt6 dictionary reader for very large dictionary sets

Who GoldenDict-ng is for, and what it replaces

GoldenDict-ng is an advanced dictionary lookup program, in the words of its README. The problem it addresses is specific: you have dictionary files from several sources, in several formats, and you want one window that searches all of them at once instead of opening a different application per dictionary. The README links to a dictformats page on the project site that lists the supported formats, so the intended workflow is importing existing files rather than buying content from the application.

The audience is people who already accumulated dictionaries: language learners with monolingual and bilingual sets, translators who keep terminology glossaries, and readers who want offline lookup. The project's own comparison table against the original GoldenDict lists what the fork changed: WebEngine with current HTML and CSS support, dictionaries over 4GB, high-DPI screens, Xapian as the full-text engine, Qt6, Anki integration, a dark theme, and daily automatic releases. Those are the reasons to pick this fork over the original, which the README says was developed at goldendict.org and github.com/goldendict/goldendict.

One caveat sits in the README itself. The performance line reads "performance optimization(eg. >10000000 headwords support)", which is a design target, not a measured figure. Nothing in the README states a benchmark, a machine specification or a timing, so treat the headword number as a claim about capacity rather than speed.

How the lookup pipeline is put together

The pieces visible in the repository layout tell you most of the architecture. The top level holds src/, thirdparty/, cmake/, vcpkg.json and vcpkg-configuration.json, so the build consumes dependencies through vcpkg rather than vendoring everything by hand. CMakeLists.txt is the build entry point, and the CI badge in the README points at a workflow named PR-check-cmake.yml, which confirms CMake is the supported build system.

At runtime the two components the README calls out are WebEngine and Xapian. WebEngine renders dictionary articles, which is why the fork can claim support for current HTML and CSS: dictionary files that use modern markup display as intended rather than degrading. Xapian is the full-text engine, which is what makes searching inside article bodies possible, not just matching headwords. The README says the fork is built with xapian as fulltext engine, and that is the mechanism behind full-text search in the interface.

The >4GB claim follows from the same design. A dictionary file of that size cannot be loaded comfortably into memory as one blob, so the index and the file access have to be structured around it. The README states the support as a feature, and does not describe the internal format used to achieve it. The resources.qrc file and the icons/ and locale/ directories indicate that UI resources and translations are compiled in, and crowdin.yml plus the Crowdin badge show translations are managed through Crowdin rather than in-repository pull requests alone.

Installing GoldenDict-ng and looking up your first word

The README does not carry install commands. It points to a Download & Install page on the project site at xiaoyifang.github.io/goldendict-ng/install/, and that page is where the per-platform instructions live. If you are building from source, the README directs you to the developer guide on the same site, and the repository layout shows CMake plus vcpkg as the toolchain. The README does not list the exact configure flags, so treat the developer guide as the source for those.

Once the application runs, the workflow is: open the dictionary settings, add the folder or files holding your dictionaries, and let the program index them. The README does not show this dialog, so follow the project documentation for the exact menu path. After indexing, typing a word in the search box queries every loaded dictionary, and the full-text engine lets you search inside article text as well as headwords.

Anki integration is listed as a feature in the README's comparison table. The README does not document the configuration steps for it, so the project documentation is the place to look before relying on that workflow.

Where GoldenDict-ng is the wrong tool

The release history is the first constraint. The three most recent releases are all tagged as daily builds with an alpha version string, for example v26.9.0_alpha.68c3397181. The README lists daily auto release support as a feature, which is honest about how the project ships. What it does not document is a rollback procedure, a stable channel, or a compatibility guarantee between builds. If your environment requires a version you can pin and audit before deployment, that gap matters more than any feature in the comparison table.

The second constraint is the platform story. The README's table covers Linux, Windows and macOS. The related searches include Android and APK queries, but nothing in the README, the repository layout or the release list describes an Android build. Anyone arriving from a mobile search should verify on the project site rather than assume a mobile package exists.

The third is scope. GoldenDict-ng reads dictionaries. It is not a spaced-repetition system, a note-taking application or a translation memory. Anki integration means exporting or sending entries to Anki, not replacing it. If your need is authoring dictionary content, this is the wrong layer entirely: the project consumes files produced elsewhere.

Finally, the licence is GPLv3+ according to the README, with the full text in LICENSE.txt. That is fine for personal use and for distributing the program unchanged. It becomes a consideration the moment you build a modified binary and ship it.

GoldenDict-ng versus the original GoldenDict

The README frames the fork by comparison, which makes the original the natural alternative. The difference in approach is not a different feature set so much as a different base. The original was built against an older Qt generation and its own rendering path; GoldenDict-ng is built on Qt6 and WebEngine, which is what allows the current HTML and CSS support the README claims. If the dictionaries you use rely on modern markup, the rendering difference is visible in the article pane, not just in the changelog.

The second difference is the search engine. GoldenDict-ng is built with Xapian as the full-text engine, per the README. That is the component behind searching article bodies rather than only headwords, and it is the piece that makes a large multi-dictionary collection usable as one corpus.

The third is scale and maintenance. The README states support for dictionaries over 4GB, high-DPI screens and a headword count in the tens of millions. The original's README does not make those claims. The trade-off is the release model: GoldenDict-ng publishes daily alpha builds, so choosing it means choosing a faster-moving target. If you want the slower, older codebase with fewer moving parts, the original remains a coherent choice, and the README points to where it lives.

Licence and the cost of keeping up with daily builds

The README states the project is licensed under GNU GPLv3+, with a copy in LICENSE.txt. The repository's licence field is not a standard identifier, so read LICENSE.txt directly if the exact terms matter to your distribution plans. This is not legal advice: GPLv3+ generally means that if you distribute a modified binary, you must make the corresponding source available under the same terms. Using the program privately does not trigger that.

The upgrade cost is real and specific to this project. Because releases are daily builds tagged with alpha version strings, there is no long-term support branch to sit on and no documented downgrade path. Each upgrade is a new build of the whole application, and your dictionaries are re-read on first launch. The README does not describe a migration or backup step for the dictionary index, so if you maintain a large collection, plan for the reindex time yourself.

On the contribution side, the README says GoldenDict is developed by volunteers and welcomes translation through Crowdin, bug reports in the issue tracker, and discussion in GitHub Discussions. The developer guide on the project site is the entry point for code. That structure means fixes arrive through the daily build channel rather than through a versioned support commitment.

Editorial conclusion

Adopt GoldenDict-ng if you already keep a folder of dictionary files and want one reader on Linux, Windows or macOS with full-text search and Anki export. Do not adopt it if you need a documented stable release cycle: the published releases are daily alpha builds, and the repository does not document a rollback path between them. Before installing, check the install page for your platform, confirm that your dictionaries are in a format listed on the dictformats page, and note that the project is GPLv3+ licensed, so redistributing a modified binary carries source obligations that your own legal review should assess.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. xiaoyifang/goldendict-ng on GitHub