Rust desktop guides & tutorials.
GPUI walkthroughs, framework comparisons, and production patterns from building gpui-starter. Covers state management, SQLite, i18n, accessibility, theming, auto-updates, and the rest of the stack.
- · #Rust#chat#desktop
Building a desktop chat application with Rust and GPUI
Architecture for a desktop chat app in Rust: WebSocket connections, message persistence with SQLite, and real-time UI updates using GPUI entities and context.
- · #Rust#creative#GPUI
Building creative applications with Rust and GPUI
Using Rust and GPUI for creative desktop applications: design tools, image editors, and music production software.
- · #Rust#data-analysis#GPUI
Building data analysis tools with Rust and GPUI
How to build performant data analysis desktop tools with Rust: large datasets, real-time visualization, and GPU rendering.
- · #Rust#developer-tools#GPUI
Building developer tools with Rust and GPUI
How to build developer tools like debuggers, profilers, and dashboards as desktop apps using Rust and GPUI.
- · #Rust#file-manager#GPUI
Building a file manager in Rust with GPUI
Architecture for a file manager built with Rust and GPUI: async file operations, tree views, and drag-and-drop.
- · #Rust#internal-tools#desktop
Building internal tools as Rust desktop apps
Why Rust desktop apps are a good fit for internal company tools: performance, security, single-binary distribution, and lower long-term maintenance costs.
- · #Rust#notes#desktop
Building a note-taking app in Rust with GPUI
How to build a fast offline-first note-taking app with Rust and GPUI. SQLite storage, markdown rendering, and full-text search.
- · #Rust#text-editor#GPUI
Building a text editor in Rust with GPUI
Architecture and implementation patterns for building a text editor in Rust using GPUI: rope-based buffers, GPU rendering, syntax highlighting, and performance.
- · #GPUI#launcher#tutorial
Building a command palette in Rust with GPUI
Step-by-step tutorial to build a VS Code-style command palette (Cmd+K) with fuzzy search in a Rust desktop app.
- · #Electron#alternatives#comparison
Electron alternatives in 2026: lighter ways to build desktop apps
A practical survey of Electron alternatives in 2026 including Tauri, GPUI, Flutter, Wails, and others. Real performance numbers and honest tradeoffs.
- · #Electron#Tauri#GPUI
Electron vs Tauri vs GPUI: which to pick for your desktop app
Electron, Tauri, and GPUI compared head to head for desktop app development. Architecture, performance, resource usage, and when to pick each one.
- · #Rust#forms#tutorial
Form validation in Rust desktop apps: a practical tutorial
How to add form validation to a Rust GUI app using gpui-form and koruma. Email, phone, URL validators with localized errors.
- · #Rust#desktop#beginner
Getting started with Rust desktop development in 2026
A beginner guide to building desktop applications with Rust in 2026: tooling, frameworks, and building your first app.
- · #GPUI#entities#deep-dive
The GPUI entity system explained: state and reactivity
How GPUIs entity system works: Model, View, Entity, Context. State management, observers, and thread safety explained with real Rust code.
- · #GPUI#rendering#deep-dive
How GPUI renders: inside the GPU-accelerated pipeline
A technical deep dive into GPUI's rendering pipeline: Metal shaders, primitive batching, texture atlas, subpixel text, and GPU optimization techniques.
- · #GPUI#egui#comparison
GPUI vs egui: retained vs immediate mode GUI in Rust
A technical comparison of GPUI (retained mode) and egui (immediate mode) for building Rust desktop applications, with code examples and real tradeoffs.
- · #GPUI#Electron#comparison
GPUI vs Electron: Rust vs JavaScript for desktop apps
An honest comparison of GPUI and Electron for desktop app development: binary size, memory, startup time, and rendering performance.
- · #GPUI#Flutter#comparison
GPUI vs Flutter for Desktop: Rust vs Dart Compared
Comparing GPUI and Flutter for desktop app development: language ergonomics, rendering performance, and ecosystem maturity in 2026.
- · #GPUI#iced#comparison
GPUI vs iced: reactive vs Elm architecture in Rust GUI
Comparing GPUIs reactive entity model with iceds Elm architecture for building Rust desktop GUIs, with code examples and tradeoffs.
- · #GPUI#Slint#comparison
GPUI vs Slint: two approaches to Rust GUI development
A practical comparison of GPUI and Slint for building Rust desktop apps: design philosophy, rendering architecture, and when each framework makes sense.
- · #GPUI#Tauri#comparison
GPUI vs Tauri: which Rust framework for your desktop app?
Comparing GPUI and Tauri for Rust desktop development: architecture, performance, ecosystem, and when to pick each framework.
- · #GPUI#tutorial#beginner
Hello World in GPUI: your first Rust desktop app
A step-by-step tutorial to build a Hello World desktop app with GPUI. From cargo init to a working window with interactive UI.
- · #Rust#i18n#tutorial
Adding internationalization to a Rust desktop app with Fluent
Tutorial on adding multi-language support to a Rust desktop app using Mozilla Fluent message format. Covers .ftl files, plural selectors, and runtime switching with English and Chinese examples.
- · #Rust#accessibility#AccessKit
Making Rust desktop apps accessible with AccessKit
Integrating AccessKit for accessibility in Rust GUI apps: screen readers, keyboard navigation, and ARIA roles.
- · #Rust#i18n#Fluent
Fluent i18n in Rust: internationalization for desktop apps
Using Mozilla Fluent for internationalization in Rust desktop apps: message format, plural rules, and locale handling with the es-fluent crate.
- · #Rust#keyring#security
Cross-platform credential storage in Rust with keyring
Learn how to use the Rust keyring crate for secure, cross-platform credential storage in macOS Keychain, Windows Credential Manager, and Linux Secret Service.
- · #Rust#file-watching#notify
File watching in Rust desktop apps with notify
How to watch files for changes in Rust desktop apps using the notify crate: hot-reload, live configuration updates, and cross-platform event handling.
- · #Rust#HTTP#reqwest
HTTP requests in Rust desktop apps with reqwest
How to use reqwest for HTTP requests in Rust desktop applications: async patterns, error handling, and response parsing with real code examples.
- · #Rust#serde#serialization
Data serialization in Rust desktop apps with serde
Using serde for data serialization in Rust desktop applications: JSON, TOML, and custom serialization patterns for config, persistence, and IPC.
- · #Rust#logging#tracing
Structured logging in Rust desktop apps with tracing
Setting up structured logging in Rust desktop apps with the tracing crate: file output, filtering, and async-aware logging.
- · #Electron#Rust#migration
Migrating from Electron to Rust: lessons learned
Practical lessons from migrating a desktop application from Electron and JavaScript to Rust with GPUI. What breaks, what improves, and what surprises you.
- · #Rust#notifications#tutorial
Desktop notifications in Rust: native backends and toast fallbacks
How to implement notifications in a Rust desktop app using native OS backends on macOS with in-app toast fallback when permissions are denied.
- · #Rust#accessibility#guide
Building accessible Rust desktop applications
A practical guide to accessibility in Rust desktop apps: keyboard navigation, screen reader support, color contrast, and ARIA roles with AccessKit.
- · #Rust#distribution#guide
Distributing Rust desktop applications: codesigning and packaging
How to package and distribute Rust desktop apps: codesigning, notarization, DMG creation, and auto-updates.
- · #Rust#async#patterns
Async patterns for Rust desktop applications
Handling async operations in Rust GUI apps: spawning tasks, updating state, backpressure, and cancellation.
- · #Rust#CI/CD#guide
CI/CD for Rust desktop applications
Setting up continuous integration and deployment for Rust desktop apps: GitHub Actions, testing, and release automation.
- · #Rust#configuration#patterns
Configuration patterns for Rust desktop applications
How to handle configuration in Rust desktop apps: file formats, defaults, migrations, and user preferences with serde, TOML, and layered config.
- · #Rust#crash#debugging
Crash reporting for Rust desktop applications
Setting up crash report generation in Rust desktop apps: panic hooks, minidumps, error reporting, and diagnostics for post-mortem debugging.
- · #Rust#debugging#techniques
Debugging techniques for Rust desktop applications
Practical debugging strategies for Rust desktop apps: logging with tracing, panic hooks, remote diagnostics, frame-time profiling, and the tools that actually help.
- · #Rust#errors#patterns
Error handling and boundaries in Rust GUI apps
Designing error boundaries for Rust GUI applications: crash recovery, user-facing messages, and graceful degradation patterns that keep your app alive.
- · #Rust#lifecycle#architecture
App lifecycle management in Rust: startup to shutdown
Managing the lifecycle of a Rust desktop application: startup sequences, state machines, shutdown handling, and crash recovery.
- · #Rust#memory#deep-dive
Memory management patterns for Rust desktop applications
Memory management strategies for Rust desktop apps: entity lifetimes, buffer pools, memory budgets, and leak prevention with real Rust code examples.
- · #Rust#performance#guide
Performance optimization for Rust desktop applications
Optimizing performance in Rust desktop apps: render batching, lazy loading, memory budgets, and profiling techniques.
- · #Rust#performance#profiling
Performance profiling for Rust desktop apps
How to profile Rust desktop applications with frame time analysis, memory tracking, and bottleneck identification in GPUI and native GUI frameworks.
- · #Rust#architecture#guide
Structuring a Rust desktop application project
How to organize a Rust desktop app project: modules, crates, file layout, and separation of concerns for maintainable long-term codebases.
- · #Rust#security#guide
Security best practices for Rust desktop applications
Securing Rust desktop apps: credential storage, update signing, input validation, and dependency auditing.
- · #Rust#state#patterns
State management patterns for Rust desktop applications
How to manage state in Rust desktop apps: entity pattern, global state, context system, and reactive updates with GPUI.
- · #Rust#telemetry#privacy
Privacy-first telemetry for Rust desktop apps
Build telemetry into Rust desktop apps with user consent gates, local-only mode, and privacy-first defaults. Real code from a production GPUI application.
- · #Rust#testing#strategies
Testing strategies for Rust desktop applications
How to test Rust desktop apps: unit tests, integration tests, UI tests, and snapshot testing strategies that work.
- · #Rust#GUI#best-practices
Rust GUI development best practices in 2026
Best practices for building GUI applications in Rust: architecture, state management, testing, and performance optimization for production desktop apps.
- · #Rust#GUI#comparison
Rust GUI frameworks in 2026: the complete comparison guide
Every Rust GUI framework compared: GPUI, Tauri, egui, iced, Slint, Dioxus, Xilem, Vizia. Features, maturity, and best use cases.
- · #Rust#C++#GUI
Rust vs C++ for GUI development: safety meets performance
Choosing between Rust and C++ for desktop GUI development: memory safety tradeoffs, Qt vs GPUI, ecosystem maturity, and real-world performance comparisons.
- · #Rust#Swift#comparison
Rust vs Swift for desktop development: a practical comparison
Practical comparison of Rust and Swift for desktop app development: performance, memory safety, UI frameworks, cross-platform support, and when each wins.
- · #Rust#security#tutorial
Secure credential storage in Rust with OS keyring
Store secrets securely in a Rust desktop app using macOS Keychain, Windows Credential Manager, and Linux Secret Service with the keyring crate.
- · #GPUI#navigation#tutorial
Building sidebar navigation in GPUI: a complete tutorial
How to implement a resizable sidebar with page routing in a GPUI desktop app. Covers Page enums, resizable panels, deep links, and keyboard shortcuts.
- · #Rust#SQLite#tutorial
Using SQLite in a Rust desktop app: a practical guide
How to integrate SQLite into a Rust desktop app with rusqlite. Schema design, WAL mode, migrations, and query patterns for local-first apps.
- · #Rust#macOS#tutorial
Adding a macOS system tray icon to your Rust app
Step-by-step guide to adding a system tray icon and menu to a Rust desktop application on macOS, using the tray-icon crate.
- · #Tauri#Electron#performance
Tauri vs Electron: performance and developer experience compared
A detailed performance comparison of Tauri and Electron covering binary size, memory usage, startup time, and CPU efficiency with real benchmarks.
- · #GPUI#themes#tutorial
Creating a theme system in GPUI with hot-reload
Tutorial: build a theme system for GPUI that reloads from JSON files at runtime without restarting the application.
- · #GPUI#Rust#architecture
From prototype to production: scaling a GPUI app
The architectural decisions that turn a working GPUI prototype into a production desktop app: state tiers, memory budgets, cancellation, and persistence.
- · #Rust#GPUI#comparison
GPUI vs egui vs iced: Rust GUI frameworks compared
A practical comparison of egui, iced, and GPUI for Rust desktop apps. Covers rendering, performance, learning curve, and when each framework is the right pick.
- · #GPUI#Rust#desktop
Building a command launcher (Cmd+K) in GPUI
Walk through how gpui-starter implements a VS Code-style command palette as a floating popup in GPUI with search filtering and cross-window events.
- · #Rust#desktop#notifications
Desktop notifications in Rust: a fallback strategy
How gpui-starter handles desktop notifications in Rust with automatic backend selection and graceful fallback when OS notifications fail.
- · #Rust#desktop#architecture
Single-instance apps in Rust: preventing duplicate windows
Prevent duplicate Rust desktop app instances with file locks and IPC forwarding. Covers cross-platform deep link handling and queue file fallbacks.
- · #Rust#GPUI#forms
Form validation in Rust with koruma and gpui-form
Learn how to build validated forms in GPUI apps using koruma derive macros and composable rules. Covers localised errors, the touched pattern, and custom validators.
- · #Rust#security#desktop
Storing secrets in desktop apps: the keyring approach
Why storing API keys in config files is a security hole, and how to use the OS keyring from Rust to keep credentials encrypted at rest.
- · #GPUI#Rust#architecture
State management in GPUI: entities, globals, and context
GPUI has three state primitives: Entity for window-scoped state, Global for app-wide singletons, and Context for side effects. How to use each one and when.
- · #Rust#GPUI#desktop
Undo and redo in Rust desktop apps
Build an undo/redo stack for GPUI apps using the command pattern, type-safe state snapshots, and bounded history. Includes working Rust code.
- · #GPUI#Rust#design
Building a custom title bar in GPUI
Replace the native macOS, Windows, or Linux title bar with a custom one in GPUI. Covers drag regions, traffic light buttons, and platform quirks.
- · #Rust#GPUI#testing
Testing GPUI applications
Practical strategies for testing Rust desktop apps built with GPUI, from plain unit tests and the gpui test harness to hand-written fakes and VisualTestContext.
- · #GPUI#Rust#desktop
Getting started with GPUI: a new paradigm for Rust desktop apps
Build your first Rust desktop app with GPUI, Zed's GPU-accelerated UI framework. Covers setup, components, async state, and navigation in one walkthrough.
- · #GPUI#Rust#desktop
Sidebar navigation in GPUI: routing without a router
How gpui-starter builds multi-page navigation with Rust enums and pattern matching instead of a web-style router, plus deep link parsing and testing.
- · #Rust#desktop#architecture
Why Rust + GPUI for desktop apps
Why Rust and GPUI beat Electron for desktop apps: lower memory, faster rendering, compile-time safety, and no bundled browser. A practical comparison.
- · #GPUI#themes#design
Deep dive: the 21-theme system
How gpui-starter's theme system works internally, from 10 semantic color tokens to runtime hot-reloading across 21 built-in themes.
- · #GPUI#i18n#Rust
Internationalization in GPUI apps with es-fluent
Add multi-language support to GPUI desktop apps using Mozillas Fluent system and es-fluent, with compile-time checks, plural rules, and runtime switching.
Building software for 9 years. TypeScript, Rust, Flutter. Writing about things I broke and fixed.