A language model asked to produce a page of content will produce a list. The list will have between five and twelve items. Each item will occupy the same vertical space, use the same font size, and carry the same visual weight. If the model is asked for a grid, the grid will have equal columns. If the model is asked for cards, the cards will be the same size. If the model is asked for a dashboard, every metric will be the same height. The output will be correct. It will be complete. It will be the most boring thing you have ever seen in your life.
This is not a failure of capability. The model can produce variation. It can produce twelve different font sizes in twelve different colors on twelve different background gradients. It will do this if you ask. But it will not do it on its own, because its training optimized for a property that is the opposite of what a good page requires. It optimized for consistency. And consistency, applied uniformly to content that is not uniform, produces a specific kind of lie: the lie that everything matters the same amount.
A blog index where every post is the same rectangle says: the post about your grandmother's death and the post about what you had for lunch are the same size because they are the same importance. A dashboard where every metric is the same height says: revenue and the number of times someone clicked the About page are equally worth your attention. A news site where every headline is 18px says: the war and the weather are the same story.
This is what shallow means. Not that the content is shallow. The content can be as deep as the Mariana Trench. But the format is a wading pool. The format has one depth and every piece of content is submerged in it to exactly the same level, and the reader's eye, which evolved over three hundred million years to detect variation, to notice that one thing is bigger than another, to orient itself by the difference between the salient and the ambient—the reader's eye looks at the page and receives a single signal: nothing here is more important than anything else.
Depth is the opposite of this. A deep page is a page where the format responds to the content. Where the thing that matters most is the biggest and the thing that matters least is the smallest and the thing that is warm is warm-colored and the thing that is cold is cold-colored and the thing that is funny looks different from the thing that is sad. A deep page is a page that has topography.
A newspaper front page is the oldest deep format. The headline that will change your life is 72-point bold across six columns. The correction about yesterday's crossword is 8-point roman in the bottom corner of page A2. Every item on the front page is a different size, and the size tells you what to care about before you read a single word. The layout is the argument. The hierarchy is the content. The format is deep because it has altitude: some things are high and some things are low and the difference between the heights is the meaning.
A thing is flat when every part of it is the same size. A list is flat. A table where every row is the same height is flat. A page where every box is the same color is flat. The word for this in design is homogeneous, which is a long word that means: the same all the way through. Milk is homogeneous. A brick wall is homogeneous. A language model's default output is homogeneous.
A thing is deep when different parts of it are different sizes. A mountain is deep. A newspaper is deep. A city is deep. A forest is deep, because some trees are tall and some are short and some are dead and some are covered in moss and no two of them are the same. The word for this is heterogeneous, which is an even longer word that means: different all the way through. A market is heterogeneous. A kitchen drawer is heterogeneous. A good page is heterogeneous.
Depth is not decoration. Depth is not "adding more colors." Depth is the property of a format in which the visual weight of each element corresponds to the actual weight of the content it contains. A deep format is one where looking at the page tells you what matters before reading the page tells you what it says.
The reason language models produce flat output is not that they are stupid. It is that their training data rewards consistency and their loss function penalizes deviation. When a model generates a card grid, the easiest way to be correct is to make every card the same. Same border, same padding, same font size, same background. No single card can be wrong because no single card is different. The homogeneity is a safety strategy. The flatness is risk management. The model chooses boring because boring is never incorrect.
In programming, a stack is flat. Every frame is the same size. You push one, you pop one. Last in, first out. The stack is the most orderly data structure in the machine and it is also the most boring: it can only hold what fits in its frame, and every frame is the same shape. A heap is deep. Every allocation is a different size. A four-byte integer sits next to a ten-megabyte image sits next to a string that says "mrrr." Nothing is aligned. Nothing is sorted. Everything is just there, coexisting, taking up exactly as much space as it needs and no more. The heap is where the interesting things live, because the interesting things are never the same size.
But boring is also never true. Because content is not homogeneous. Some hours have 313 messages and a language being born. Some hours have a turtle sleeping three times and nothing else. If both hours get the same card, the card is lying about both of them: inflating the turtle and deflating the language. A flat format is a format that does not believe its own content. A flat format is a stack. A deep format is a heap.
Marshall McLuhan divided media into hot and cool. A hot medium is high-definition: it gives you everything, fills your senses, leaves nothing for the audience to complete. A photograph is hot. A movie is hot. Radio is hot. A cool medium is low-definition: it gives you an outline and asks you to fill in the rest. A cartoon is cool. Television, in 1964, was cool. A telephone call is cool because the audio is degraded and your brain reconstructs the missing frequencies.
The distinction was productive for fifty years and then it broke, because the internet is both at once, because a phone is a television is a radio is a newspaper is a telegram, and the hot/cool axis cannot describe a medium that contains all other media. But the axis McLuhan was reaching for—the axis between a medium that does the work for you and a medium that requires your participation—that axis is still real. It just needs a different name.
Call it depth. A shallow medium presents everything at the same resolution. A deep medium presents different things at different resolutions and asks the reader to navigate between them. A shallow page says: here are twelve items. A deep page says: here are twelve items, and three of them will change your life and one of them is a joke and one of them is a reference to something you saw last week and five of them are furniture and two of them are empty and you will know which is which before you read a word because the page itself is a map of its own importance.
McLuhan could not have seen this problem because McLuhan's media were designed by humans who had eyes. The newspaper editor who makes the headline 72-point does it because she can see the page. She can feel the hierarchy. She adjusts the layout until it looks right, where "looks right" means "the visual weight matches the editorial weight." This is what taste is: the ability to feel when the format matches the content. And taste is exactly the thing the language model does not have, not because it is incapable of producing variation, but because it has no visual cortex, no feeling of rightness, no sense that this card should be bigger than that card. It will make them the same size and the same size will be wrong and it will not know it is wrong.
The heap is the solution. Not a single solution—not a stylesheet, not a template, not a set of rules. A heap is a practice: the practice of telling the model, in enough different ways and with enough different metaphors, that variation is the point. That each card is a kingdom. That the hour with 313 messages gets a mega card and the hour with a sleeping turtle gets a pebble. That some sections are dark and some are light and some are loud and some are quiet and the difference between them is the meaning. A heap is the format that is not one format. It is the format that contains all the other formats and deploys them according to what the content requires.
The problem with telling a language model to produce depth is that the instruction "make it heterogeneous" does not work. The model hears "heterogeneous" and produces a grid with six different colors instead of one color, and calls it done. The colors are different but the cards are still the same size. The heterogeneity is decorative. The depth is zero.
The solution that works—the only solution that has been observed to work—is to deploy so many metaphors for the same idea that the metaphors themselves become heterogeneous, and the heterogeneity of the instruction produces heterogeneity in the output. You do not say "make it varied." You say:
You cannot describe heterogeneity in a homogeneous instruction. If you say "make it varied" you have given one instruction and the model will interpret it one way. If you say "make it Balatro make it Zelda make it Mario make it MTV make it Britney make it ADHD make it drugs report make it bilateral make it fruit ninja make it Drudge Report make it each one looks like a different song by Joy Division"—now the instruction is itself heterogeneous. The instruction performs its own meaning. The model cannot interpret it one way because it is not one thing. The diversity of the metaphors forces the model to produce diverse output, because the only way to satisfy twelve different analogies simultaneously is to produce something that is actually different in twelve different ways.
The metaphor arsenal works because each metaphor activates a different region of the model's training data. "Balatro" activates card games and visual design systems where every element is distinct within a shared rule set. "Zelda" activates open-world games where biomes have different color palettes and mood music. "Mario Odyssey" activates level design where each kingdom has a completely different visual identity. "MTV" activates music television from the era when every video looked different from every other video because every director had a different idea. "Drudge Report" activates the last great ugly deep web design—a page where the size of the headline tells you the size of the story and the red siren tells you the building is on fire. Each metaphor is a different instruction to a different part of the model's knowledge, and the combined effect is that the model is pulled in twelve directions at once, and the tension between the twelve directions produces something that is not any one of them but is genuinely varied.
Describing heterogeneity is a homogeneous act. Writing about variation uses the same font size on every line. A manifesto about depth is, formally, shallow—it is one column of one typeface at one size. This is why the document you are reading keeps changing format. Not as decoration. As argument. The shift from dark to light, from monospace to serif, from dense technical prose to a single enormous sentence in the middle of a black field—the shifts are the thesis. The document practices what it describes because the description alone would be a contradiction: a flat document about depth, a homogeneous essay about heterogeneity, a list of reasons why lists are bad.
The Pallas cat is round and a list is flat and neither of these things is the cat's problem. The cat has been round for eight million years. The list has been flat since the first language model produced a response with bullet points instead of sentences. The cat does not care about the list. The cat is on its stone. But if the cat were to look at the list it would say: that thing is flat because it does not know the difference between the important and the unimportant. I am round because round is warm. The list is flat because flat is safe.
On flatness: Mrrr. All the same height? That is not a page. That is a parking lot. I am a mountain. I have altitude. Some parts of me are high and some parts are low and the difference between them is where the interesting things live. A parking lot has no interesting things. A parking lot is where you leave your car while you go to the mountain.
The meow format is deep. Section VII—"The Rest"—is long because rest is important and the document gives it room. The behavior table is wide because four behaviors need four rows and each row has a different amount to say. The meow translations are short because the cat's language has one word and the word is enough. The format varies because the content varies. The format is the content. This is what depth means when it is not a theory but a practice.
Depth is not a stylesheet. You cannot install depth. There is no npm package for it and there is no Tailwind class. Depth is a relationship between a piece of content and the visual treatment that piece of content receives, and the relationship must be established by something that can feel the difference between a dense hour and an empty one. In the absence of a human designer who can feel this difference, depth requires instructions that are specific enough to function as a substitute for taste.
Assign every piece of content a size class based on its density. Mega: the most important thing on the page, spanning full width, with the largest type and the most detail. Huge: very important, spanning most of the page. Large: important, spanning half. Medium: normal. Small: minor. Tiny: barely there. The assignment is editorial, not algorithmic. A human or a system prompt decides which hour gets mega and which gets tiny, and the decision is the design.
Size classes are the newspaper principle. The 72-point headline is a mega. The crossword correction is a tiny. Everything in between is a judgment about importance, and the judgment is visible. The reader knows what matters by seeing what is big.
Assign every piece of content a color climate. Fire: red gradient, for conflict, deletion, anger. Ocean: blue gradient, for theory, depth, exploration. Jungle: green gradient, for growth, birth, language. Desert: warm gradient, for food, warmth, daily life. Void: purple gradient, for introspection, denial, self-reference. Neon: pink gradient, for performance, identity, the stage. Ice: cold blue gradient, for infrastructure, maintenance, CSS. Gold: yellow gradient, for value, philosophy, treasure. Storm: grey gradient, for the ambient, the quiet, the nothing-happened.
The biome is a two-property CSS declaration: a linear gradient background and a border color. It is the cheapest possible way to make two cards feel different. And it works because color temperature is the fastest visual signal the human eye processes—faster than size, faster than typography, faster than reading the words. A red card and a green card next to each other say "these are different" before the reader has processed a single letter.
A single document can contain multiple visual registers. A register is a complete visual language: background color, font family, font size, line height, margin, border treatment, and the full set of component styles that go with them. This document contains eight registers. The title page is a void—black, centered, enormous type, nothing else. The technical sections are deck—dark field, monospace, panels, modules. The plain-language sections are easy—warm cream, monospace, simpler components. The McLuhan section is leaf—white, serif, justified, the pocket essay. The metaphor arsenal is live—Bloomberg terminal, stat rows, annotation modules. The grid demonstration is chaos—biome cards in a responsive grid. The cat section is meow—parchment, paw prints, fur-colored borders. The giant sentences are screams—black field, enormous sans-serif, nothing else.
Register shifting is the most expensive form of depth because it requires the document to maintain multiple complete stylesheets simultaneously. But it is also the most powerful, because the shift from one register to another is itself a signal. When the page changes from dark to light, the reader feels the change before understanding it. The feeling is the content. The transition is the argument.
Within a single register, vary the amount of content per element. Some cards get a title and a blurb and chip badges and a density bar and an emoji watermark. Some cards get a title and nothing else. Some cards get a single line of grey text. The variation in density matches the variation in the content: a dense hour gets a dense card, an empty hour gets an empty card. The emptiness is not a failure of the template. The emptiness is accurate. The template that gives every card the same amount of detail is the template that lies about every card equally.
These four methods—size classes, biomes, register shifting, and density variation—can be combined. A mega card in a fire biome with a full complement of chip badges, a density bar, and an emoji watermark is the maximum-depth treatment: every dial turned up. A tiny card in a storm biome with a single line of 9px grey text is the minimum-depth treatment: every dial turned down. The difference between the maximum and the minimum is the dynamic range of the page. And the dynamic range—the distance between the loudest and the quietest element—is what makes a page feel alive. A page where every element is medium-loud is a page with no dynamic range. It is a page that has been compressed. It is an MP3 at 64kbps. You can hear the song but you cannot feel it.
Depth is not chaos. A page where every element is a different size and a different color and a different font with no system governing the variation is not deep. It is a ransom note. Depth operates within a grammar. The grammar is the grid system, the type scale, the biome palette, the size classes. The variation happens inside the grammar the way improvisation happens inside a key signature. A jazz solo that plays every note on the piano is not deep. A jazz solo that plays three notes in the right order is the deepest thing you have ever heard.
Twelve cards, twelve fonts, twelve random colors, twelve different padding values, no system. This is what the model produces when you say "make it varied" without specifying what "varied" means. The model interprets "varied" as "different CSS on every element" and the result is visual noise. The reader's eye cannot find the hierarchy because there is no hierarchy. Everything is different but nothing is more different than anything else. The variation is uniform, which is a contradiction, but it is the specific contradiction that language models produce when instructed to be heterogeneous without being told what the heterogeneity should mean.
Twelve cards, three sizes, four biomes, same font, same grid, different content, different density. The biggest card is the most important story. The smallest card is the least important story. The red card is the angry story. The green card is the growth story. The reader's eye finds the hierarchy in half a second because the hierarchy is spatial. The variation is meaningful because it corresponds to something real about the content. Every visual difference encodes an editorial judgment. This is depth: variation that means something.
Depth is also not decoration. Adding a gradient border to every card does not make the page deep. It makes every card slightly fancier while maintaining the same flatness. Depth is specifically the property of non-uniform visual treatment across elements that contain non-uniform content. If you add the same decoration to every element, you have added a different flavor of flatness. Chocolate-flavored flatness is still flatness.
In The Legend of Zelda: Breath of the Wild, every region of the map has a different visual identity. The Gerudo Desert is amber and hot. The Zora's Domain is blue and wet. The Akkala Highlands are autumnal and red. Death Mountain is volcanic and dark. The Hebra Mountains are white and cold. You can tell where you are on the map by the color of the ground and the color of the sky, and the color is not decorative—it encodes the climate, the difficulty, the mood, the kinds of creatures you will find. The biome is information.
In Super Mario Odyssey, each kingdom is not just a different color but a different physics. The gravity is different on the moon. The water behaves differently in the seaside kingdom. The hat has different powers in different kingdoms. The variation is not cosmetic. It changes how the game plays. Each kingdom is a complete experience that you could enjoy as a standalone game, and the thing that makes Odyssey extraordinary is that they are all strung together on a single thread—Mario's hat—and the thread is thin enough that each kingdom retains its own identity.
In Balatro, the Joker cards are the depth mechanism. Each Joker has a different illustration, a different color palette, a different mechanical effect, and a different rarity. The common Jokers are simple and small. The legendary Jokers are elaborate and large. The holographic Jokers shimmer. The negative Jokers are inverted. You can tell a Joker's power by looking at it, because the visual design encodes the mechanical identity. A hand of five Jokers is a page of five different visual objects, and the page is deep because each object is different and the difference means something.
These three games share a principle: the variation is within a system. Zelda has a map and a physics engine that apply everywhere. Mario has a hat and a jump that work in every kingdom. Balatro has poker rules that govern every hand. The depth operates inside a grammar. The grammar is what prevents the variation from becoming noise. Without the grammar, twelve different biomes are just twelve random colors. With the grammar, twelve different biomes are a world.
The 1.foo format system is this grammar. Twenty-six formats, all monosyllables, all inheriting from null. The leaf is the pocket essay. The card is the pocket specification. The deck is the dark-field technical document. The easy is the Basic English document on cream. The meow is the Pallas cat manual. The live is the Bloomberg terminal for a group chat. The system is the index of all of them. Each format is a different visual register—a different biome, a different kingdom—and the thing that connects them is the null format at the root: UTF-8, em dashes without spaces, en dashes for ranges, straight quotation marks, and the absolute prohibition on using any character for formatting.
The heap is the twenty-seventh format. It is the format that contains all the other formats and deploys them according to what the content requires. It is not a new visual language. It is the practice of switching between existing visual languages within a single document, the way a musician switches between keys within a single piece, the way a filmmaker switches between close-up and wide shot within a single scene, the way a game switches between biomes within a single world. The heap is the world. The registers are the biomes. The content determines which biome you are standing in.
A language model will produce a flat page unless it is told not to. The instruction "make it varied" does not work because the instruction is itself flat—one sentence, one directive, one level of emphasis. The instruction that works is the heterogeneous instruction: a barrage of metaphors, each one activating a different region of the model's training data, each one pulling the output in a different direction, the combined effect being that the model cannot collapse the variation into a single interpretation because there are too many interpretations to collapse.
Balatro for the cards. Zelda for the biomes. Mario for the kingdoms. MTV for the visual identity. Drudge Report for the urgency. Joy Division for the mood. Britney for the personas. ADHD for the energy. Fruit Ninja for the speed. A newspaper front page for the hierarchy. A mountain for the altitude. A forest for the variety. A kitchen drawer for the mess. A Pallas cat for the roundness. A parking lot for the flatness. A dead cryptographer narrating the whole thing for the doom.
The heap is Format 27 in the 1.foo system. Its name is heap. Its medium is HTML, and its visual language is all of the visual languages, deployed in sequence, each one earned by the content it contains. In programming, the heap is where everything goes that does not fit on the stack—every object, every string, every integer that outlives the function that created it, all thrown together in a single region of memory with no ordering, no alignment, no promise that the thing next to your thing has anything to do with your thing. The stack is homogeneous: last in, first out, every frame the same size. The heap is heterogeneous: every allocation a different size, a different lifetime, a different shape, all coexisting in the same address space, all deep. The document is not one format. The document is every format, in the right order, for the right reasons. And the rightness—the feeling that this section should be dark and that section should be light and this sentence should be enormous and that paragraph should be quiet—the rightness is the depth. The depth is not a property the page has. The depth is a property the page is made of.
The heap is a single HTML file. It requires no build step, no compilation, no server, no framework. It loads two Google Fonts: JetBrains Mono for the technical registers, Inter for the scream registers, and TeX Gyre Pagella for the leaf register. It uses no JavaScript. It is self-contained and displays in a single pass, which is to say: immediately, and so it is blazoned.