Library / SDK
vczh-libraries/GacUI avatar
vczh-libraries/GacUI

GacUI: a UI library whose buildable source sits in three other repositories

Native C++ UI library, cross-platform, MVVM and data binding, XML description, multi-language, core/renderer cross-process separation, etc

2,709 stars325 forksC++NOASSERTION

At a glance

What is it?
GacUI is a cross platform C++ interface library with data binding, MVVM, XML described UI and the Workflow scripting language, plus an optional split between core and renderer across processes. The part that decides how you actually consume it is the license and packaging section: the tree here is reference material, and the compilable sources are published per platform in separate repositories.
Who is it for?
GacUI is worth evaluating if your application needs a native interface on several operating systems from one UI description, and if you are willing to vendor C++ sources rather than link a binary. Before you commit, check four things.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • vczh-libraries/GacUI2,709 ★ · +9
Star history
Repository2026-10-042026-11-15
vczh-libraries/GacUI2.7k2.7k

9 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The compilable sources are published per platform, and this tree is reference material

GacUI is split across five repositories before you write a line of application code. Windows native and remote rendering implementations are released in the Release repository, Linux ones in the wGac repository, macOS ones in the iGac repository, and browser support in the GacJS repository. The GacUI repository itself carries a note that the source code in it is for reference only, and asks you to use the source code in the Release repository instead. Using the library means taking C++ source files directly, from the Release folder for Vlpp, Workflow or GacUI, and everything else in this tree is stated to be for library development only. That applies to the three code generation tools as well: GacGen.exe lives under Tools/GacGen, and GacBuild.ps1 lives in the Release repository, for applications that build several XML resources with dependencies between them. Directory names in the tree make the same point structurally, with Source/, Release/, Tools/, Test/, Import/, Deprecated/ and ToDo/ all sitting side by side.

Two ways to carry the UI, and the generated one is the recommended one

The XML layer has two consumption paths and they differ in what the compiler can see. The first is dynamic loading with C++ dynamic reflection opted in, which is what lets you load a foreign UI with complex behaviour at run time. The second generates XML and Workflow into C++ source files for static linking, and that path is the one marked recommended. Its stated payoff is opting out of C++ dynamic reflection, which is described as significantly improving performance and reducing binary size. So the trade is explicit: run time loading of interfaces you did not compile against, or compile time specialisation with a smaller and faster binary. Workflow is embedded in the XML description, so the script that drives the UI travels in the same file as the layout, and an interface defined for another process is described with that script language too.

USERIMPL marks the only place your edits survive the next code generation run

The code generator does not overwrite your work, it discards anything outside a marker. GacGen.exe merges your modifications in C++ code and modifications in XML together and generates new C++ code behind, and the generated code contains a mark written as USERIMPL(/* ... */). That is the place to add code. Every change you make outside those places is thrown away on the next GacGen.exe run, which makes the marker the real contract between you and the generator rather than a comment. The generator can also fill event handlers for you, though the guidance is to use MVVM and data binding instead, and the same tools turn several XML files into binary resources, including images, in a compressed binary format. GacGen.exe covers the single project case and GacBuild.ps1 covers the multi resource case where one XML file depends on another.

MVVM interfaces are declared in XML and the C++ declaration is generated

Data binding here does not mean writing accessors by hand. You define the interfaces your MVVM pattern needs in XML, and GacGen.exe generates the C++ interface declaration for you, so the view model contract and the generated view live in the same description. Expressions in the Workflow script language can be used in data binding and in statements inside event handlers, which is the alternative to writing C++ in code behind. A view model does not have to live in the same process: it can be implemented in another process in a language of your choice, and that FFI integration starts from defining interfaces with the Workflow script. The browser path extends the same idea, where GacJS connects TypeScript view models through the remote protocol and Workflow RPC. In other words the binding expression is a language boundary, not only a UI feature, and the same script travels over the process boundary.

The automation endpoint is an HTTP server you have to switch on yourself

The accessibility bridge is the security sensitive part of this library, and the README is explicit about that. Because UI Automation does not work when the screen is locked, GacUI prepares facilities to expose UIA features through an http server brought up with the application, and that service must be explicitly activated in the source code for security reasons. Nothing starts it for you. The wiring is manual and has a fixed order: construct the concrete service matching whichever controller is active, of which there are four, normal, hosted, core and renderer, substitute it, start either the Windows HTTP or the MiniHTTP endpoint, run GuiApplication, then stop the endpoint and the service before unsubstituting. Both endpoints expose the same Controls, Dom and IO contract, and MiniHTTP is used by the remoting demos and is not yet part of GacUI's public API. The upstream documentation warns that the MiniHTTP remote-protocol demo does not implement security and recommends a separate transport stack for an actual application. Assess access controls and network exposure before enabling an endpoint. The coding-agent section says the interface can be operated even when the screen is locked.

