Bento puts the editor, the presenter and the CRDT in one HTML file
Bento, the office suite that fits in a file
At a glance
- What is it?
- A TypeScript office suite distributed as a single 560 KB HTML document that carries its own viewer, presenter and editor, with collaboration keys living in the file and an optional relay that sees only ciphertext. Editing stays desktop-first and live-collab undo is snapshot based, so it is a fit for teams that share files rather than for mobile authoring.
- Who is it for?
- Bento suits teams that want documents to stay readable plain files and that share decks by sending the file itself, and it suits offline work since Offline mode hard-blocks the network paths that would otherwise leak.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- nyblnet/bento5,670 ★ · +687
| Repository | 2026-09-11 | 2026-11-15 |
|---|---|---|
| nyblnet/bento | 5k | 5.7k |
687 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
One 560 KB file that rewrites its own JSON on save
The distribution unit is the product. The README names a single file, `Bento_Slides.bento.html`, available from the GitHub releases page or straight from bento.page, roughly 560 KB, with no account and no installer, and states that opening it in any modern browser is the editor. The deck data lives in a plain readable JSON block near the top of the document, left uncompressed on purpose so old files and outside tools can splice it. Saving is handled by the File System Access API, with a download fallback when that API is missing, and the file rewrites its own data block rather than exporting a sidecar. So the deck, fonts, images, charts, animations and the editor all travel together, and a copy from 2026 opens in 2036. There is no server component in the app itself: the build is described as single-page with no backend to stand up.
Morph animation reads the model, not the DOM
Presenting is not a slideshow over rendered pixels. Elements that share an id animate between slides, carrying position, size, color and gradients across the transition, which means duplicating a slide and rearranging its contents makes the motion design itself. The architecture note credits Reveal.js for navigation and says morphs are computed from the document model rather than from the DOM, so the animation survives a re-render. Animation is written in-house in `anim.ts`, and charts are also in-house in `charts.ts`, covering bar, line, pie and scatter with a dependency-free engine that stays live during a presentation, including tooltips, zoom, and data that morphs when a bar chart turns into a pie. One renderer, `render.ts`, draws the model for the editor canvas, for thumbnails and for present mode.
Collab keys are minted in the file, so possession is membership
Collaboration is end-to-end encrypted with AES-GCM, and the keys live in the file rather than on a server. Keys are minted client-side at document creation, and the file itself acts as the invitation: anyone who opens a copy joins the room, which means revocation is performed by rotating keys rather than by removing an account. The sync is an in-house CRDT in `sync/crdt.ts`, including character-level text merging, and offline edits merge back precisely. The convergence rig at `scripts/test-sync.ts` fuzz-tests it across hundreds of thousands of checks. The sync relay in `server/sync-worker/` is optional and described as a blind relay that stores ciphertext and learns nothing, and the README suggests reading the source, which it puts at about one file.
The relay sees timing and a room key hash, nothing readable
The security section is unusually specific about what leaks. The relay sees ciphertext, connection timing, and a hash of the room key; it cannot read content, names, or structure. Update checks fetch a static manifest and send nothing about you or your document, and the app verifies signature, hash, and version monotonicity before applying anything. Releases are ECDSA-signed and offered in the app, and updating writes a new file so the previous one stays as your rollback. Two limits are stated rather than hidden. Presence names are claims and not proofs, which is fine inside a room that already shares a key but not as enterprise identity, where signed frames are described as designed and not built. And undo during live collaboration is snapshot-based, so it can revert a collaborator's concurrent edit to the same property.
Offline mode hard-blocks updates and collaboration instead of degrading
Offline mode is a switch with consequences rather than a fallback. When it is on, nothing leaves the machine, and updates and collaboration are hard-blocked with the app saying so. That is the honest version of local-first: you lose the signed self-update path and the relay connection together, and you get privacy in exchange. The same local-first stance runs through the AI story, where the README claims full offline use with local open-weight models by pointing Ollama, llama.cpp, or LM Studio at a deck. Editing itself is desktop-first, and the project says phones view and present well, so the authoring path is the part you should check against your own devices before committing.
Agents edit the JSON block in place, no plugin required
Because the document is plaintext JSON near the top of the file, any assistant that can read and write a file can edit a deck, with no plugin and no API. Two entry points are offered. File harnesses edit the `#bento-doc` JSON in place, and Claude Code users additionally get a packaged `bento-slides` skill installable from the repository plugin marketplace with `/plugin marketplace add nyblnet/bento`, which even downloads the latest app by itself. Chat round-trip works for any chatbot: copy the document JSON out through Save then Copy document JSON, let the assistant rewrite it, and paste it back. Chatbots can also round-trip the document programmatically through `window.bento.loadDoc`. The agent guide is one page, at docs/agents.md in the repository and at bento.page/agents.md.
Building the file locally, with the signing key kept off the network
The source build needs Node 20+ and npm, and the commands run inside the slides directory:
cd slides
npm install
npm run dev # dev server (http://localhost:5173)
npm run build:single # → dist-single/Bento_Slides.bento.html (the product)That last command is the one that produces the artifact people actually run. The CRDT rig has its own entry point, `node scripts/test-sync.ts`, which runs the convergence checks. Releases are cut locally on purpose, so the signing key never leaves the maintainer's machine, and the procedure is written up in docs/RELEASING.md. The repository root shows how broad the project is beyond the app itself: convert/, dash/, home/, kernel/, plugins/, schema/, scripts/, server/, site-src/, slides/, spaces/, and type/ sit alongside docs/, CHANGELOG.md, CLAUDE.md, AGENTS.md, SECURITY.md, and a .nvmrc.
Morph, PDF export and eight UI languages inside the same shell
Everything else sits in that same 560 KB shell rather than in separate packages: speaker view, comments, layouts, hidden interactive states, hover reveals, motion paths, PDF export, page sizes, and eight UI languages. The README also points at a feature tour, because bento.page/slides is the entire app running on a starter deck, and at a gallery of designed templates you can take and modify. Two documentation files describe the format for people who want to write against it: docs/format.md is called the normative `bento/slides` document model spec covering every element type and the slide, state and layout shapes along with collab fields, and docs/collab-design.md covers the CRDT, the E2EE relay, and the signed-write RBAC design with its threat model. CLAUDE.md doubles as the development guide and as the file agents read.
Editorial conclusion
Bento suits teams that want documents to stay readable plain files and that share decks by sending the file itself, and it suits offline work since Offline mode hard-blocks the network paths that would otherwise leak. It does not suit mobile authoring, which the project calls desktop-first while phones view and present well, and it does not suit sensitive collaboration without reading the security notes first: presence names are claims rather than proofs, and enterprise identity is designed but not built. Before adopting it, check whether snapshot-based undo during live collaboration matters to your editing pattern, and read the relay source, which the project puts at about one file.
Frequently asked questions
Is Bento one file or an app you have to install?
One file. The README names a single `Bento_Slides.bento.html` of roughly 560 KB that you open in any modern browser, with the viewer, presenter and editor all inside the document and no installer involved.
How does Bento handle live collaboration without a server account?
Collaboration is E2EE with AES-GCM and the keys are minted client-side and live in the file, so anyone who opens a copy joins the room and rotating keys is the revocation. The optional relay in `server/sync-worker/` stores ciphertext and sees only ciphertext, connection timing and a hash of the room key.
What does Offline mode actually turn off in Bento?
Nothing leaves your machine, and updates and collaboration are hard-blocked rather than quietly degraded, with the app telling you so. The README claims full offline use with local models such as Ollama, llama.cpp or LM Studio.
What are the known trade-offs in Bento?
Undo during live collaboration is snapshot-based and can revert a collaborator's concurrent edit to the same property. Presence names are claims rather than proofs, and signed frames for enterprise identity are designed but not built. Editing is desktop-first while phones view and present well.
How do I build the single file Bento artifact myself?
With Node 20+ and npm, run `cd slides` then `npm install`, and use `npm run build:single` to produce dist-single/Bento_Slides.bento.html. `npm run dev` serves the editor at http://localhost:5173, and `node scripts/test-sync.ts` runs the CRDT convergence rig.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/nyblnet-bento)Star history chart for your README
[](https://hysenlabs.com/projects/nyblnet-bento)Was this useful?