Egui – An immediate mode GUI written in Rust

Original Article ↗ Hacker News Discussion ↗

An immediate-mode GUI library for Rust, egui, is drawing interest for how quickly it enables cross‑platform desktop and WebAssembly UIs, especially for prototypes, game overlays, visualization tools, and niche apps like plasmid or CAD editors. Commenters highlight its strengths—simple APIs, portability, and smooth performance on many devices—alongside notable trade-offs such as awkward layout for complex interfaces, limited internationalization and text selection, and inconsistent behavior on some mobile browsers. There is also debate over its redraw model, font rendering quality on low‑DPI screens, and the broader implications of canvas-based UIs versus traditional HTML/DOM for accessibility and debuggability.

Use cases and strengths

  • Used for a wide range of tools: data viewers, scientific sims, CAD-like tools, photo/glitch art editors, plasmid editors, embedded-device configuration UIs, and game overlays.
  • Integrates with game engines (e.g., via Bevy bindings) and is seen as especially suitable for in-game/2D overlays on 3D rendering.
  • Popular for “scrappy prototypes” and small cross‑platform utilities, including browser builds via WebAssembly.
  • Many commenters report using it daily and consider it their default choice for quick, functional desktop GUIs.

Immediate‑mode model, layout, and redraw behavior

  • Core model: UI code runs each frame; widgets are rebuilt from state instead of being retained.
  • Debate over whether it “redraws everything all the time”: some say that in native setups you can tie redraws to events; others point to cases where network or other external events require manually triggering redraws.
  • Single‑pass layout works well for straightforward top‑to‑bottom, left‑to‑right layouts; more complex dependent layouts can cause mispositioning or jitter across frames.
  • Two‑phase layout is approximated by discarding a frame and recomputing, which can work but leads to edge cases like briefly displaying out‑of‑bounds values.
  • Several reports of window resizing quirks and difficulty expressing proportional layouts (e.g., 60/25/15% width splits).

Performance and platform behavior

  • Some find demos extremely snappy on mobile; others see high CPU usage even when idle, slow text input on phones, and various mobile browser errors (missing WASM, runtime panics, blank page on iOS Safari).
  • Concerns about power usage if redrawing at high FPS for non‑game apps; others argue you can and should gate redraws.

Text, internationalization, and accessibility

  • Current internationalization is limited: Arabic text becomes tofu; text shaping work is in progress via Rust bindings to HarfBuzz‑style libraries.
  • Font rendering can look blurry on low‑DPI displays; canvas/WebGL UIs lack subpixel rendering that DOM text enjoys.
  • Inability to select/copy text on mobile (and in many canvas/native UIs generally) is a major complaint, especially versus HTML’s text‑first model.
  • This also raises accessibility and automation concerns; workarounds rely on OS‑level OCR features.

Developer experience and tooling

  • Rust compile/link times can make rapid UI iteration feel slow; suggestions include faster linkers and hot‑reloading, though the latter is described as immature.
  • Version lockstep between egui, winit, wgpu, etc., causes friction when APIs break.
  • Requests for higher‑level tooling: dialog/WYSIWYG builders, global font‑size and high‑contrast options, and easier “serious”/pixel‑perfect design support.
  • Some view egui as excellent for functional UIs and prototypes but not ideal for complex, highly polished visual design.