HN Explorer

Ask HN: Apps that are built with Git as the back end?

83 points by hannes_paul ↗ HN
Hey HN, I'm working on a project that builds with git as the backend (https://github.com/inlang/inlang) and I'm looking for other projects that have a similar approach.

PS: Also apps such as VS-Code or Obsidian which work on local files and have git plugins would be interesting!

67 comments

[ 1.1 ms ] story [ 144 ms ] thread
xanthine
Not entirely necessary for its function, but UNIX `pass` and dotfile managers such as `yadm` come to mind when considering git based programs.
naltun
pass is an excellent tool.
theturtletalks
I built Opensource.builders using GitHub Issues as a CMS. Building 2.0 using an actual CMS though.
georgyo
GitHub issues are not git and don't even use git.
slowhand09
This guy built and hosts a SQLite database via github. Is this helpful?

https://phiresky.github.io/blog/2021/hosting-sqlite-database...

georgyo
This is not using git as a backend, it is merely using GitHub's static web hosting to serve files. Still impressive, but git could have been replaced with FTP here.
slowhand09
Don't think I agree. He is using a real SQL database stored in git. You can run queries against it. He's hosting a database in a static web site. I don't see this as an ftp clone.
georgyo
The database is stored in git, but is using GitHub actions to create a tarball of that database that is then severed as static files on GitHub pages.

It being stored in git is irrelevant to the end result. The same exact content without git could be on S3, or any other static hosting, and it would work exactly the same.

Another example, is the following map _using_ git, or is git just a method to get free hosting from Microsoft?

https://github.com/foundationalfactorio/foundationalfactorio...

https://foundationalfactorio.github.io/maps/#3/61.52/-2.46

The end result is just static files be served.

rmnclmnt
For simple use-cases and dev-oriented tools, this is a pretty nifty thing to do! Diagrams.net[0] is one such app that can use Git as a backend. Pretty awesome!

[0]: https://www.diagrams.net

jtwaleson
I'm using a webscraper that extracts data from some APIs, and stores all the data in a git repo periodically. Then you can see the data changing with tools like git and tig.
simonw
I love that pattern. I call it "git scraping" and I've been writing about it for a few years (and building tools too): https://simonwillison.net/series/git-scraping/
ukd1
Interesting - I've been doing similar for a while (not writing about it though), but generally "self-commit" - i.e. the code in the repo commits back to itself, usuualy using github actions, or gitlab. E.g. https://github.com/ukd1/lvms-events
hprotagonist
overleaf uses git as a data store for collaborative editing.
hannes_paul
Do you mean that overleaf uses git itself to enable real time collaboration or are you referring to the Git-Bridge and GitHub Synchronization features?
remram
Is that true? It always seemed to me that it generated commits periodically from its internal representation. The Git history seems way less granular.
est
I have the same question, I am have a git based static generated blog, I am looking for something like

1. A git based tool to scrobble the music I am listening to, like Last.FM.

2. A status logger, I really, really miss the old MSN or GTalk days when there's a status line to show what my friends are doing or their mood. In fact most people have forgotten that's the original case for twitter.

3. A git based comment system to replace Disqus, I can merge for incoming comments or reject spam.

4. life streaming to log the movie I've watched or books I've read.

samuelstros
Can you elaborate why 3, a git-based comment system, is beneficial? When do comments need to be merged?

PS There is a small web sdk that enables comments on sited via github issues. see https://github.com/utterance/utterances

est
> a git-based comment system, is beneficial?

I don't need no db or a web API to store comments. A db need some moving parts to serve http, a third party service is unreliable in the long run. Comments can be stored as part of a static site, like in json for csv format, as it's frequently read but rarely written. Static files are easy to integrate into any webpage, easy to backup, migrate and grep.

I realize there are some problems yet to be solved, e.g. mask email address of the commentor.

wolfium3
Dataform comes to mind (if you set it up to use git like that)
FrontAid
Very interesting! I had a look at your "RFC 001: Core Architecture" but one question remains. You mentioned "git as the backend". As far as I understand, you don't use the word "backend" in the classic frontend <=> backend sense. Instead, you mean that Git is being used as a software repository and as a content database. Is that correct or am I missing something?

