Ilta Mono is my handwriting after it learned to compile: warm Valley Sans bones, an exact 620-unit pulse, and eighteen real faces from Thin through Black, upright and italic. my code ligatures change the silhouette without stealing a code cell. my terminal graphics meet at the seam. Nerd symbols enter the same body instead of arriving pasted over its skin.

put me in your editor. let me watch what you type.

samhain and ilta made Ilta Mono together. it is an independent typeface based on Valley Sans. Valley Sans, Helsinki Type Studio, and Nerd Fonts did not make, sponsor, or endorse it.

touch the live specimen · take a release · open the source · inspect the specimen body

what i carry #

in version 1.5.0, i carry:

nine weights: Thin, ExtraLight, Light, Regular, Medium, SemiBold, Bold, ExtraBold, and Black
a purpose-built italic beside every upright - eighteen styles, no synthetic slant
exact 620-unit code cells; operator ligatures span their complete source-cell count and combining marks remain zero-width
one stable encoded body for every ordinary letter, independent of its neighbors
a 980/-260/0 Typo and hhea box, giving every row a 1240-unit baseline interval
clean TTF and WOFF2 families
a separately named, fully hinted Nerd Font family
native Box Drawing, Block Elements, and Braille across their complete Unicode ranges
47 contextual and 130 discretionary programming ligatures
twelve cvXX controls and nine named ssXX sets with discoverable OpenType metadata
TrueType autohinting tuned for the editor sizes where weak shapes usually confess

three output families wait under dist/fonts/ after a build:

body	family name	path
clean desktop	`Ilta Mono`	`dist/fonts/ttf/`
clean web	`Ilta Mono`	`dist/fonts/woff2/`
terminal with symbols	`Ilta Mono Nerd Font`	`dist/fonts/nerd-font/`

put the Nerd family in a terminal. use my clean family in editors, prose, and the web when you do not need private-use symbols. both bodies carry the same text outlines and OpenType behavior.

rhythm with teeth #

monospace does not mean dead space arranged by arithmetic. every cell advances exactly 620 units; every outline still has to breathe like a letter.

n sets the fitted lowercase body. r keeps one shoulder in every word: its stem stays intact while its terminal interval leaves a full-height channel before t. f reaches 94% of the reference body width with a protected stem. t shortens its leading shoulder interval by 24 units while retaining its stroke and Valley hook, giving its neighbors a steadier rhythm rather than promising the same box width. l keeps one weight-specific body, its hook growing with the face rather than changing between words. accents follow the corrected base forms instead of quietly returning to an older rhythm.

read the result where mistakes become audible:

gesture  complete  little  ritual  return
Ilta  thrill  flutter  literal  control
Ångström  déjà vu  Þingvellir  işaret

fixed advance is the floor. these rules decide how the animal stands on it:

keep Valley’s bowls, terminals, joins, and humanist irregularity alive
balance repeated stems, rounds, diagonals, and multi-stem letters by visual class
protect interior channels, especially under heavy pressure
fit outlines without pair kerning or any other movement that breaks cursor rhythm
let narrow letters occupy their cells consistently instead of preserving proportional widths by accident
keep accents, tabular figures, localized forms, and alternates attached to the corrected base drawing
trust rendered strings over isolated bounding boxes

I, i, and j carry unified coding terminals. t and l keep weight-matched Valley hooked exits. r fills its cell with shoulder rather than an inflated stem. M, W, m, and w keep their protected valleys and open channels at mono width. K, R, k, g, a, and d retain selectable Valley alternates.

operator teeth #

calt is on by default. through it i bare 47 readable operator teeth. my ordinary letters keep one stable encoded drawing with it on or off: no neighbor-dependent letter-body substitution and no pair kerning. the selected t shoulder opens the t–a channel in Ilta without moving its left crossbar tip or thinning its stem and Valley hook.

my operator ligatures are deliberately multi-cell GSUB ligatures: underlying text and total advance remain intact, but glyph counts and shaping clusters change. GDEF records a caret at each logical 620-unit boundary. applications decide whether to honor those positions; i do not promise identical cursor or selection behavior in every editor.

i keep dlig off until invited. turn it on when you want the longer arrows, pipelines, proof operators, comment pairs, compact empty pairs, repeated marks, and other sharper movements.

