ODH: an online dictionary popup for any page or PDF, with Anki cards

The problem: looking up a word without losing your place

Reading in a second language has a specific friction point. You hit a word you do not know, you open a dictionary in another tab, you search, you read the definition, and then you have to find your way back to the paragraph you were on, which in a long article can cost you more than the lookup itself. Opening a new tab for every unknown word is a tax paid dozens of times a chapter.

Online Dictionary Helper is a Chrome and Firefox extension that removes that tax. It shows definitions for words and phrases from an online or builtin dictionary, taken from the user's selection on any webpage, and it also works inside PDF documents using pdf.js. So the definition appears in a popup above the selection rather than in a window that takes you somewhere else.

The audience is language learners and readers of technical text in a language they read slowly, which is a broader group than students. The project topics name anki, chrome-extension, dictionary, dictionary-script and popup-window, and the Anki support is not an afterthought: it is the reason a definition can become a flash card without being retyped.

The extension is installed from the Chrome Web Store or from Firefox Add-ons, so there is no build step for an ordinary user. The project is MIT licensed, the repository is not archived, and the last push was on 2026-10-18, so it is being worked on.

The mechanism: selection, a popup, and a script you supply

The interaction is a small, well defined sequence. You select a word with the mouse, by dragging, by double-clicking, or by pressing a hotkey defined in the options page, and a popup window appears above the selection showing the definition. If the word or phrase is a clickable link, you use the predefined hotkey or hold the Alt key while selecting, which is a detail that only matters on pages full of links and is the kind of thing that tells you this extension has been used for a while.

The interesting part is what produces the definition. The extension ships with a builtin dictionary and can load others, and the project makes a point of it: what might set this extension apart is that users can grab online dictionary content with their own customised script, running under extension development mode. The development guide in doc/development.md covers the details, and doc/scriptlist.md lists the existing dictionary scripts.

That design has a consequence for evaluation. The extension is a shell, and the quality of the lookup depends entirely on the script you load. If the dictionary you want has no script, you write one, and if you do not want to write one you are limited to whatever the community has published. For most users that is a reasonable arrangement, because a dictionary script is a small piece of code against a documented interface, but it does mean the project is not a complete product out of the box.

The offline dictionary and the English word deformation table are a related wrinkle. The source code on GitHub does not contain that data, so the repository is not a complete copy of what the installed extension does.

The Anki path: a note from a definition, through AnkiConnect

The Anki integration is the feature that turns a reader into a vocabulary builder, and it works through AnkiConnect, an Anki add-on that has to be installed separately, with Anki itself running.

The setup is described in the options page, in a section called Services Options, where you set the Anki deck, the note type and the field names to put your expression, sentence, reading, definition and similar values into. Mapping the fields explicitly is the right design, because Anki note types vary and a fixed field layout would break on anything but the default.

Once that is configured, the interaction is a single button. While Anki and AnkiConnect are installed and running, a green (+) button appears at the top right corner of each definition in the popup window, and pressing it adds the word or phrase to Anki as a note.

The distinction between the two Anki parts is worth making, because it is a common source of confusion. Anki is the spaced repetition application, AnkiConnect is the bridge that lets another program talk to it. The extension needs both, and it needs Anki running at the moment you press the button, which is a real constraint if you close Anki between sessions.

The unit test list in the package.json includes a test file for ankiconnect, so the bridge behaviour is covered by the test suite rather than only by manual use.

The options page: hotkey, context limits and dictionary choice

The options are organised into three sections, and each one is a decision you will actually change.

General Options carries the switches. Enabled turns the extension on and off. AutoSel.Hotkey configures the hotkey used to select words or phrases, with four choices: Off, which disables the hotkey, or the Shift, Ctrl or Alt key. Max.Context sets the maximum number of sentences extracted from the context of the page, which is how much surrounding text travels with the lookup, and Max.Example sets the maximum number of example sentences from the dictionary, which the documentation notes requires support from the dictionary script.

