# Inky: the ink editor that compiles while you type

> Inky is a desktop editor for ink, inkle's narrative scripting language. It is aimed at writers who need to see their branching story run before they ship it, and it ships a copy of the inklecate compiler inside the app.

**inkle/inky** — An editor for ink: inkle's narrative scripting language

- Repository: https://github.com/inkle/inky
- Website: http://www.inklestudios.com/ink
- Stars: 2,737 · Forks: 340
- Language: JavaScript
- License: not declared
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/inkle-inky

## What Inky is for, and who should open it

ink is a markup language for interactive narrative, the one inkle used for 80 Days. Writing it in a general text editor means you find out whether a knot resolves, a divert lands or a choice reaches a reachable state only after you run the compiler yourself. Inky closes that loop: it is an IDE, in the README's wording, because it gives you a single app that lets you play in the editor as you write, and fix any bugs in your code.

The audience is narrow and that is the point. If you are a game writer or narrative designer shipping ink into Unity, Godot or a web runtime, Inky is the writing surface. If you only read ink occasionally, a syntax-highlighting plugin in your existing editor is cheaper than a second application. The README is candid about the trade: Inky has been used extensively on multiple projects by different developers, but it is specialist software made by game developers in their spare time, and it is not as feature complete as many other text editors.

## How the editor, the compiler and the play pane fit together

Inky is an Electron application. The interface is HTML, CSS and JavaScript, the editing surface is Ace, and some components come from Photon, a dependency the README notes could probably be removed since it only covers small portions of the CSS. Bundled inside the app is a copy of inklecate, the command line ink compiler. That bundled compiler is the mechanism behind most of the feature list.

Because inklecate is local and fast enough to run repeatedly, Inky compiles as you type. Errors appear while you write rather than at save time. The same compile pass feeds the issue browser, which lists errors, warnings and TODOs and jumps to the exact line number and file. Divert targets such as -> theStreet are hyperlinked and followed with alt-click, which works because the compiler already resolved those targets. The play pane keeps a record of the choices you made, so when a recompile happens it fast-forwards to the last point you were in the flow; you edit a line mid-story and stay where you were instead of replaying from the start.

Multi-file projects need no manifest. Inky infers the structure from the INCLUDE lines, so typing INCLUDE yourfile.ink creates a new include file. That is a deliberate contrast with engines that require a project file to describe the file set. File watching covers the other direction: changes on disk, including edits made through source control, are reflected in the editor.

## Downloading Inky and running a first ink file

The README points to the releases page for Mac, Windows and Linux builds: download the latest release, unpack it and open the app. There is no package manager install documented for end users. Once Inky is open, create a file with a .ink extension and write a knot with a choice and a divert. The play pane on the right compiles the file as you type, so a typo in a knot name shows up as an error in the issue browser before you run anything.

When the story is ready for a runtime, Inky exports ink's compiled JSON format. The README notes this is not necessary if you use the ink-Unity-integration plugin, but it is useful for other runtimes such as inkjs on the web.

```bash
# Build from source (macOS)
# double-click INSTALL_AND_RUN.command, or:
npm install
npm start
```

On Windows the README gives the same pair of commands from Powershell inside the app directory. For later runs, if no npm packages changed, RUN.command on Mac or npm start in the shell is enough. Inky's own build scripts sit at the repository root: BUILD_FOR_MAC.command, BUILD_FOR_WINDOWS.bat, BUILD_FOR_LINUX.sh and BUILD_PACKAGE.command.

## Project settings: custom snippets and the instruction prefix

Per-project customisation lives in a JSON file that sits next to your main ink file and shares its name, with a .settings.json extension. If your story is my_great_story.ink, the settings file is my_great_story.settings.json. The README warns that you need to understand what a JSON file is before editing it, which is a fair signal that this is not a preferences dialog.

```json
{
  "customInkSnippets": [
    { "name": "Camera", "ink": ">>> CAMERA: Wide shot" },
    { "separator": true }
  ],
  "instructionPrefix": ">>>"
}
```

Each entry in customInkSnippets is one of three shapes: an ink snippet with a name and an ink string, a separator written as {"separator": true}, or a submenu with a name and a nested submenu array in the same format. Snippets land in the Ink menu. The instructionPrefix key is the more interesting one. At inkle, the README explains, writers mark game instructions with >>>, and that text is passed through to the runtime as plain text for custom game code to interpret. Inky is not told what the prefix means; it highlights lines carrying it in both the editor and the player view so you can see at a glance that the line is not player-facing prose.

