# TiddlyWiki5: A Single HTML File That Thinks Like a Wiki

> TiddlyWiki5 is a JavaScript wiki that runs as one self-contained HTML file in a browser or as a Node.js server. It suits people who want notes they own outright, and it punishes anyone expecting a conventional database-backed wiki.

**TiddlyWiki/TiddlyWiki5** — A self-contained JavaScript wiki for the browser, Node.js, AWS Lambda etc.

- Repository: https://github.com/TiddlyWiki/TiddlyWiki5
- Website: https://tiddlywiki.com/
- Stars: 8,668 · Forks: 1,251
- Language: JavaScript
- License: NOASSERTION
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/tiddlywiki-tiddlywiki5

## What TiddlyWiki5 is for, and who it is actually for

The project describes itself as "a non-linear personal web notebook that anyone can use and keep forever, independently of any corporation". That sentence is the whole pitch, and it is unusually precise about the audience. A tiddler is the unit of content, and tiddlers link to each other rather than sitting in a page hierarchy, which is why the README calls the notebook non-linear.

The people this fits are individuals: researchers accumulating notes across years, writers who want a private wiki without a server bill, and developers who want to read and modify the software they keep their notes in. The README states that the entire user interface is itself implemented in WikiText, so the editor, the sidebar and the styling are all content you can open and change. That is the real differentiator. Most wikis give you a plugin API; this one gives you the wiki itself.

It is not aimed at teams. Nothing in the README describes user accounts, permissions, concurrent editing or an audit trail. If your problem is "twenty people need to edit the same page and we need to know who changed what", this is the wrong tool, and no amount of plugin installation changes that.

## Single file in the browser versus a Node.js server

TiddlyWiki5 ships in two shapes, and the README is explicit that the single-file application is the easy one. For advanced users and developers, it says, there is a Node.js client and server configuration, and that same configuration is used to build the single-page application.

The single-file shape is one HTML document containing the JavaScript engine and all your tiddlers. You open it in a browser, edit, and save. The README's offline instructions tell you to click the save button, which writes a fresh copy of the file. There is no server, no database and no network dependency, which is also why the README can promise you keep it independently of any corporation.

The Node.js shape splits the same engine across a folder. The repository layout reflects this: core/ holds the engine, core-server/ holds the server-side pieces, editions/ holds the packaged wiki editions, and plugins/ and themes/ hold optional components. A wiki folder is a directory of individual tiddler files, and the server renders and saves them. This is the shape you want if you intend to keep the wiki in Git, because each tiddler becomes a diffable file rather than a line inside a binary-ish HTML blob. The trade-off is that you now maintain a Node.js process and a folder structure, and the README does not document rollback or conflict resolution for simultaneous edits.

## Installing TiddlyWiki5 on Node.js and starting a wiki

The README gives the install path directly. Install Node.js first, then install the package globally. The package.json declares an engines constraint of node >=20.0.0, so a recent Node.js is required rather than merely recommended.

The README's per-platform notes are short. On Debian or Ubuntu it lists apt install nodejs, possibly followed by apt install npm. On Arch Linux it gives yay -S tiddlywiki, which installs Node and TiddlyWiki together. On macOS it gives brew install node. For Android it points at Termux.

```bash
npm install -g tiddlywiki
```

If that fails, the README says to re-run it as an administrator with sudo npm install -g tiddlywiki on Mac or Linux. Then confirm the binary is on your path.

```bash
tiddlywiki --version
```

The README says you should see TiddlyWiki report its current version, giving "5.4.1" as an example, and that you may also see other debugging information. The most recent release listed for the repository is v5.4.1, dated 2026-07-10.

Now create a wiki folder and start the server. The README's own sequence is two commands.

```bash
tiddlywiki mynewwiki --init server
tiddlywiki mynewwiki --listen
```

The first creates a folder for a new wiki that includes server-related components. The second starts TiddlyWiki. Visit http://127.0.0.1:8080/ in your browser, then try editing and creating tiddlers, which is what the README suggests. The port is 8080 and it comes from the README, not from a flag you need to invent.

Finally, the README offers an optional step: make an offline copy by clicking the save button in the interface. That is the bridge between the two shapes. You can run a server for convenience and still export a single HTML file you can open anywhere.

## Where TiddlyWiki5 gets awkward

The licence situation is the first thing to check, and it is genuinely confusing. The repository's package.json declares "license": "BSD", but the repository also carries a license file and a licenses/ directory, and the metadata the repository exposes reports the licence as NOASSERTION. Those do not agree. If you are embedding TiddlyWiki5 in something you distribute, read the license file and the licenses/ directory yourself rather than trusting the package.json field, and get a lawyer's opinion rather than mine.

The second limitation is storage semantics in the single-file edition. Your notes live inside the HTML file, and saving means writing a new copy of that file. The README does not document rollback, versioning or recovery if a save goes wrong. A Git repository around the file mitigates this, but that is your discipline, not a feature.

