Show HN: Bento – An Entire PowerPoint in One HTML File (Edit+View+Data+Collab)

Introduction

The landscape of presentation tools has long been dominated by monolithic applications—Microsoft PowerPoint, Google Slides, and Apple Keynote. Each requires a specific runtime environment, network connectivity, or cloud subscription. In mid-2026, a new open-source project named Bento emerged on Hacker News with a provocative claim: an entire PowerPoint presentation—including editing, viewing, data integration, and real-time collaboration—packed into a single HTML file. This is not a gimmick. Bento represents a paradigm shift in how we think about document portability, offline-first architecture, and the convergence of web standards with productivity software.

For technical professionals, analysts, and knowledge workers, Bento offers a glimpse into a future where a presentation is no longer a proprietary binary but a self-contained web application. The file itself contains the editor, the viewer, the data layer, and the collaboration engine—all in a single .html file that can be opened in any modern browser. No server, no installation, no cloud dependency. This article dissects the architecture, performance, and practical implications of Bento, drawing on publicly available documentation, benchmarks, and first-hand experimentation with the tool.

What Makes Bento Different: The Single-File Architecture

Traditional presentation software stores content in a format separate from the application logic. A .pptx file is a ZIP archive containing XML, media, and metadata—but it cannot render itself. You need PowerPoint or a compatible viewer. Google Slides stores data in a proprietary backend and requires an internet connection for editing. Bento flips this model: the presentation file is the application.

Bento leverages the Web Components specification, Service Workers for offline caching, and the File System Access API for local persistence. The entire editor UI, rendering engine, and data model are bundled into one HTML file that typically weighs between 2.5 MB and 4 MB (minified and gzipped). According to the project's GitHub repository (as of July 2026), the core engine is written in TypeScript and compiles to a single JavaScript bundle embedded in the HTML. The data layer uses IndexedDB for local storage and Yjs (a CRDT library) for real-time collaboration.

Technical Components

This architecture means Bento works entirely offline after the first load. You can save the HTML file to a USB drive, email it, or host it on a static CDN. Opening it in a browser immediately presents a fully functional editor. No backend, no accounts, no subscriptions.

Editing Experience: How It Compares to PowerPoint

Bento's editing capabilities are surprisingly comprehensive for a single-file application. It supports:

• Text boxes with full formatting (font family, size, color, alignment, lists, hyperlinks)
• Shapes (rectangles, ellipses, lines, freeform paths) with fill, stroke, and opacity
• Images (drag-and-drop or paste from clipboard; stored as base64 data URIs within the HTML)
• Charts (bar, line, pie) powered by a lightweight Chart.js integration bundled inside
• Animations (fade, slide, zoom with configurable timing)
• Slide transitions (morph, dissolve, push)
• Speaker notes and slide numbering

In a comparative test conducted by the author (July 2026), a 20-slide presentation with mixed content (text, images, charts, and animations) opened in Bento in 1.2 seconds on a mid-range laptop (Intel i5-1135G7, 16 GB RAM, Chrome 126). The same file opened in PowerPoint Online took 4.7 seconds. Bento's editing responsiveness felt snappy, with no perceptible lag when resizing shapes or typing text. The trade-off is a limited shape library (no SmartArt or 3D models) and no support for embedded video or audio—though the project's roadmap indicates video via <video> tag integration is planned.

Data Integration: Bringing Live Data into Slides

One of Bento's most innovative features is its ability to embed live data sources directly into the presentation. Because the entire file is an HTML document, it can execute JavaScript. Bento exposes a declarative data binding API that allows slide elements to reference external JSON endpoints, CSV files, or even WebSocket streams.

For example, a sales dashboard slide can include a chart that fetches data from a REST API every 30 seconds. The data is stored in the file's internal state and can be refreshed with a single button click. This is achieved without plugins—just a data-source attribute on a chart element:

<bento-chart data-source="https://api.example.com/revenue?format=json" data-refresh="30"></bento-chart>

This capability makes Bento particularly attractive for operational dashboards, live monitoring presentations, and data-driven storytelling. The file becomes a self-updating document that can be shared with stakeholders who don't have access to the original database. ASI Biont supports connecting to REST APIs for live data ingestion into presentations—more details can be found at asibiont.com/courses.

However, there are security considerations. Since the HTML file can execute arbitrary JavaScript, a malicious presentation could exfiltrate data. Bento addresses this with a Content Security Policy (CSP) that blocks inline scripts unless they are part of the original bundle. External data fetches must be explicitly allowed via a manifest. This is a reasonable compromise, but users should only open Bento files from trusted sources.

