[opensourcedex]

bento is a free, open source office suites project written in TypeScript and released under MIT. It has 5,129 GitHub stars, 356 forks and 38 open issues, and was last pushed 2 hours ago. On this registry it ranks #4 of 11 tracked projects in Office Suites, with 5 head-to-head comparisons available.

What is bento?

Bento is an MIT-licensed, local-first PowerPoint alternative that ships as a single self-contained HTML file, in which the deck carries its own viewer, presenter and editor so that anyone who opens it in a modern browser can edit or present it without installing anything.

What it is

Bento is a browser-based office application written in TypeScript and published under the MIT licence, distributed as a single-page app rather than installed desktop software. Its shipped artifact is Bento_Slides.bento.html, roughly 560 KB, and the project describes itself as a PowerPoint alternative. Fonts, images, charts, animations and the full editing interface travel inside that one file, so the document is the software. Document data sits in a plain, readable JSON block near the top of the file, marked #bento-doc.

The problem it solves is ownership and durability. The README argues that office documents have become things people rent, locked in a vendor's cloud and readable only while that vendor keeps its servers running. Bento takes a file-centric path instead: a copy saved in 2026 is expected to open in 2036, saving rewrites the file's own data block instead of syncing to a remote store, and there is no account and no installer. Where a team wants collaboration, an optional relay stores only ciphertext.

Key capabilities

  • Morph presenting — elements sharing an id animate between slides across position, size, color and even gradients; duplicating or rearranging slides designs the motion itself.
  • Live collaboration — AES-GCM end-to-end encryption with keys held in the file, never on a server, merged by a custom CRDT that includes character-level text merging.
  • Blind relay — the optional sync relay at server/sync-worker/ stores ciphertext and learns nothing; the source is about one file.
  • Charts built in — bar, line, pie and scatter drawn by a dependency-free engine, live during presentations with tooltips, zoom and bars that morph into a pie.
  • Designed for AI — the plain JSON block lets agents edit .bento.html files in place, and chatbots round-trip the document through window.bento.loadDoc; the guide is docs/agents.md.
  • Signed self-updates — releases are ECDSA-signed and offered in-app; updating writes a new file, leaving the old one as a rollback.
  • Offline mode and output — Offline mode hard-blocks updates and collaboration; the shell also carries speaker view, comments, motion paths, page sizes, PDF export and 8 UI languages.

Who uses it and how

  • Anyone sending a deck to a recipient who has nothing installed: the recipient opens the file in a browser and the file is the software.
  • Privacy-sensitive or air-gapped workers using Offline mode, where updates and collaboration are blocked by design.
  • AI-assisted authors via file harnesses such as Claude Code, Cursor or Aider; Claude Code users install a packaged bento-slides skill with /plugin marketplace add nyblnet/bento.
  • Users of local open-weight models who point Ollama, llama.cpp or LM Studio at the deck so nothing leaves the machine.
  • Small teams collaborating through the relay, which sees only ciphertext, or by exchanging file copies whose edits merge back precisely.

Getting started

Download the single Bento_Slides.bento.html from the GitHub Releases page or from bento.page/releases/slides/Bento_Slides.bento.html and open it in a modern browser; there is no account and no installer. To try it immediately, open bento.page/slides, which runs the entire app on a starter deck that doubles as the feature tour.

How it compares

The commercial products named in the project's topics and README are Office 365 and PowerPoint. Bento is MIT-licensed and keeps the document on the user's own disk, while those suites are rented, gated behind a login and dependent on the vendor continuing to run its servers. Nothing in Bento's model involves a per-seat subscription: the file is free to download and works afterwards without any server.

When to use it — and when not to

Bento suits presentations that must survive as files, recipients who cannot be asked to install software, and documents that must stay on the local machine. A self-hoster who wants live collaboration must operate the optional server/sync-worker/ relay, and in-place saving relies on the File System Access API, with a download fallback where that is unavailable. It is a weaker fit for anyone needing spreadsheets or word processing: the shipped artifact is Bento Slides, and the broader "office suite" framing in the tagline is not yet backed by other modules in the facts.

project readme (upstream, from github) — read inline

Bento — the office suite that fits in a file

This PowerPoint alternative is a single HTML file. A Bento deck carries its own viewer, presenter, and editor inside the document — open it in any browser, edit it, present it, send it. The person you send it to needs nothing: the file is the software.

Try it in 10 seconds: open bento.page/slides — that's the entire app, running on a starter deck that doubles as the feature tour. Or grab a designed template from the gallery and make it yours.

Download the app: grab the single Bento_Slides.bento.html from the GitHub Releases page or straight from bento.page (~560 KB, no account, no installer). Open it in any modern browser and it is the editor. Save, and it rewrites itself with your deck inside.

Why this exists

Office documents used to be things you had. Now they're things you rent — locked in someone's cloud, behind someone's login, readable only while a company keeps its servers on. Bento takes the other path:

  • One file, forever. Deck, fonts, images, charts, animations, and the full editor travel together. A copy from 2026 will open in 2036.
  • View-source honest. Your data sits in a plain, readable JSON block at the top of the file. No binary formats, no lock-in, no archaeology.
  • It saves itself. The file rewrites its own data block on save (File System Access API, with a download fallback). No app to install, ever.
  • Local-first, provably. Flip on Offline mode and nothing leaves your machine — updates and collaboration are hard-blocked, and the app says so.

