Comparisons
.gui vs React and Vue: a file format, not a UI framework
A question that comes up fast: "why is the dotgui site built in Vue, not .gui?" Because .gui isn’t a framework you deploy; it’s the design the framework gets built from. Here’s the distinction.
When people first meet .gui, a very common reflex is to slot it next to React or Vue and ask which one wins. There’s even a sharp version of the question aimed straight at this site: "if .gui is so good, why is dotgui.org itself built in Vue instead of .gui?" It’s a fair thing to ask, and the answer is the whole distinction: React and Vue are UI frameworks you build and run an application with; .gui is a design file format, not a framework at all (.gui is not a runtime). They aren’t competing; they sit at different stages of the same pipeline.
Different layers, not different options
React and Vue are runtimes: you install them, write components that hold state and logic, and ship a running application whose interface only exists after their code executes in a browser. .gui runs no logic and ships nothing; it’s a static, self-contained file that describes an interface (.gui vs HTML). Asking "React or .gui?" is like asking "React or a Figma file?": the design is the input, the framework is what you build from it. The right sentence is "design it in .gui, then generate the React (or Vue) code," not "pick one."
| React / Vue | .gui | |
|---|---|---|
| What it is | A UI framework / runtime | A design file format |
| You install it? | Yes, plus a toolchain | No, you open the file |
| Holds state & logic | Yes | No: static by design |
| Is the shipped app | Yes | No: it’s the design the app is built from |
| Portable across stacks | No: framework-specific | Yes: convert to React, Vue, SwiftUI, Compose, HTML |
So why is this site built in Vue?
Because that question actually reveals how the format is meant to be used, not a contradiction. dotgui.org is a real, deployed web application: it needs routing, interactivity, and a runtime, which is exactly the job a framework like Vue exists to do and exactly the job .gui deliberately does not do. What actually happened is the useful part: the site’s pages were designed as .gui files first (generated with AI, iterated on, previewed), and once the design was right, converted into a Vue project to ship. The .gui file was the source of truth for the design; Vue is the runtime it was built into. A design format shipping as itself would be the contradiction, the same way you wouldn’t deploy a Figma file as your production frontend.
The mental model: .gui is upstream of your framework. Ideate and agree on the design as a .gui file, then generate React/Vue/SwiftUI/Compose from it and build the real app there.
Where each one is the right tool
Reach for React or Vue when you’re building the actual product: anything with behavior, data, and state that has to run. Reach for .gui one step earlier: to generate and compare interface ideas cheaply, hand a design between an AI agent, a designer, and a developer as one portable file, and keep a readable source of truth for what the screen is supposed to look like before it’s entangled in framework code (What problem does .gui solve?). One doesn’t replace the other; .gui makes the step before React or Vue an open, machine-readable artifact instead of a screenshot or a locked design-tool document.
Frequently asked
Is .gui a replacement for React or Vue?
No. React and Vue are UI frameworks you install and ship a running app with; they hold state and logic. .gui is a static design file format that runs no logic and ships nothing. It doesn’t compete with them; you design a screen as a .gui file and then generate React or Vue code from it, the way you’d build from a Figma file. They’re different stages of the same pipeline.
Why is the dotgui website built in Vue instead of .gui?
Because dotgui.org is a real deployed web app that needs a runtime (routing, interactivity, state), which is exactly what a framework like Vue is for and exactly what .gui deliberately isn’t. The site’s pages were designed as .gui files first (generated with AI and iterated on), then converted into a Vue project to ship. The .gui file was the design source of truth; Vue is the runtime it was built into. Deploying a design format as-is would be the actual contradiction.
Can I build a full application directly from a .gui file?
Not as a runtime: a .gui file has no logic, state, or data binding, so it isn’t a shippable app on its own. What you do is generate framework code (React, Vue, SwiftUI, Compose, HTML) from it and build the real app there. .gui is the portable design upstream of the framework, not a substitute for it.