jcyamo.dev

The Disassembled Web · 000 · Intro

Part of The Disassembled Web

What If You Started From Zero?

If you want to build a web application today, you don’t start from scratch. You scaffold. You type a single command into a terminal, and an AI or a CLI tool spins up a universe for you—a server, a database, a frontend framework, a styling engine, and a build pipeline—all configured, connected, and ready to ship.

In an age of AI assistants that can scaffold an entire app from a single prompt and “vibe coding” where we stitch together black-box libraries until it feels right, it’s fair to ask: why would anyone build from scratch?

Because AI can give you the answer, but it can’t give you the conviction to know if it’s the right answer. A tool that generates a complex state management solution is useless to you if you don’t fundamentally understand why your component kept re-rendering in a loop. “Vibe coding” can ship a product, but it can’t ship a product you can debug with confidence when it breaks under load at 3 AM.

We have stopped understanding how our tools work. We treat the framework like a black box. We paste in the snippet, we import the hook, and we trust that it works. And most of the time, it does. But when the abstraction leaks—when the tool fights back against your specific needs—we’re left helpless. We can tweak the configuration, but we can’t fix the engine because we’ve never seen the pistons move.

The Disassembled Web is a hands-on series about going back to the source.

The Build

We are constructing The Void Reader—a minimalist, browser-based zine reader built from absolute zero. We start with nothing but a blank .html file and watch it grow into a sophisticated, offline-capable Progressive Web App with a custom component system, state management, and server-side rendering.

Each post ends with a git tag marking the project’s exact state at that milestone. You can check out any point in the journey:

git checkout v3ss3l-003   # The project as it stood after The Open Door
git diff v3ss3l-001 v3ss3l-002   # Everything that changed in The Glyph post

Tags follow the series naming convention: v3ss3l-001 through v3ss3l-006 for Part 1, continuing with s1g1l-*, 4n1mu5-*, and so on through Part 7.

We start with semantic HTML and modern CSS, crafting a focused reading experience with no JavaScript at all. Then we slowly introduce vanilla JS to manage a growing collection of zines. As the application’s needs outgrow the simplicity of vanilla code, we feel the pain points firsthand and build our own solutions from scratch. Piece by piece, we construct our own component-based library, our own state management hooks, and finally, a server-side rendering system.

By the end, we will have an application we understand from the network request all the way down to the individual DOM node.

The journey unfolds in seven parts:

  1. The Vessel — Semantic HTML, CSS, and the visual medium. A perfect, accessible, static container.
  2. The Library — JavaScript, JSON, and the flow of information. The machinery to manage content.
  3. The Animus — The Virtual DOM, reactivity, and the rendering engine that makes the UI feel alive.
  4. The Akasha — State management, hooks, and memory.
  5. The Hermetic — PWA depth, File System Access, and the application shell.
  6. The Substrate — Backend, database, and the foundation.
  7. The Logos — Server-side rendering, hydration, and the final synthesis.

We aren’t doing this to replace React, Vue, or Next.js. We are doing this to understand them. We will feel the pain of vanilla JavaScript before we invent a Virtual DOM. We will struggle with tangled event listeners before we build a state manager. We will experience the slow load times of client-side rendering before we implement server-side hydration. By building the solutions ourselves, the “magic” disappears and is replaced by a durable, unshakable intuition.

The Siren’s Call

At key moments in this journey, you will feel a powerful temptation: the urge to abandon our custom-built solution and just use a battle-tested framework.

This feeling is not a distraction; it is the entire point.

We won’t dodge the question. We’ll name it: The Siren’s Call of the Framework. At the precise moment our own solution starts to feel a little too custom, we’ll pause. We’ll acknowledge the immense power and convenience of the production-ready tools. We’ll respect the thousands of hours of engineering that went into them.

Then we’ll reframe. The goal is not to replace these tools, but to build the mental model required to master them. By building our own diff algorithm, we demystify React’s Reconciliation. By building our own useState, we understand why hooks have the rules they do.

