FlowGit: Rust and Svelte Git client claims sub-85MB RAM and a 48-hour discard safety net

A developer has released FlowGit, a cross-platform visual Git client built on Tauri v2 with a Rust backend and a Svelte 5 frontend, and laid out its architecture in two posts on dev.to. The pitch targets two chronic complaints about existing Git GUIs: heavy resource use from Electron-based applications, and the fact that a mistaken "discard changes" permanently destroys uncommitted work.

A native stack instead of a bundled browser

According to the dev.to write-ups, FlowGit's backend is written entirely in Rust and calls libgit2 through C bindings directly, rather than shelling out to the git CLI and parsing its output. The interface is Svelte 5 compiled down to plain JavaScript, using the framework's Runes reactivity with raw state handling to avoid proxy overhead when the commit list grows to tens of thousands of entries. The desktop shell is Tauri v2, which renders the UI in the operating system's own webview — WebView2 on Windows, WebKit on macOS — instead of shipping a copy of Chromium with every install.

The performance numbers, as reported by the author

The benchmarks in the posts were run by the developer on a repository of roughly 35,000 commits and have not been independently verified. They claim idle memory use under 85MB, cold startup in under 0.4 seconds, an installer of about 30MB, and a commit graph locked at 60 FPS with 50,000 commits on screen. For comparison, the same tables put GitKraken at roughly 750MB to 1.5GB of idle RAM with 4 to 7.5 second launch times, and SourceTree somewhere in the 350–600MB range — the two posts quote slightly different figures for the rival clients.

The graph rendering approach is the most technically interesting part. Lane topology and spline routing for the commit graph are computed in parallel across CPU cores using Rust's rayon, and all canvas painting is delegated to an OffscreenCanvas inside a dedicated web worker, keeping the main UI thread free. Virtual scrolling is claimed to hold memory flat whether the view contains 500 or 150,000 commits.

Undo buttons for destructive Git operations

The headline safety feature is a discard trash. Before FlowGit touches anything on disk during a discard, it snapshots the affected hunks or files into an embedded local SQLite database. A trash inspector then lets the user review the discarded diff and restore it for 48 hours. This addresses a genuine gap: uncommitted changes deleted by a discard exist nowhere in git's object database or reflog, so in ordinary clients that data is simply gone.

A second mechanism acts as a general undo. FlowGit keeps a transactional journal of operations, so pressing Ctrl+Z after a mistaken checkout, reset, rebase, branch switch or stash computes the reverse transition and restores the earlier workspace state. The second post also describes a set of repair tools, including automatic cleanup of stale index.lock files, a pre-commit check that blocks staged secrets and oversized binaries, and guided fixes for detached HEADs and interrupted rebases.

The rest of the feature set

The diff viewer is built on Monaco, the editor that powers VS Code, with split and unified views, per-line and per-hunk staging, and interactive blame. Merge conflicts are handled in a four-pane, three-way resolver showing each side plus the common ancestor and a live result preview. There is a worktree manager for working on several branches in separate folders, drag-and-drop interactive rebase with an in-memory simulation that warns of conflicts before a branch is dropped, a tool for scrubbing a file from the entire repository history, and a keyboard command palette. GitHub integration covers pull request review and live streaming of Actions CI logs. The second post states the client is free, MIT-licensed, collects no telemetry and runs offline.

Why it matters

Electron's memory footprint is a familiar grievance, and a Tauri-plus-Rust client claiming sub-100MB idle use is a useful data point in that debate — provided the numbers survive third-party testing, which so far they have not received. The more original contribution is the safety model. Snapshotting data before destructive operations and journaling state transitions to support undo are standard ideas elsewhere in software, but rare in Git GUIs, where one misclick can still eat an afternoon of uncommitted work. If FlowGit's approach catches on, it raises the bar for what developers should expect from every client in this category.