# Wikiman: one fuzzy search across man pages, wikis and tldr pages, offline

> Wikiman is a shell script that puts manual pages, tldr-pages, ArchWiki, Gentoo Wiki, FreeBSD docs and DevDocs behind a single fuzzy search, with no network access needed once the optional sources are downloaded. The trade is that a wiki source is a large local snapshot, and the DevDocs source returns nothing until you pick a book.

**filiparag/wikiman** — Wikiman is a universal offline documentation search engine for manual pages, tldr-pages, ArchWiki, Gentoo Wiki, DevDocs, and FreeBSD documentation

- Repository: https://github.com/filiparag/wikiman
- Stars: 1,025 · Forks: 25
- Language: Shell
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/filiparag-wikiman

## One fuzzy finder over documentation that usually lives in different places

Wikiman is described as a universal offline documentation search engine. It can browse system manual pages, tldr-pages, the ArchWiki, the Gentoo Wiki, FreeBSD documentation and many other sources curated by DevDocs.

The problem it addresses is mundane and real. On a Linux workstation, the answer to how do I do X might live in a man page, in a tldr example, in an ArchWiki article, or in a DevDocs book, and finding it means remembering which of those four places holds the answer. Wikiman flattens that into one search.

The interface it provides is an easy one for browsing documentation without the need to be exact and connected to the internet. Three different matching strategies sit underneath, and they differ per source because the data differs. Full text search is used for wikis, partial name and description matching for man pages, and fuzzy filtering is applied to the search results.

That last one is what makes it feel good in practice. Fuzzy filtering means a mistyped or half remembered keyword still lands on the right page, which matters more here than in a browser search box where you would simply retype.

There is one important default to know. By default, Wikiman only searches manual pages, and the documentation instructs you to follow the additional sources instructions to download and enable the optional ones. So the tool is useful the moment you install it and gets much better once you invest in the local wiki snapshots.

## The shell widget, which is the part you will actually use daily

The most interesting feature is not the command line interface, it is the shell widget. Wikiman can be launched using a shell key binding, default Ctrl+F, and the current command line buffer is used as the search query.

That detail is what makes the tool feel native. You are halfway through typing a command, you are unsure of the flag, you hit Ctrl+F, and the words you have already typed become the query. You do not have to remember the command name to search for its documentation, because you already typed it.

You add the appropriate line to your shell configuration file to make the binding permanent.

```bash
# bash
source /usr/share/wikiman/widgets/widget.bash

# fish
source /usr/share/wikiman/widgets/widget.fish

# zsh
source /usr/share/wikiman/widgets/widget.zsh
```

Three shells are supported, with a separate widget file for each, and they are installed into /usr/share/wikiman/widgets/ by the build. The Makefile has a widgets target that depends on core and copies the widgets directory into place.

The command line interface itself is small and conventional. The usage is wikiman with options and keywords, and if no keywords are provided it shows all pages. The option set covers search language with -l, sources with -s, the fuzzy finder with -f defaulting to fzf, quick search mode with -q, AND operator mode with -a, disabling the quick result preview with -p, keeping the viewer open after a result with -k, showing a source column with -c, the HTML viewer with -H defaulting to w3m, raw output with -R, listing available sources and exiting with -S, printing widget code for a specified shell with -W, version with -v, and help with -h.

Two of those are worth pulling out. The -S flag lists the available sources and exits, which is how you confirm what is actually enabled on your machine. The -W flag prints the widget code for a given shell, which means you can inspect what the widget does before sourcing it into your configuration.

## Optional sources are downloaded snapshots, and size is the reason

The optional sources are listed explicitly: ArchWiki with the key arch, DevDocs with devdocs, FreeBSD Documentation with fbsd, Gentoo Wiki with gentoo, and TLDR Pages with tldr.

They are not bundled because of their large size. The documentation says so directly, and that single sentence explains the whole design of the tool. Wikiman is a thin shell program, and it would be absurd to ship a copy of the ArchWiki inside a package.

So you download their latest snapshots yourself with a small make invocation.

```bash
# Download latest Makefile
curl -L 'https://raw.githubusercontent.com/filiparag/wikiman/master/Makefile' -o 'wikiman-makefile'

# Example for Linux: install ArchWiki and TLDR pages
make -f ./wikiman-makefile source-arch source-tldr
sudo make -f ./wikiman-makefile source-install
sudo make -f ./wikiman-makefile clean
```

