Bangle.io: A Web-Only Markdown Note Taker That Skips Electron

The Problem It Solves: Local Markdown Without Native Apps

Bangle.io targets a specific pain: note taking apps that either lock your data into a proprietary format or force you into a heavy desktop runtime. The README positions it as 'Notion, but local only.' You edit notes in a browser, and the files land as human-readable Markdown on your computer. That combination matters for people who want the visual editing experience of a modern rich text editor but refuse to surrender their notes to a cloud service or a closed database. The intended user is someone who already works with Markdown files, possibly a Zettelkasten user, and wants a web interface without syncing or conversion steps. It is not for someone who needs offline access on a phone or a native desktop feel, because the project explicitly says 'No Electron' and is web only.

How It Works: WYSIWYG Editing That Writes Markdown

The core mechanism is a split between what you see and what is saved. Bangle.io renders rich text formatting in the browser, but the underlying storage is Markdown. The README says 'Even though we save things in Markdown format, Bangle will enrich your eyes with rich text formatting.' That implies a conversion layer between the editor's internal document model and the Markdown serialization. The editor itself is built on bangle.dev, a sister project. That library is what 'unlocks us to build a powerful editor like Notion or Dropbox paper,' according to the README. It also claims to support 'real time collaboration,' though no details are given about how that would work in a local-only, web-only app. The data flow appears to be: you open bangle.io in a browser, it reads Markdown files from your local file system, you edit with rich text, and the app writes back Markdown. The README does not explain how the browser gains file system access, but modern web APIs like File System Access could be involved, though that is speculation.

Getting It Running: Commands and Ports

The README gives two commands for development. Run `pnpm install` to install dependencies, then `pnpm start` to start a development instance on `localhost:5173`. For parallel worktrees, you first run `eval "$(node scripts/dev-ports.js --env)"` to give dev, preview, Storybook, and Playwright servers deterministic ports for that worktree. That is a concrete setup path, but note that the README does not list any configuration keys or environment variables beyond that script. For end users, there is no install step: you head to https://bangle.io to use the app. The project uses pnpm, not npm or yarn, which is a minor friction point for contributors who are not already on pnpm. The development setup assumes a Unix-like shell for the `eval` command, so Windows users may need to adapt.

The Performance Claim: Thousands of Notes, But No Evidence

The README makes a strong performance assertion: 'Throw thousands of notes at it and Bangle will chug along fine.' It even suggests trying a heavy project like the 10,000 Markdown Files repository. That is a testable claim, but the README provides no benchmark numbers, no methodology, and no architecture details to back it up. As a reviewer, I cannot confirm it from the material. The claim likely refers to the app's ability to index or load a large directory of Markdown files, but without a description of how the app handles file indexing, searching, or lazy loading, it is just a promise. If you are considering Bangle.io for a large note archive, you should run that 10,000-file test yourself and watch memory usage and UI responsiveness. The absence of any performance documentation is a red flag for a project that makes performance a headline feature.

Extensibility: A Promise, Not a Reality Yet

Bangle.io was 'built ground up to be extended by awesome extensions,' but the README says only 'We have bunch of community extensions coming out soon.' That phrasing suggests the extension ecosystem is not yet available or is immature. The architecture is built on bangle.dev, which is a modular editor toolkit, so extension points likely exist in the codebase, but the README does not document how to write an extension, what APIs are exposed, or how to install one. For an engineer evaluating this project, the lack of extension documentation is a real limitation. You cannot plan to build a plugin on day one. You would need to read the source code or wait for the community extensions to appear. This is a case where the README oversells what is actually usable today.

Licensing and Maintenance: AGPL-3.0 and Unknown Activity

Bangle.io is licensed under AGPL-3.0. That is a strong copyleft license, and it has implications if you want to modify the app for internal use or integrate it into a commercial product. The AGPL requires that if you modify the software and make it available over a network, you must offer the corresponding source code to users. That is a significant consideration for any organization, and this article is not legal advice. The repository is not archived, but the last push date is unknown and no recent releases were retrieved. That makes maintenance status unclear. The README references a RANT.md file, which could indicate known frustrations or design decisions, but its contents are not included here. Before adopting Bangle.io for a long-term project, you should check the commit history and open issues on GitHub to see if the project is actively maintained. The lack of release tags is a warning sign for a project that is still in v2, as the description says.

Alternatives: What Else Does Local Markdown Editing?

The most direct alternative to Bangle.io is Obsidian, a desktop app that also works with local Markdown files and offers a WYSIWYG-like live preview mode. The key difference in approach is that Obsidian is a native Electron app, which Bangle.io explicitly avoids for speed and web purity. Obsidian has a mature plugin ecosystem and a large user base, but it is not web-only and it is not open source (the core is proprietary, though the plugin API is open). Another alternative is Joplin, which is open source (AGPL as well, ironically) and supports Markdown notes with a desktop and mobile app, but it uses a database for note storage rather than plain files on disk, which changes the portability story. If you want a purely web-based editor that writes to local files, Bangle.io is unusual, but if you are willing to use a desktop app, Obsidian gives you a richer extension ecosystem today. The trade-off is exactly what Bangle.io's README highlights: no Electron, but at the cost of a less proven ecosystem.

What to Verify Before You Trust It

The README is short and promotional. It claims performance, extensibility, and real-time collaboration, but none of those are documented in detail. The collaboration feature is particularly suspicious for a local-only app. Before you rely on Bangle.io for daily note taking, verify three things. First, test the live app at bangle.io with a large folder of Markdown files and see if it actually handles thousands of notes smoothly. Second, check the GitHub repository for recent commits and open issues to gauge maintenance activity, since the last push is unknown. Third, read the RANT.md file in the repository, because it likely explains design trade-offs that the README omits. If those checks pass, Bangle.io could be a lightweight alternative to heavier note apps. If they fail, you are better off with a more established tool.

Editorial conclusion

Adopt Bangle.io if you want a browser-based note editor that writes plain Markdown to your local disk and you value no data lock-in over native app polish. Do not adopt it if you need offline desktop behavior, real-time collaboration out of the box, or a permissive license. Before committing, verify that the current build on bangle.io matches the README's promises, check the AGPL-3.0 obligations for your use case, and confirm that the extension ecosystem you expect actually exists today, since the README only says community extensions are 'coming out soon.'

Official sources

1. Official documentation
2. Official README
3. Project repository