operator-mono-lig: adding Fira Code style ligatures to Operator Mono

What operator-mono-lig actually solves

Operator Mono is a paid typeface from Typography.com that many developers use for its cursive italics. It ships without programming ligatures, so `!=`, `=>` and `>=` render as separate characters. Fira Code popularised the opposite approach: a free monospaced font where those sequences collapse into single glyphs. operator-mono-lig sits between the two. It generates new OpenType fonts for Operator Mono that include ligatures similar to those in Fira Code, and the README notes the ligatures were custom created in Glyphs, with italic versions as well.

The audience is narrow by design. You need a valid Operator Mono licence, because the tool does not contain the typeface. The README states that because Operator Mono is not a free font, you must have the original font files, and that the utility merges ligature definitions into a copy of the original font. The generated family is named Operator Mono Lig so it can be installed side by side with the original. If you are looking for a free download of Operator Mono, this project is not that, and the README points you at Typography.com instead.

How the ligature merge works

The repository is a Node.js driver around font tooling. Top-level entries include `index.js`, `calt.js`, `extract.js`, `genpreview.js`, `genspacers.js`, `build.sh` and `build.bat`, plus directories named `ligature`, `ligature_source`, `features` and `original`. The `original` folder is where you place your licensed OpenType files; the build reads from there and writes results into `build`.

Version 2 reworked font generation to support advanced OpenType features like those in Fira Code. The README calls out two visible behaviours: the cursor now moves inside the ligature, and repeating characters are handled properly. The caret-position GIF in the README illustrates the first point. That matters more than it sounds. A ligature that swallows the caret makes editing inside an expression painful, which is why many people abandon ligature fonts after a week.

The `package.json` dependencies are small and unglamorous: `hash.js`, `xml-formatter`, `xmldom` and `xpath`. That mix suggests the pipeline manipulates the font's XML representation rather than doing everything in a single binary step. The Python side comes from fonttools, which is a prerequisite rather than a bundled dependency.

Installing operator-mono-lig and building your first font

Prerequisites are the original Operator Mono font, Python (v2.7+), Node.js, and fonttools. On macOS the README warns that the default system Python 2.7 does not work and you should install Python 3; fonttools is then installed with `pip3`. On Windows and Linux the instruction is `pip install fonttools`, and on Linux under WSL or WSL2 you may need to confirm fonttools is on PATH or install it through `sudo apt install fonttools`.

pip install fonttools

Clone the repository or download the latest release and unzip it. Copy your Operator Mono OpenType files into the `original` folder. Filenames must not include spaces, so `OperatorMonoSSm-Book.otf` is fine and `Operator Mono SSm Book.otf` is not. Then install dependencies and run the platform build script.

npm install

# Windows
build

# Linux/Mac
./build.sh

The new font files land in the `build` folder. Install them on your system, then point your editor at the generated family. The README gives this VS Code example, including the Windows variant and a weight hint.

  "editor.fontFamily": "OperatorMonoSSmLig-Book",
  "editor.fontLigatures": true,
  // for Windows
  "editor.fontFamily": "Operator Mono SSm Lig",
  "editor.fontLigatures": true,
  "editor.fontWeight": "500",   // adjust for desired weight

If you would rather not install Python, Node and fonttools yourself, the README links an executable Docker image maintained at drod3763/kiliman-operator-mono-lig-docker. You clone that repository, copy your OpenType files into its `input` folder, and run the compose service.

docker-compose run --rm operator-mono-lig

Customising ligatures with profiles.ini

By default every available ligature is added. A `profiles.ini` file in the `./original` folder changes that. Each profile is a section, the first should be named default, and the profile name is appended to the generated family, so a `[Go]` section produces a font named Operator Mono Lig Go. That lets you keep one build for a language whose operators you dislike as ligatures and another for everything else.

# name of profile (one or more sections, first should be name default)
[default]
# glyph=altglyph
greater_equal.liga=greater

