I increasingly feel that browsers are carrying too much historical baggage.

Today every browser ships gigantic subsystems:

• a JavaScript engine
• an HTML parser
• a CSS engine
• a DOM engine
• a rendering engine
• layout systems
• style systems
• compatibility layers for decades of legacy behavior

Modern browser engines are among the most complicated software projects humanity has ever built.

And yet when I look at where the web is actually going, I see something different emerging.

I think the future web should become a universal VM.

And WebAssembly should become its true target.

The Browser as an Operating System

Modern browsers already behave like operating systems:

• sandboxing
• permissions
• process isolation
• scheduling
• GPU access
• networking
• storage
• IPC
• security boundaries

The browser is no longer just a “document viewer”.

It is becoming a secure portable runtime platform.

But the current stack is still deeply tied to the document-web era:

• HTML
• CSS
• JavaScript
• DOM

Those technologies made perfect sense when the web was mostly:

• documents
• articles
• forms
• hyperlinked pages

But increasingly the web is becoming:

• applications
• IDEs
• games
• creative tools
• simulations
• operating environments

The web is evolving from “documents” into “software”.

WebAssembly Feels Like the Real Direction

WebAssembly changes the philosophy completely.

Instead of:

• interpreting scripts
• mutating giant DOM trees
• depending on browser-specific behavior

applications become compiled software.

Language
   ↓
WebAssembly
   ↓
Universal Web VM

This is much cleaner.

The browser no longer needs to understand every language ecosystem.

It only needs to provide:

• security
• sandboxing
• graphics
• audio
• networking
• storage
• scheduling
• host APIs

Everything else becomes portable compiled applications.

HTML/CSS/JS Become Legacy Mode

I do not think the legacy web should disappear.

Backwards compatibility matters.

But I think the future browser architecture should invert priorities.

Instead of:

• HTML/CSS/JS being the core platform
• Wasm being an addon

it should become:

• Web VM as the core platform
• HTML/CSS/JS as compatibility mode

Imagine browsers shipping a tiny “legacy web subsystem”:

• a small JavaScript engine like QuickJS
• compact HTML/CSS parsers
• lightweight renderer
• compatibility layer

Not the giant endlessly-growing engines we have today.

Small enough that they could realistically remain forever.

The old web keeps working indefinitely.

But modern software targets the VM directly.

The Web VM

What I imagine is something closer to:

Web VM
├── Wasm runtime
├── GPU API
├── Audio API
├── Windowing/UI APIs
├── Networking
├── Filesystem/storage
├── Sandboxing
└── Legacy web subsystem

Applications compile into this environment.

Not into JavaScript.

Not into HTML trees.

Into the VM itself.

A More Powerful WebAssembly

Current WebAssembly is still heavily influenced by C and Rust assumptions:

• static typing
• low-level memory
• structured execution

But I think Wasm will evolve.

And honestly, it already is evolving.

Features like:

• GC
• reference types
• exception handling
• component models

are pushing Wasm toward something much more dynamic-language-friendly.

I believe future Wasm runtimes could become excellent targets for:

• JavaScript
• Ruby
• Python
• Lua
• Lisp
• functional languages

Not through awkward transpilation.

But through real compilation pipelines.

JavaScript Should Compile to the Web

Ironically, I think JavaScript itself should eventually compile to WebAssembly.

Not be the platform.

Be a language targeting the platform.

The same should be true for:

• Ruby
• Python
• TypeScript
• Kotlin
• Swift
• Zig
• Rust
• anything else

The web becomes language-neutral.

That is the truly open future.

The Browser Should Disappear Into the Operating System

I also think the current separation between:

• operating systems
• browsers
• app stores
• web apps
• native apps

feels increasingly artificial.

The web has become too fundamental to live inside a single application called “the browser”.

Right now we have:

• OS taskbars
• browser tabs
• desktop apps
• browser apps
• app stores
• websites

Everything exists in separate worlds.

It feels fragmented.

You open a browser.
Then inside the browser you open tabs.
Inside those tabs you run applications.
But the operating system itself already has concepts like:

• windows
• applications
• task switching
• icons
• launchers
• search

The duplication feels wrong.

Tabs Were a Historical Artifact

Browser tabs made sense when the web was mostly:

• pages
• documents
• browsing sessions

But modern web applications are not really “pages” anymore.

A web IDE.
A game.
A design tool.
A music app.
A messenger.

These are applications.

Treating them as temporary tabs inside another application increasingly feels outdated.

The browser should stop being “an app containing apps”.

The operating system itself should understand the web natively.

One Unified Application Model

I imagine a future where:

• native apps
• web apps
• local apps
• remote apps

all coexist naturally.

One taskbar.
One app launcher.
One search system.
One desktop.

No distinction.

Web apps appear exactly like native applications:

• pinnable
• movable
• searchable
• launchable
• multitaskable

And equally important:

Native apps and web apps appear together in the same ecosystem.

The Web Becomes the Universal App Store

In this world, the web itself becomes the app store.

Not controlled by one company.
Not locked behind one platform.

The operating system’s search bar becomes the universal entry point.

You type:

• installed native apps
• pinned web apps
• local tools
• remote tools
• websites
• cloud applications

all in one place.

Search → everything

The distinction between:

• “opening a website”
• “launching an app”

starts disappearing.

Instant Applications

One beautiful thing about the web is immediacy.

You can open software instantly without installation friction.

I think that should remain.

Users should be able to:

• launch a web app instantly
• use it temporarily
• never install anything

But if they use it often:

• pin it
• move it on the desktop
• integrate it into the OS
• let it behave like any native app

The same application can fluidly exist as:

• a temporary session
• a pinned app
• a full integrated desktop experience

without artificial boundaries.

The Open Ecosystem

Of course companies like:

• Apple
• Google
• Microsoft

will always build their own ecosystems:

• payment systems
• discovery systems
• curation layers
• branding
• UX styles

That is fine.

But I think the core platform itself should remain open.

No company should fully own application distribution.

The web is too important for that.

Native and Web Stop Being Different Worlds

Eventually I think the distinction between:

• native software
• web software

should mostly disappear.

Applications should simply target:

• the operating system
• the universal web VM
• the shared runtime layer

And users should not have to care how the application was built.

Only that it works.

Fast.
Secure.
Portable.
Open.

That feels like a much healthier future than:

• locked app stores
• isolated ecosystems
• giant browser silos
• duplicated runtime stacks

A future where the web is not “inside” the operating system.

The web becomes part of the operating system itself.

The Real Open Web

Today the web is “open” mostly through standardization of:

• HTML
• CSS
• JavaScript

But that also hardcodes enormous complexity into every browser forever.

I think the next stage of openness is different.

The browser becomes:

• a secure universal VM
• a portable runtime
• a standardized execution environment

And languages compete above it freely.

That feels cleaner.
More scalable.
More future-proof.

And honestly, more elegant.

The Legacy Web Never Dies

One important part of this vision:

The old web still works.

Forever.

The browser still contains:

• a tiny HTML engine
• a tiny CSS engine
• a tiny JS runtime

Enough to preserve decades of content.

But no longer the center of the platform.

The center becomes the VM.

The Web as Universal Compute Platform

I think we are slowly heading toward a future where:

• browsers look more like operating systems
• applications look more like portable binaries
• Wasm becomes a universal target
• the web becomes language-agnostic

And eventually:

• “web app”
• “desktop app”
• “native app”

may stop meaning fundamentally different things.

At that point the web is no longer a document platform.

It becomes the universal runtime and viewer for software, files, documents and digital experiences.