Building things at the intersection of AI, systems, and real-world products.
CTO / founder. I spend most of my time designing multi-agent systems, experimenting with LLM reasoning, and shipping actual products instead of demos. Currently focused on autonomous agents, orchestration, and making AI useful beyond toy use-cases.
Background in software engineering, distributed systems, and teaching. I’ve worked with startups, governments, and enterprise teams—usually stepping in where things are messy and need to scale.
I care about:
• shipping over talking
• clear thinking over hype
• systems that actually work in production
Expect posts about AI, architecture, dev tooling, and occasional strong opinions.
Here is the author of Gea Stack. There is no browser in the device, none of these devices could run one with 512KB of RAM (+2-8MB of PSRAM). We instead transpile TypeScript and CSS into native code, so the UI you build with web technologies look and behave identical on a microcontroller.
Thank you! I am the guy on the video. We will be open sourcing Gea Stack next month, and in the meantime I am showcasing the examples we've built so far. The underlying framework, Gea, is already available for the web on https://geajs.com.
I am pondering about this, but would love to see an example to make it more concrete. The way I see it is that this reactivity is completely on the compiler's side, and there's no more ambiguity or pitfalls than misrepresenting a dependency array in a react hook.
As an open-source builder and a streamer, I'm afraid I will leak keys on stream any time soon. And fun story—I did leak the API keys to my smart lights once, and the company (Govee) had a 30-day grace period for any revoked keys!
It still looks too tedious to manage all this—curious to see if there's an easier way. Currently I use 1Password in my teams to share .env config, but we basically c/p to local git folders, so there's still a lot to lose.
I'm especially worried about the growing number of supply chain attacks. Curious to see how you tackle these.
Feel free to question anything you like and I'll help you find the answers.
This is a well-trodden path. All aspects of object mutation and its effects are obvious and well-known. What is pass by ref and what is pass by val is also pretty obvious. One can easily pass in primitive values and not worry about two-way binding if they choose to. One can also easily not mutate any props they receive from their parents. This is already the best practice in eslint for like 10 years. This is not easy, this is trivial.
I don't want to recurse into philosophy but one could argue an assignment is more declarative than a function call :) Solid is function calls everywhere, and extra code, vs plain objects.
I see your point. I designed Gea to be one-way binding only first, and then decided to add two-way binding for props passed as objects. People can still easily only use one-way binding. Maybe this becomes a preference in the compiler config?
The argument for Gea to support two-way binding is basically circular and I believe well-made at this point. I want a framework to respect a language. Breaking two-way binding when it's a concept in the underlying language is like breaking Liskov's Substitution Principle. You can do it, but you probably shouldn't.
JSX is more succinct and efficient than raw DOM API because it's declarative, where the raw API is imperative.
Thank you for the discussion, I find it very interesting and I'd love to understand how you think. Why do you think setStore and produce let you model your application more succinctly and efficiently than just a direct assignment?
And what kind of types of boilerplate do you see Gea is opting out of?
Gea in fact supports regular HTML strings out of the box—that's what the compiler turns the JSX into anyway. However IDE tooling is still in the works for syntax highlighting regular HTML.
What syntax would you prefer from Svelte? Like for hooks / stores, or rendering?
Heh, sorry, I (the author) wasn't the one who created the post. But the idea is reactivity in JS shouldn't require new syntax.
Gea works best with the compiler, I documented a non-compiled (only compiles JSX) browser usage here: https://geajs.com/docs/browser-usage.html but this obviously requires manual store observers and manual DOM updates, which means it's not _really_ benefiting from Gea.
Very interesting benchmark results... well, I guess that's proxies for you.
Getters in Gea are designed to be used as computed properties by the components' rendering cycles, and in that, they don't need explicit memoization. I believe users can implement their own memoized computed variables if they require repetitive access—in which case each store's `observe` method could be utilized in updating the memoized value whenever a specific value changes in the store.
And for the async case, for now the compiler doesn't handle this scenario. It could be added, but as you expect, for now the same `observe` method could help here as well to listen to changes on store0.url and refetch accordingly.
Thanks for your insights. I was originally hesitant about the performance of proxies, too, but they turned out to be great. The benchmarks (https://geajs.com/benchmark-report.html) also show good results. Both in terms of memory and CPU cycles, even though proxies are obviously adding an overhead, it's not day and night (https://jsben.ch/proxy-vs-object-performance-benchmark-dtxo6 is a good test for this). With a proxy, you can set a property 25 million times per second (on my M4 Max machine in Safari) with only 4% perf loss vs defineProperty, and Chrome is about half the perf with 20% loss vs defineProperty. So, still, 12.5 million setters per second is pretty good. Of course if your use case demands more performance, nothing beats a hand-optimized vanilla JS code.
Since Gea doesn't rerender the template _at all (well, for the most part, at least)_, in theory we wouldn't really gain much from getter memoization, mainly because we create proxy observers for computed values that update the DOM in place only when the underlying value updates.
And since stores are plain old JS classes, there's no need for an "async store" concept. Just update a value in the store whenever you want, track its loading state however you want, either synchronously or asynchronously, and the observers will take care of them. If you refer to another pattern that I'm not aware of, please let me know.
Because JavaScript _is_ the language and people know it. I never understood the concept of a "React developer", for example, although I saw many junior devs who were very well-versed in React and didn't completely understand JavaScript.
In the end, it's a design choice. Of course frameworks don't inherently _need_ to be beholden to the standards of the underlying language, but I think this is just simpler, therefore a worthy goal to pursue.
I wish I could bring it to React! That would save so many developers and so much natural resources!
I've been working on the library for 6 months, and it's built upon my previous libraries tartJS (2011), erste (2017) and regie (2019). I just like to squash my commits before I make a public release, and that just happened 4 days ago :)
CTO / founder. I spend most of my time designing multi-agent systems, experimenting with LLM reasoning, and shipping actual products instead of demos. Currently focused on autonomous agents, orchestration, and making AI useful beyond toy use-cases.
Background in software engineering, distributed systems, and teaching. I’ve worked with startups, governments, and enterprise teams—usually stepping in where things are messy and need to scale.
I care about: • shipping over talking • clear thinking over hype • systems that actually work in production
Expect posts about AI, architecture, dev tooling, and occasional strong opinions.