The second section is AnkiConnect Options, for the deck, the type name and the field mapping described above. The third is Dictionary Options, where you enter the name of your own script and load it with the Load Script button, and choose which dictionary, builtin or loaded, provides the definitions.

Those two limits are the interesting engineering in the options page. Without them, a lookup on a long article would drag a large amount of context and a large number of examples into a request and a popup, which is slow and unreadable. With them, the user decides how much context is worth carrying, and the dictionary script decides how many examples it is willing to return.

The popup itself, with its list view state, error view state, add user and search user screens, is documented in the project README with screenshots in both a light and a dark theme, and the background document explains the reasons the extension was built.

The data gap: the dictionary JSON is not in the repository

The development section of the documentation contains a caveat that is easy to miss and expensive to discover later. The source code of the extension on GitHub does not contain the offline dictionary and the English word deformation table data. The suggested route is to download the extension from the Chrome Web Store, or to use a Chrome extension downloader to fetch the plugin's crx file and extract the dictionary JSON file from it.

That is an unusual instruction, and it is the kind of thing that tells you about the project's constraints. The dictionary content is treated as data that the user brings rather than as part of the source, which keeps the repository small and avoids shipping a word list, but it also means a developer cloning the repository does not get a working offline dictionary until they extract it from a packaged build by hand.

There is a second reason the data is not in the tree, and it is the extension's own design. The deinflector, which is the component that reduces a word form to its dictionary form, is only useful for a particular language, and the unit test list includes a deinflector test file, so the English word deformation table is the one shipped in the package. A user with a different language brings their own script, and their own rules.

For an evaluator, the practical test is simple. Clone the repository, run the test suite, and check the dictionaries list. If a script for the dictionary you use exists, the extension is a good fit. If not, you are writing a script, and the development guide is the first document to read.

The build and test setup: node 24, eslint and a unit suite

The package.json is marked private and describes itself as development tools for the ODH Chrome extension, so the repository is not published as a package. It declares the toolchain explicitly:

    "engines": {
        "node": "24.x",
        "npm": "11.x"
    },

with npm 11.19.0 pinned as the package manager and a .nvmrc file in the repository, so the Node version is a constraint rather than a suggestion. The runtime dependencies list is short, and the development dependencies are just the ESLint stack, so the extension itself has no build step in the sense of a bundler.

The scripts show how the project is checked. Linting is strict, with warnings treated as failures:

        "lint": "eslint . --max-warnings=0",

The tests are split in two, and the split is informative. The contract tests check the JSON and the manifest, which is what a browser extension store validates before it will list the package. The unit tests run the node test runner over a list of files that names the architecture directly: envelope, message, envelope-producers, sandbox-bridge, ankiconnect, builtin, deinflector, settings, settings-pages, message-boundaries and offscreen-setup.

Those names describe the internals. An envelope and its producers are how the extension packages data for a dictionary script, a sandbox bridge is how a script is executed in a constrained context, a message module handles the protocol between the popup, the options page and the background worker, and offscreen-setup suggests recent work on handling content in an offscreen document. There is also an eslint.config.mjs at the root, and a .vscode/ directory for editor configuration.

The project welcomes pull requests, and the documentation is explicit about where things go: extension source in /src, and dictionary scripts in /src/dict.

Editorial conclusion

Adopt ODH if you read a lot of web pages or PDFs in a second language and want a lookup that does not cost you the page you are reading, especially if you already keep vocabulary in Anki. Do not adopt it if you need offline dictionary data out of the box, because the source tree does not include the offline dictionary or the English word deformation table, and the extension is distributed through the Chrome Web Store and Firefox Add-ons rather than as a package. Before you install, read doc/background.md for the reasoning, check the dictionaries list for a script that matches the dictionary you actually use, and confirm that Anki and AnkiConnect are running before you expect the card button to work.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. ninja33/ODH on GitHub
4. README