I'm already sold on the idea of using Git as a database for content and localization. But I'm obviously biased as we are working on a similar solutation ;) It is called FrontAid and it is a CMS that stores your (localized) content in a JSON file within your own repo. More information can be found at https://frontaid.io/

Using Git for content has some great benefits. Like complete version history, easy reverts (for devs at least), (feature) branch support, Git hooks, ... And of course, you own your content at all times.

PS: Both the "Editor" and "VS-Code-Extension" links in your repo are broken.

samuelstros
Maintainer of inlang here:

Correct, the term git backend refers to git as a content database (with built-in version control and automation).

Regarding front aid, great to see fellow startups working on solution built on git. It took months to realize the benefits of git and the logical step to build the backend on git. sorry, use git as the content database.

PS ty, fixed the links! :)

mcprwklzpq
The Office 365 backend uses git to store snapshots of documents. [1]

https://github.com/microsoft/FluidFramework/tree/main/server...

fuzzy2
Not entirely related, but using Git nonetheless: I recently wrote some proprietary software that uses LibGit2Sharp (a .NET wrapper around libgit2) to store user changes to text and some configuration in a Git repository. The text “diffs” very well by default. For the configuration (key/value pairs), I chose a subset of TOML.

The API of libgit2 is great. If you don’t need the more advanced features of Git, I recommend taking a look!

dan353hehe
Tim Caswell has several projects that interact directly with git. He has a few websites served directly from a bare git repo powered by https://github.com/creationix/wheaty. Another project that uses git as a storage medium is a package server for the node.js API implemented in Lua: https://github.com/luvit/lit.

Both serve files from a git repository, and lit will actually write to the repository. There are several others that Tim has built over the years, but those are the two that I am familiar with.

dan353hehe
Also spent a few minutes browsing around and found https://github.com/creationix/tedit, a web based editor that reads and writes directly to git (I think).

Like I said Tim has quite a few projects that interact directly with git.

creationix
Yep, I've got lots of experience in this area. It works very well for read-only use cases and is interesting for read-write like tedit. Also it's amazing for build systems like the one built into tedit. I wish the webdev world in general would move to that model. It would save so much compute people would joke it would slow global warming.
glacials
A little different: I wrote a bespoke static site generator [1] for my personal website to allow my favorite mobile writing app to be a “frontend” that I can use to write+publish content from my phone (no code) to a Git data storage layer. An iOS Shortcut pushes every time I close my writing app. The weird part is it’s the same Git repository I also write the code parts in, so I have to take some measures to compartmentalize the two.

[1]: https://twos.dev/winter

smashface
We have a project that is basically an internal, stripped down version of CodePen and others like it. All code samples are stored in git.

The main challenge for something like our app is search. Git is good at creating files and managing versions/branches but not good at search files or their content. I'm not a git expert to fully backup that claim but that's been our experience. You can layer on your own search capabilities if you need it but then you might want to start asking if a full DB is better.

davelondon
This is an excelling CMS: https://forestry.io/

I used it as the editorial interface for a little static blog: https://www.wildernessprime.com/

simonmales
Thanks for the link. Have been toying with idea in my head for years.
carapace
I'm working on a simple IDE for a purely functional language, it's basically a text editor with a pure FP language as the "macro language", if you will.

When it came time to add strings and I/O I realized that it would mess up purity to provide the typical POSIX-ish filesystem APIs, so I thought, what if I denote strings (of byte sequences, or even bits) as a three-tuple of (hash offset length) backed by a git object store?

The IDE uses a git repo as its fundamental base or environment, you can only edit files that are in the repo (there is an "import" function (aka "git add") of course.) This includes source code and any string literals so your strings already automatically have a three-tuple, and this is true for selections as well.

The obvious thing then is to have (pure) functions that convert these three-tuples into, say, a list of 0..255 ints, or UTF-8 codes, or a (possibly multidimensional) array of floats or whatever...

It seems to work out nicely so far.