Hacker News Reader

Comment by panphora | Hacker News Reader

I'm building a self-modifying HTML runtime inspired by TiddlyWiki [0]. It lets you build "HTML apps" in a single file with plain CSS/JS. These apps are shareable and hostable, but you can also download and use them locally as offline apps [1].

The cool thing is each HTML file is able to modify/overwrite itself, so users can use the app's own UI to modify it (e.g. a dashboard where users can add new fields by clicking a button to clone a DOM node, everything's persisted).

The key insight: collapsing the UI/state/logic layers into a single self-contained HTML file eliminates entire categories of complexity - no build steps, no deployment, no state synchronization. Everything you need is just right there.

[0] https://hyperclay.com/

[1] https://hyperclay.com/hyperclay-local

View on HN

This looks _very_ cool --- does it align with:

https://www.goodreads.com/book/show/192405005-hypermedia-sys...

(and if not, are you aware of a book which touches on/explains your technique?)

Do you think a visual tool for this could be created? (something like Lazarus or Interface Builder or QT Designer...)

Yes, there's definitely philosophical alignment with the hypermedia approach: keeping things simple and leveraging HTML's native capabilities. In fact, I use hypermedia-oriented techniques on all the dashboard pages in the Hyperclay web app.

But in Hyperclay apps, the DOM is the source of truth -- there's nothing else. So there's no need for more than a single AJAX call (to save the page). HTMX is built to support a more traditional multi-page stack, whereas Hyperclay is built around single-file HTML apps.

The idea is that every HTML file is its own visual tool for modifying its own UI/data. For instance, you could build a page layout editor that lets users drag-and-drop components, and the editor itself would be part of the saved HTML file. An infinite variety of visual tools can (and will) be built on top of this structure.

As for essays about this vision, I'd recommend "Local-first software" [0] and "Malleable software" [1]

[0] https://www.inkandswitch.com/essay/local-first/

[1] https://www.inkandswitch.com/malleable-software/

I'm a little experienced with TiddlyWiki, from memory: `rclone serve webdav` in the directory with TiddlyWiki will let you "write in place".

My use case was a home maintenance wiki/manual, the incredible benefits of something like TiddlyWiki in this use case is the ultimate survivability of it.

Open `HomeManual.html` in any browser and you can read it (and modify it!) and literally File -> Save As... `HomeManual-2025-07-18.html`. For more convenience: `rclone serve webdav` and the "(*) Save..." button works to save in place.

Ultimate survivability. Self-contained, it works on mobile, pairs great with SyncThing, devolves into read only, has a "normie-understandable" option for modifications.

Really, what I'd prefer is a bit less complexity of the wiki itself, and some slightly better integration between `exportAllPages("*.md")` and "AllTogether.html". I'd love to be able to pop open vim 90% of the time and somehow "merge things" as expected (conflict-aware, diff-ish integration).

Take a look at the use cases I've described and it'd be amazing to have a framework "Quine.html" (that can self-reproduce) that was less complicated than all the cruft that's built up in TiddlyWiki.

Like RedBean?

redbean is an open source webserver in a single-file that runs natively on six OSes for both AMD64 and ARM64. Basic idea is if you want to build a web app that runs anywhere, then you download the redbean.com file, put your .html and .lua files inside it using the zip command, and you've got a hermetic app you deploy and share.

https://redbean.dev/

I'd forgotten about that one... cosmo/ape (and *.zip) opens up a few interesting use cases for portability, but the in-place editing with web-dav and ability to use the browser as an IDE (file->save) would have to be built-out with something like redbean.

Seriously, if you haven't, go check out the "zen" of tiddlywiki: https://tiddlywiki.com/#GettingStarted

You download "blank.html", make changes, then save it as "mine.html" and you're off to the races. It's pretty wild!

Hyperclay is quite interesting, well done! But to use it we need to install an app? I think the UX of tiddlywiki that just work is better

No app installation needed, Hyperclay files are just HTML files, so they work like TiddlyWiki in that regard. You can download them and use them locally with any text editor, or even implement TiddlyWiki's saving mechanism if you prefer that workflow.

The key difference is when you want to share your creation on the web. With TiddlyWiki, you typically share a read-only version, requiring visitors to download and save their own copy. With Hyperclay, you can host that same HTML file on any server and live-edit it directly in your browser (if you're the owner). When people clone it, their clone is shareable and available on the web.

So you get the best of both worlds: the simplicity of a single HTML file that "just works" offline, plus the ability to publish it as a living document that you can edit directly in the browser.

Think of it as TiddlyWiki's philosophy extended to the shared web. Same single-file simplicity, but now your changes can be seen by others.

> Think of it as TiddlyWiki's philosophy extended to the shared web.

Sorry but I'm having issues seeing this as a feature. TiddlyWikis can be shared as easily as sending an attachment. Running a server, tho, is not simple at all for the common user.

It looks cool. Two quick things: - the pricing page is an unstyled 404 right now - the docs subdomain requires javascript to display at all which is fine I guess but odd because the examples are viewable without javascript enabled

Otherwise really interesting, thanks for sharing!

Reply on news.ycombinator.com