The directive form is `glyph=altglyph`, so the example substitutes the plain `greater` glyph for the `greater_equal.liga` ligature. The README says you can also prevent a ligature from being added, though the snippet it shows only demonstrates the substitution case. If you need the removal syntax specifically, the README is the place to check, because it is not spelled out in the excerpt above.

Weights, italics and the maintenance gap

This is where the project gets uncomfortable. Version 2 shipped ligatures for a fixed list: Operator Mono SSm Light and Light Italic, SSm Book and Book Italic, SSm Medium and Medium Italic, SSm Bold and Bold Italic, plus Operator Mono Light and Light Italic, and Operator Mono Book and Book Italic. The README says plainly that v2 does not include all weights, that updating the other fonts means redoing all the ligatures, and that the author does not have time for it right now. There is a help-wanted note offering to buy a Glyphs Mini licence for a Mac user willing to do the work.

That is a real constraint, not a footnote. If your editor is set to Operator Mono SSm Bold Italic you are covered; if you use a weight outside the list, you are not. The README also runs a poll asking which weight people use, which is a signal that prioritisation is still open rather than settled.

The last push to the repository was on 2026-04-02, and the most recent tagged release is v2.5.2 from 2024-03-20. v2.5.1 removed a canvas dependency that caused issues, and v2.5.0 added new ligatures. The gap between the last push and the last release suggests small maintenance rather than active feature work. Note also that `package.json` declares the licence as ISC while the repository metadata says MIT, and the `test` script is a stub that exits with an error. There is no automated test suite to lean on.

Alternatives and when to skip this

The obvious alternative is Fira Code itself, which is free, ships ligatures as its default behaviour, and has no licence prerequisite. The difference in approach is that Fira Code is a font you install; operator-mono-lig is a patcher that modifies a font you already own. If you have no attachment to Operator Mono's italic letterforms, Fira Code removes an entire class of setup problems: no Python, no fonttools, no filename rules, no weight matrix.

A second option is a Nerd Font patched build, which people search for under names like operator mono lig nerd font. That is a different goal: Nerd Fonts add icon glyphs for terminal prompts and file trees, not programming ligatures. The README here does not describe Nerd Font patching, so do not expect those icons from this build.

Skip operator-mono-lig if you need a free font, if you cannot supply the original OpenType files, or if you rely on a weight outside the published list. Also skip it if you want a maintained upstream with a release cadence you can plan around; the README's own help-wanted section is the clearest statement about where the project's capacity sits.

Licence and upgrade cost

Two licences are in play and they are separate. The Operator Mono typeface is commercial, sold by Typography.com, and the README states you must have the original font files. Nothing in this repository grants you rights to the typeface. The tooling itself is permissively licensed, though the repository metadata says MIT while `package.json` says ISC, so if you need certainty about the tooling licence, read the LICENSE file rather than either field. This is not legal advice; check the terms that came with your Operator Mono purchase before distributing anything you build.

Upgrade cost is low in the ordinary case. Pull the repository, drop your files into `original` again, rerun the build script, and reinstall the output. Your `profiles.ini` lives in `original`, so it survives a code update as long as you keep that folder. The cost that does not go away is the weight gap: a new Operator Mono weight will not produce a matching ligature font until someone redraws the glyphs, and the README does not promise a timeline for that.

Editorial conclusion

Adopt operator-mono-lig if you already own an Operator Mono licence and want ligatures without switching typefaces. Skip it if you need every weight, if you do not have the original .otf files, or if you want a free font, because the README is explicit that Operator Mono is not free and this tool only merges ligature definitions into a copy of it. Before building, check that your filenames have no spaces, that the weights you use appear in the supported list, and that Python 3 is the interpreter on your PATH on macOS.

Frequently asked questions

Official sources

1. Issues
2. kiliman/operator-mono-lig on GitHub
3. License: MIT
4. README
5. Releases