OlaProis

Small correction: Ferrite uses egui (by Emil Ernerfeldt), not anything from Zed. Different ecosystem entirely.

- Zed uses their own gpui framework - Ferrite uses egui — an immediate-mode GUI library

egui is great for rapid development but has limitations. The v0.3.0 custom editor widget is specifically because egui's built-in TextEdit blocks features like proper multi-cursor and code folding. We're not getting much "for free" there — the Mermaid renderer, syntax highlighting integration, and view synchronization are all custom.

That said, egui definitely accelerated the initial UI work. Credit where due!

Exactly. The AI is great at "write me a function that does X" or "convert this to async." It struggles with: - Graph layout algorithms (crossing minimization, layer assignment) - State machine interactions (how does undo interact with sync scroll when switching view modes?) - Performance debugging (why is syntax highlighting slow on scroll?)

The domain knowledge still matters. AI just compresses the boilerplate time.

Valid skepticism! A few counterpoints:

Market exists: Obsidian has 1M+ users, Typora is popular, iA Writer has a loyal following. These aren't VS Code users who wandered off — they're writers, PKM enthusiasts, and note-takers who find IDE-style editors overwhelming for prose.

Different audience: Developers might prefer VS Code + Markdown Preview Enhanced. But Ferrite targets people who want a focused writing tool, not a general-purpose editor that happens to support Markdown. Think "writing app" vs "code editor with Markdown support."

Native advantage: Most Markdown tools are Electron (Obsidian, Typora, Mark Text). Ferrite offers instant startup, lower RAM, and native performance — appeals to the "I want my tools to feel fast" crowd.

You might be right that it won't achieve mass adoption. But there's a niche for "Obsidian but native and lighter" that I think is underserved.

Ha! I appreciate the compliment (I think?). To be transparent: yes, AI tools were used during development — they're fantastic for boilerplate, documentation, and exploring unfamiliar APIs.

But this wasn't "2 sessions" — Ferrite has been in development for months with ~30,000 lines of Rust across 50+ modules. The Mermaid renderer alone is ~6000 lines of layout algorithms (Sugiyama-style graph layout, sequence diagram activation tracking, nested state machines, etc.).

AI helped ALOT, but there's no "generate full app" prompt that produces working text editors with native diagram rendering, rope-based text buffers, and custom window chrome. Still takes understanding the domain.

That said, you're right that the development velocity is higher than 5 years ago. Exciting times!

Great feedback, thank you! You're absolutely right — the screenshots are taken at high resolution, which makes them hard to read on smaller displays.

I'll retake them with a more focused window size and less dead space. Appreciate the specific guidance!

Thanks for flagging this! You're right — Wooji-Juice's Ferrite is a well-known iOS audio recording app.

The name collision is unfortunate. We picked "Ferrite" for the magnetic/persistent storage connotation (ferrite cores were early computer memory). Different domain (text editor vs audio), different platforms (desktop vs iOS), but I understand the SEO/discoverability concern.

Open to suggestions if the community feels strongly about a rename! Though at this stage, with GitHub issues, releases, and now HN discussion, there's some established presence.

Definitely interested in the concept! Though it's not on the immediate roadmap.

A few thoughts: - Obsidian's plugin system is JavaScript-based, which makes sense for Electron. For a native Rust app, we'd likely want something like WASM plugins or Lua scripting. - v0.3.0 includes plans to extract the Mermaid renderer as a standalone crate and potentially the editor widget as a library — this modular architecture would be a foundation for future extensibility.

What kinds of plugins would you want? Knowing specific use cases would help prioritize. Custom renderers? File format converters? External tool integrations?

In the meantime, Ferrite has a "Live Pipeline" feature that lets you pipe JSON/YAML through shell commands (jq, yq, etc.) — not a full plugin system, but useful for custom transformations.

Ferrite is privacy-focused in that it's fully offline — no telemetry, no cloud sync, no accounts, no network calls (even Mermaid diagrams render locally in pure Rust).

However, files are stored as plain text, same as Obsidian/VS Code/any text editor. Encryption at rest isn't currently on the roadmap.

For encrypted storage, you might consider: - Using Ferrite with an encrypted volume (VeraCrypt, LUKS, FileVault) - git-crypt for encrypted git repos

That said, if there's strong interest in built-in encryption (vault-style or file-level), I'd love to hear more about the use case. Would you want password-protected vaults? Per-file encryption? Something else?

