DEV Community

Vanya Proskuriakov
Vanya Proskuriakov

Posted on

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

#git #html #showdev #sideprojects

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
Enter fullscreen mode Exit fullscreen mode

Backend:

None
Enter fullscreen mode Exit fullscreen mode

Database:

Git
Enter fullscreen mode Exit fullscreen mode

Synchronization:

git pull
git fetch
git push
Enter fullscreen mode Exit fullscreen mode

Messages:

{
  "from": "SA6E",
  "text": "Mom, please cook macaroni",
  "timestamp": 1749340800
}
Enter fullscreen mode Exit fullscreen mode

That's basically it.

The Entire Client Is One File

The most ridiculous part is the client.

The client is:

messenger.html
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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.

Top comments (0)