Building a GUI app in Rust is... complicated. Not the language — Rust itself is a joy. But pick any Rust GUI framework and you immediately hit a wall of tradeoffs. Too heavy. Too verbose. Too restrictive. Too experimental.
The founder of Ply just lived through that wall for two years. What they built to escape it might be the framework you've been waiting for.
The Problem Every Rust Developer Hits
You want to build an app. Not a game, not a CLI tool — an actual interactive application with buttons, text inputs, layouts that respond to window resizing.
In Rust, your options are:
- Bevy — Powerful ECS game engine, but it crams everything into a data-oriented design that turns simple UI into "thousands of lines of virtual database queries"
- Iced — Clean architecture, but everything needs
.into()and..default()and the nesting reads backwards - egui — Fast immediate-mode GUI, but you're manually calling
.add_space()and allocating rects for every gap - Slint — Beautiful nesting, but it's a separate markup language that doesn't integrate with Rust
- Macroquad — Inspired by Love2D, but it's a rendering library, not an app engine. No layout, no text input, no UI structure
This is the wall the Ply author hit. They wanted to build a multiplayer board game with a server, client, and shared game logic. One language. Full control. Clean architecture.
Everything they tried fell short.
What Ply Actually Got Right
After two years of hitting limits, they built Ply 1.0 — and the philosophy behind it is worth understanding.
Immediate-mode is actually faster. Ply rebuilds the UI every frame. That sounds inefficient, but the author argues correctly: the layout takes a fraction of a percent of frame time. Most time goes to the GPU anyway. You have to redraw every frame. Tracking mutations is more overhead than rebuilding.
Builder pattern + closures. No more .end() calls everywhere. No more ..Default::default(). Just chainable methods:
ply.element()
.background_color("#3b82f6")
.rounded(8)
.padding(16)
.child(text("Hello"))
Managers handle state across frames. Textures, fonts, materials, network requests — all managed automatically. You tell Ply where your image is, it handles caching, eviction, and lifetime. This was the hardest part of building on raw Macroquad + Clay.
Full feature set at 1.0:
- Flexbox-like layout with padding, gaps, alignment, scrolling, floating elements
- Rich text input with cursor, selection, undo/redo, multiline, password mode
- Inline text styling (colors, gradients, shadows, wave animations)
- GLSL shaders on any element
- HTTP + WebSocket networking that never blocks
- Accessibility via AccessKit on desktop
- Cross-platform: Linux, macOS, Windows, Android, iOS, web
The Interactive Docs Are The Thing
Here's what stood out to me: the docs aren't just documentation. They're interactive playgrounds where you can tweak values and see results instantly.
This is what Rust documentation should look like. Not "here's the API, figure it out" — but "here's the concept, play with it."
The author explicitly built this because they "spent two hours just figuring out how to construct a FloatingElementBuilder" in other frameworks. Every second you don't spend on boilerplate is a second spent actually building.
Why This Matters
The Rust GUI story has been "pick your poison" for years. You accept tradeoffs: verbose syntax, restrictive patterns, experimental status, markup languages that don't feel Rust-y.
Ply 1.0 is the first framework that explicitly designed for "full control without the weight." Not a game engine pretending to be a UI framework. Not a markup language. Not a reimplementation of web patterns in Rust.
Just an app engine that respects both your time and your control.
cargo install plyx
plyx init
Two commands to get started. That's the entire onboarding.
Full disclosure: I haven't built a real app with Ply yet. But I've hit every wall the author describes — the verbose syntax, the framework weight, the "just use Tauri" deflections. If Ply delivers on even half of this, it's the framework the Rust community has needed for a long time.