Opening: A Number That Started a Conversation
On July 22, 2026, a post appeared on Hacker News: “Show HN: Bento — an entire PowerPoint in a single HTML file.” Within eight hours, it had racked up 591 upvotes and 141 comments. That number alone is a signal — in a community that gathers the world’s most discerning technical readers, a project getting this kind of attention means it touched something real.
I clicked the link and saw a browser tab containing a fully functional slide editor. There was a toolbar, a thumbnail sidebar, the ability to type, draw shapes, insert charts, and add notes. Press Esc to enter edit mode, arrow keys to play your presentation, S to open speaker view. Nothing extraordinary — except for one fact: this editor isn’t a website, and it isn’t an app. It’s just an HTML file.
Figure: Bento Slides editing interface. Top toolbar, left thumbnail panel, main editing area, and bottom navigation — identical to mainstream slide software, but all of it runs inside a 560KB HTML file.
“The File Is the Software”
That sentence is the core philosophy behind Bento. I found the complete source code on GitHub — the project is called bento, by author starfallg, MIT licensed.
Let’s run a comparison. A standard PowerPoint .pptx file is a compressed archive containing XML, images, audio, and other resources — but it can’t run on its own. You need PowerPoint installed (or Office 365 in the browser) to open and edit it. A Microsoft 365 personal subscription costs hundreds of dollars a year, and the installer takes several gigabytes.
Bento flips that around: it puts the software inside the file.
Open bento.page/slides and a complete slide editor appears directly in your browser. You create content, adjust layouts, add animations right there on the “page.” The most surprising part: when you hit Ctrl+S, the HTML file rewrites itself — your edits are saved back into the file itself. The next time you double-click that file, it opens the full editor with everything you saved last time.
I put together a size comparison:
| Item | Size | Extra software needed? |
|---|---|---|
| Bento default presentation | ~560 KB | No, just a browser |
| PowerPoint installer | 3-5 GB | Requires installation |
| Keynote installer | ~1.5 GB | Requires installation |
| Google Slides (web) | Depends on network | Requires login and internet |
The difference is several thousandfold. That comparison alone raises a question worth answering: why does a presentation need gigabytes of software to support it?
Peeking Inside the File
To understand how Bento achieves such a small footprint, I looked at its file structure. A .bento.html file has several layers from the outside in.
The outermost layer is a valid HTML document. It has a DOCTYPE declaration, <head> and <body> — meaning any browser can open it. But its internal structure is unusual.
Near the top of the file there’s a <script> tag with id “bento-doc” and type “application/bento+json.” This stores all slide data as plain-text JSON — every page’s content, each element’s position and size, colors, fonts, animation settings. You can view it directly in the browser with “View Source” — completely human-readable.
This design has a profound advantage: data and code are separate but coexist in one file. AI tools can read and modify the JSON block directly; developers can search and replace with a text editor; version control systems can diff it line by line.
The rest of the file — the actual “software” — lives in a compressed JavaScript block. It contains several key components: a presentation engine based on Reveal.js, a custom animation system, a custom chart rendering engine, and a Vue-driven editor interface. Before version 0.7.0, Bento used GSAP for animations and ECharts for charts. The author replaced them all with custom implementations for one straightforward reason: to shrink the file from 1.3 MB to 560 KB.
Figure: Bento’s GitHub project page — 260 commits, 389 stars, showing an active development pace. The MIT license means anyone can freely use and modify it.
A Blank Sheet of Paper with a Swiss Army Knife Inside
If I had to describe Bento’s design philosophy in one image, it would be this: a blank sheet of paper with a complete Swiss Army knife hidden inside.
The traditional office software model is “buy the tool first, then make things.” Want to create slides? Install PowerPoint (or buy a Mac for Keynote) first, then create a new file. The file itself is fragile — send a .pptx to someone without Office installed, and they can’t open it.
Bento’s model is “the thing you make is itself the tool.” Download an HTML file from bento.page/slides and you get a “presentation shell.” Create content inside it, save, and that file becomes a self-contained presentation — it is both the content and all the tools needed to open it.
Send this file to a colleague via WeChat, email, or AirDrop. They double-click it and see your slides — ready to present, ready to edit. No installation steps needed, no account registration required.
The difference in experience becomes clear with a simple scenario:
Imagine you’re a project manager who just finished a quarterly report. You send the file to your boss, who opens it on their phone. In the traditional model, they’ll likely see “can’t open this file” or a formatting mess. With Bento, they just need a browser — and everything looks exactly as you designed it: layout, animations, charts, all intact.
Collaborative Editing: Encrypted Blind-Relay Design
Even more interesting is Bento’s collaborative editing feature. I initially wondered: how can a single HTML file support multi-user real-time editing? Where is the data stored?
The answer: the data lives in the file, and edits sync through an encrypted “blind-relay” channel.
When you start a collaboration session in Bento, the file generates a set of encryption keys locally. The collaborators you invite receive the same file copy (with the key embedded). Each person’s edits are encrypted and sent to a relay server running on Cloudflare Durable Objects — a server that does exactly one thing: forward encrypted data to everyone else in the room.
This relay server is designed to be “blind” — it passes ciphertext, the server itself cannot read any of your content. It can’t see your text, charts, images, or even your name. It’s just a courier for encrypted data.
The sync engine uses CRDT (Conflict-Free Replicated Data Types) technology. This is a well-studied approach in distributed systems that allows multiple people to edit the same data simultaneously without needing a central server to decide “whose edit wins.” Bento’s CRDT is custom-built — the author noted in the HN discussion: “What I’m most satisfied with is the smoothness of the CRDT.”
There’s also a thoughtful touch: offline editing. You can modify your slides without internet access, and when the connection is restored, your changes automatically sync with the team. CRDT ensures the merge is correct — no accidental overwrites.
A Side Project Built by a Dad in His Spare Time
In the HN comments, I found some interesting background. Someone asked how long it took and how much AI assistance was involved. Author starfallg replied: “Started last week, worked on it in my spare time, all done through Claude Code. I’d love to write code the old way, but I’m leading a technical team at a renewable energy company, and when I get home I’ve got a preschool-aged kid — I just don’t have the time.”
This reveals a few things: most of Bento’s code was AI-assisted (the author used Claude Code), the entire project from concept to release took about a week of spare-time work, and the author is a technical manager whose day job has nothing to do with office software.
This might explain why Bento’s design differs so radically from traditional office software — it carries no legacy baggage of “backward compatibility with old formats” and no path dependency of “we must design it like Office.” It was built from the perspective of “what does a developer actually need?”
The Boundaries and Limitations of 560KB
Of course, as a project barely a week old, Bento has its limitations. I noticed several during testing:
First, it’s currently suited for presentations of moderate complexity. If you need extremely fine-grained layout control, complex master slide designs, or heavy processing of high-resolution images, traditional tools are still more mature.
Second, its collaborative editing currently depends on the author’s Cloudflare account for relay service. While the author says “the cost is cheap, well within budget,” heavy concurrent usage could introduce reliability concerns. That said, the code is fully open-source, so any team can deploy their own relay server.
Third, its file format is currently a proprietary JSON structure. Though the source is open and the format is readable, there’s no direct conversion path to or from .pptx. The author suggests a workaround: feed the .pptx to an AI and have it regenerate in Bento’s format.
What This Project Really Means
If you see Bento merely as a “PowerPoint replacement,” I think you’re missing the deeper thinking behind it. The more valuable question Bento raises is this: in an era when AI can write code, should we rethink how software is distributed?
The traditional software distribution model — download an installer, install runtime dependencies, register an account, log into a cloud service — feels increasingly excessive for lightweight tools. Bento offers an alternative: fuse software and content into a single file, use the browser as the runtime, and give the file the ability to run itself without any infrastructure.
This idea isn’t entirely new. TiddlyWiki tried something similar more than twenty years ago — a self-contained HTML file that was both Wiki engine and Wiki content. TiddlyWiki still has a loyal user base, but it never broke into the mainstream.
But the times may be different now. Browser capabilities are incomparably more powerful (the File System Access API lets web apps read and write local files directly, WebCrypto API provides browser-grade encryption), modern frontend toolchains make building complex single-page apps vastly more efficient, and AI-assisted coding dramatically lowers the technical barrier to implementing ideas like this. Bento happens to sit at the intersection of all these trends.
I saw a comment on HN that roughly said: “This project is a brilliant indictment of the Google Workspace team’s inaction in the AI era.” Whether that’s fair or not, Bento does raise a question worth considering: when a 560KB HTML file can handle the full pipeline of editing, presenting, and collaborating on a presentation, do we really need hundred-gigabyte Office suites and monthly cloud subscriptions?
The answer might not be a simple “yes” or “no.” Most users in the real world probably need both Bento’s lightweight simplicity and traditional office software’s stability and ecosystem compatibility. But Bento’s existence at least shows us that another path is possible — a path that’s lighter, freer, and more your own.
Reference Links
- Show HN: Bento — Original Hacker News post and discussion (591 points, 141 comments)
- Bento GitHub Repository — nyblnet/bento, MIT license, 260 commits
- Bento/Slides Online Demo — A ready-to-use editor with built-in demo slides
- Bento Official Website — Templates Gallery and project overview
- TiddlyWiki — Self-contained HTML Wiki system, spiritual predecessor to Bento’s design
- Reveal.js — Open-source HTML presentation framework, Bento’s rendering foundation
- Cloudflare Durable Objects — Infrastructure backing Bento’s collaborative relay service
- File System Access API — The browser API that enables Bento’s “self-saving” capability
