Begin with a vertical 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. Still, 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 one 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; it is 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 = 2s_1 + m_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 stroke semantics were considered. A plain binary count:

And a growing cycle:

The binary count is clearer: 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:

The clock can also be sketched 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 full quadrant uses five stroke positions with fixed binary weights $1, 2, 4, 8, 16$; 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 that page toggles between two layouts. .html