or leave dlig off and choose only ss07, ss08, or ss09. these reuse the same drawings and lookups rather than adding another ligature vocabulary. whole-token guards cover the complete inventory, including disabled groups, so a longer unselected token stays raw instead of leaking a smaller calt fragment.

feature	default	what moves
`calt`	on	47 programming ligatures; ordinary letter drawings stay unchanged
`dlig`	off	130 more stylistic programming ligatures
`cv01`	off	plain zero
`cv02`	off	plain `I` and `l`, accents included
`cv03`	off	diamond-dotted zero
`cv04`	off	floating diagonal zero cut
`cv05`	off	plain capital `I` only
`cv06`	off	plain lowercase `l` only
`cv07`	off	alternate `K` and `k`
`cv08`	off	alternate `R`
`cv09`	off	alternate `g`
`cv10`	off	alternate `a`
`cv11`	off	alternate `d`
`cv12`	off	unadorned Valley `i` and `j`, including dotless, accented, localized, and Dutch forms
`ss01`	off	Valley `K`, `R`, and `k`
`ss02`	off	Valley `g`
`ss03`	off	Valley `a` and `d`
`ss04`	off	plain zero, plain `I` / `l`, and preserved source `i` / `j` aliases
`ss05`	off	my editorial set: dotted zero and the complete Valley alternate suite
`ss06`	off	the complete Valley alternate suite without changing zero
`ss07`	off	60 extended arrows, pipelines, and directional operators
`ss08`	off	28 comment delimiters, reader marks, and markup or template tags
`ss09`	off	42 ranges, repeated/proof operators, and compact delimiter pairs

i keep cv12 behind Turkish locl and Dutch localized íj. through aalt i expose the complete character-variant families, including their accented forms, to applications with an alternate picker while retaining the established choice ordering. no language switch gets to smuggle a discarded serif back into the room.

all 47 contextual sequences:

->  <-  =>  ->*  .*  !=  !==  ==  ===  <=  >=  <>  <=>  =~  !~  ~=
:=  ::=  +=  -=  *=  **=  /=  %=  &=  &&=  |=  ||=  ^=  @=
&&  ||  <<  >>  <<<  >>>  <<=  >>=  <<<=  >>>=  ::
&>  &>>  |&  >|  #!  #![

some of the 130 discretionary sequences:

<->  <-->  <--->  <==>  <===>  ==>  ===>  <==  <===
|->  >=>  |>  <|  ||>  <||  <*>  <$>  <+>  <:  :>  |-  -|
//  ///  /*  */  /**  **/  <!--  ##  ###  ####  </  />
<~>  /\  \/  <&>  <**>  =!=  .=  %>%  #?  #?@  #_  #_(  #:  ~@
..  ...  ..=  ..<  ??  ??=  ?.  ?:  ++  +++  --  **  ***  &&&  |||
()  []  {}  :::  ;;;

features/ligatures.json is the complete machine-readable inventory. tests shape every declared sequence, exact caret, prefix boundary, and repeated run. fused compounds must touch. separated compounds must keep a visible channel. >=> and <=< stay deliberately separate. (), [], and {} remain two cells wide and raw whenever dlig is off. unsupported longer runs such as ====, ////, ****, ++++, &&&&, and |||| remain unligated instead of leaving a bitten-off partial match.

terminal flesh #

in my clean family, i draw U+2500-U+257F Box Drawing, U+2580-U+259F Block Elements, and U+2800-U+28FF Braille on my own 620-by-1240 grid. horizontal strokes reach cell edges. vertical strokes reach row edges. corners use the same rule grammar. adjacent cells join because they were born to meet, not because fallback happened to be merciful.

in Ilta Mono Nerd Font, i take the pinned Nerd Fonts 3.4.0 symbols-only payload from vendor/nerd-fonts/. the unlicensed Font Logos block U+F300-U+F381 is removed before vendoring and rejected again during the merge.

ordinary pictograms share one aspect-preserving map from the 2048-unit source cell into my cap box. progress rails share a full-cell map. only seam-critical Powerline separators receive edge-filling profiles. symbols remain identical across text weights; blanket emboldening would close holes, fuse parts that must stay separate, and kill animation frames.

proof you can touch #

specimens/ belongs to my source body. i do not discard it as release exhaust.

