Year: 2025

In another post, I compared every web page to a jail cell with two prisoners: paralyzed and harmless content, and unpredictable and dangerous code.

Because content on the Web is locked inside those jail cells, we can’t do certain things with it: annotate, combine, or create visible connections between pages. Even something as basic as saving a page often doesn’t work properly.

The Solution: New Data Formats

We need a web page format that contains HTML but is inherently incapable of containing scripts. A format like that wouldn’t need a jail cell. We’d be free to do all those things—annotations, content combinations, connections—that are currently impossible.

I proposed such a format, along with two other formats. I call the new format for text-based web pages HDOC.

But a new data format alone isn’t enough. If all we do is introduce it, we’re just creating a separate, smaller Web next to the existing one. Imagine the massive, entrenched Web—let’s call it Web 2. And next to it, a tiny Web 1.

If Web 1 is small and separate, how popular will it become? Will mainstream browsers ever support it? Some people—educators, for example—might use it for specific projects, like interactive parallel histories with visible connections. They’d publish materials on their websites, and students could access them using specialized software.

That’s fine. But it still leaves most content locked inside existing websites. Can we also free that content, instead of just creating new content in the new format?

Getting content out of the jail

Here’s the key insight: The jail of Web 2 is your browser. It starts empty. You request a web page, and your browser downloads it and locks it up.

But the content itself doesn’t live in that jail. It lives on a server.

Most web pages today are dynamic, meaning they don’t exist as standalone files. They’re generated on demand, pulling content from a database. That content is stored separately from the code, and separately from navigation elements that we don’t need on Web 1.1, like headers, footers, and menus.

So, getting content into HDOC format is easy: we just need a piece of code on the server that creates an additional endpoint for each page. It takes the same content from the database the original page would use, wraps it in an HDOC template, and sends it to the client.

Adapting servers for Web 1.1

How do we get this code on all servers? It’s a gradual process. Only website owners can do it. 

For WordPress sites, I developed a plugin. Install it, configure it, and every page on your site will have a static version. Original page will have a download link.

For other content management systems, similar plugins need to be developed.

For custom-built sites, the owner would have to implement a custom solution—but it’s not hard. Just extract the data from the database and wrap it in the HDOC template.

If a website consists of standalone HTML files, the only way to adapt it for Web 1.1 is to generate a static HDOC version of each file. Fortunately, such websites usually have only a few pages, so this process is often straightforward.

What About Web Apps?

Some websites act more like apps—think social networks. They don’t just serve up pre-built pages; they send you code that builds the page in real-time inside your browser.

That doesn’t work in Web 1.1, where code is not allowed on the client. So, these sites would need to modify their infrastructure, adding server-side code and possibly extra servers to generate static versions of their pages.

For social networks, the extra server load will be relatively small. Think about how many tweets you scroll past before finding one worth saving—that difference can be orders of magnitude.

Supporting the Static Web (Web 1.1) will come at virtually no cost for large websites and, for many small sites, it will be completely free.

Incentives

Will people actually start adding the necessary code to their websites? I believe everyone has a reason to do so. It might be difficult to explain at first, but once momentum builds, Web 1.1 adoption could grow exponentially—effectively duplicating the entire Web. I delve deeper into incentives in another post.

Conclusion

If enough websites adopt HDOCs, it won’t just be a small parallel web. It will start unlocking the content that’s currently trapped in Web 2. And once that happens, new ways of using the Web—annotations, recombination, richer interconnections—will become possible all over the Web.

For a long time, there have been only two main ways to interact with a computer screen: command-line interface (CLI) and window-based graphical user interface (GUI). I came up with the third one. I call it continuous space Interface (CSI).

What is wrong with window-based interface?

Have you ever noticed how awkward it is to navigate your computer? First of all, you don’t have enough space. The size of your screen determines how much working space you have.

Everything is crammed into sliding windows that constantly overlap. If you want to view one thing, you have to push something else out of the way. Or you stack windows on top of each other, creating a mess.

Because there is always not enough space, everything is dense. Whenever you need to make a choice, you always have to choose out of 100 items.

• Need to open an app? Here is a list of your 100 apps.
• Need to use a bookmark? Here are 100 bookmarks to choose from.
• Need to find a note? There are countless notes, so you have to use search.

Windows are constantly shifting relative to each other, making it hard to orient yourself. Every time you need to switch contexts, you have to pause and think, How do I get there?

The only thing that remains somewhat stable is the folder hierarchy—which is a nightmare of its own. Humans didn’t evolve to navigate tree structures. It’s an unnatural, abstract way to organize information.