The pattern is the same for every source, and the Makefile targets are visible in the repository's own Makefile, which lists source-all, source-reinstall, source-install, source-clean, source-deinstall, source-uninstall, source-local, and one target per source, including source-arch, source-devdocs, source-fbsd, source-gentoo and source-tldr. The BSD variant differs in that the files move from /usr to /usr/local, and the freebsd docs and tldr pages example shows that difference with source-local.

After installation the sources should be enabled automatically if the sources configuration variable is empty, which is a detail worth knowing because it means an empty sources line means all available sources rather than none.

Two operational realities follow. First, the snapshots are as fresh as the last time you ran the download target, so a wiki article that changed last week is not in your copy. Second, this is why the tool is called an offline search engine rather than a documentation browser, and why a refreshing step has to be part of your routine.

## DevDocs needs a book, and returns nothing until you name one

The DevDocs source behaves differently from the rest, and the note about it is the one piece of configuration most likely to confuse a new user.

The DevDocs source provides access to documentation for hundreds of unrelated individual projects, organized into separate books. To choose which books are active, you prepend your Wikiman queries with =book, for example =c,cpp,python. By default this source returns no results, as no books are selected automatically.

So if you install the devdocs source and search for something like fopen, you get nothing, and the reason is that no book has been selected. The syntax is a prefix operator on the query rather than a separate flag, and it takes a comma separated list, which means you can carry several books at once, for example a C book and a Python book in the same query.

This is a defensible design. A DevDocs snapshot without a book selection is an index of hundreds of projects, and a full text search across all of them is neither fast nor useful. By making the selection explicit in the query, the source stays small and the results stay relevant.

It does mean the DevDocs source is opt in twice, once for the download and once for the query, and the second step is invisible if you do not read the documentation. The general principle for Wikiman is worth stating plainly: the man page sources are always available, the wiki and tldr sources are enabled by downloading them, and DevDocs additionally requires naming a book in the query.

## Configuration in an ini file, with a fallback for the system

The user configuration file is at ~/.config/wikiman/wikiman.conf, and the fallback system wide configuration is /etc/wikiman.conf. If you have set XDG_CONFIG_HOME, the user configuration is looked up from there instead.

The example configuration shows the full set of knobs, and they map one to one onto the command line options.

```ini
# Sources (if empty, use all available)
sources = man, arch

# Fuzzy finder
fuzzy_finder = sk

# Quick search mode (only by title)
quick_search = true

# Raw output (for developers)
raw_output = false

# Manpages language(s)
man_lang = en, pt
```

The fuzzy_finder setting is the interesting one, because the default is fzf but the example shows sk. Since Wikiman shells out to a fuzzy finder, you can point it at whichever one you already use. The language settings are separate for man pages and for wikis, so you can have man pages in en and pt while your wiki source is zh-CN, which is a realistic setup for a bilingual machine.

The postprocess_man key is the other one that changes behaviour rather than a label. It takes a command, with the example being bat -l man --color always --style plain, so the raw man output is piped through a pager that highlights it. Setting a different command there replaces the man page formatter with whatever you prefer.

To list available languages, the documentation gives find commands per source, for example listing the man page locale directories excluding English, the ArchWiki HTML directory, the FreeBSD docs directory and the tldr pages directory. That is a manual operation, so the answer is a directory listing rather than a flag.

## Shell scripts as plugins, with a search function as the contract

Wikiman is designed to be extensible, and the extension mechanism is worth understanding because it is unusually simple.

Each source has its module in the sources/ directory, and these modules are loaded as needed during runtime. The source modules are POSIX compliant shell scripts. Wikiman calls their search function, which reads the query variable and configuration variables, and prints results to standard output.

That is the entire plugin contract. A source is a shell script that exports a function named search, reads $query, and prints rows. The repository layout shows the same structure for the rest of the tool: a sources/ directory, a widgets/ directory for the shell key bindings, a completions/ directory, a build/ directory, plus wikiman.sh as the main program, wikiman.conf, the Makefile and a man page source in wikiman.1.man.

The design has real virtues. A new source is a shell script, so it can be written in an afternoon and reviewed as text, and the runtime loading means an unused source costs nothing. It also means the tool stays a POSIX shell program rather than acquiring a language runtime, which is what lets it install as a small package on Arch, Debian, Fedora, openSUSE and FreeBSD alike.

The cost is that the contract is a convention rather than an interface with types. A source module that prints malformed rows will not be caught by a compiler, and anyone writing a source is expected to read the existing modules in sources/ as the reference. That is a reasonable trade for a shell tool, but it is a trade.

## Installing on a distribution, and what the packages carry

