I Accidentally Built a Messenger That Consists of a Single HTML File

Vanya Proskuriakov — Tue, 09 Jun 2026 19:52:29 +0000

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:

GitHub Repository

And yes.

You can send:

Mom, please cook macaroni

using a Git commit.

Unfortunately, it works.

DEV Community: Vanya Proskuriakov

I Accidentally Built a Messenger That Consists of a Single HTML File

I Accidentally Built a Messenger That Consists of a Single HTML File

The Original Joke

The Architecture

The Entire Client Is One File

Privacy

Identity

The Development Process

Why Git?

Is It A Joke?

Why Does This Exist?

Project Status