## Where Inky stops being the right tool

The README's project status section is unusually direct: Inky is not as feature complete as many other text editors, and TODO.md lists missing features and known issues. Treat that as the boundary rather than a disclaimer. If your work depends on editor features that have nothing to do with ink, such as a language server for a second language, deep plugin ecosystems or remote pair-editing, Inky is not the place to look for them.

Two smaller constraints follow from the design. The settings file is read from a JSON file you maintain by hand, so a malformed file is a failure mode with no described recovery path; the README does not document validation or error reporting for it. And the bundled inklecate is a copy, not a live dependency: the README does not document a way to point Inky at a different compiler build, so behaviour tracks the version shipped with the release you downloaded. If your runtime pins a specific ink version, check which one your Inky release carries before assuming the editor and the runtime agree.

## Inky against a general code editor with an ink plugin

The realistic alternative is the editor you already use, with an ink syntax definition and a terminal running inklecate. The difference is not highlighting; both approaches colour the text. It is the compile loop. A general editor gives you a file and a shell, and you decide when to compile and how to read the output. Inky runs the compiler continuously, collects its diagnostics into a browsable list with line and file targets, links divert targets for alt-click navigation, and keeps your place in the play pane across recompiles.

The second difference is project structure. A general editor sees files. Inky reads the INCLUDE lines and derives the story's structure from them, so creating an include file is typing one line rather than adding a file to a manifest. If you keep ink in source control, that inference plus file watching means edits arriving from a branch show up in the editor without reopening anything. If you mostly edit a single flat ink file and compile from a script, that machinery buys you little.

## Build requirements, licence and upgrade cost

Building from source needs node.js. The README's Linux instructions were tested on a fresh Ubuntu 16.04 LTS VM and list build tools, git, curl, a NodeSource setup script for node 8.x, and mono, which the bundled inklecate requires. Those are old targets; expect to substitute a current Node release and accept that the documented sequence may not match a modern distribution. Release 0.15.2 landed on 2026-05-05, after 0.15.1 in 2024-06-17 and 0.15.0, the Highland release, in 2024-06-10. The repository is not archived, and the gap between 0.15.1 and 0.15.2 shows the release cadence is slow and irregular rather than scheduled.

The licence is not stated in the repository metadata available here, so check the repository for a licence file before you depend on Inky in a commercial pipeline or redistribute a build. Upgrading is a download: the README points at the latest release, and there is no documented migration step between versions. The cost that does accumulate is the settings file, which is per project and hand-maintained, so every project that uses custom snippets carries its own copy to keep in sync.

## Conclusion

Adopt Inky if you write branching narrative in ink and want a play pane that remembers your choices, an issue browser that jumps to the offending line, and multi-file INCLUDE handling without a project file. Do not adopt it if you expect the polish of a general-purpose text editor: the README itself says Inky is not as complete as many other text editors, and TODO.md carries the known gaps. Before committing, verify that a build for your platform exists on the releases page, open your main ink file, and confirm that the issue browser lists your project's warnings and TODOs and that alt-clicking a divert target jumps to its definition.

## FAQ

### Is Inky free to download?

The README links to the GitHub releases page for Mac, Windows and Linux downloads, and the repository is public. The licence is not stated in the repository metadata available, so check the repository for a licence file before relying on it commercially.

### How do I install Inky on Linux?

The README's Linux section was tested on a fresh Ubuntu 16.04 LTS VM and lists build tools, git, curl, a NodeSource setup script for node 8.x and mono, or you can download a release build. The repository also contains BUILD_FOR_LINUX.sh.

### How do I create a multi-file ink project in Inky?

Inky infers the story's structure from the INCLUDE lines, so there is no project file to maintain. To create a new include file, type INCLUDE yourfile.ink where you want it included.

### Can Inky export ink to JSON?

Yes. The README says Inky can export to ink's compiled JSON format, which is useful for other ink runtime implementations such as inkjs for running ink on the web. It is not necessary if you use the ink-Unity-integration plugin.

## Sources

- [inkle/inky on GitHub](https://github.com/inkle/inky)
- [Issues](https://github.com/inkle/inky/issues)
- [Project website](http://www.inklestudios.com/ink)
- [README](https://github.com/inkle/inky/blob/master/README.md)
- [Releases](https://github.com/inkle/inky/releases)

---

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