In the scriptorium of a Benedictine monastery, some time in the ninth century, a monk unrolled a length of parchment and began at the top. He recorded what had happened. Then the year turned, and he moved down. Then the year turned again. The record grew downward, season by season, reign by reign, in a single unbroken column of time.
This was the chronicle form. It was not invented by any one person. It emerged independently across literate cultures because it reflected something true about how time actually works. It begins. It continues. It accumulates, always downward, always in sequence, with no gaps permitted and no reordering allowed.
We have been making vertical timelines for over a thousand years. When a developer runs git log, the output is a vertical column, newest at the top, oldest receding below. Stack traces read from top to bottom. Changelogs list releases in descending order. The vertical sequence is not a convention developers happen to tolerate; it is the native shape of code work: one thing follows another, in order, without rearrangement. The Chronicle layout in Codex Stellarum is the latest version of the same idea.
THE OLDEST INFORMATION DESIGN
In 1765, the English chemist and polymath Joseph Priestley published something that had never existed before: a visual representation of history. His "Chart of Biography" plotted 2,000 years of lives along a single horizontal band, each person rendered as a line whose length corresponded to their lifespan. Time moved left to right. Density of lines signalled density of intellectual activity. The shape of human knowledge became visible at a glance.
Priestley called it a "rational amusement." His contemporaries called it revolutionary. Within a decade, the idea of mapping time visually had spread across Europe.
But Priestley was building on a tradition that stretched back centuries. The Anglo-Saxon Chronicle, begun under Alfred the Great in the ninth century, is one of the oldest continuous historical records in the English language. It moves in a single direction: forward. Year follows year in strict sequence, with no retroactive reorganisation and no attempt to group events thematically. The form itself makes a claim about time: it moves in one direction only, and the record must follow.
In 1871, the American cartographer Sebastian Adams published his Synchronological Chart of Universal History, a twenty-three-foot continuous scroll mapping the whole of human civilisation from Eden to the present day. Scholars could unroll it, trace a dynasty from birth to collapse, and place it alongside every other dynasty unfolding in the same years. The scroll made time tangible. You could hold two centuries in your hands.
All of these objects share a single structural decision: time runs in one axis, from the earliest point to the most recent, without interruption. Developers make this same decision every time they write a commit message. The log is the record. It only runs forward.
GEOLOGICAL TIME
There is a reason geologists use the vertical column as the primary model for deep time. The layer at the bottom came first. The layer at the top came last. The sequence is not a convention; it is a physical fact.
Sedimentary rock records history the way the monastic chronicles recorded it: continuously, without selection, in strict order of occurrence. Every year deposits its layer. Dry years leave thin bands. Flood years leave thick ones. A volcanic eruption leaves a grey seam that can be identified at sites thousands of miles apart. The record is honest because it cannot be otherwise. The top is now. The bottom is the beginning. Everything in between is exactly where it belongs.
The Chronicle layout applies this principle to GitHub contribution data. Each year occupies a horizontal band. Weeks run left to right within that band. Bands stack from oldest at the top to most recent at the bottom. Contribution density determines star brightness. The result is a layered record, read from past to present, in which nothing is hidden and nothing is reordered.
Every quiet week is visible. Every burst of activity forms its own bright stratum. Read downward through the bands, and the strata of a coding career resolve into something unmistakable: the intense pre-launch week, bright and dense; the refactoring quarter, steady and even; the gap when you changed jobs and barely touched a keyboard. A side project appears as scattered bright spots that never consolidated into a sustained band. Open-source contributions surface as irregular flares around a library release or a conference talk, then fade again. The shape of a working life, read downward, accumulates into something that looks very much like geology.
THE HONEST LAYOUT
Some layouts summarise. The GitHub contribution grid, for instance, arranges the full year as a compact rectangle. It is readable at a glance, which is useful, but the glance is what you get. Individual weeks blur into colour. The shape of the year resolves into a general impression of activity or inactivity, and the fine-grained rhythm of how the work actually unfolded is lost to compression.
The Chronicle layout does not compress. Every week occupies the same amount of space, regardless of what happened in it. A week with no commits sits in the record at the same visual weight as a week with fifty. This is what makes it the most honest of the available layouts. It hides nothing, because its structure prevents hiding. The gaps are fully visible. The dry spells are fully rendered. The record is complete.
This will feel familiar to developers who care about their craft. The same instinct that keeps a git history clean, that writes a thorough changelog, that documents a breaking change rather than quietly shipping it, finds the Chronicle legible rather than exposing. Transparency in a codebase and transparency in a timeline come from the same disposition: a preference for the complete record over the curated summary.
This is not always comfortable. Seeing a vertical timeline of your contributions means seeing everything, in sequence, from the year you began. The long quiet after a project ended. The erratic rhythm of a year when other things were consuming your attention. The three-week stretch where a single pull request sat in review and the rest of the work stalled around it. The moment when output picked up again and held.
Developers who choose the Chronicle tend to want exactly this. They are not looking for a flattering summary. They are looking for a narrative: a story of how their practice has developed over time, told in the only way a story can be told: beginning, middle, now.
NARRATIVE IN ONE AXIS
Cognitive scientists distinguish between two modes of understanding: categorical and narrative. Categorical understanding groups things by type and compares across dimensions. Narrative understanding places events in sequence and derives meaning from the order of things, from what came before and what followed.
Humans are constitutively narrative creatures. A sequence of events becomes a story almost automatically. We supply causation, detect turning points, anticipate resolution.
The vertical timeline activates this directly. Reading downward through the Chronicle, the eye follows the same path it follows when reading text: from the established past toward the unresolved present. A dense cluster reads as a chapter. A long gap reads as a pause. A change in rhythm reads as a transition. The year you learned a new language shows up as a different texture: commits concentrated in exploratory repositories, sparser in production work, then gradually normalising as fluency arrived. The period of deep maintenance work has its own signature: steady, even, unspectacular bands that indicate a codebase being held together rather than extended.
The star rendering reinforces this. Bright stars and dark voids form a landscape with features: peaks and valleys, the bright streak of an intensive period, the dark quiet that followed it. The brain reaches for the same pattern-recognition machinery it uses for reading text and for reading the night sky. The result feels less like a chart and more like a record: less like analysis and more like memory.
READING YOUR OWN CHRONICLE
When you see your contributions rendered in Chronicle form for the first time, the experience is usually one of recognition rather than discovery. The data is not new. You lived through all of it. But the vertical sequence places the familiar material in a context that makes its structure legible in a new way.
The thin years and the thick ones. The period when commits came every single day. The gap that lasted longer than you remembered. The slow return to momentum, and then the steady output that followed, year by layer by year. The open-source project that briefly lit up a whole band, then receded into a faint scatter as the community took over. The side project that quietly died: a bright cluster followed by nothing, not abandoned in haste but simply outcompeted by the next thing.
Sebastian Adams unrolled his twenty-three-foot scroll and saw the whole of human history at once. The Chronicle layout in Codex Stellarum offers something smaller but more personal: the whole of your own working history, in sequence, from the first contribution to the most recent, rendered as a single column of light and dark.
The oldest information design still works because time has not changed its direction.
Your Chronicle is waiting. Enter your GitHub username at codexstellarum.com to preview your atlas - free to try, prints from £25.