Apps that are built with Git as the back end?

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.

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

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

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.

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

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

Gerrit's database is fully based on git.

https://gerrit-review.googlesource.com/Documentation/note-db...

Etckeeper exists: https://etckeeper.branchable.com/ It puts your /etc/ directory in version control, with some automation so you don't have to manage it as much.

I don't think it really counts as an app with a backend, and it can use other VCSs as the data store (it used to default to mercurial until a few years ago), but it's up there as one of the things I install early when I'm using a new system.

It has only saved me once or twice, but each time I've been glad it's there.

Twitter distributes config files across their entire fleet (hundreds of thousands of machines) using git and a cron job. Commit your config change, wait a few minutes and there it is.

Source: I’m a former tweep.

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.

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!

GitJournal comes to mind, "Mobile first Markdown Notes integrated with Git".

https://github.com/GitJournal/GitJournal

Recent HN discussion: https://news.ycombinator.com/item?id=31914003

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.

Wake is a build tool that aims to replace make/bazel/etc. It requires that source files are checked into git before it will recognize them. https://github.com/sifive/wake

I build projects with git as the hosting and backend using code that commits back to it's own repo. Usuauly it's when I need to host, run and store things - and might want to look at historic data. Using github actions, you can do this pretty simply, and free if it's open-source. E.g. https://gist.github.com/ukd1/6efdf12a19036b9edc537e64b1d331e... - a real-world example is https://github.com/ukd1/lvms-events - which each day parses some html --> ical, and hosts it in git.

This markdown based daily tweet scheduler uses git and GitHub Actions to post tweets on your behalf

https://github.com/reidjs/markdown-tweet-scheduler

The system used to produce ddr.densho.org uses Git and git-annex to manage archival metadata and binaries. Unfortunately it's not directly visible on the site and is not open-source licensed.

The original use case was to support branch archives in remote rural areas with poor connectivity who were collecting video oral histories. The metadata could be synced over the wire to the central hub but binaries would be shipped periodically on hard drives. "Never underestimate the bandwidth of a station wagon loaded with backup tapes".

Git's structure has excellent properties for maintaining the fixity of data and helps with provenance and chain-of-custody documentation.

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

Was talking a bit about this project of a colleague of mine.

"The miniature single-file buzz-word-compliant Git based chat client." https://github.com/JKrag/GitSlick

He wrote it out of a need and it actually works for his use-case:

> I created GitSlick mostly for sending messages to myself from one machine to another, mostly for use on e.g. customer machines where I can't use our own company Slack, and may be limited in what other tools I can install.

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.

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.

Spring Cloud Config Server, allowing git versioned configuration of all your spring services + changing config in running services without restart. Alternatively sql or several other backends can be used.

https://cloud.spring.io/spring-cloud-config/multi/multi__spr...

Not entirely necessary for its function, but UNIX `pass` and dotfile managers such as `yadm` come to mind when considering git based programs.

I think Delicious Library was for a while at least. I remember the author of it, doing a presentation about using git as storage: https://academy.realm.io/posts/altconf-wil-shipley-git-docum...

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

Ansible Automation Platform (Formerly Ansible Tower) uses git as the backend. https://www.ansible.com/products/controller

I know GNU Jami (a P2P chat program) uses Git as its data-store extensively— from what I could tell, checking out ~/.local/share/Jami/, all messages are stored in git commit messages, for instance.

I believe Cocoapods, a dependency tool for iOS/OSX development, uses Git under the hood. https://cocoapods.org/

The leading package manager for macOS Homebrew (https://brew.sh) is Git-based.

my project :)

https://doggos.com/add-business/

when you submit this form, a PR is created with githubs pull request API and a build is triggered on vercel. but the site is static and has no backend otherwise. if building the PR passes, the new link is aliased to production

Logseq (local alternative to Roam, comparable to Obsidian) has a Git plugin. I think Syncthing lets you use Git for versioning.

My medical terminology value set creation tool uses git (well, a java implementation of git) to store and version value sets

Oxidized and Rancid, the network device configuration backup solutions both use got on the backend.

https://ikiwiki.info/

Just stumbled upon https://www.datalad.org/ Used by neuroscientists: https://centerforopenneuroscience.org/projects

This guy built and hosts a SQLite database via github. Is this helpful?

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

Dataform comes to mind (if you set it up to use git like that)

Syncthing can keep a local history for a dir with git.

brew.sh backend is git.

This is not a good idea however. Anything you install that has thousands of files will slow down brew substantially during updates. GitHub has had issues specifically with brew.sh misusing their service.

Git should not be a backend for any application, it was not designed for such purpose...and you will be violating GitHub or any source host TOS.

WikiJS has a Git storage backend.

I built Opensource.builders using GitHub Issues as a CMS. Building 2.0 using an actual CMS though.

overleaf uses git as a data store for collaborative editing.

The https://tldr.sh/ clients all essentially are frontends for the git repository where the pages are stored.