Ferride

Ferride is a small desktop text editor built with a Rust/Tauri backend and a React frontend.

It is a learning exercise and a portfolio project, not a production editor. The goal of the repo is to show a responsive desktop editing loop with a web UI on top of Ropey-backed text storage.

Why I Built This

I wanted a project that forced me to deal with editor mechanics instead of wrapping a textarea:

• translating between visual and logical positions
• keeping the UI responsive while edits round-trip to a backend
• handling selection, undo/redo, and file lifecycle in a native shell

Current Scope

• create, open, save, and save-as
• optimistic local edits for typing, backspace, paste, and selection replacement
• undo/redo
• search and replace
• soft wrapping and virtualized rendering
• mouse and keyboard selection
• unsaved-change prompts on close and quit
• status bar error reporting for backend and file failures

Ferride currently has native menu code for macOS and non-macOS builds.

Screenshots

Editor with search/replace open:

Selection and status bar:

Editing view:

Architecture

• Frontend state: a React useReducer drives cursor state, selection, dirty state, search UI, and optimistic rollback.
• Visual layout: the editor builds virtualized visual lines from logical lines and only renders visible rows with react-window.
• Edit path: the frontend applies local edits immediately, then syncs with Tauri and rolls back if the backend rejects the change.
• Backend storage: Rust keeps the canonical document in a ropey::Rope, along with undo/redo stacks and the current path.

Relevant files:

• src/components/Editor/hooks/reducer.ts
• src/utils/local-edits.ts
• src/utils/utils.ts
• src-tauri/src/commands.rs
• src-tauri/src/editor.rs

Performance Note

On August 25, 2026, the current production frontend bundle built to about 280 KB of JavaScript before gzip and about 86 KB gzipped from yarn build. That is a build artifact measurement, not an editor throughput benchmark.

I have not yet recorded a proper large-file editing benchmark, so I am not claiming measured scalability beyond the current virtualization approach.

Toolchain

Tested in this repo with:

• Node.js 26.4.0
• Yarn 1.22.19
• Rust 1.96.1
• Cargo 1.96.1

src-tauri/Cargo.toml declares rust-version = "1.96".

Development

git clone <repo-url>
cd Ferride
yarn install --frozen-lockfile
yarn tauri dev

Checks

yarn install --frozen-lockfile
yarn build
yarn test
cd src-tauri
cargo fmt --check
cargo clippy -- -D warnings
cargo test

GitHub Actions runs the same frontend build and Rust validation steps on pushes and pull requests.

Local packaging on this machine is currently verified through the macOS .app bundle. DMG creation is not part of the default local build because hdiutil create fails at the OS level here, including outside Tauri.

Status

This repo now has automated frontend and Rust tests for the core edit/search/reducer paths, but it still needs:

• a short demo GIF
• a measured large-file editing benchmark