We all know why the state of web is bad and it’ll only keep getting worse as we keep adding more layers of abstractions on top of each other.

The root cause

“HTML pages are meant to be hand written”

It’s really simple, because web is not designed for what we use web today for. Don’t get me wrong - the idea that we can download and run applications on a sandboxed environment on a universal client is a revolutionary idea of itself1.

But the hard truth is that web when it was created was a way to share documents - like research papers with other people. You can still see that all the basic HTML tags like <h1>, <b>, <i> are basically equivalent of the formatting we have in modern day word processor applications. HTML pages are meant to be hand written similar to a word document.

Patchwork begins!

“Like we would have been colonizing Mars if we hadn’t wasted our time with this toy language.”

I wanna prefix this section by saying it’s a rant. If you don’t want to hear me yap, feel free to skip to next section for actual content. If you’re into my rant I would recommended reading the footnotes for more context and jokes. And also, events in this section are not in chronological order and I skipped some of them.

But HTTP is basically TCP protocol anyways - so people started dynamically generating page contents based on URL requested which led to the great era of Web 2.0 - pioneered by Perl and CGI-bin shenanigan 2.

But before we go into this great era, the web needs some patchworks because plain HTML and some limited style using <font> tag looks disgusting for a average user. So we invented CSS!

Since the gates are open for average consumers, we need things like form validation, disable submit button if user didn’t agree to terms and conditions, and so on… So we created the worst toy scripting language which is meant to be used for tiny scripting here and there in just 10 days.

But even at this point web was a paradise of a place - we had applications like Facebook (or Myspace) which unironically had real human beings! The real patchworks are just about to begin! We need more fancy UI because alot of people started using internet and lot more businesses are starting to create user friendly webpages. So we invented JQuery - a patchwork for toy language that actually made it usable3.

And guess what, it’s not good enough mate! Classic Google having Google problems created Angular.js (not the same Angular that we know today btw). And the classic Facebook having Facebook problems and physically unable to use existing solution made by Google (I don’t know why) created React.

And betwixt all this somebody thought that it would be a great idea to run that stupid toy scripting language outside browser (like wtf!) which is the single grave mistake of humanity in my opinion. Like we would have been colonizing Mars if we hadn’t wasted our time with this toy language.

And lot of patchworks happened to fix this broken language which was never meant to be taken seriously. Alternatives and supersets for this stupid language started emerging to re-introduce types 4 and other goodies like CoffeeScript, ActionScript, Dart5, Applets, etc… and the only patchwork that still lives to this day is Typescript.

The patchworks started overloading so we need bundles like Gulp, Webpack (also written in same slop language) and transpilers like Babel, Typescript Compiler6. And now in 2026 we are in era of server components where this toy language layer is added to the server to render React pages7 on the fly8.

I am going stop this rant here - I could go on forever! But I need to come back to main topic of this article.

My idea

“It basically cut down all these patchworks!”

The tl;dr is web was not created for what we use it today, current web has at least thousand layers of patchwork to be what it is today. My idea is neither revolutionary nor new. It basically cut down all these patchworks!

We need some new protocol that is a simple bytecode that can be sent over TCP:

  • No separate languages like HTML, Yavascript - one single protocol.
  • Not locked to a specific toy scripting language. Doesn’t matter how you generate the bytecode.
  • Clients have the freedom to choose how to style the UI. The protocol itself should provide all UI elements (like menu bar, popup, side draw, etc…).
  • The protocol itself should be simple for any sane developer to write a client so that you won’t need big tech to vendor lock your ass with a browser and a incomprehensible standard.

So in other words just like our present day web, but bytecode and all SPA-like feel and modern components (the whole reason we use stuff like React) are all built-in.

I even did a tiny Proof-of-concept (not full demo) on this idea in this repo where I demo a simple client for Windows and Linux, where the bytecode is generated from Lua.

local UI = require('ui')

UI.render(function()
  -- <h1> to <h6>
  for i = 1, 6 do
    UI.text('Heading ' .. i, { size = i })
  end

  -- Normal text
  UI.text('Normal text')

  -- Button with onclick
  UI.button('Click Me!', {
    id = 'my-button',
    on_click = {
      UI.action.change_text('my-button', 'Changed!')
    }
  })
end)

Demo Output

Again, you don’t even need to use Lua, you can even raw dog this with C (which I a have also done in this repo). That’s the advantage of bytecode.

Conclusion

My idea won’t become a reality - I know that for a fact because all businesses and big tech have invested shit ton of money on current-day web. Nobody is willing to throw away all their code for greater good - that how it is9.

Why would companies Google give up their monopoly on browsers?

The harsh reality is nobody really cares about it as long as it’s barely functional and my stupid idea of saving humanity will forever stay an idea :(

Like when nobody cares, is it even worth saving?

-Siddeshwar

Footnotes:

  1. In the era of thick clients (Visual Basic) we would literally have to go to each and every computer and manually update the software. ↩

  2. This piece of info is already forgotten in the mist of modern day web development. Like nobody in web dev nowadays knows what CGI-bin was - and what TCP is (which is funny that their entire job is to implement a TCP protocol). ↩

  3. People nowadays don’t really know how much of a game changer JQuery was - because lot of it’s best features like $("#something"), $.ajax() are now built-in. And you don’t even need to worry about IE compatibility! People who still remembers XMLHttpRequest, ActiveXObject will understand what I mean. ↩

  4. It’s funny that we used statically typed language to create a toy dynamically typed language and now patching up with superset to re-introduce types back again! This is a circus! ↩

  5. Lot of people (even the OGs) don’t know this but Dart was actually created as a fix language for web! But this never became a reality! ↩

  6. Man the audacity of these web devs to convert one hight level language to another high level language and call it “compiler” is crazy. ↩

  7. Totally a great idea that went really well. ↩

  8. Funny that we came back full circle to original Web 2.0 - MVC but with more slop. Man this is really a circus! ↩

  9. Our entire financial system is still running on COBOL. Read this if you’re baffled but this fact. ↩