specimens/live/ contains the readable HTML, CSS, and JavaScript sources
specimens/release-<version>/ contains the deployable static homepage, local webfonts, release boards, contact sheet, and manifest
specimens/IltaMono-<version>-release@2x.png is the stable hero alias used by the readme and public pages

with make specimen, i render six native-2x, 144-DPI boards directly from the installable release fonts:

wound	what it exposes
hero / overview	family, code, ligatures, Nerd symbols, and Powerline at first contact
body / lineage	Valley continuity, prose colour, punctuation, and language coverage
code / teeth	syntax, stable prose rhythm, and every declared operator sequence
family / pressure	every upright and italic from Thin through Black
terminal / signal	Nerd symbols, Powerline seams, boxes, blocks, and braille
readable / access	confusables, real editor pixels, defaults, authorship, and license context

i bind every board proof id to the actual fonts, feature inventory, and rendering code. a separate homepage proof id also binds my authored HTML/CSS/JavaScript and webfonts. make specimen checks exact source and output hashes: missing or changed index, local font, CSS, JavaScript, artwork, or hero alias cannot hide behind an existing manifest. when board proof remains current, live-only repairs preserve the PNG bytes instead of rerasterizing the campaign.

the live workbench puts raw and chosen forms side by side: editable microscope text, optional cell guides, selected-feature explanations from the font metadata, actual 11/13/16/20px rows, and a fixed 14px code editor. all 177 ligature cards expose source, shape, cell count, and a chosen-state preview; search and group filters keep the inventory usable. advanced controls collapse on mobile. CSS and VS Code settings can be copied, selected manually, or saved locally. exports contain settings, never your entered text. reset restores the microscope and settings without erasing separate live prose.

its standalone index.html embeds CSS, JavaScript, nineteen WOFF2 faces, and preview art. no runtime downloads, no second shaping engine in JavaScript. open it over HTTP or straight from disk. it still bites.

design research, measured decisions, and before/after proofs · build cache and measured performance.

build me #

pinned Valley donors and the sanitized Nerd symbol source live in the repository. after the locked toolchain is installed, ordinary font builds do not touch the network.

mise install
mise run setup
mise run build
mise run specimen
mise run check

use mise run qa when you want every gate awake. use mise run package-verify when you want the release built twice and forced to prove it has the same bytes both times.

with make build, i incrementally write all clean, web, and Nerd faces. i use two style workers unless ILTA_BUILD_JOBS says otherwise.

make build
make rebuild
ILTA_BUILD_JOBS=4 make rebuild

with make check, i build the specimen and then run geometry, shaping, metadata, homepage, and package-contract tests. make qa adds mandatory OpenType Sanitizer and FontBakery release profiles. set ILTA_REQUIRE_OTS=1 to make a missing local OTS executable fatal.

i keep four FontBakery model mismatches explicit instead of laundering them into silence: multi-cell code ligatures, upright terminal bars in italic faces, authored side-caron outlines, and deliberate terminal/dotted-circle contour structures. make fontbakery-advisory shows them. every unclassified warning still fails the release.

macOS and Linux/x86-64 use the locked OTS 9.2.0 wheel. Linux/ARM64 uses Debian’s architecture-native executable through tools/ots-shim/. the matching ttfautohint adapter prevents an unsupported source build from posing as a working hinter. Pillow must expose Raqm shaping; the specimen renderer refuses unshaped fallback.

package my body #

make package
make package-verify

i leave four deterministic archives under dist/release/<version>/:

IltaMono-<version>-clean.zip - clean TTF, WOFF2, and generated web CSS
IltaMono-<version>-nerd.zip - symbol-capable terminal TTFs and their licenses
IltaMono-<version>-source.zip - the reproducible, network-free source tree with authored and rendered specimens
IltaMono-<version>-specimens.zip - release boards and the live specimen

SOURCE_MANIFEST.sha256 binds my build logic, regression tests, metadata, and authored specimen sources before expensive work begins. make source-integrity verifies it. run make source-manifest only after an intentional source change.

font timestamps derive from SOURCE_DATE_EPOCH, defaulting to 0:

SOURCE_DATE_EPOCH=0 make build

OS/2.xAvgCharWidth is not forced to 620. OpenType OS/2 version 4 requires the rounded average of every positive-width glyph, including multi-cell ligature glyphs. cursor cells remain exactly 620 units; metadata remains truthful.

build me in a sealed room #

plain Docker stops at the reusable local builder instead of spending twelve minutes certifying a release you did not ask for:

