Introduction

There is a particular quality to the glow of a CRT monitor — a hum, a flicker, a warmth — that no flat panel has ever quite replicated. It is the quality of presence: the sense that the machine is doing something right here, right now, not streaming a performance from somewhere else. The aesthetic of retro computing draws its power from this presence.

This article traces the lineage of that aesthetic — from the room-sized mainframes of the 1960s to the pixel-art CSS frameworks of today. We will not romanticize; we will contextualize. Every constraint that produced the retro look was, at the time, a limitation.

Origins (1960s–70s)

The earliest computer displays were oscilloscopes repurposed to draw characters. The TX-0 at MIT (1956) and the PDP-1 (1960) used vector displays — the electron beam drew lines directly, producing the iconic game Spacewar! in 1962.

"The machine had no graphics. We had to imagine the screen into existence. Every pixel was a decision."

— Stephen Russell, creator of Spacewar!

    ▄▄▄████▄▄▄
    ██░░░░░░██
    ██░░▄▄░░██
    ██░░██░░██
    ▀▀▀▀▀▀▀▀▀▀
   SPACEWAR! 1962
            

Character-based terminals followed: the ADM-3A (1976) popularized the 80×24 grid we still associate with green-screen terminals. Its keyboard layout — including the HOME, ESC, and arrow keys — became the de facto standard.

The Home Boom (1980s)

The 1980s saw the migration of pixel art from research labs to living rooms. Three machines defined the era:

The Apple II (1977)

The Apple II brought color graphics (limited to 6 colors via NTSC artifacting) into homes. Games like Castle Wolfenstein (1981) and Prize Mansion (1982) showed what could be done with creative palette abuse.

The Commodore 64 (1982)

The C64's VIC-II chip powered 16 colors, hardware sprites, and a SID audio chip that defined an entire generation of chiptune music. Its sprite multiplexing technique allowed more than 8 sprites on screen — a hack that became an art form.

The Nintendo Entertainment System (1985)

The NES 2A03 chip enforced tile-based rendering: 8×8 pixel tiles composed larger backgrounds. This constraint produced the chunky, readable aesthetic of games like Super Mario Bros. and The Legend of Zelda.

NES.css, Pico.css, and other modern frameworks inherit this aesthetic consciously — but the constraints of the original hardware were not chosen. They were dictated by 6502 assembly code budgets and 2KB of working RAM.

Decline & Revival

By the mid-1990s, 3D acceleration (3dfx Voodoo, 1996) and CD-ROM storage killed the pixel-art mainstream. The aesthetic became a meme — ironic, nostalgic, kitsch.

Then, around 2010, three things happened:

1. Indie games like Shovel Knight and Stardew Valley revived pixel art as a deliberate choice.
2. CSS art communities on CodePen and Reddit rediscovered the aesthetic as a constraint exercise.
3. Frameworks like NES.css (2018) packaged the look into reusable design systems.

Today: The Classless Revival

dotmatrix.css belongs to a group of classless retro frameworks. NES.css requires explicit classes (<button class="nes-btn is-primary">), while frameworks like Pico, Water, and dotmatrix.css style semantic HTML tags directly.

This shift mirrors a deeper change in web architecture: the move from imperative class application to declarative semantic markup. The HTML5 spec's push toward meaningful tags (article, aside, nav) gave classless frameworks something to work with that didn't exist in the HTML 4 era.

"A button doesn't need a class to be a button. It needs to be a button."

References

1. Russell, S. (2001). Programming the PDP-1. Computer History Museum.
2. Mortensen, T. (2018). NES.css: 8-bit CSS framework. GitHub.
3. Lacina, F. (2020). The Sprite Multiplexing Trick. Retro Gamer Magazine #212.
4. Holwerda, T. (2012). The Pixel Art Renaissance. OSNews.