TLDR

HTML, for me, has become to thinking what Python is to computation: the readable glue layer where heterogeneous capabilities compose. Markdown, the backend, the developer-and-illustrator pair - defaults that came with serious work drop away one rung at a time when you build at this layer.

Forty seven algorithms running in a single HTML file. Code on the left. Structure on the bottom. Controls underneath. Step it, scrub it, change the input.

The page is not describing the algorithms. It is the algorithms. The merge sort is sorting. The dynamic programming table fills cell by cell as you watch. No server. One file, runs anywhere, including on your phone, including offline after the first load.

I built it last week to explain algorithms to my son. The week before that, an atlas of the 444 specimens it draws from. The week before that, something else. By my count, twenty six interactive assets in four weeks.

Python did not win because Python is fast. Everyone knows, Python is slow. Python won because it became the readable glue layer above C, CUDA, Fortran, and the other things doing the actual lifting. NumPy is C. PyTorch is C++ and CUDA. The work happens elsewhere. Python composes.

That is a structural property. Once a language becomes the readable layer above accelerated machinery that everyone else also wants to call into, gravity takes over. Every new capability gets a Python binding because that is where the audience is. Every team that builds something useful exposes it to Python because that is where the audience builds. Self reinforcing. Universal in a decade.

HTML is winning the same way for a different stack. WebGPU does the matrix math. IndexedDB handles persistent storage. The File System Access API owns the user’s disk. Web Workers run things on separate threads. Transformers.js loads the model. WebRTC handles peer to peer. WebAssembly runs whatever does not fit in JavaScript. None of these are HTML. All of them plug into HTML.

The work happens elsewhere. HTML composes. That is exactly the property that made Python what it became, applied to a different family of capabilities, in a different decade, for a different kind of work.

The analogy is not just metaphor. It is the same structural move running in another context.

The first interactive asset I built four weeks ago was a polemic about commute taxation. Twelve hundred words of argument with one chart. I had been writing pieces like that as docs for a year. Putting the same argument inside an HTML file with one interactive chart did something to it. The argument did not change. The reader’s relationship to it did. Markdown asks the reader to trust the writer’s compression. HTML lets the reader test it.

Marshall McLuhan said the medium is the message in 1964, watching television displace print. The form of communication shapes what the receiving mind has to do, independent of the content. Markdown rewards trust. HTML rewards participation. Same argument, different cognitive regime in the reader.

Markdown dropped at rung one.

Rung two was the explorer. I built one for corporate contributions to the global commons, country by country, industry by industry. Filterable, searchable. The data sits inline in the file. The filter runs in the browser. There is no backend at all. A reader on a slow connection downloads one HTML file once and explores a hundred companies for as long as they want. The server class of work, for this kind of artefact, simply went away.

Server dropped at rung two.

Rung three was the animated explainer. The semiconductor field guide. Twelve layers of the chip industry, each layer animating its own structure as you watch, vanilla SVG and JavaScript. India 2500 years to the Republic, two hundred and three events on a map walked through with timeline scrubbing. To explain something this complex with words alone, you used to need two specialists. A developer to build the interactive demo. An illustrator to draw the static diagrams that filled the gaps. HTML at this rung collapses both. The developer and the illustrator did not disappear. They collapsed into Claude. The medium being where they used to live changed underneath them.

The illustrator and the developer dropped at rung three.

Rung four is the one that surprises people. On my portfolio page, naklitechie.github.io there are single HTML files that run Whisper transcribing audio entirely in the browser, that load Gemma into a tab and run it multimodally on a laptop’s GPU, that play chess against Stockfish. The model lives in a tab. The data never leaves the device. There is no server because there is no need for one.

Backend dropped at rung four.

What is left, after four rungs, is an HTML file. Twenty six of them at assets.chiragpatnaik.com, plus the github.io portfolio. Four weeks of building. Each rung dropped a default that came along for the ride when the only way to build was the heavier stack.

None of this means the heavier stack is wrong. Apps for clients, multi-user systems, anything with shared state and real authentication, still want what frameworks give you. The point is that an enormous amount of work is not those things. Personal tools, explainers, arguments made interactive, single user models, reference material that wants to be manipulated rather than read. For that class of work, HTML at this layer is enough. It was always going to be enough. The infrastructure underneath finally caught up.

Python won by becoming the medium computation reached for. HTML is winning by becoming the medium thinking reaches for. The properties that made the first true are the same properties making the second true. Heterogeneous capabilities below, a readable layer above, the audience and the builders converging on the same place because that is where converging happens. Once a medium gets gravity, the gravity does the rest.

Twenty six assets in four weeks is not a credential. It is a measurement of how little friction is left between the thought and the artefact when the medium is right. The thought wants to be tested by the reader. The artefact wants to be one file. The medium that makes both possible is the one that wins.

McLuhan died in 1980. The medium he built his argument on, television, had already started becoming something he had not described. The medium that proved him most right is one he never saw, applied to a kind of work he could not have known would exist. A theory that survives the medium it was built on, applied to a medium its author could not have predicted, is not a slogan. The medium is the message. Said in 1964 about television. Truer in 2026 about HTML.

Traces

This piece nearly tried to be three. Two were carved out mid-draft.

The first carve-out was Marshall McLuhan. The medium is the message, said in 1964, watching television displace print. The argument lands harder applied to HTML in 2026 than it did when he made it. The McLuhan frame is too dense to be a closing paragraph in someone else’s argument. Its own piece.

The second carve-out is the question of why I cannot stop building these. Four pieces drafted in a day on the way to an airport is a pattern, not a productivity story. Closer to The Addiction Economy than to anything in this one. Its own piece.

Claude’s first draft of this piece spent five hundred words attacking the framework stack — Lovable, v0, the venture economics of why monetisable tools persist. I cut it. The argument is what HTML can do, not what frameworks can’t. Frameworks are still right for client work, for shared state, for anything multi-user. The polemic was eating the piece. Without that section the structural argument lands cleaner and the reader is not asked to take a side they did not come to take.

Claude opened by floating two alternative analogies for what HTML had become: HTML is the new Excel, HTML is the new PDF. Both miss the orchestration property, which is what makes Python Python. I pushed back. The Python analogy held. The other two didn’t.

Mid draft, while Claude was still working through the progression section, I tweeted “Read Claude’s thought process. That’s the tweet.” The piece argues the medium reveals the thinking. I read the trace and tweeted the trace. The argument enacted itself before the piece was finished.