Wikiman ships as packages for the usual Linux distributions and as a port for FreeBSD, and the dependency list is the same everywhere.

On Arch Linux it comes from the extra repository, with the ArchWiki as a separate optional package.

```bash
pacman -S wikiman

# Optional: Enable ArchWiki
pacman -S arch-wiki-docs
```

If you are on Manjaro or another Arch based distribution, you download the latest .pkg.tar.zst package from the Releases tab and install it locally, and then follow the additional sources instructions to add ArchWiki as a source.

```sh
sudo pacman -U wikiman*.pkg.tar.zst
```

On Ubuntu and Debian the latest .deb package works with apt.

```bash
sudo apt update
sudo apt install ./wikiman*.deb
```

Fedora and openSUSE use the .rpm package, with the openSUSE line noting that signature verification is skipped.

```bash
# Fedora
sudo dnf install wikiman*.rpm

# openSUSE (skip signature verification)
sudo zypper in wikiman*.rpm
```

For FreeBSD there is a port in the Ports Collection, textproc/wikiman, or a .txz package.

```bash
portsnap auto
cd /usr/ports/textproc/wikiman
make install
```

The manual installation path lists the dependencies as man, fzf, ripgrep, awk, w3m, coreutils and parallel, and then builds from a clone.

```bash
git clone 'https://github.com/filiparag/wikiman'
cd ./wikiman

# Switch to latest stable release (optional)
git checkout $(git describe --tags | cut -d'-' -f1)

# Available targets: all, core, widgets, completions, config, docs
make all

# Only for BSD users: install to /usr/local instead of /usr
make local

# Install Wikiman
sudo make install
```

One portability note that decides whether the tool works at all on your system: Wikiman uses GNU find and awk, so BSD users have to install findutils and gawk.

## Conclusion

Wikiman fits a Linux or BSD engineer who wants one keybinding to reach a manual page, a wiki article and a tldr example, and who wants that lookup to work on a machine with no network, in a terminal, without a browser. It does not fit a user who needs the wikis to be current, because the optional sources are downloaded snapshots that you refresh yourself, and it does not fit someone who expects a full text search engine over a large wiki without also accepting large local snapshots. Check three things before you adopt it. Check the dependency list, which is man, fzf, ripgrep, awk, w3m, coreutils and parallel, and note that BSD users additionally need findutils and gawk because the script uses GNU find and awk. Check which sources you actually enable, since by default only manual pages are searched and the wikis are excluded because of their large size. And check the DevDocs behaviour, since that source returns no results by default because no books are selected, and the book list is chosen by prefixing a query with =book and a comma separated list. The last push was on 2026-07-11, the newest tagged release is v2.14.1 from 2025-05-14, and the license is MIT.

## FAQ

### What documentation sources does Wikiman search?

System manual pages by default, with optional sources for ArchWiki, DevDocs, FreeBSD Documentation, Gentoo Wiki and TLDR Pages. The wikis are not bundled because of their large size and are downloaded as snapshots you refresh yourself.

### Why does the DevDocs source return no results?

Because no books are selected automatically. You choose which books are active by prefixing the query with =book and a comma separated list, for example =c,cpp,python.

### How do I bind Wikiman to a key in my shell?

Wikiman can be launched with a shell key binding, default Ctrl+F, using the current command line buffer as the search query. Add the source line for your shell from /usr/share/wikiman/widgets/, with separate widget.bash, widget.fish and widget.zsh files.

### What dependencies does Wikiman need?

man, fzf, ripgrep, awk, w3m, coreutils and parallel. Because Wikiman uses GNU find and awk, BSD users also have to install findutils and gawk.

### Where is the Wikiman configuration file?

The user configuration is at ~/.config/wikiman/wikiman.conf, with a system wide fallback at /etc/wikiman.conf, and XDG_CONFIG_HOME is honoured if set. Options include sources, fuzzy_finder, quick_search, raw_output, man_lang and wiki_lang.

### What license is Wikiman released under?

MIT, with a LICENSE file at the root of the repository. The Makefile reports version 2.14.1, and the last push was on 2026-07-11.

## Sources

- [filiparag/wikiman on GitHub](https://github.com/filiparag/wikiman)
- [Issues](https://github.com/filiparag/wikiman/issues)
- [License: MIT](https://github.com/filiparag/wikiman/blob/master/LICENSE)
- [README](https://github.com/filiparag/wikiman/blob/master/README.md)
- [Releases](https://github.com/filiparag/wikiman/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/filiparag-wikiman