I Accidentally Built a Messenger That Consists of a Single HTML File
A few days ago I had a stupid thought.
What is the minimum amount of technology required to send a message to your mom?
Not billions of dollars worth of infrastructure.
Not a distributed cluster.
Not an end-to-end encrypted communication platform.
Not a super app.
Just:
"Mom, please cook macaroni."
The more I thought about it, the stranger modern messaging systems started to look.
Eventually I ended up building a messenger that consists of a single HTML file and stores messages in Git repositories.
Unfortunately, it works.
The Original Joke
The project started as a joke.
What if a messenger had:
- no backend
- no database
- no registration
- no phone numbers
- no servers
Just:
- HTML
- Git
- JSON
At first this sounded ridiculous.
Then I realized Git already knows how to:
- store data
- synchronize data
- keep history
- work offline
- replicate repositories
- merge changes
- handle identities
In other words:
Git already solves most of the problems messaging systems need to solve.
The Architecture
The architecture is surprisingly boring.
Frontend:
HTML
CSS
JavaScript
Backend:
None
Database:
Git
Synchronization:
git pull
git fetch
git push
Messages:
{
"from": "SA6E",
"text": "Mom, please cook macaroni",
"timestamp": 1749340800
}
That's basically it.
The Entire Client Is One File
The most ridiculous part is the client.
The client is:
messenger.html
Not an installer.
Not a package.
Not Electron.
Not a launcher.
A file.
You double-click it.
The messenger starts.
I wanted to see how far I could push the idea of:
"What if HTML is the application?"
The answer turned out to be:
Much further than expected.
Privacy
Macaroni Messenger does not promise privacy.
In fact, it explicitly promises the opposite.
If your repository is public:
your messages are public.
If your repository is private:
everyone with repository access can read them.
If you need privacy:
install an encryption plugin.
Good luck.
I find this approach more honest than pretending that every communication system is somehow magical.
Identity
Every client gets a tiny identifier.
Something like:
SA6E
Do I guarantee uniqueness?
No.
Did I try?
Yes.
Will collisions happen?
Probably.
Will this matter for a family chat?
Probably not.
The entire philosophy of the project is:
Do not make things complicated when they can be funny.
This does not prevent them from being real software.
The Development Process
The most absurd part of the story is how the project was built.
I have a Codex subscription.
One evening I wrote a roadmap.
Then I went to sleep.
Literally.
While I was asleep, the coding agent continued implementing the roadmap.
I woke up the next morning.
The messenger existed.
This repository is the result of that mistake.
Why Git?
People keep asking:
Why Git?
My answer is always the same:
Because Git already knows how to store files.
Most modern software introduces complexity because complexity already exists somewhere else.
Macaroni Messenger does the opposite.
It aggressively reuses things that already exist.
Need synchronization?
Git.
Need history?
Git.
Need replication?
Git.
Need backups?
Git.
Need offline support?
Git.
Need transport?
Still Git.
Is It A Joke?
Partially.
The funny thing is that the more I worked on it, the less it felt like a joke.
The user interface looks like a messenger.
The messages are delivered.
The history works.
Search works.
Synchronization works.
The architecture is surprisingly resilient.
At some point I realized I had accidentally built:
- a messenger
- a Git client
- an append-only event log
- a distributed communication protocol
all at the same time.
Why Does This Exist?
Macaroni Messenger is not a political statement.
It is not a manifesto.
It is not trying to replace Telegram.
It exists because I wanted to answer a simple question:
How much software do we actually need to send a message?
The answer turned out to be:
Less than I thought.
A lot less.
Project Status
- Works
- One HTML file
- Git backend
- No servers
- 1000% vibecoded
Repository:
And yes.
You can send:
Mom, please cook macaroni
using a Git commit.
Unfortunately, it works.