Also, why do we still have to name every file we save? In the real world, you don’t label every piece of paper you set on your desk.

Imposed hierarchies

Apps impose hierarchies that you may not want to use. For example, you may have a certain project in mind. There are things on your computer that belong to that project, like bookmarks, notes, files, etc. But where are they? They are all over the place.

• Bookmarks live in your browser, buried among bookmarks from unrelated projects.
• Notes are trapped in your Notes app.
• Files are hidden somewhere in a folder maze.

Each time you need something, you’re forced to either sift through 100 options or rely on search.

How did we get here?

A lot of these design choices were made when computers were primitive by today’s standards.

• Hierarchical directories? Invented before computers even had screens.
• Window-based GUI? Developed in the ’70s, when it made sense given the limitations of the time.

Back then, these ideas were practical. Today, they’re just outdated traditions.

We now have computers powerful enough to render entire 3D worlds in real-time—yet we’re still clinging to outdated design principles like folder hierarchies. Instead of designing interfaces that work for us, we keep making things convenient for the computer.

The solution. Continuous space interface

You know what’s easy to navigate? The real world.

In the real world, you don’t shuffle through sliding windows—you place things in space. Related objects are positioned closer together. You don’t need search bars or hierarchical menus to find your stuff. You just know where things are because of spatial memory.

So why don’t computers work the same way?

They can. We already build immersive digital spaces in video games. Imagine an operating system designed like that. Instead of staring at a cluttered desktop, you’d enter a spatial environment—a 2D or 3D space where your data isn’t locked inside folders but arranged visually, like objects in a room.

No more sliding windows—just move through your workspace instead of rearranging it.

No more file names—just like objects in real life don’t need labels, your digital documents can be identified by their location in space.

No more rigid hierarchies—just arrange things in a way that makes sense to you.

You may think that such navigation will be too slow. But in reality it will be like playing a video game on a God mode. There will be all sorts of navigational tricks and shortcuts that will make you navigation super fast while keeping it continuous. You want to avoid ‘teleportations’ or instant changes in your environment that disorient you.

No imposed hierarchies

In a spatial interface, you control the organization.

Say you’re working on a project. Instead of digging through separate apps, you could have everything—notes, bookmarks, images—right there in one space.

Imagine a simple rectangle representing your project. Inside, you place everything related to it. No more choosing between 100 options or relying on search. Instead, your choices are always visually and spatially obvious.

You can organize your projects the same way, by placing related projects closer together.

This may remind you of folder hierarchies. But this is a hierarchy that you create. Not something inconvenient that is imposed upon you.

Here is an example of a 3D interface:

How to implement Continuous Space Interface

We don’t need to build an entirely new operating system from scratch. Instead, we can start with an app. While a dedicated OS might be useful in the future, the best way forward is to test the concept in a more controlled way first.

We can also define a limited scope to begin with. The app could handle essential elements like:

• Text documents
• Images
• Links
• File shortcuts
• Lines and arrows

More features can be added later. Do we need spreadsheets? Maybe—but it’s not necessary to include everything from the start.

LZ Desktop

I’ve already built an early version of this concept. I call it LZ Desktop (Large Zoomable Desktop). It’s far from finished, but I released it anyway—because it’s the first step toward building a new kind of web, which I discuss in other posts.

As I continue to improve the app, others can start creating content in new formats that currently only this app understands.

Here is a short video demonstrating some features of this app:

You can download the app here.

How I came up with this idea

I wouldn’t have realized there was something fundamentally wrong with computers if not for Ted Nelson. He started designing interfaces for computer screens before computers even had screens, imagining a world where computers would connect and interlink information seamlessly.

The way I understand his vision, connectivity was meant to be the core feature of computers. You should be able to link and combine pieces of content from different places—whether on your local system or across the network. Instead of isolated files and rigid structures, everything would flow together.

But his ideas didn’t prevail. Instead, computers and the web became highly containerized. Everything is locked inside a box—a file is a container, a web page is a container, an app is a container. The seamless connectivity Nelson envisioned was thrown away, all in the name of security and scalability.

I believe connectivity is too important to sacrifice. There are other ways to ensure security without isolating everything into silos. As for scalability, you don’t need to scale everything. The most common actions people take on computers—writing, linking, saving information—could be standardized, eliminating unnecessary variations in how different apps handle the same tasks. There’s no need for every application to reinvent how text is processed or how links are created.

