- 614comments
- 820comments
- 292comments
- 361comments
- 22comments
- 161comments
- 132comments
- 92comments
- 72comments
- 84comments
- 226comments
- 83comments
- 13comments
- 7comments
- 42comments
- 82comments
- 195comments
- 17comments
- 27comments
- 110comments
- 45comments
- 75comments
- 47comments
- 58comments
- 461comments
- 14comments
- —discuss
- 146comments
- 9comments
- 28comments
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.
Bookmarked, thanks
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?
It loosk more like React Native: https://github.com/geastack/examples/tree/main/apps/notes-na...
https://www.youtube.com/watch?v=o5RDfAmzE7s
It supports Gea frontends (https://geajs.com). Technically it could compile React with a plugin, but that is left to the community as an exercise :)
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 defers to platform defaults, Android compositor, UIKit/AppKit native views or CoreGraphics for the canvas on Apple platforms, GDI/GDI+ on Windows, whatever SDL2 chooses on Linux. If you have a Three.js app, it uses Metal on iOS and macOS, Direct3D 11 (open) and 12 (commercial license) on Windows and XBox.
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
It compiles TypeScript statically to C++, there's no JS engine or VM running.
They mention OpenGL for the bigger targets, but I was wondering how this worked for the ESP32. Turns out they wrote a custom 2D rasterizer specifically for this target, basically a miniature version of a browser layout engine: https://geastack.com/blog-we-taught-a-chip-to-run-css
"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.
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!]
I understand and appreciate the concern. We've been working on Gea Stack for about a year now. Started with https://geajs.com, then decided to enlarge the capabilities. The current capabilities have been under development for the past 6 months. We are in the process of forming a new company around Gea, and already collaborating with multiple embedded device vendors, development partners and customers who are interested in the technology.
There's a broader philosophy of "firmware freedom" that we want to bring to the world. Practically, you should buy hardware for what it is, and run your own firmware on it. E-book readers and unlocked bootloaders in the Android world is doing a pretty good job at this, so we want to contribute to this movement by making the development of such solutions dead simple, both for humans and AI. Incidentally, TypeScript, JSX, and CSS happen to be the languages AI knows best.
So, it's an ambitious project with a real team behind it, with commercialization on the horizon.
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.
It took us 6 months to build the compiler. We analyze literally the hell out of the call graph. We started with strictly typed TS, which is trivial to compile. Then we added a dynamic fallback for projects that have "unknown"s and "any"s, then we had several architectural changes which allowed us to inspect those "claim"s. If you think about it, marking a variable "any" is a lazy claim. If it's ever used in one place and in one shape (akin to duck typing), you can create a static struct out of it...
So there's no byte code, and while not every single dynamic language feature has a corresponding static compilation, the base is pretty broad. So much so that Hono, the web framework, with all its dependencies, compile just fine.
Nice.
I will keep an eye on this for future use.
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.
Another data point: hello.c in GTK4 used over 100MB last I checked.
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:
or even:
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.