The goal is to arrive at a place where you can use the most powerful tools available—not with blind faith, but with the deep, internalized understanding of a master builder.

Enter z3r0

This isn’t just a linear tutorial. It is a narrative.

z3r0 is a hacker—not in the way the media meant when they started using the word to mean criminal, but in the original sense: someone who opens the box not because he has permission, but because he has to know what’s inside.

He grew up in the ‘80s on 14.4k modems and BBSes, devouring issues of Phrack on flickering monitors. Not because he was political. Not because he had an agenda. Because those pages were a manual for curiosity without limits—a signal that it was not only possible to understand how a system worked at its lowest level, it was expected. He experimented with AOL warez because the system said he shouldn’t, and that barrier made the machinery behind it all the more interesting to understand. He disassembled computers because once you’ve seen the guts of something, you stop seeing magic and start seeing engineering—a different, deeper kind of wonder.

That instinct never went away. It just grew up.

Years ago, z3r0 retreated from the modern ecosystem—tired of watching the “library of human thought” he loved drown in tracking scripts and megabytes of bloat. But he didn’t disappear. He sat down in front of a blank file and asked himself the same question he’s always asked when something stops making sense: What’s actually inside this thing?

He has returned to build The Void Reader. And he’s documenting every layer of it—not as a tutorial, but as a log. The compulsion that made him pop the lid off a Commodore is the same one driving him to write his own diff algorithm instead of importing one.

As the application evolves, so does the content. We introduce new zine series to test the architecture—moving from a single static page to a library of multiple works. The Void Reader is the application we are building. The zines are the content that fills it. One is the vessel; the other is the soul.

I’ll let him take it from here.

--------------------------------------------------------------------------------
1NTR0 · 000 · THE HUM
--------------------------------------------------------------------------------

You can feel it, can’t you?

If you sit in front of the machine long enough, you stop seeing the code.
You stop seeing the pixels. You just feel the hum.

It’s the low-level vibration of the modern web. It’s the tracker firing
in the background. It’s the framework hydration script churning through the
DOM. It’s the ads loading, the analytics pinging, the heavy, heavy weight
of 8MB of JS just to render a paragraph of text.

I remember when the web was quiet.

I remember when a page was just a document. You requested it. It arrived.
You read it. It was done.

Somewhere along the line, we stopped building documents and started building
machines. We built engines to process text. We built factories to render
images. We built entire operating systems inside the browser window, just so
we could display a list of links.

I got tired of the noise.

So, I stepped away from the chaos. I turned off the notifications. I closed
the social tabs. I sat down in front of a blank text file and I asked myself
a simple question:

What if I start from zero?

What if I strip away the frameworks? What if I ignore the “best practices”
that tell me to install a library for everything? What if I build a web
application using only the raw materials - the HTML, the CSS, the JS - that
the browser gives me for free?

This series is the record of that experiment.

I am building The Void Reader.

It’s a zine reader. A simple tool for reading text files. No ads. No
trackers. No bloat. Just the content, sitting quietly on the screen.

But to get there, I have to build it from scratch.

I am going to start with nothing but a semantic HTML shell. I will sculpt
the layout with CSS, pixel by pixel. I will only introduce JS when the
content demands it. And when my needs outgrow the simple tools - when I
need state management, when I need a virtual DOM, when I need server-side
rendering - I won’t just paste in a library.

I will build those tools myself.

I will build my own useState. I will write my own diff algorithm. I will
construct my own rendering engine.

It’s not because I hate React. It’s because I want to know why React works.
I want to look at the code and understand the mechanism, not the magic.

This is a journey into the basement of the web. It’s for anyone who has ever
looked at a bloated bundle and wondered: Where is all this weight coming from?

It’s time to turn down the volume.

It’s time to build something quiet.

-- z3r0
--------------------------------------------------------------------------------