The 4KB File That Broke the Web: How Håkon Wium Lie Wrote CSS in a Café — And Spent 10 Years Fighting Netscape, Microsoft, and a Language Called JSSS

The Café Where Design Broke Free

It was October 1994, and Håkon Wium Lie sat in a café near CERN, staring at the ugliest web pages he'd ever seen. Every site looked like a physics paper — black text, blue links, gray backgrounds. No fonts. No colors. No layout.

Tim Berners-Lee had invented HTML to share research documents, not design magazines. But now the web was exploding beyond academia. Companies wanted branding. Designers wanted control. Publishers wanted newspapers, not academic journals.

The problem? HTML mixed content and presentation into an unholy mess. Want red text? Wrap it in <font color="red">. Want centered text? Use <center>. Every visual decision lived inside the content, making pages impossible to redesign without rewriting every single HTML tag.

Håkon opened his text editor and started typing. He called it "Cascading HTML Style Sheets" — a simple language to separate what content was from how it looked.

He had no idea he was about to start a 10-year war.

The Proposal That Nobody Wanted

Håkon's first CSS draft was 4 kilobytes. The syntax looked like this:

h1.font.size = 24pt
h1.font.weight = bold
h1.color = blue

Simple. Clean. Readable.

He emailed it to the www-talk mailing list — the same place Tim Berners-Lee had announced the World Wide Web three years earlier. The response was... crickets.

Most developers didn't see the point. HTML worked fine for documents. Why add complexity?

But Bert Bos, a Dutch researcher, replied. He'd been working on his own style sheet language called "Argo." It used a different syntax but solved the same problem. The two met at a conference in Chicago.

They merged their ideas. Håkon's cascading model (where styles could inherit and override each other) combined with Bert's cleaner property syntax:

h1 {
  font-size: 24pt;
  font-weight: bold;
  color: blue;
}

This was CSS 1. They submitted it to the W3C in 1995.

Then Netscape showed up.

The Browser War Nobody Talks About

Marc Andreessen's Netscape Navigator owned 80% of browser market share in 1995. They were moving fast, adding features weekly. And they had their own plan for styling the web.

It wasn't CSS.

Netscape wanted JavaScript Style Sheets (JSSS) — a system where you'd write JavaScript code to control visual styles:

tags.h1.color = "blue";
tags.h1.fontSize = "24pt";

To Netscape's engineers, this made perfect sense. JavaScript was already in the browser. Why invent a new language? Just use the one we have.

Brendan Eich, who'd created JavaScript in 10 days, championed JSSS. It shipped in Netscape 4.

Meanwhile, Microsoft was building Internet Explorer. They looked at CSS and JSSS and thought: "We can do better."

They proposed their own standard: Document Style Semantics and Specification Language (DSSSL) — a complex, SGML-based system borrowed from print publishing. It was powerful but horrifically complicated.

The web now had three competing style systems:

• CSS (W3C standard, not implemented)
• JSSS (Netscape only)
• DSSSL-inspired proposals (Microsoft)

None were compatible. Developers were furious.

The Meeting Where CSS Almost Died

In 1996, the W3C convened a workshop in Boston. Browser vendors, designers, and academics crammed into a conference room to settle the style sheet war.

Netscape argued JSSS was simpler — developers already knew JavaScript. Why learn a new syntax?

Microsoft argued for power — designers needed print-level control, not web-toy features.

Håkon and Bert defended CSS with one argument: separation of concerns.

CSS wasn't just about syntax. It was about architecture. With CSS:

• Designers could work on styles without touching HTML
• One stylesheet could control thousands of pages
• Accessibility tools could apply user stylesheets for people with disabilities
• Browsers could implement styles incrementally — if they didn't understand border-radius, they'd just ignore it

With JSSS, every page needed to download and execute JavaScript just to display text. With DSSSL, simple sites would need complex compilers.

CSS won by one vote.

Netscape refused to implement it.

The Browser That Changed Its Mind

Internet Explorer 3 shipped in August 1996 with partial CSS support. It was buggy — float barely worked, positioning was broken, and the box model was implemented backwards — but it existed.

Netscape Navigator 4, released in 1997, shipped with JSSS. No CSS.

Developers had to choose: write separate stylesheets for each browser, or stick with inline HTML styling.

Most chose HTML. CSS looked dead.

Then something unexpected happened: Web standards advocates — a grassroots group of designers and developers — started a public pressure campaign. They built CSS-only sites. They published tutorials. They wrote angry blog posts.

The most influential was Eric Meyer, a developer who published "CSS: The Definitive Guide" in 2000. His book didn't just teach CSS — it evangelized it. He showed what was possible: complex layouts, beautiful typography, responsive designs.

