Begin with a vertical line, a stem. The plane around it divides into four quadrants: top-right, top-left, bottom-right, bottom-left. In each quadrant five primitive strokes are available: two horizontals, one diagonal, one anti-diagonal, and one outer rail. A Cistercian numeral is a selection of these strokes: one decimal digit per quadrant, four digits per stem, every integer from $0$ to $9{,}999$ expressible as a single glyph.

The historical system—call it medieval—assigns each digit $d \in \{0,\dots,9\}$ a fixed stroke pattern. The assignments are conventional: $1$ is a horizontal at the top of the stem, $2$ a horizontal further down, $3$ a diagonal connecting their endpoints. The ten shapes follow no compositional rule, they must be learned by rote. But the encoding is effective. Write a numeral as a 4-tuple $(a_0, a_1, a_2, a_3)$, one digit per quadrant, and the code is the Cartesian product

Cycling each digit to the next quadrant is the action of $C_4 = \langle \sigma \rangle$ on coordinates:

Everything above is notation—a way to write integers. What follows is a separate question: can these glyphs also measure time?

Ten thousand glyphs is already enough for a clock. Map each day onto the full code space, cycling through every glyph exactly once before resetting at midnight:

At midnight the glyph is a bare stem ($0$), and it accumulates strokes through $9{,}999$ before resetting. The progress bar visualizes each interval as it elapses. Let $S = 86{,}400$ and $N = 10{,}000$. The duration of one interval follows from the Euclidean division

which yields

Each interval lasts $q + r/N = 8.64$ seconds. The progress bar encodes this directly: one short segment of $0.64\,\text{s}$ (with proportional width $r/N$ of a full segment), followed by $q = 8$ full segments of $1\,\text{s}$ each.

The clock works, but the numeral system beneath it is opaque: you cannot read the time without memorizing all ten stroke patterns. This prompts two structural modifications, each pulling in a different direction.

The compact variant discards the outer rail, leaving four primitives per quadrant. Since $2^4 = 16 > 10$, the ten digits still fit as subsets of these four strokes, and glyphs become visually lighter. But the mapping from digit to subset remains conventional, no more compositional than the medieval original:

The combinatorial variant moves in the opposite direction. It retains all five primitives and treats each as an independent binary feature. A quadrant's state is a $5$-bit mask, the glyph is the union of active strokes. No lookup table is needed; the binary representation is the visual. This restores full compositionality but expands the code space dramatically:

The compact variant is economical, the combinatorial variant is principled.

The goal is a modern, human-readable clock: hours, minutes, and seconds visible at a glance, with every stroke remaining a single toggleable bit. Instead of dividing the day into $10^4$ abstract intervals, we factor its seconds into a mixed-radix product

and assign each factor to a quadrant: hours ($0$–$23$), low minutes ($0$–$29$), low seconds ($0$–$29$), and a two-bit flag $f = 2m_1 + s_1$ combining the upper halves of minutes and seconds.

Within each quadrant the value is written as a binary mask over the five primitive strokes: the combinatorial variant's compositional grammar, restricted to only the states the factor requires. The result reads as a conventional clock (each quadrant carries a human-legible time component) while every stroke remains an independently toggleable bit. No digit alphabet needs to be memorized, the glyph is fully determined by the time.

Two semantics were considered. A plain binary count:

And a “growing” cycle:

The binary count wins: each stroke carries a fixed weight, and reading a quadrant is simple addition. The growing cycle looks more deliberate but requires internalizing a sequence rather than five positional values. With this choice the four quadrants are:

We see that the clock is realizable in unicode:

Because each quadrant maps to a familiar time unit, the glyph is readable after minimal training; hours and minutes separate visually the same way they separate conceptually, and the full state (hour, minute, second, half-minute flag) compresses into a single 19-bit stem:

Each of the five stroke positions carries a fixed binary weight: $1, 2, 4, 8, 16 + 30;$ and the displayed value is their sum. The flag quadrant works at smaller scale: its two strokes act as independent half-indicators, one for seconds, one for minutes. If you only care about hour and minute, one flag stroke tells you whether minutes are in the lower or upper half.

A standalone version is available. Clicking anywhere on the page toggles between two layouts. .html