What's inside

Feature Description
Morph presenting Elements that share an id animate between slides — position, size, color, even gradients. Duplicate a slide, rearrange, and the motion designs itself.
Live collaboration E2EE (AES-GCM) with keys that live in your file, never on a server. The file itself is the invitation: anyone who opens a copy joins. Offline edits merge back precisely — our own CRDT, character-level text merging included.
A blind relay The optional sync relay (server/sync-worker/) stores ciphertext and learns nothing. Read the source; it's about one file.
Charts, built in Bar / line / pie / scatter drawn by our own dependency-free engine, live during presentations: tooltips, zoom, and data that morphs when a bar chart becomes a pie.
Designed for AI The document is plain JSON in the file, so agents edit .bento.html files in place and chatbots round-trip the JSON (window.bento.loadDoc). See docs/agents.md.
Signed self-updates Releases are ECDSA-signed and offered in-app. Updating writes a new file — the old one stays as your rollback. No server ever touches your documents.
Everything else Speaker view, comments, layouts, hidden interactive states, hover reveals, motion paths, PDF export, page sizes, 8 UI languages — in a ~560 KB shell.

Use it with AI

Because the document is plain JSON living in one plaintext block near the top of the file, any assistant that can read and write a file can edit your deck — no plugin, no API. Two ways in:

  • File harnesses edit the #bento-doc JSON in place: Claude Code, Cursor, Aider, or any agent with filesystem access. Claude Code users get a packaged bento-slides skill (installable from this repo's plugin marketplace: /plugin marketplace add nyblnet/bento) that even downloads the latest Bento app by itself.
  • Chat round-trip for any chatbot: copy the document JSON out (Save → Copy document JSON), let the assistant rewrite it, paste it back.

It works fully offline with local open-weight models — point Ollama, llama.cpp, or LM Studio at the deck and nothing leaves your machine. The agent guide is a single page you can drop into any model's context: bento.page/agents.md (also in this repo at docs/agents.md).

Architecture in one paragraph

slides/src/model.ts defines the JSON document model; one renderer (render.ts) draws it for the editor canvas, thumbnails, and present mode (Reveal.js drives navigation; morphs are computed from the model, not the DOM). Animation is an in-house engine (anim.ts), charts are in-house (charts.ts), collaboration is an in-house CRDT (sync/crdt.ts — pure data, fuzz-tested by scripts/test-sync.ts across hundreds of thousands of convergence checks). The shell compresses to ~560 KB with the document block left as plaintext so old files and outside tools can always splice it. The deep dive: docs/architecture.md.

Security model, honestly

  • Collab keys are minted client-side at document creation and live only in the file. Possession of the file = membership; "Rotate keys" = revocation.
  • The relay sees: ciphertext, connection timing, and a hash of the room key. It cannot read content, names, or structure.
  • Presence names are claims, not proofs — fine within a shared-key room; enterprise identity would need signed frames (designed, not built).
  • Update checks fetch a static manifest and send nothing about you or your document. Signature + hash + version monotonicity are verified in-app.
  • Known trade-offs: undo during live collab is snapshot-based and can revert a collaborator's concurrent edit to the same property; editing is desktop-first (phones view and present well).

Build from source

Node 20+ and npm are all you need — the app is a single-page build with no backend to stand up.

cd slides
npm install
npm run dev            # dev server (http://localhost:5173)
npm run build:single   # → dist-single/Bento_Slides.bento.html (the product)

node scripts/test-sync.ts runs the CRDT convergence rig. Releases are cut locally so the signing key never leaves the maintainer's machine — see docs/RELEASING.md.

Where to read more

  • CLAUDE.md — the deep architecture + development guide (also what AI agents read to work in this repo).
  • docs/architecture.md — how a .bento.html file is built, the on-disk format, and the runtime layout.
  • docs/format.md — the normative bento/slides document-model spec (every element type, slide/state/layout shape, and collab fields).
  • docs/collab-design.md — the CRDT, E2EE relay, and signed-write RBAC design + threat model.
  • docs/agents.md — the document format, for AI agents.
  • CHANGELOG.md — the version history.
  • Layout: slides/ is the app (source in slides/src/); server/sync-worker/ is the blind relay; docs/ and scripts/ are the guides and build tooling.

Contributions welcome — start with CONTRIBUTING.md. Found a security issue? See SECURITY.md.

Community

Planning a substantial contribution? Check the pinned What's in flight issue and the open PRs first, and say what you're planning before you build it — see CONTRIBUTING.md.

Roadmap

bento/slides is the first app — a PowerPoint alternative, shipping now. bento/spaces (notes), bento/dash (sheets & tables) and bento/vault follow, each as its own self-contained .bento.html distributable. The current release lives on bento.page and reaches every existing file through the signed update channel.

License

Bento is open source under the MIT License — all software here is MIT, © 2026 The Bento authors. Bundled runtime components (reveal.js, Moveable, Selecto) are MIT; the embedded typefaces (Fraunces, Instrument Sans) are OFL; gallery imagery is public-domain (see scripts/gallery-photos/SOURCES.md). Each component keeps its own license.

Frequently asked questions

Is bento free to use?

bento is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does bento do?

Bento, the office suite that fits in a file

What is bento written in?

bento is primarily written in TypeScript. Its source is publicly available at https://github.com/nyblnet/bento, and it has 5,129 GitHub stars.