Open a terminal. Any terminal. The default is white text on a black background. It has been this way since the first CRT monitors drew phosphor green on darkness in the 1960s. For the first thirty years of computing, every interface was dark by default. Not because anyone made a design decision. Because that’s what screens are. Screens emit light. When they’re off, they’re black. The default state of every digital surface in existence is darkness.
Then we decided to make them look like paper.
The paper metaphor
The Xerox Alto shipped in 1973 with a white background. The idea was simple and, at the time, reasonable: people were used to paper. Documents were black text on white pages. If you wanted people to adopt computers for writing and reading, you should make the screen look like the thing it was replacing.
The Macintosh followed suit in 1984. Windows in 1985. By the 1990s, the white background was so entrenched that nobody questioned it. White was “clean.” White was “professional.” White was the default, and defaults are almost impossible to dislodge once they’re set.
But paper and screens are fundamentally different media. Paper reflects light. Screens emit it. When you read black text on a white page in a book, the page is reflecting ambient light into your eyes at whatever intensity the room provides. When you read black text on a white screen, the screen is firing photons directly at your retinas at whatever intensity the backlight provides.
This distinction matters enormously, and we’ve been ignoring it for forty years.
What the science says
The research on light and dark interfaces is more nuanced than either side usually admits. But here’s what we actually know.
In bright ambient conditions—a sunlit office, an outdoor café—light interfaces are easier to read. The high contrast of dark text on a light background fights the ambient light effectively. This is the same reason books work: reflected light in a bright environment produces clear, readable text.
In low ambient light—evening, dimmed rooms, bedtime—dark interfaces are significantly easier on the eyes. A bright white screen in a dark room creates a massive luminance differential between the display and its surroundings. Your pupils constrict to handle the screen, then dilate when you look away, then constrict again. This cycling is what causes eye strain, headaches, and that vaguely sick feeling you get after staring at a bright screen for hours in a dark room.
A dark interface in a dark room keeps the luminance differential low. Your pupils stay relatively stable. The text is still perfectly readable—light text on a dark background has excellent contrast—but your eyes aren’t doing gymnastics every time you glance away from the screen.
Now consider when most people actually use their devices. Morning: still dark in winter, maybe dim bedroom light. Commute: variable, often dim. Office: usually well-lit, fair enough. Evening: dimmed living room. Bed: dark. The majority of device usage happens in conditions where dark interfaces are physiologically better for your eyes.
And yet the default, everywhere, is light.
The OLED argument
There’s a practical argument too, and it’s getting stronger every year.
OLED screens—which are now the default on flagship phones and increasingly common on laptops and monitors—work by lighting individual pixels. A white pixel is fully on. A black pixel is fully off. Literally off, consuming zero power.
A dark interface on an OLED screen uses measurably less battery. Google published data showing that dark mode on OLED screens reduces power consumption by 30–60% depending on the brightness level. On a phone, that’s the difference between your battery dying at 6pm and lasting until you get home.
This isn’t a marginal gain. It’s significant, measurable, and it scales. Every phone, every tablet, every OLED laptop in the world would use less power if the default interface was dark. Multiply that by billions of devices and the energy savings are not trivial.
The counter-argument is that LCD screens don’t benefit from dark mode because the backlight is always on regardless of what’s being displayed. This is true. But LCD is a dying technology. The trajectory is clear: OLED is the future of displays. Building for light defaults is building for yesterday’s hardware.
Klim as proof
I keep coming back to the Klim Type Foundry website. It’s become something of a design bible for me, not because it’s flashy but because it demonstrates so many principles so cleanly.
Klim uses a dark background. Not pure black—a very dark grey, which avoids the “floating text” problem of pure #000000—but unmistakably dark. And the effect is striking. The typography floats. The letterforms, which are the entire point of a type foundry’s website, become luminous objects against the dark field.
This is the “darkness as canvas” principle. When the background is dark, everything placed on it gains presence. A heading isn’t just text on a page. It’s light emerging from darkness. It demands attention not through size or weight but through the fundamental physics of contrast.
Compare this to the typical light-background website. White space is beautiful and useful, but it’s also everywhere. Every website, every app, every document defaults to white. The text sits ON the surface. It’s placed, arranged, laid out. It’s competent but it’s never luminous. Light-on-dark text genuinely glows in a way that dark-on-light text cannot, because light-on-dark is working with the physics of the medium rather than against it.
Klim’s navigation is minimal. The content breathes. The specimens—those massive type samples—feel alive against the dark background in a way they simply wouldn’t on white. The dark default isn’t a stylistic choice. It’s a design choice that makes the content better.
Why light won (and why it shouldn’t have)
If dark interfaces are better for most usage conditions, better for battery life, and better for content presentation, why is light the default everywhere?
Three reasons.
The paper legacy. The Xerox Alto decision in 1973 created a default that every subsequent operating system inherited. Defaults are incredibly sticky. Most people never change them, and most designers design for the default. Once light mode was the default, the entire design industry optimised for it. Colour systems, typography, photography—everything was calibrated for light backgrounds.
The “clean” association. Western design culture has a deep association between whiteness and cleanliness, simplicity, and professionalism. A white website feels “trustworthy” in a way that a dark website doesn’t, and this isn’t about design principles—it’s about cultural conditioning. We’ve been trained to read white backgrounds as “legitimate” and dark backgrounds as “edgy” or “niche.” Banks use white. Gaming companies use dark. The association is arbitrary but powerful.
Dark mode is harder to build. This is the real reason most apps don’t default to dark, and it’s the reason worth taking seriously. Building a dark interface that looks good is genuinely more difficult than building a light one. Shadows don’t work the same way. Elevation cues need to be rethought. Photography and illustrations designed for light contexts look wrong on dark backgrounds. The entire visual hierarchy needs to be reconsidered.
Most design systems handle this badly. They build a light theme, then “invert” it for dark mode by flipping the background to black and the text to white. This produces a dark mode that feels like an afterthought—because it is one. Colours that looked rich on white look garish on black. Shadows that created depth on white become invisible on dark. The subtle grey hierarchies that made the light theme feel sophisticated collapse into a murky mess.
The solution isn’t to invert. It’s to build dark-first.
Building a colour system that inverts cleanly
The key insight is semantic tokens. Not literal values, not hex codes, not “grey-100 through grey-900.” Semantic tokens that describe function, not appearance.
Instead of --color-grey-900 for your body text and --color-grey-100 for your background, you use --color-text and --color-bg. Instead of --color-grey-700 for secondary text, you use --color-text-secondary. Instead of --color-grey-200 for borders, you use --color-border.
The semantic layer is the contract. It says: “this token means body text, whatever that looks like in the current theme.” The literal value behind it changes between light and dark, but the meaning stays the same.
This sounds obvious but almost nobody does it properly. Most colour systems I encounter are built as a palette—a stack of greys, a set of brand colours, maybe some status colours—and then components reference the palette directly. background: var(--grey-50). This works fine until you try to build dark mode, at which point you realise that --grey-50 means “almost white,” which is the background in light mode but absolutely not the background in dark mode. So you either maintain two completely separate colour systems or you write a mountain of overrides.
Semantic tokens solve this. You define the meaning once and the values twice:
Light theme: --color-bg: #ffffff; --color-text: #1a1a1a; --color-border: #e5e5e5;
Dark theme: --color-bg: #111111; --color-text: #e5e5e5; --color-border: #333333;
Every component references the semantic token. No component ever references a literal colour. When the theme switches, every component updates automatically because the contract hasn’t changed—only the implementation has.
But here’s the part people miss: if you build light-first and then try to add dark mode later, your semantic tokens are inevitably shaped by light-mode assumptions. You’ll have tokens like --color-shadow that assume shadows are dark things cast downward. In dark mode, elevation isn’t communicated by shadows—it’s communicated by lighter surfaces. Your semantic model is wrong from the start.
Build dark-first. Get the elevation system, the contrast ratios, the colour relationships right on a dark canvas. Then add the light theme. You’ll find that a colour system designed for dark adapts to light far more gracefully than the reverse.
Respecting the user
There’s a CSS media query called prefers-color-scheme. It tells you whether the user has set their operating system to light or dark mode. Every modern browser supports it. Every modern operating system exposes the preference.
The correct behaviour for any application is to respect this preference. If the user has told their operating system “I want dark mode,” your app should be dark. If they’ve said “I want light mode,” your app should be light. This isn’t a feature request. It’s basic respect for user agency.
And yet. The vast majority of websites ignore prefers-color-scheme entirely. They serve a light interface regardless of the user’s preference. Some offer a toggle—a little sun/moon icon in the corner—but the default is always light. The user has to actively opt into dark mode on every single website they visit, even though they’ve already told their operating system their preference.
This is a small indignity but it accumulates. Every light-default website in a dark-mode operating system is a flash of white in an otherwise dark environment. You’re browsing at night, everything is dark, you click a link, and suddenly your screen is a lighthouse. Your pupils contract. You squint. You reach for the dark mode toggle if there is one, and accept the blinding if there isn’t.
The argument against respecting prefers-color-scheme is usually that “our dark mode isn’t ready yet” or “we haven’t designed for dark.” Which is exactly my point. If you’d built dark-first, you wouldn’t have this problem. The dark mode would be the primary mode, the light mode would be the adaptation, and respecting the user’s preference would be trivial.
Darkness as canvas
Let me come back to the philosophical argument because I think it’s the most important one, even if it’s the hardest to quantify.
A screen is not paper. A screen is a window that emits light. The natural state of that window is dark. When you fill it with white, you’re fighting the medium. You’re using energy to simulate a material (paper) on a device that is fundamentally not that material.
When you leave the screen dark and let content emerge from it, you’re working with the medium. Text becomes light. Images become windows into other worlds. The interface recedes and the content advances. The screen stops pretending to be paper and starts being what it actually is: a surface that can produce any colour, any brightness, any image, from nothing.
There’s a word for this approach in other creative fields. In painting, it’s called chiaroscuro—the use of strong contrasts between light and dark to create volume and drama. Caravaggio didn’t start with a white canvas and add shadows. He started with darkness and pulled figures into the light. The result is paintings that feel alive in a way that evenly-lit compositions don’t.
Rembrandt did the same thing. So did Vermeer, in his own quieter way. The dark background isn’t empty space. It’s the context that gives the light its meaning.
Digital interfaces can do this too. A dark interface isn’t an absence of design. It’s a canvas that makes everything placed on it more present, more intentional, more alive. A button on a dark background glows. A photograph on a dark background floats. Typography on a dark background is luminous.
This is what Klim understood. This is what terminal designers understood fifty years ago. This is what we forgot when we decided screens should look like paper.
The default matters
I’m not arguing that light mode shouldn’t exist. It should. Some contexts demand it—bright outdoor conditions, certain accessibility needs, personal preference. The toggle should always be there.
What I’m arguing is that the default should be dark. The starting point. The thing you get if you never touch a setting.
Defaults are the most powerful design decisions you can make. Research consistently shows that the vast majority of users never change defaults. Whatever you set as the default is what most people will use, forever. If the default is light, most people will use light mode even if they’d prefer dark, because the friction of finding and flipping the switch is enough to stop them.
By defaulting to light, we’re making a choice for billions of people. We’re choosing higher eye strain in low light. We’re choosing higher battery consumption on OLED screens. We’re choosing to fight the physics of the medium rather than work with it. We’re choosing forty-year-old assumptions about paper over the reality of what screens are.
Respect the medium. Respect the user. Start dark.
Everything else can earn its way to white.