Scrappy – Make little apps for you and your friends

I like the spirit of it, but the execution isn't what I'm looking for. With this being a hosted solution, it makes me dependent on another SaaS tool for little personal projects. If it's a little counter needed for an afternoon, that's not such a big deal. However, if I'm looking for a scrappy little app I may use for years, this is a problem. Plus, no matter how low the learning curve gets, it will still exist, so I want something that I can use for the long term for things like this. This makes my mind go to approachable and easy languages that allow the user to easily throw a GUI on it. I don't think code needs to be completely abstracted away, just made easy and tailored to what people will do. Look at how many people on MySpace were able to learn some CSS. Maybe they copy and paste someone else's stuff at first, but that's the foot in the door before they eventually look at how to tweak it.

I typically end up using basic HTML/CSS/JS for stuff like this today. If I really need backend code, I'll use basic PHP (no frameworks or anything). But this ties me to a browser, which I'm not always a fan of. Some of these fairly scrappy little projects at work (done in the browser like this, and with AutoHotKey) have been going for 10+ years now, with very little maintenance. The AHK script I haven't touched in probably 8 years, since I moved to macOS at work, yet people still use it countless times per day. If AHK decides to stop operating, it's no big deal, the code that exists will still run. The same can't be said for these SaaS solution to this problem. People looking for scrappy solutions aren't looking to remake their solution every time a founder decides to move on to something else more interesting or profitable.

This looks like something that should be done like a TiddlyWiki. A TiddlyWiki is a whole Webapplication in a single HTML-File. Traditionally, when you change something, you just save the HTML-File and it self-replicates with the new data. There are now also TiddlyWikis which can save to backends and probably some other ways.

Building a whole platform around self-replicating HTML-files with optional backend-access seems to be the more reliable solution for small personalized stuff. At least it has a strong resilience.

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

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/