Fair point about fragmentation! Ferrite uses Comrak which implements CommonMark + GitHub Flavored Markdown (GFM) — arguably the closest thing to a "standard" we have.

We chose Markdown because: - It's what most developers already use (README files, documentation, wikis) - Plain text files are portable, grep-able, git-friendly, and won't lock you in - GFM covers tables, task lists, strikethrough, and autolinks which handles 90% of use cases

We also support JSON, YAML, and TOML with native tree viewers. Wikilinks ([[links]]) and backlinks are planned for v0.3.0 for folks wanting Obsidian-style knowledge bases.

That said, I'd love to hear what format you'd prefer — always interested in expanding support!

Great catch! Mermaid styling syntax (style and classDef directives) is on the roadmap for v0.3.0. Currently the diagrams render with Ferrite's theme colors (light/dark).

For privacy, you're in the right place — Ferrite's Mermaid rendering is 100% native Rust, no JavaScript, no external services, no network calls. All ~6000 lines of diagram rendering happen locally. We're even planning to extract this as a standalone crate so others can use it.

Thanks for reporting! This is a build environment issue - v0.2.1 was built on Ubuntu 24.04 which has newer glibc (2.39) and libssl3t64.

*Fix:* I've updated the CI to build on Ubuntu 22.04, which will make the .deb compatible with 22.04+.

This will be included in v0.2.2. For now, workarounds: 1. Use the `ferrite-linux-x64.tar.gz` (standalone binary) instead of .deb 2. Build from source: `cargo build --release`

Sorry for the inconvenience!

100% pure Rust! No JS interpreter. Parses Mermaid syntax directly and renders via egui drawing primitives. Supports 11 diagram types: flowchart, sequence, state, class, ER, pie, mindmap, timeline, user journey, git graph, gantt. Much faster than spawning headless Chrome!

Interesting idea! Typst is compelling (Rust-based too). Not on immediate roadmap but could be a future addition. TeX is heavier but possible via external tools + pipeline feature.

Not yet! [[wikilinks]] and backlinks are natural additions. I will add it to the Roadmap? Love community input on what Obsidian features matter most!

> - ~15MB vs ~300MB+ (no Electron) > - Instant startup vs seconds > - Native Mermaid rendering (no extension juggling) > - Built-in JSON/YAML tree viewer with pipeline shell integration > - Session restore, minimap, zen mode baked in > > If you live in VS Code already, an extension might be fine. Ferrite is for those wanting a focused, fast Markdown environment.

Fair point - I should be more transparent. Yes, Claude assisted significantly with development. The .gitignore excludes AI config files because they where not needed in the project and aren't useful to others. I'll add a note to the README about AI-assisted development. The code is reviewed and understood, not blindly accepted.

Which view/file caused this? v0.2.2 (coming soon) has significant performance optimizations for large files - deferred syntax highlighting, galley caching. If you can reproduce, please open an issue with details!

Thanks for reporting! This is a packaging issue - need to create a proper .app bundle. On the roadmap for v0.3.0 (macOS signing & notarization). For now, running from terminal is the workaround.

egui is fantastic for rapid prototyping - immediate mode makes state management simple. Main limitation: TextEdit isn't designed for code editors (no multi-cursor, can't hide folded text). v0.3.0 will replace it with a custom widget. The default styling does scream "egui" - spent time on custom theming to avoid that

Valid point! Native rendering won't be pixel-perfect with mermaid.js. The trade-off is speed and no JS runtime. For documents staying in Ferrite, it's great. For sharing, we're adding SVG export in v0.3.0 so you can use mermaid.js for final renders if needed.

Thanks! Typora is great - Ferrite aims for similar polish but with native Mermaid, structured data support (JSON/YAML/TOML tree viewer), and the pipeline feature for shell integration. And it's open source!

This is exactly the plan for v0.3.0! Extracting the ~7000 line Mermaid renderer into a standalone crate with SVG/PNG output and CLI support. Pure Rust, WASM-compatible. Stay tuned!

Thanks! The end-goal is a fast, native Markdown editor that "just works" - no Electron, no web tech, instant startup. v0.3.0 will extract Mermaid as a standalone crate and build a custom text editor widget to unlock features egui's TextEdit blocks (proper multi-cursor, code folding). Long-term: potentially extract the editor as a headless Rust library since that's missing in the ecosystem. See ROADMAP.md for details