The browser path runs the core as WebAssembly and keeps HTTP for renderer tests

WebAssembly is the primary browser story, and the transport used with it is not. GacJS primarily runs the GacUI core as WebAssembly in a browser, with HTML5 rendering and optional TypeScript view models connected through the remote protocol and Workflow RPC, and WebAssembly demos are published alongside it. HTTP appears in the same description as an alternative transport, and the stated purpose is mainly for testing HTML5 rendering without WebAssembly. That distinction matters when you plan a deployment: the transport you would reach for first is presented as a testing path. The other optional renderer arrangements are described in the same list of switches rather than as defaults: native renderers, TUI renderers, hosted mode for rendering all windows inside one native window, and core and renderer separation across processes. Any of them can be left off.

No standard licence identifier, and a terms file in a repository of its own

The licence story needs reading before anything else, and the README says so in its own first line of that section: read the LICENSE file first. This project carries no standard licence identifier in its metadata at all, while the tree does contain a LICENSE.md file, and the README points the actual terms at a separate License repository rather than restating them. On top of that, the reference and release copies are described as different things: the source in this tree is stated to be for reference only, with the Release repository named as the one to use. Those are two separate questions, what the terms say and which copy they cover, and the README does not spell out whether they are the same terms for both. Contribution is handled here, with pull requests welcomed to this repository. The last commit on the default branch, named master, is dated 2026-09-24, and there are no published GitHub releases.

Four documentation entry points, a mirror, and agent instructions in the tree

The documentation is not in this repository either. Four links are given at the top of the document section: the home page for the whole library family, the Gaclib reference, the GacUI reference, and gaclib.net as a mirror of the GitHub pages above, which matters when the hosted pages are unreachable. Two of those pages carry the material you need first, a tutorial on running the library and a demos section for every sample. Alongside them the tree keeps text aimed at tooling rather than readers: Project.md, AGENTS.md, a .cursorrules file, TODO_TASK.md and a ToDo directory, which is the context the coding agent support section refers to when it claims rich instructions and documentation for developing with an agent. The same section also claims the applications can be understood and operated by an agent without blocking normal computer use, which is the property that depends on the HTTP automation endpoint described earlier.

Editorial conclusion

GacUI is worth evaluating if your application needs a native interface on several operating systems from one UI description, and if you are willing to vendor C++ sources rather than link a binary. Before you commit, check four things. First, the licence: this project carries no standard licence identifier, and the terms live in LICENSE.md and in a separate License repository, so read them for the copy you actually compile. Second, whether your platform has a published implementation at all, because Windows, Linux, macOS and the browser each come from a different repository. Third, whether you want the generated code path with its USERIMPL marks and its discard rule, or the dynamic path with reflection turned on. Fourth, if a coding agent will drive your UI, remember the automation endpoint is an HTTP server you have to enable yourself, and that the cross-platform MiniHTTP endpoint used by the demos is not yet part of GacUI's public API. The remote protocol is under development and currently lacks text-box support.

Frequently asked questions

Where do I get the GacUI source code for Windows, Linux or macOS?

From separate repositories: the Release repository for Windows, the wGac repository for Linux and the iGac repository for macOS, each carrying native and remote rendering implementations. The GacUI repository states that its own source is for reference only and asks you to use the Release repository instead.

What licence is GacUI released under?

The project carries no standard licence identifier in its metadata, and the README sends you to the LICENSE.md file in the tree and to a separate License repository for the terms. Because this tree is described as reference only while the Release repository is the one to use, check which copy the terms you read cover.

What does the USERIMPL mark mean in GacGen generated code?

It marks the place where your own code belongs. GacGen.exe merges your C++ changes with your XML changes and regenerates the code behind, and every modification made outside the USERIMPL marks is discarded on the next run.

Does GacUI run in a browser, and which transport does it use?

Yes, through the GacJS repository, which primarily runs the GacUI core as WebAssembly with HTML5 rendering and optional TypeScript view models. HTTP is described there as an alternative transport used mainly for testing HTML5 rendering without WebAssembly.

How do I let a coding agent inspect a GacUI application?

GacUI can expose UI Automation features through an http server started with the application, because UI Automation itself does not work while the screen is locked. That service has to be activated explicitly in your source code for security reasons, and MiniHTTP, used by the remoting demos, is not part of GacUI.

Official sources

  1. Issues
  2. README
  3. vczh-libraries/GacUI on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/vczh-libraries-gacui.svg)](https://hysenlabs.com/projects/vczh-libraries-gacui)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/vczh-libraries-gacui.svg)](https://hysenlabs.com/projects/vczh-libraries-gacui)

Was this useful?