Instead of forcing users to navigate a maze of folders and incompatible tools, we could create an environment where these fundamental actions work seamlessly across the system. For more specialized cases, containers can still be used, but they shouldn’t be the default for everything. 

Post scriptum

At first glance, this post might seem off-topic for this website, which is focused on transforming the Web rather than computer interfaces in general. But the Continuous Space Interface is deeply connected to that transformation. It doesn’t need to become mainstream to have an impact—its mere existence can set off a chain reaction that pushes the Web toward new formats and interactions. But that’s a topic for another post, and this one is long enough already.

The World Wide Web started as a web of documents. That was back in the early ’90s. Web pages were static HTML documents—simple, read-only pages that just presented information. There was no interactivity. Then, in 1995, JavaScript was added to browsers, changing everything.

When you add a script to a web page, the page has to become a container. You don’t want the code on a page to access your file system, for example. You don’t want it making unauthorized requests to other servers. So, browsers imposed all sorts of restrictions to keep code in check. But in doing so, they also locked up content.

The Web as a Jail

Imagine each page in your browser as a jail cell. Inside every cell, there are two prisoners: content and code. Content is like a disabled person—paralyzed. It consists of text and images, which just sit there passively. It’s harmless.

Code, on the other hand, is unpredictable. You don’t know who wrote it. You downloaded it from some website, and now you have to run it on your computer. So, it’s placed in a container—a controlled environment. Each web page is its own separate container.

Why Is This a Problem?

Each page, being locked in its own container, becomes its own isolated universe, completely disconnected from everything else. The entire Web is now just a collection of parallel worlds with no bridges between them.

Because of this, certain features become impossible. For example, you can’t have visible connections between pages. You can’t combine multiple documents from different websites onto a single page.

You also run into all sorts of problems with saving and caching documents. Try saving a web page, and very often, the saved version appears broken. Pages today are too dependent on live server connections. If a server goes down, the content disappears.

The Web started as a web of documents, but it was transformed into a web of containers running apps inside them. These apps often don’t function without an internet connection. They construct pages on the fly, eating up your computer’s RAM and slowing everything down. Worse, many of them track your activity and collect data on you.

The Solution: Bring Back the Static Web

The Web should primarily be a web of documents, with containers used sparingly. Right now, it’s the opposite—it’s a web of containers. Even if a page has no code, it doesn’t matter. It’s still in a container. Browsers treat all pages the same.

To rebuild the Static Web, I propose three new data formats:

• HDOC: A static equivalent of an HTML document. It uses standard HTML tags but can’t contain any scripts.
• CDOC: A collage format that can contain images, text, lines, and other documents (including HDOCs). It’s based on SVG and is partially defined at this time.
• SDOC: A 3D scene format that can include various document types. This is still in the conceptual phase but will be based on an existing 3D graphics format.

All three formats are purely static and contain no executable code. This means they don’t need to be locked inside a container. You can save them on your computer, and they will always appear the same. They have no dependencies. They are as robust and enduring as Sumerian clay tablets.

By adopting these formats, we can move back to a Web that is durable, reliable, and truly interconnected—just as it was meant to be.

Examples

Almost any web page can have an alternative version in the form of an HDOC. Here is what downloading an HDOC looks like:

Here is an example of visible connections between web pages – something that is impossible on the modern Web with regular web pages:

And in this video you can see how an HDOC can be downloaded into a 3D environment:

Adoption of the Web 1.1

At first, the new data formats will be used in spatial storage apps, like LZ Desktop. You will browse web as usual, using your favourite browser. Web 1.1 will help you download and spatially organise webpages on your computer.

I wrote about stages of Web’s evolution and incentives for its adoption in other posts.

Inspiration for the new Web

The Web I propose—Web 1.1, or the Static Web—is heavily inspired by Ted Nelson’s project Xanadu. Ted Nelson, one of computing’s pioneers, coined the word “hypertext.” Today, we associate hypertext with HTML, but what he envisioned in the 1960s was much more ambitious.

Modern Web links (which Nelson calls “jump-links”) are just one small part of what Xanadu aimed for. Xanadu had visible connections between documents, transclusions (where a document could include parts of another document), built-in versioning, and more.

I’ll dive deeper into Xanadu in another post.

Will Web 1.1 succeed?

You may be skeptical. After all, anyone can invent a new data format. The real question is whether it will gain adoption.

The reason I’m optimistic about Web 1.1 is that I believe I’ve identified strong incentives for website owners to start using these new formats.

I talk about that in another post.