meistertigran

I am not familiar with it, but I was thinking about making an open source version of this, but using webRTC, to just directly allow peer-to-peer synchronization without a centralized server.

In this type of scenario there are a lot considerations to be made though, specifically since you can't use CRDT's to handle concurrent updates on the data you have to either 1) not allow offline use of the apps, 2) create a merge conflict resolving interface or 3) just overwrite all changes with the latest one.

Idk if people would be interested in this and I haven't been using my HTML tools for a while now, so it's just an idea, maybe someone else wants to work on.

I was also heavy on these single-file HTML tools. My problem was not being able to sync the localstorage data between PC and smartphone. I made a paid service which did that automatically. It didn't take off unfortunately, and I am keeping it on maintenance mode because it has some amount of free users that rely on it.

For anyone interested, to achieve synchronization I basically just use the https://github.com/google/diff-match-patch lib and save the patches in a db for each version with a version id. Then there's a generic JS file that I inject to uploaded HTML files that monkey patches the localstorage methods and optimistically updates the localstorage at the same time sending the diff to the server to save to the db.

It's not about speed for me. Reading faster forces me to focus, while my mind wanders off when I read slowly.

I read fast and then stop to think about it.

What I took from this is that you have a really engaging writing style. Was interesting to read from start to finish.

Thanks! Pretty much, yes. Also if you are a dev and just don't want to spin up a server for every simple app you vibe code, you could find this useful.

To be honest, I wanted this for myself and felt guilty not making something more serious out of it since I liked the idea.

So like, Obsidian, but for HTML?

The file itself provides both the dynamic functionality and data storage, but you need an engine (like obsidian) to make the data persistence and dynamic parts work together. I.e. if there is a button that adds a task to a todo app, your engine modifies the HTML file with the new content.

I share your opinion about the quality of vibe coded apps. It's definitely not something you can pull off with 0 programming knowledge at this moment. I don't know how the quality of LLM written code will change in the future, but I do believe a lot of custom apps that basically just store and display data can already be easily one-shotted.

The more complex the app becomes, the harder it will be to maintain it with vibe coding. Personally I have chosen to just create specialed apps, that do one thing well, to avoid that complexity.

You don't get localStorage persistence though.

I had the same problem, regarding localStorage synchronization. For that I made htmlsync.io, but only really worth it for people who have many local apps like that and really need the localStorage sync.

You can do that with htmlsync.io

To be completely honest, I don't see how this is more useful than adding a sync layer to localStorage. I did make a service that does that at htmlsync.io and am genuinely curious how this solution is better.

This is really cool. About to try it out!

I build something along those lines as well. My problem was that I couldn't synchronize localStorage data, so I made htmlsync.io.

Can you share the paper mentioned in the demo video?

I have been doing something very simillar!

Instead of giving it a VPS, I just made a tool that allows synchronization of localStorage data.

I now just upload the HTML it generates and have an app instantly.

Org mode is nice, but ultimately you are adapting someone else's approach. The best is making your own, for which you know all features and which works exactly as you want it to work.

This is accurate. It's about having something that works with your specific personality type.

That's why I personally just give some instructions to an LLM and create a simple scrapy HTML app that does exactly what I need.

I think the key point here is that you made a solution for yourself. If you would've finished the one you started, you would've known all it's features and could've customized it to your liking. Personally I just use AI to spin up a quick HTML file that solves any personal productivity needs I have.

I am working on htmlsync.io, an easy way to synchronize localStorage between devices. I found myself using AI a lot to generate single-file HTML web apps that saved data in localStorage and wanted to have access to them from phone. This was my solution.

You can create a demo directly in the home page. No signup required.

You don't even need to have a file, you can use a template.

No problem. You can use the upload form on the homepage as well, it doesn't require a sign up.

There's a button on the homepage "Watch How It Works", does that not open for you?

Here's a link to the video - https://www.youtube.com/watch?v=PbKFCEUy2ps.

Think so too. Also because different companies have different "reviews" of his work. Some saying he was only good at interviews, others saying the quality of work was good. Must have been diffferent people working.

I have found that you can't let the LLM do the thinking part. It's really fast at writing, but only writes acceptable code, if the thinking has been done for it.

In some cases, this approach might even be slower than writing the code.

A lot if it is just technical jargon. Which doesn't mean it's bad, one has to have a way to talk about things, but the underlying logic, I've found, is usually graspable for most people.

It's the difference between hearing a lecture from a "bad" professor in Uni and watching a lecture video by Feynman, where he tries to get rid of scientific terms, when explaining things in simple terms to the public.

As long as you get a definition for your terms, things are manageable.

At first, I created a simple API via Python that was basically mimicking the localStorage API. It would accept getItem and setItem requests and write it to a file. In the HTML file I was replacing localstorage calls to calls to the API automatically, via a script that was doing a simple search-and-replace on the file. I was also assigning a custom subdomains via nginx to each html file, so that it could have the max 10MB storage that localstorage can have.

After a while it became clunky doing things with separate scripts, so I ended up creating - htmlsync.io. It's still pre-alpha, but registrations for the free tier are open.

Actually implementing persistent storage for simple apps isn't that hard, especially for a big corp. Personally, I was using LLMs coding capabilities to create custom single-file HTML apps, that would work offline with localStorage. It's not that there aren't good options out there, but you can't really customize them to work exactly how you want. Also it takes like half an hours to get what you want.

The only downside was not being able to access the apps from other devices, so I ended up creating a tool to make them online accessible and sync the data, while using the same localStorage API. It's actually pretty neat.