Designers realized CSS wasn't a W3C academic exercise. It was freedom.

By 2000, Netscape's market share had collapsed to 15%. Microsoft's Internet Explorer 5 had better CSS support (still broken, but better). Netscape scrambled to add CSS to Navigator 6.

JSSS was quietly removed from the codebase. Nobody mourned it.

The Box Model War

But CSS still had a crisis: the box model.

In CSS, every element is a box with:

• Content (the actual text/image)
• Padding (space around content)
• Border (line around padding)
• Margin (space outside border)

When you set width: 200px, what are you measuring?

The CSS spec said: "Content width." So a 200px-wide box with 10px padding and 5px border would actually render at 230px total width.

Internet Explorer disagreed. Microsoft's engineers thought developers meant "total width." IE counted padding and borders inside the width.

This wasn't a bug. It was a philosophical disagreement about how developers think.

Every CSS layout broke differently in IE. Developers used browser detection and served separate stylesheets — defeating the entire point of CSS.

The solution? CSS3 added box-sizing: border-box in 2010 — letting developers choose which model to use.

Today, almost every modern stylesheet starts with:

* {
  box-sizing: border-box;
}

IE's "wrong" implementation became the industry standard.

The Framework That Made CSS Work

CSS was standardized by 1998, but it was still painful to use. Browser bugs required elaborate hacks. Layouts needed float-based grids that broke constantly. Responsive design didn't exist — you built separate mobile sites.

In 2006, Mark Otto and Jacob Thornton at Twitter got frustrated. They were building Twitter's interface with inconsistent styles across teams. Every engineer wrote CSS differently. The codebase was chaos.

They built an internal toolkit: Bootstrap.

Bootstrap wasn't revolutionary CSS — it was a system. Predefined classes for grids, buttons, forms, and typography. Developers could build interfaces by combining classes:

<div class="container">
  <div class="row">
    <div class="col-md-6">Half width</div>
    <div class="col-md-6">Half width</div>
  </div>
</div>

They open-sourced it in 2011. Within six months, Bootstrap became the most-used CSS framework on the web.

Suddenly, CSS was productive. You didn't need to be a CSS expert to build good-looking sites.

But frameworks created a new problem: CSS bloat. Bootstrap's full CSS file was 150KB. Most sites used 5% of it but shipped 100%.

The pendulum swung back.

The Utility Revolution

In 2017, Adam Wathan was building user interfaces at a consulting company. He was tired of writing custom CSS for every component. He was tired of naming things.

He had a radical idea: what if CSS classes were just inline styles with better names?

Instead of:

.card {
  padding: 1rem;
  background: white;
  border-radius: 0.5rem;
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

What if you wrote:

<div class="p-4 bg-white rounded shadow">

Each class did one thing. p-4 meant "padding: 1rem". bg-white meant "background: white". No custom CSS. No naming debates.

He called it Tailwind CSS.

The CSS community hated it. It violated every best practice:

• Semantic HTML? Gone.
• Separation of concerns? Destroyed.
• Reusable styles? Nonexistent.

But developers loved it. Tailwind let you build interfaces fast without context-switching between HTML and CSS files. And because it only shipped the classes you actually used (via build-time purging), final CSS files were tiny — often under 10KB.

By 2023, Tailwind had overtaken Bootstrap. The utility-first approach won.

The Future Håkon Never Imagined

In 2024, CSS has features Håkon couldn't have imagined in 1994:

• CSS Grid: two-dimensional layouts that finally killed float hacks
• Flexbox: one-dimensional layouts that make centering things trivial
• CSS Variables: dynamic values that change at runtime
• Container Queries: responsive design based on parent size, not viewport
• CSS-in-JS: libraries like styled-components that write CSS in JavaScript (ironically, Netscape's JSSS vision, resurrected)

The language that started as 4KB in a café is now a 1,500-page specification.

But the core idea — separation of content and presentation — still powers the web.

The Legacy

Håkon Wium Lie never made billions from CSS. He didn't get acquired by Google or go public. He became CTO of Opera, a niche browser, and later worked on web standards at W3C.

But CSS is his legacy.

Every website you visit uses it. Every button, every layout, every animation. From Netflix's cinematic interfaces to Stripe's minimalist dashboards to your company's internal tools.

CSS won because it was boring. It didn't require JavaScript execution. It didn't need a runtime. It just worked — incrementally, progressively, and universally.

Netscape bet on JavaScript. Microsoft bet on complexity. Håkon bet on simplicity.

And the web bet on Håkon.