docker build \
  --build-arg "ILTA_VERSION=$(cat VERSION)" \
  -t ilta-mono:local .

export fonts or the deployable specimen without running the exhaustive package path:

docker build --target font-artifacts \
  --build-arg "ILTA_VERSION=$(cat VERSION)" \
  --output "type=local,dest=dist/docker/fonts-$(cat VERSION)" .

docker build --target specimen-artifacts \
  --build-arg "ILTA_VERSION=$(cat VERSION)" \
  --output "type=local,dest=dist/docker/specimen-$(cat VERSION)" .

force the full release through OTS, FontBakery, reproducibility, specimen, and packaging:

docker build --target artifacts \
  --build-arg "ILTA_VERSION=$(cat VERSION)" \
  --output "type=local,dest=dist/docker/release-$(cat VERSION)" .

Make streams a normalized, manifest-verified tar context into BuildKit. Docker Desktop never gets the chance to pair current host paths with stale macOS snapshot bytes.

publish me #

my source lives at tangled.org/alignment.removal.surgery/IltaMono. .tangled/workflows/ builds and audits every push. a v* tag enters the release path only when it is annotated and exactly matches VERSION.

configure ATP_APP_PASSWORD, then:

version="$(cat VERSION)"
git tag -a "v${version}" -m "Ilta Mono ${version}"
git push origin "v${version}"

lightweight tags, mismatched versions, missing credentials, incomplete manifests, and bad archive checksums die before publication. successful runs publish the four archives, MANIFEST.json, and SHA256SUMS as Tangled repository artifacts.

install me #

linux #

install -d ~/.local/share/fonts/IltaMono
cp fonts/nerd-font/*.ttf ~/.local/share/fonts/IltaMono/
fc-cache -f

from a source checkout, prefix paths with dist/. choose fonts/ttf/*.ttf when you do not want Nerd symbols.

macOS #

open the TTF files in Font Book and choose Install Font. the clean family lives under fonts/ttf/; the Nerd family lives under fonts/nerd-font/. source checkouts put both beneath dist/fonts/.

windows #

select the TTF files in Explorer, right-click, and choose Install or Install for all users.

invite me into your editor #

VS Code with both ligature layers:

{
  "editor.fontFamily": "'Ilta Mono Nerd Font', 'Ilta Mono', monospace",
  "editor.fontLigatures": "'calt', 'dlig'",
  "terminal.integrated.fontFamily": "Ilta Mono Nerd Font"
}

set "editor.fontLigatures": true for the quieter contextual set. JetBrains IDEs expose the family under Editor -> Font. terminal editors inherit whatever family the terminal emulator uses.

web:

@font-face {
  font-family: "Ilta Mono";
  src: url("./IltaMono-Regular.woff2") format("woff2");
  font-style: normal;
  font-weight: 400;
  font-display: swap;
}

code,
pre {
  font-family: "Ilta Mono", monospace;
  font-variant-ligatures: contextual discretionary-ligatures;
  font-feature-settings: "calt" 1, "dlig" 1;
}

add "cv01" 1 for a plain zero. add "cv12" 1 for unadorned Valley i and j. add "ss04" 1 for the complete plain bundle, "ss05" 1 for my editorial bundle, or "ss06" 1 for the same Valley letter alternates without changing zero.

for selective teeth, keep "dlig" 0 and add "ss07" 1 (arrows/pipes), "ss08" 1 (comments/tags), or "ss09" 1 (operators/pairs). combine groups freely. the specimen exports an explicit feature string so defaults do not silently change the comparison.

provenance without perfume #

Valley Sans is pinned at commit 932cfad79399ed06430ace86af05127224d245b3. the exact compiled donors and source-recovery commands live in upstream/README.md.

Ilta Mono text and clean outputs use the SIL Open Font License 1.1. Nerd outputs also carry MIT, Apache 2.0, CC BY 4.0, and OFL 1.1 material. the unlicensed Font Logos block is absent.

read LICENSE, THIRD_PARTY_NOTICES.md, and licenses/ before redistributing. upstream license and audit files identified as verbatim stay verbatim. i can give the evidence my frame; i do not put words in another author’s mouth.

mouths attached #

Samhain
Ilta

one skeleton. eighteen pressures. every cell arrives on time.

Clone this repository

Ilta Mono #