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:
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.
