Not apparent at first, but this is a TypeScript to c++ compiler at the core (https://github.com/geastack/compiler), with bindings for various platforms.

Ah this is for embedded apps. Pretty neat!

It also supports iOS, macOS, Android, Windows, Linux, XBox for Three.js games, as well as (some) Node.js apps.

could you throw a react project (WEB) at it and get a native macos project out of it?

What do they use for graphics and audio?

Each platform has its native bindings. For graphics, you write CSS and HTML canvas API as well as JSX, it renders to native components and their alignments, the canvas API is converted to native surfaces, whatever the platform uses.

I mean, is it OpenGL, Vulkan, Metal? etc...

It's not clear at first glance, but given (1) the apps are written in JavaScript (2) the project has repos for different OS native bindings, my bet is some kind of embedded JavaScript engine that just calls through to OS native widets

"The earlier implementation could not be driven to zero of them, because boxing was load-bearing in its emitter"

In the docs of the repo of their TS to C++ compiler. https://github.com/geastack/compiler

I see what you’re getting at, but let’s not pretend like “load-bearing” is something that AIs made up. It was a turn of phrase long before AIs became mainstream and people are still allowed to use it.

"geatsc: the GeaStack TypeScript-to-C++ compiler. A clean-room rewrite built on one rule — a statically typed value that reaches a dynamic carrier is a defect, not a fallback."

The whole thing is like this

But to be fair, it's late 2026 so it's to be expected now that the vast majority of code and surrounding artifacts are AI generated. It's just a fact of life.

the amount of ai used in this makes me think its pure vaporware. has anyone actually confirmed any of this is real or works?

Watch the demo videos here: https://www.youtube.com/watch?v=uCfFTZSG-PQ&list=PL9pDl_Oth4...

The code is on GitHub, for example for the first video that renders a 3D cube with CSS the code is at https://github.com/geastack/examples/tree/main/apps/css-3d-c.... It takes only a couple of CLI commands to get it running. For reference, I'm using a WaveShare ESP32-S3 AMOLED Touch 2.06" device here, but the same code renders on every target Gea compiles for.

The concern with a lot of projects that look largely AI made isn't that the current state works, but that this current state might be all that ever happens so people who try to use it end up relying on a dead project unless they maintain it themselves.

[refusing to reword the "it is not X, it is Y" - I'm not an LLM but I don't care that much if you think I am!]

with a lot of ai projects it's often that the only thing that does work is the demo. and im not saying this to be rude, its an ambitious project and im afk so i cant test it myself.

how does it compile js to c++? js is so dynamic it makes me think it either compiles to some kind of bytecode or its a heavily restricted subset of the language.

How many memory does it cost for a simple hello world window? VS Qt, Tauri

As much as it would cost a native app. Say, on Mac, a plain AppKit app consumes 16-17 MB, gea consumes 18-20 MB, Qt consumes 25-35 (depending on whether you use QML or not) and Tauri consumes 58-60 MB. Tauri suffers a lot from all the WebKit dependencies, as its UI is not native but rather HTML rendered by WebKit.

Author of tsonic.org here (which is very similar, but for Rust, C# and Mojo - WIP).

One of the biggest complaints I get is about missing documentation on what TypeScript is not supported.

For example, the following is obviously impossible:

  const a = eval("...something....");

or even:

  a: unknown, or a: any.

The rest of it is largely doable. But people want to see what's not supported. Otherwise it's not clear to them what to avoid.

Ah, amazing project! Congratulations. I was just writing under another thread that we support any and unknowns in two different ways. First, most any and unknowns are lazy programming—if you trace the call graph you can prove they have concrete types, or used only in one shape. If we can't prove a type narrows properly, we lower it to a boxed dynamic value carrier so it doesn't block compilation. Like JSON.parse—for this we have a special syntax, you can do JSON.parse(x) as T, to define the type, and if you don't it becomes a dynamic value whose price you pay only for that site / variable.

We also have limited support for `new Function("...")` via a small evaluator written in C++ that parses and runs the generated body. We mainly built this for Fastify's generated routing functions so it doesn't support classes, asynchronous, destructuring, etc, but conditionals, loops, variable declarations etc work.

There is no "eval" yet, but the same support shape could be added for it too, as the mechanism is already there.

The approaches and the limitations are documented here:

https://github.com/geastack/compiler/blob/main/docs/EVAL.md https://github.com/geastack/compiler/blob/main/docs/DYNAMIC-...

I've been working on this full-time since late 2025. Happy to share what I've learned - feel free to email me as well if you wish to.

so it doesn't support classes, asynchronous, destructuring

For users, this general category of problems (not knowing these edges) is the hardest. It's amplified if you pull libs from npm. One of the best ways to test compatibility is to test with non-trivial projects, or existing codebases. For example, one which has helped me a lot is trying to compile Microsoft's typescript-go compiler, after translating it from golang to TypeScript via a separately written tool. Large projects surface a ton of issues.

Also curious - how do you handle "number"? i32, i64, doubles, floats, i16 etc have very different performance characteristics. Also, things like sparse arrays, Error.stack etc. I haven't documented them in my project yet, but it's quite high up in the list of things people actually care about.