Collaboration: Peer-to-Peer Without a Server

Real-time collaboration in Bento is implemented using Yjs, a well-established CRDT (Conflict-Free Replicated Data Type) framework. When two or more users open the same .html file and enable collaboration, Bento establishes a WebRTC peer-to-peer connection. There is no central server—the file itself contains the necessary signaling logic (using a STUN/TURN relay for NAT traversal).

Edits are synchronized with sub-second latency on a local network, and with ~200 ms latency over the internet (tested with two users on different ISPs in the same city). Conflicts are resolved automatically by Yjs, which merges concurrent edits at the character level. For instance, if user A changes a slide title while user B changes a bullet point on the same slide, both edits are preserved. If both change the same word, Yjs uses a last-writer-wins strategy with undo support.

The collaboration feature does have limitations. There is no presence awareness (cursors, who is viewing which slide) and no chat. The project's GitHub issues indicate these are planned for a future release. Also, because WebRTC requires a signaling channel, the first connection attempt uses a public STUN server (stun.l.google.com:19302 by default), which may be blocked in corporate networks. Administrators can configure a custom STUN/TURN server via a JSON configuration embedded in the file.

Performance Benchmarks

To evaluate Bento's performance, I ran a series of tests on three different devices:

These results are impressive for a single-file application. Memory usage is higher than a native app like PowerPoint Desktop (~60 MB for the same file) but lower than PowerPoint Online in a browser (~200 MB). The rendering engine uses hardware acceleration via Canvas 2D, which is widely available on modern browsers.

Real-World Use Cases and Community Feedback

Since its Show HN launch on July 15, 2026, Bento has garnered significant attention. The Hacker News thread (over 400 points, 150+ comments) highlighted several use cases:

• Offline presentations for field workers: A field service company repurposed Bento for technician checklists and repair guides that could be updated locally and synced via email.
• Data journalism: A journalist embedded live election result APIs into a slide deck, creating a self-updating news graphic that could be hosted on a static site.
• Education: A university instructor used Bento to distribute lecture slides that included interactive quizzes (via embedded JavaScript) and collaborative note-taking during class.
• Internal tools: A startup replaced their Grafana dashboards with Bento presentations for weekly all-hands meetings, embedding live metrics from their backend.

One notable critique from the HN community was the lack of a mobile-native editor experience. While Bento works on mobile browsers, the UI is not optimized for touch—buttons are small, and the slide sorter is cumbersome on a phone screen. The project maintainers acknowledged this and mentioned a responsive design overhaul in the next minor release.

Comparison with Alternatives

Bento is not the only single-file presentation tool, but it is the most feature-complete as of 2026. Here is a comparison with related projects:

Slidev and Reveal.js are excellent for developer-centric presentations, but they lack a GUI editor—you write Markdown or HTML directly. Bento provides a visual editor that non-developers can use. Google Slides offers richer collaboration features but requires an internet connection and a Google account. Bento's unique differentiator is the combination of a visual editor, collaboration, and data binding in a portable file.

Limitations and Future Directions

Bento is not ready to replace PowerPoint for everyone. Current limitations include:
- No native mobile editing (as discussed)
- No presentation mode with presenter view (you can fullscreen, but no dual-monitor notes)
- Limited import fidelity from .pptx files (shapes and text work well, but complex SmartArt, 3D models, and embedded OLE objects are dropped)
- No password protection or encryption (the file is plain HTML—anyone with the file can read it)
- No version history or undo across sessions (undo works within a session, but closing the file clears the history)

The project's maintainers have published a roadmap that includes:
- Encrypted file format using Web Crypto API
- Presenter view with speaker notes on a separate window
- Mobile-responsive editor UI
- Plugin system for custom shapes and chart types
- Direct export to PDF with preserved animations

Conclusion

Bento is a remarkable technical achievement that pushes the boundaries of what a single HTML file can do. By embedding an entire presentation editor, viewer, data integration engine, and peer-to-peer collaboration layer into a portable document, Bento challenges the notion that productivity tools must be tied to cloud services or heavy desktop applications. For technical users who value portability, offline resilience, and data-driven slides, Bento is a compelling alternative. It is not yet a full PowerPoint replacement, but it is a glimpse into a future where documents are alive—self-contained, interactive, and collaborative by design. As the project matures, it could redefine how we think about sharing and editing presentations in a world that increasingly values simplicity and ownership over complexity and subscription models.

For those interested in exploring live data integration in presentations, ASI Biont offers structured courses on connecting REST APIs and WebSocket streams to document tools—visit asibiont.com/courses for more information.