The third is the interface-as-content design. Because the UI is WikiText, upgrading the engine can interact with your customisations in ways a plugin API would contain. The README points developers at tiddlywiki.com/dev, described as the official developer documentation, and notes that developer documentation is in progress. That phrasing matters: if you plan to write plugins, you are working against documentation the project itself describes as incomplete.

Finally, the Node.js requirement of node >=20.0.0 rules out long-lived systems pinned to older runtimes. There is no supported older-Node path in the package metadata.

## TiddlyWiki5 compared with a database-backed wiki

The obvious alternative class is a server wiki backed by a relational database and a web framework, where pages are rows, users are accounts, and the application code is separate from the content. The difference is not cosmetic. In that model the content and the software are different things, and the software is upgraded by someone with server access.

In TiddlyWiki5 the content and the software are the same artefact. A tiddler can define a macro, restyle the sidebar, or add a button that runs a filter. The README states the entire user interface is implemented in hackable WikiText, and the repository layout backs that up: themes/ and plugins/ sit alongside core/ as first-class directories, and editions/ packages them into distributable wikis.

That gives you an extremely short path from "I want the sidebar to behave differently" to "the sidebar behaves differently", with no build step and no deployment. It also means there is no boundary between your changes and the project's changes. When you upgrade, you are merging, not installing. A database-backed wiki gives you a clean upgrade because your content never touches the application code. TiddlyWiki5 gives you total control and asks you to manage the consequences.

For a single person keeping notes for a decade, the first trade is clearly better. For an organisation with a change-management process, the second is.

## Maintenance, upgrades and what you are signing up for

The repository is not archived, and its last push was on 2026-09-21. The most recent release is v5.4.1, dated 2026-07-10, while package.json on the default branch reads 5.5.0-prerelease, so development is happening ahead of the released version. That is a normal pattern for this project and it tells you something practical: the default branch is not the version you install from npm.

The upgrade cost depends entirely on which shape you chose. A single-file wiki is upgraded by generating a new empty wiki from the new version and importing your tiddlers into it. Your customisations travel with the tiddlers, which is convenient until one of them depends on an internal behaviour that changed. A Node.js wiki is upgraded by installing the new global package and restarting; the wiki folder stays put. Neither path is documented in the README as a rollback procedure, so keep the previous version's output or a Git history before you upgrade.

Maintenance is otherwise close to zero in the browser shape, because there is no process to keep alive and no dependency to patch. That is the strongest argument the project has, and it is a real one. The cost is that you, personally, are the backup strategy.

## Conclusion

Adopt TiddlyWiki5 if you want a personal notebook that survives as a single HTML file you can copy, or if you want a Node.js wiki whose entire interface is editable WikiText. Do not adopt it if you need multi-user accounts, a relational store, or a conventional server-rendered CMS. Before committing, run tiddlywiki mynewwiki --init server, edit a few tiddlers, and confirm that saving works in your browser, since the single-file edition depends on browser storage rather than a server. Then check the licence text in the repository's license file, not just the package.json field, because the two disagree.

## FAQ

### What is TiddlyWiki5 used for?

It is a non-linear personal web notebook: a wiki whose content is stored as tiddlers that link to one another rather than in a page hierarchy. The README presents it as usable either as a single HTML file in the browser or as a Node.js application, and describes the entire user interface as implemented in hackable WikiText.

### Is TiddlyWiki5 free?

There is no paid tier described anywhere in the repository material. The package.json declares "license": "BSD", but the repository also contains a license file and a licenses/ directory, and the repository metadata reports the licence as NOASSERTION, so read the license file itself before relying on that field.

### How do I install TiddlyWiki5 on Node.js?

The README gives npm install -g tiddlywiki, followed by tiddlywiki --version to confirm the install. The package metadata requires Node.js 20.0.0 or later.

### How do I start a TiddlyWiki5 server?

Run tiddlywiki mynewwiki --init server to create a wiki folder with server components, then tiddlywiki mynewwiki --listen to start it. The README says to visit http://127.0.0.1:8080/ in your browser and try editing and creating tiddlers.

### Can I use TiddlyWiki5 without Node.js?

Yes. The README describes TiddlyWiki as a single-file application that is easy to use, and presents the Node.js client and server configuration as an option for advanced users and developers. The README also describes making an offline copy by clicking the save button in the interface.

## Sources

- [Issues](https://github.com/TiddlyWiki/TiddlyWiki5/issues)
- [Project website](https://tiddlywiki.com/)
- [README](https://github.com/TiddlyWiki/TiddlyWiki5/blob/master/README.md)
- [Releases](https://github.com/TiddlyWiki/TiddlyWiki5/releases)
- [TiddlyWiki/TiddlyWiki5 on GitHub](https://github.com/TiddlyWiki/TiddlyWiki5)

---

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