Somebody's been reading The Oatmeal recently

(but seriously, very cool)

Very nice concept!

I've been thinking for a while that the web really suffers from not having a built-in concept of (ideally fairly anonymous) identity. I shouldn't need to maintain a whole authentication system and a database full of PII just to let you see the same data across your laptop and your phone...

At first I thought it is tiddlywiki but it is not.

This is coming close to WWW's original vision because the very first web browser was also an editor. Tim Berners-Lee's application on the NeXT was basically a wrapper for the operating system's built-in rich text editing class named TextView. (It later became NSTextView on Apple's Mac OS X and still powers the TextEdit app on Mac.)

We lost editing for two reasons:

1) The HTTP PUT method didn't exist yet, so edited HTML files could only be saved locally.

2) Mosaic built a cross-platform web browser that defined what the WWW was for 99% of users, and they didn't include editing because that would have been too complex to build from scratch in their multi-platform code base.

Very good. I was wondering why nobody did something like that before. At least this was my conclusion from my google searches few months ago. From a design perspective, I don't like storing state in the DOM itself, I would have find much more flexible to have the state in a json as a single source of truth and use reactive patterns such as state change => ui change and not hiting the DOM directly. That sounds like big framework things, but it saved me from acute headaches in a personal similar framework I did for self-contained apps. It was not HTML but I thought I would apply the same logic if I had to do it for html apps too.

Looks like it's on Github at https://github.com/panphora/hyperclay-local

Am I the only one that does not understand what the author wants to explain ?

Do we need a story with illustration to understand how a new framework works ? What's the plain markdown 2 to 3 paragraph that explains the concept ?

Edit : here it is. https://docs.hyperclay.com/docs/docs-tldr-paste-in-llm/#how-...

> Whenever the page changes—or the user explicitly saves the page—we grab all the HTML, make a few modifications, and then POST it to the backend’s “save” endpoint.

Wait, so instead of storing JSON we store HTML with all its verbosity and all its tags that have nothing to do with the user edit (e.g. a small profile description change) ? What about if the webmaster then wants to change the HTML title of the profile description block ? The user's version just diverged from the webmaster's ?

Interesting idea. Well put it on the list of things I should try some day.

After a quick look at the site, I like the idea. But I wonder where it's limitations start to get in the way.

How about security, if I can modify the page, who else can? And who controls that?

How much code and logic does it handle before getting difficult to maintain? And how much data?

If I make an useful app with it, say to track beers, can I share the app with other people without so they can track their own beers, without sharing my personal data?

This is really neat! It echoes many of the ideas we've been exploring with the Webstrates project (https://webstrates.net). We've been using the DOM as persistence layer for building malleable collaborative software for smaller groups, whereas hyperclay focuses on using the same mechanisms for traditional webpages. Recently, I have been experimenting with a local-first approach to Webstrates (https://github.com/Webstrates/MyWebstrates). Might be interesting to explore if a Webworker-based approach like in MyWebstrates could be used for offline editing in hyperclay.

Here's a video of the creator explaining more

https://www.youtube.com/watch?v=OUiTBFDxwaM

If you use Claude to generate apps in the artifact they are very similar - self contained and easy to create and share.

I appreciate the storytelling and the nice graphics, but after reading 10 screen lengths of this story I still don't understand what technology they are using to achieve this.

Is it a lot of words to talk about localstorage? How exactly are the changes persisted to the HTML file? Is it using FileSystemAPI to overwrite the previous HTML file? How can they implement it seamless for the user without them having to choose the proper file in the "Save As.." dialog?

The title reminds me of TiddlyWiki.

Great name, cool idea and this guy communicates well. Inspiring to see!

Slightly tangential: a lot of my vibe coding experiments are standalone SPAs because I can't be bothered to set up a secure server (and I am too cheap to pay for it). I love that I can open my "mobile-first" apps directly from my phone's Downloads folder.

I have a feeling that a lot of these little tools people make with low-code vibe AI apps do not require more than a single HTML page with JS imports.

(I also suspect that there is a ton of duplication in what people create, but, of course, I have no data to back it up.)

Very interesting.

Pricing page returns a 404 as of now, though.

https://www.hyperclay.com/pricing

This reminds me of a self contained svg editor running in the browser , that I wrote a few years ago.

To take this concept one step further towards perfection, you would want to lose the backend completely and persist directly to a git repo using https://isomorphic-git.org/

For people who are confused: Hyperclay is a NodeJS server and frontend JS library that allows HTML pages to update their DOM and then replace their own .html source with the updated version.

Imagine clicking a checkbox, which adds the `checked` attribute to its element, then using Hyperclay to globally persist this version of `document.body.outerHTML`, so that it's there next time someone visits the page. There's automatic versioning and read/write permissioning.

It's a pretty cool project! I'll definitely try for my own personal tools.

Do note that, from my understanding, it's most useful when there's one developer who is also the only content editor. Otherwise you'll have editors overwriting each other's changes, and if there are multiple copies there's no easy for the developer to push a change to all copies.

Someone rediscoved Windows 98 HTA archives.

https://en.wikipedia.org/wiki/HTML_Application

Very interesting concept.

I've imagined our internal claim cases to be standalone html pages, making them easily versioned for when new regulations come.

Simplicity is a good goal to have, and these guys have it.