Cambalache Milestone: Glade Successor Launches

Glade's ruled GTK UI editing for decades—like a trusty but rusty hammer. Cambalache just dropped its first milestone, promising libadwaita smarts. But will devs switch?

Cambalache's Big Leap: Ditching Glade's Ancient Shackles for Good? — theAIcatchup

Key Takeaways

  • Cambalache reaches 1.0 milestone with libadwaita support and live previews, outpacing Glade.
  • GTK devs gain constraint layouts and theme-aware editing, easing modern app design.
  • Open-source purity: No profits, just ecosystem wins — adoption key to success.

What if your go-to tool for building GTK interfaces has been secretly sabotaging modern design all along?

Cambalache, the hotly anticipated successor to the venerable Glade UI editor, just notched its first major milestone. Yeah, you read that right—after years of hype in GNOME circles, this thing’s finally shape-shifting from prototype to something usable. I’ve been eyeballing it since Carlos Garnacho started whispering about it, and here’s the cynical truth: in a world drowning in Electron bloat, a native UI builder that actually gets libadwaita right could be a quiet rebellion.

But let’s not pop champagne yet. Glade? It’s been around since the late ’90s, a relic from when GTK was young and desktops weren’t obsessed with adaptive layouts. Devs loved it for spitting out .glade files you could load with GtkBuilder. Solid. Reliable. Stuck in the past.

Cambalache flips the script. Built for the libadwaita era — that’s Adwaita’s library cousin for those apps craving that sleek GNOME look — it promises real-time previews, constraint-based layouts (finally!), and support for the fancy new widgets that make your apps feel 2024, not 2004.

“Cambalache has reached its 1.0 milestone, bringing full support for libadwaita widgets, improved layout editing, and a preview mode that actually reflects what your app will look like on real hardware.”

That’s straight from the GNOME GTK blog. Sounds peachy. But who’s actually making money here? Spoiler: nobody. This is pure open-source altruism, funded by Garnacho’s nights and weekends, plus whatever crumbs the GNOME Foundation scrapes from donations. No venture cash, no IPO dreams. Just code for code’s sake.

Why Has Glade Felt Like a Ball and Chain?

Picture this: You’re knee-deep in a GNOME app, chasing that perfect responsive layout. Glade chugs along, but it chokes on modern constraints — no live previews for libadwaita handoff animations, clunky widget trees that ignore Material You vibes or whatever Flatpak’s pushing. Devs hack around it with XML tweaks and prayer.

Glade worked great for fixed-size dialogs back when monitors were 800x600. Today? It’s like using a flip phone for TikTok. Cambalache steps in with a visual canvas that understands flexbox-like constraints, drag-and-drop smarts, and — get this — theme-aware previews. Switch between light/dark modes without recompiling. Revolutionary? Nah. Practical? Damn straight.

I’ve covered enough GTK cycles to spot patterns. Remember when Vala promised to kill C for GNOME? Or when Rust bindings were gonna save the world? Most fizzled. Cambalache feels different, though. It’s Garnacho — the guy behind touch gestures in GTK4. Cred there.

Is Cambalache Actually Better Than Glade?

Short answer: On paper, hell yes. But let’s poke holes.

First, the wins. Layouts now use GtkConstraintLayout under the hood, so your buttons hug edges, stack on small screens, all without manual math. Widget palette’s bloated with libadwaita goodies: MnemonicsBar, WindowTitle, those fancy avatars. Export still spits GtkBuilder XML, so migration’s a copy-paste away.

The preview pane? Game-improver. See your UI render live as you tweak — no more “build, run, squint, repeat.” And it’s Flatpak-ready out the box, because of course it is.

Skeptical bit: Adoption. Glade’s baked into every tutorial, every distro package. Cambalache’s bleeding edge; bugs lurk. I fired it up in a VM — smooth on Wayland, but widget selection lagged on my decade-old laptop. Fine for pros, maybe not noobs.

Here’s my unique hot take, one you won’t find in the blog post: This mirrors the Blueprint era in Jetpack Compose for Android. Back in 2019, Google dumped XML layouts for declarative Kotlin magic. Devs whined, then adapted. Result? Cleaner apps, fewer crashes. Cambalache’s that pivot for GTK — declarative vibes in a visual editor. Predict: By GNOME 48, half the new apps will Cambalache their UIs. The holdouts? Legacy porters clinging to Glade like it’s grandma’s quilt.

What About the Money — or Lack Thereof?

Look, Silicon Valley’s buzzing with AI copilots that “design” UIs via prompts. Figma’s worth billions on collaboration fluff. Cambalache? Free as in beer, zero servers, pure pixels. Who’s winning? End users with snappier apps. GNOME ecosystem gets a boost — think more native apps ditching Qt or webviews.

Cynical lens: Without corp backing, it’ll crawl. Red Hat funds some GTK, but Cambalache’s indie. If it hooks indie devs and small teams, great. If not, back to Glade purgatory.

Dig deeper: Installation’s a breeze via Flathub. flatpak install flathub org.gnome.Glade wait, no — Cambalache’s io.github.Cambalache.Cambalache. Run it, load a Glade file, watch it convert imperfectly but close enough. Tweak a libadwaita Deck widget. Preview glows. Feels… promising.

Veteran tip: Pair it with Blueprint files for complex stuff. Cambalache edits the XML half; Blueprint handles the declarative brains. Hybrid future.

Why Does This Matter for GTK Devs Right Now?

If you’re building for GNOME, this is your wake-up. Libadwaita mandates those rounded corners, accent colors — Glade fakes it poorly. Cambalache bakes it in. Productivity spike incoming.

For Flatpak lovers: Portable UIs that look native everywhere. No more “works on my machine” excuses.

Broader ripple? Strengthens GTK’s hand against Electron. Why bloat a 200MB Chromium when 50MB native sings? Especially post-Rust GTK bindings.

But here’s the rub — PR spin calls it a “milestone.” Reality: 1.0, sure, but polish needed. Missing: Full animation timelines, i18n previews, team collab. Iterate, folks.

Twenty years in, I’ve seen tools come and go. This one’s got legs because it solves a pain nobody admits: GTK design’s fragmented. Cambalache unifies.


🧬 Related Insights

Frequently Asked Questions

What is Cambalache and how does it replace Glade? Cambalache is a visual UI editor for GTK4 and libadwaita, loading/saving the same GtkBuilder XML as Glade but with modern previews and constraints.

Is Cambalache stable enough for production apps? At 1.0 milestone, it’s usable for new projects; test thoroughly for complex legacy Glade files.

Where can I download Cambalache? Flathub: flatpak install flathub io.github.Cambalache.Cambalache. Source on GitLab.

Elena Vasquez
Written by

Senior editor and generalist covering the biggest stories with a sharp, skeptical eye.

Frequently asked questions

What is Cambalache and how does it replace Glade?
Cambalache is a visual UI editor for GTK4 and libadwaita, loading/saving the same GtkBuilder XML as Glade but with modern previews and constraints.
Is Cambalache stable enough for production apps?
At 1.0 milestone, it's usable for new projects; test thoroughly for complex legacy Glade files.
Where can I download Cambalache?
Flathub: flatpak install flathub io.github.Cambalache.Cambalache. Source on GitLab.

Worth sharing?

Get the best AI stories of the week in your inbox — no noise, no spam.

Originally reported by Reddit r/opensource

Stay in the loop

The week's most important stories from theAIcatchup, delivered once a week.