This post was last updated on February 27, 2026.
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 navigation elements 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.
But that’s usually not the best way, because we end up with two endpoints for the same piece of content. A better way is to use an Embedded HDOC. It’s just a regular HTML page with additional information that allows client software to turn that page into an HDOC locally. If the client software is not compatible with Web 1.1 formats, it will show such pages as regular HTML pages without any visible changes. This way, two versions of the same content are served from one URL.
Just like with creating a new endpoint, we need a piece of code on the server that will create Embedded HDOCs.
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 invisible additional information. People with Web 1.1 compatible software like Visible Connections Chrome extension will see those pages as HDOCs. All other users will not see any changes on your website.
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 include additional information on each page programmatically according to the specification of the Embedded HDOC.
If a website consists of standalone HTML files, you can just include additional information manually on existing HTML pages.
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.
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.