Bento: The Presentation File That Contains Its Own App

A deep dive into the single-file office suite that fuses the deck, the editor, the presenter, and the AI-ready document model into one portable HTML artifact.

9 min read • View on GitHub • More from nyblnet

A folded HTML document sits on a desk like a physical object, with layers inside it showing a JSON script block, a tiny editor panel, a presentation screen, and a lock icon. A thin thread connects the file to a browser window and an AI pen hovering nearby. The image explains Bento's core idea: the document is not a payload for the app, it is the app.
Bento treats a presentation file as a complete software object, not an export from one.
Key Takeaways

Most slide tools treat the file as an output. Bento flips that relationship. The `.bento.html` file is the runtime, the data store, the editor, and the presentation surface in one package.

To avoid this loop, I ended up creating Bento, a single HTML file with everything you need in a slide tool including animations and shared editing. There's no install or cloud login, everything works offline.

The file is the product

That is the first thing to understand. Bento is not trying to be a better web app wrapped around a deck. It is trying to make the deck itself behave like a durable software object.

The payoff is simple. You can open it offline, inspect it directly, edit it with a tool or an agent, and save it back into the same artifact. No account. No export step. No separate project folder that quietly becomes the real source of truth.

That shifts the category. A normal slide app sells a workflow. Bento sells survivability.

Why Bento feels different from every slide tool

ProductDistribution modelFile formatOffline?Self-editing file?AI-friendly by default?Collaboration modelLong-term portability
BentoSingle HTML artifactPlain JSON inside HTMLYesYesYesEncrypted blind relayHigh
Reveal.jsWeb deck or static exportHTML or MarkdownYesNoPartialUsually externalMedium
SlidevDev-server presentationMarkdown plus VueUsuallyNoPartialLocal toolingMedium
MarpMarkdown to slidesMarkdownYesNoPartialExport focusedMedium
Google Slides / PowerPointHosted or installed appProprietary app formatMixedNoNoCloud account or desktop appLow to medium

Bento's comparison story is not about feature count. It is about what kind of object the presentation becomes when the software is done running. In Bento, the artifact is still alive.

A browser window cuts open a highlighted JSON block from within an HTML shell, then stitches it back into the same shell with surgical arrows. A pristine outer layer remains intact while the data layer is replaced and saved. The image explains how Bento can save itself back into its own file.
Bento rewrites the document into its original shell instead of exporting into a separate copy.

Inside the document model

Bento's core trick is that the document stays legible. The top of the file is plain JSON, not a sealed package. That means the same structure can be parsed by the UI, by a script, or by an AI agent without reverse engineering a binary container.

The repo's architecture follows that logic. The model defines the source of truth. Rendering turns that model into the editor, thumbnails, and presentation. A stable `id` supports synchronization, and a `morphId` lets motion preserve identity across slides.

type ElementBase = {
  id: string
  morphId?: string
  // other shared fields
}

// The same model feeds edit, render, and sync.

The same document model powers editing, viewing, saving, collaboration, and AI access.

That is why the file reads more like source code than a generated export. Bento's design makes the document itself the interface contract.

How Bento saves itself

The save path is where the philosophy gets real. Bento captures a pristine shell before the DOM mutates, then splices the current JSON state back into that shell when you save. If the browser supports File System Access API, the app can write to the existing file. If not, it falls back cleanly.

The key idea is restraint. Bento does not rebuild the whole artifact from scratch every time. It preserves the surrounding structure and rewrites only the living document data. That is a much better fit for a file that wants to remain inspectable and stable over time.

The trick that makes animation feel native

Bento's motion system is not decoration bolted onto the top. It is part of how the document behaves. Morph transitions use stable identity across slides, and the custom animation engine handles the kind of motion that makes changing layouts feel continuous instead of abrupt.

That matters because presentation software often treats motion as a separate layer from content. Bento does the opposite. It ties motion to the model, so a slide can move without losing its sense of being the same thing.

The result is less flashy than it sounds, which is a compliment. Good motion here serves orientation, not spectacle.

How collaboration works when the server cannot read the file

Bento's collaboration model is deliberately narrow. The server is a blind relay. It moves encrypted updates around, but it does not become the owner of the document. The file holds the keys.

That is a different social contract from the usual cloud suite. In a typical SaaS editor, the platform is the seat of record. In Bento, possession of the file is effectively possession of the room key.

Collaboration traitBentoTypical cloud suite
Server visibilityBlind relayServer can usually inspect data
Key custodyLocal filePlatform account
Ownership feelingFile-centricAccount-centric
Offline continuityBuilt inOften partial
Trust boundaryClient sideVendor side

Why AI support is not an add-on

Bento is built for agents in the boring, useful sense. The JSON lives where a tool can read it. The repo includes guidance for agents, and the structure is simple enough for deterministic edits instead of brittle file surgery.

That is more ambitious than adding an AI button. It means the format itself is designed to survive machine intervention. Human and agent workflows are not separate paths here. They are the same path, just with different hands on the keyboard.

{
  "slides": [
    {
      "id": "intro",
      "elements": [
        {
          "id": "title-1",
          "morphId": "title",
          "text": "Bento"
        }
      ]
    }
  ]
}

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.

nyblnet, Project Documentation · nyblnet/bento README

What Bento is actually competing with

Bento is not trying to beat Google Slides on familiarity or PowerPoint on institutional inertia. It is competing on a different axis: durability, inspectability, and machine-readability.

That puts it in the same conversation as Reveal.js, Slidev, and Marp, but the answer is not just that Bento is local-first. It is file-first. The distinction sounds small until you try to edit, sync, and preserve a deck as one portable artifact.

Bento's wager is that the next useful document format is not a bigger app. It is a better file.