Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsiTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
The Git Cherry Tree author replaced a Tauri/React interface with Iced, a Rust-native GUI library, and the result was a modest rendering gain and a simpler Linux distribution, not a dramatic speedup. Under the author’s largest-diff scrolling workload, frame time dropped from about 9–10 ms to about 3–6 ms per frame. Linux users received a single file under 20 MB. The costs were a much larger UI codebase, about 24,000 lines of TypeScript becoming 45,000 lines of Rust, and a lengthy binary-size optimization effort.
The account below is a single developer’s report from their own app and workload. It explains what changed, what the numbers do and do not support, and what to weigh before making the same move.
Why the author left the web-based UI
The React/Tauri client was usable. The author reports it could render diffs of up to one million lines. Several problems had accumulated, however:
- Inter-process communication for large data transfers. Moving big payloads between the Rust backend and the web frontend was the most persistent technical friction.
- Image-loading flicker and timing. Images in the interface loaded with visible timing problems.
- Antivirus false positives. Launching browser processes triggered antivirus flags.
- Linux binary portability. The author found the path to a distributable Linux binary unsatisfactory.
Performance was not the headline reason. The author’s own summary is blunt: “Performance: Not really, actually!” The web UI was fast enough that the move was about accumulated friction and packaging rather than rendering speed.
#1 Best Overall
The author had earlier tried four or five Rust UI frameworks and found them hard to use, which is why React on top of Tauri was the first choice. Later, Iced looked like the strongest of the frameworks tried, partly because a recent release had improved it.
The measured changes
The table below collects every figure the author reported. All of them come from one application and one workload on the author’s own machines. The blog post’s publication year is not shown in the copy consulted, so treat these as a snapshot of that release cycle rather than current benchmarks. They are not an independent benchmark, and the author did not publish a methodology detailed enough to reproduce across hardware.
| Measure | Tauri/React web UI | Iced version | Context reported by the author |
|---|---|---|---|
| Frame time while scrolling the largest diffs | 9–10 ms per frame | 3–6 ms per frame under load | Author’s workload; the author called the 3–6 ms result “faster than web, but not by an order of magnitude” |
| Opening a million-line diff, click to visible display | Roughly three to four times slower than Iced; absolute figure not stated | About 700 ms | Single client and workload, not a framework-vs-framework test |
| UI implementation size | About 24,000 lines of TypeScript | About 45,000 lines of Rust | At feature parity; the author attributes part of the growth to vendored Iced elements and more polished styling |
Where the extra code came from
A Reddit commenter asked whether the jump came from “Message/update plumbing or styling you used to get free from CSS?” That is the right question. Iced uses an Elm-style cycle of application state, messages, view logic, and update logic, so every interaction has to be written as explicit code. Styling that a browser stylesheet supplies for free must also be written out. The author’s account confirms the second factor and the vendored widgets; it does not break down the line count by category.
Rank #2
Binary size fell, rose, and then returned close to the start
Binary size is the least intuitive part of the story. Many readers assume a native Rust application will be smaller than a web-based one. The author’s measurements show the path was not straight.
| Stage | Binary size | What happened |
|---|---|---|
| Web version (Tauri/React) | 15 MB | Baseline |
| First Iced build | 8 MB | Early, minimal feature set |
| After adding features | 23 MB | Feature parity brought size back up |
| After optimization | 15.3 MB | Dependency review, custom syntax highlighting and icon work, Cargo feature changes, and compiling a custom standard library |
| Hypothetical with panics set to abort | About 11 MB | An estimate only, not the shipped result |
The lesson is that the framework does not set the final size on its own. The optimization work decided where the binary landed.
Linux: from unsatisfactory to a single file
Tauri is officially cross-platform, and Linux is supported. The author’s problem was the burden of their own Tauri build and portability path, not an absence of Linux support. Tauri v2 specifies WebKitGTK 4.1 on Linux, and its process model uses the operating system’s WebView, so a Tauri Linux build carries a system-library dependency that must be present on the target machine.
Iced’s project documentation lists Windows, macOS, Linux, and Web support. It offers two renderers: wgpu, which uses the GPU, and tiny-skia, a software fallback. The fallback is what let the author’s app run on an older laptop without Vulkan.
Recommended Free Tools
The author’s result is concrete: a single file under 20 MB that ran on the Linux systems they tested, including that older laptop. The author describes this as running “anywhere.” That is the author’s characterization, not verified compatibility with every Linux distribution, desktop environment, or graphics driver. Test on the distributions your users actually run.
Windows IPC: the reason the data path mattered
The author also measured the Tauri inter-process path on Windows in their own implementation. These figures explain why large transfers were the main pressure point.
| Path or operation | Reported behavior |
|---|---|
| Simple command round trip | At least 3 ms to get a response; unbounded latency when the channel was busy |
| Tauri commands for data transfer | About 2–10 MB/s |
| One large payload | About 100 MB/s, while freezing the UI |
| Internal download protocol | About 40 MB/s |
These are Windows results from the author’s setup. They do not describe Tauri on Linux or macOS, and they are not a general statement about Tauri’s IPC design.
Tauri/React and Iced compared
The right comparison is not “which is faster.” It is which trade-offs match your team and your app.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →| Factor | Tauri with a React frontend | Iced |
|---|---|---|
| Languages | Rust core, HTML, CSS, and JavaScript or TypeScript frontend | Rust throughout |
| Rendering | Operating-system WebViews; WebKitGTK on Linux | wgpu renderer, or tiny-skia software fallback |
| Linux support | Officially supported; WebKitGTK 4.1 required for Tauri v2 | Officially supported; software fallback for systems without Vulkan |
| Binary and dependencies | WebViews are dynamically linked, not included in the executable | Not stated in the sources consulted |
| Maturity | Not stated in the sources consulted | Project documentation calls Iced “experimental software”; the crate documentation consulted shows version 0.15.0-dev |
| Styling | CSS and web tooling | Written in Rust; no built-in animation system and no virtualized list (the author wrote both) |
Because the Iced crate documentation displayed a development version when consulted, check the current release and its known limitations before adopting it.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Costs the author reported
Verbose code and a larger UI layer
The Iced implementation was more verbose than the TypeScript it replaced, and the author said the increase in code volume surprised them. Budget for more lines, not fewer, when translating an interface built on a browser stack.
Animation, lists, and image loading
The author found animation behavior and image loading easier to shape in Iced for this application. Iced did not supply an animation system, though, and the virtualized list the app needed had to be written by hand. These are first-person engineering observations about one app, not general verdicts on the framework.
Cursor, highlighting, and Windows startup
Cursor and text-highlighting behavior caused recurring problems. On Windows, startup and window resizing needed a custom rendering and window-initialization sequence. Plan time for platform-specific debugging, particularly on the operating system you develop on least often.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Learning curve
Iced’s documentation assumes familiarity with Rust ownership, borrowing, lifetimes, futures, streams, and trait bounds. A team that knows web development but not Rust will need training before the first screen works, and that cost belongs in the estimate.
Who should consider the same move
The case fits teams in a specific position. Check these before committing:
- Your team already writes Rust well, or is willing to learn it before rewriting the UI.
- Your interface depends on large, data-heavy views such as diffs or long lists, where the cost of moving data to a web frontend shows up in measurable frame times.
- You can tolerate a library that calls itself experimental, and you can absorb the work of building missing pieces such as animation and virtualized lists.
- Your distribution goal is a self-contained binary, and you have tested it on the exact Linux environments your users run.
- You can budget for platform-specific debugging on each target operating system.
If most of these do not hold, the author’s experience suggests staying with the web stack and attacking the specific bottlenecks, such as the IPC path for large payloads, instead of rewriting the whole interface.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
