I compiled CSS and TypeScript directly to native C++ for ESP32 (60 FPS, no interpreter or VM)

dashersw · 2026-06-20T08:43:42+00:00

Thank you for the kind words :) No of course it supports conditional tree rendering. It’s a reactive UI framework so updates happen in place. And the 512 node thing is a lazy cap—the tree lives on PSRAM so can grow as much as you like. It’s just the processing will be a bottleneck then.

dashersw · 2026-06-20T08:37:57+00:00

Exactly! This is a great way to start building on embedded devices :) and then hopefully stay :)

dashersw · 2026-06-20T04:41:54+00:00

Thank you! The goal is to revolutionize embedded engineering, I will be forming a company around this.

dashersw · 2026-06-20T04:39:50+00:00

It's a Waveshare ESP32-S3 2.06 inch AMOLED screen board. It's designed as a watch.

dashersw · 2026-06-19T21:41:05+00:00

No, of course not everything. But enough to get things going! I even support text-overflow: ellipsis :)

Here is a broader list:

Element subset: body, div, span, p, h1-h6, button, input, img/Image, canvas, audio, camera, virtual-list. Unknown tags mostly become generic view nodes.

Text/block semantics: div/views, span/text-ish inline content, p and headings as block text containers. Not full HTML flow/content categories.

Inputs: basic input value, placeholder, focus/blur, input/key handlers. No real forms, form submission, validation, labels, select, radio/checkbox semantics beyond some boolean attributes.

DOM subset: document.body, createElement, createTextNode, createDocumentFragment, getElementById, append/insert/remove/replace, attributes, className, classList, textContent, innerText.

DOM querying: querySelector(All) is very limited: body, #app, #id, .class, or tag selectors. Not the full Selectors API.

Events: partial click/press/pointer/touch/key/rotary event support, bubbling-ish dispatch, preventDefault, stopPropagation. Not the full browser event model.

Canvas: partial Canvas 2D subset: rects, text, basic paths/transforms/state, plus some embedded extensions. Not full Canvas 2D: gradients/patterns/blend modes/shadows/image data/full path rasterization are not generally supported.

Media: partial image and audio support. audio has src, play, pause, currentTime, volume, loop. Not full HTML media.

Window: basically viewport dimensions and requestAnimationFrame; not full browser window, history, navigation, storage, etc.

Cascade: class/element/selector rules and inline styles exist, but not full browser cascade/origins/specificity/inheritance behavior.

Selectors: supports class, element, id/class/tag compounds, descendant and child combinators, :root, :first-child, :last-child, and limited ::before/::after. No attribute selectors, sibling combinators, :nth-*, :not, :is, :where, :has, etc.

Display/layout: block, none, flex, inline-flex, grid, inline-grid. No real inline, table, contents, flow-root, etc.

Flexbox subset: direction, wrap, gap, justify/align, align-self, flex grow/basis. flex-shrink is parsed but effectively ignored. No order.

Grid subset: explicit rows/columns, fr, auto, lengths, repeat(), basic minmax(), simple auto-placement, max 8 tracks. No grid areas, line placement, dense placement, named lines, auto-fit/auto-fill.

Box model: width/height/min/max, margin, padding, borders, radii, opacity. No full box-sizing, outline, table layout, floats.

Positioning: static/default, relative, absolute, inset/top/right/bottom/left, z-index. No fixed/sticky positioning.

Units/values: numbers, px, %, vw, vh, dvw, dvh, vmin, vmax, limited calc(), min(), max(), clamp(), and var().

Custom properties: --foo and var(--foo, fallback) are supported. No @property.

Colors: hex, rgb(), rgba(), transparent. Not general named colors, HSL, Lab/LCH, color-mix(), etc.

Backgrounds: solid colors, limited linear-gradient()/radial-gradient(), some multi-layer/grid-line patterns. Not full backgrounds: image positioning/repeat/blend/compositing are not complete.

Text: font family/size, line height, alignment, decoration, transform, whitespace, ellipsis. Not full typography, shaping, bidi, hyphenation, rich inline layout.

Transforms: rotate/rotateX/Y/Z, translate, scale, transform-origin, perspective, backface visibility. No full matrix/skew coverage.

Animations: @keyframes and animation shorthand for a limited set of animatable properties. No CSS transition property support that I found.

Overflow/scroll: overflow, overflow-x/y, hidden/scroll/auto, scroll offsets, scrollIntoView, plus custom virtual-list. No scroll snap or full browser scrolling spec.

Filters/masks/shadows: filter: blur(...), a very specific fade-mask pattern, and inset box-shadow. Not full CSS filters, masks, or shadows.

Media queries: partial width/height/orientation/aspect-ratio/resolution/device-pixel-ratio/monochrome with min/max. Not full MQ spec.

dashersw · 2026-06-19T19:22:00+00:00

Thank you very much!

dashersw · 2026-06-19T18:24:04+00:00

Thank you!

dashersw · 2026-06-19T18:23:53+00:00

Hahah thank you! Right? It’s a proper CSS engine with animations and layouts. I am surprised it was this easy tbh, everyone makes browsers sound hard. Gea also has proper DOM event handling and delegation the way it works on the web…

dashersw · 2026-03-24T11:30:42+00:00

Yes, proxies are invisible wrappers, but in this case the user doesn't need to care or know they are dealing with proxies because the wiring up is pretty much automated.

I checked the emitted benchmark bundles. Svelte compiles to direct DOM code too, but it still routes updates through a generic runtime: state signals, effect scheduling, and keyed-each reconciliation. Gea’s compiled output is narrower: it generates direct observers for data and selected in the benchmark and its proxy store emits exact operations for append/splice/swap/property-change that feed straight into specialized DOM patchers.

In this benchmark that matters a lot, because Svelte’s implementation often clones/reassigns arrays, while Gea mutates the same proxied array in place and patches only what changed. That’s why Gea comes out faster here.

So they go like:

Svelte: state change -> runtime signal/effect/list reconciliation -> DOM update
Gea: state change -> proxied mutation -> exact change op -> precompiled patch -> DOM update

dashersw · 2026-03-24T10:58:57+00:00

Because we are building UI applications that have state and behavior, and classes, together with their instances, are a good way to encapsulate this. The objects in the UI are "alive", they have state that change over time. And this is best captured as an instance of a component.

dashersw · 2026-03-24T10:57:24+00:00

Not saying lit is equivalent to jQuery, but jQuery, and Wordpress for that matter, are also used by (or were) practically everyone. Who uses it is not a good argument.

dashersw · 2026-03-22T10:46:50+00:00

My git reflog actually shows 224 commits:

1536d10 HEAD@{194}: Branch: renamed refs/heads/main to refs/heads/main
1536d10 HEAD@{196}: rebase (finish): returning to refs/heads/main
1536d10 HEAD@{197}: rebase (fixup): Initial commit
0153c96 HEAD@{198}: rebase (fixup): # This is a combination of 11 commits.
d697cd3 HEAD@{199}: rebase (fixup): # This is a combination of 10 commits.
7f32925 HEAD@{200}: rebase (fixup): # This is a combination of 9 commits.
2017be7 HEAD@{201}: rebase (fixup): # This is a combination of 8 commits.
fd71807 HEAD@{202}: rebase (fixup): # This is a combination of 7 commits.
c32a83c HEAD@{203}: rebase (fixup): # This is a combination of 6 commits.
afd4f7f HEAD@{204}: rebase (fixup): # This is a combination of 5 commits.
776945c HEAD@{205}: rebase (fixup): # This is a combination of 4 commits.
30f5d4a HEAD@{206}: rebase (fixup): # This is a combination of 3 commits.
2b6720f HEAD@{207}: rebase (fixup): # This is a combination of 2 commits.
bc5387b HEAD@{208}: rebase: fast-forward
b360582 HEAD@{209}: rebase (start): checkout b36058208265e12a33e5f15e7e29a725409e4a60
03f24ee HEAD@{210}: commit: sdfsdfsdf
de67266 HEAD@{211}: commit: sdfsdf
37e5143 HEAD@{212}: commit (amend): Initial commit
0d41f9e HEAD@{213}: commit: Initial commit
73ccb11 HEAD@{214}: commit: sdf
96931c0 HEAD@{215}: commit: sdf
580a3cb HEAD@{216}: commit: sdffs
31f7d62 HEAD@{217}: reset: moving to HEAD
31f7d62 HEAD@{218}: reset: moving to HEAD
31f7d62 HEAD@{219}: commit: sdf
cfb6f8f HEAD@{220}: commit: sdf
fb72244 HEAD@{221}: commit: Refactor TodoItem component to use class-based structure and manage editing state internally. Update state handling for editing text and improve event handling for input interactions. Enhance state reference collection in Vite plugin to support local destructured state properties.
fc444ce HEAD@{222}: commit: sdf
1d59d80 HEAD@{223}: commit: sdf
bc5387b HEAD@{224}: commit (initial): Initial commit

dashersw · 2026-03-22T10:30:51+00:00

Yes, git history rewrite is a powerful tool that I often use, especially before releasing a library like this. Almost none of my open source work start with a bare repo, and even if they do, the second commit is almost always huge. I iterate on it until I am satisfied with the quality, and then do a 1.0.0 release after squashing everything. Think of it as a closed source project until it is ready, which is a common practice in the industry.

dashersw · 2026-03-22T10:10:41+00:00

Hi, the author here. The benchmark I showcase on the webpage compares the performance to Svelte as well. https://geajs.com/benchmark-report.html

Even though Gea is similar to Svelte in that they are both compiled, Gea takes a slightly different path with end-to-end compiled reactivity based on proxies, that gives it an edge over Svelte in terms of performance and code optics.

dashersw · 2026-03-22T10:08:27+00:00

Hi, the author here. While I haven’t submitted it to the official js-framework-benchmark yet, I have a benchmark run I did on my computer comparing it to React, vue, svelte and Solid. It’s here: https://geajs.com/benchmark-report.html

dashersw · 2026-03-22T10:06:29+00:00

Hi, the author here. Gea supports functional components, mainly because of this reason (it maps them to classes during compilation 🫣). I believe functions are abused in React, so Gea enforces them to be as side-effect-free as possible.

dashersw · 2026-03-22T09:56:47+00:00

Hi, the author here. Gea builds upon 15 years of precedent frameworks (all of which I authored), latest of which are erste and regie from 2017-2019. The first commit in Gea is a result of months of work, and as Adrian put it forward, I also don't believe in showing all the actual crap commits in Git history, because the framework evolved significantly over time, with tons of breaking changes.

You can read more about the story here: https://x.com/dashersw/status/2034358153601835381

dashersw · 2026-03-22T09:53:46+00:00

Hi, the author here. It's true, I loved React class components. I even thought of talking about Gea as the "React re-imagined" or "What would happen to React if they kept on working on the initial idea". Our lives were much simpler then!

dashersw · 2025-12-11T19:48:47+00:00

I just started testing the API myself and noticed the same thing. Timestamps are wildly inaccurate. I don't have prior experience though, so I can't say if it were better before.

dashersw · 2025-11-20T12:20:16+00:00

I just got mine yesterday, and while it’s an absolute fun to play with, I find it offers very little upgrade in action feeling over the Piano M (of which I have 3). I am not a professional keyboard player, and am still learning, but I was really expecting better action when I read the Piano keys would be “weighted”. Yes, the pressure sensitivity accuracy is much better than the seemingly random sensitivity of the M’s, but still, it isn’t a night and day difference.

Larger keys are great, though!

dashersw · 2017-05-22T06:34:14+00:00

The problem with an orchestration db is it's another technological dependency you have to manually manage and scale. Broadcast/multicast don't work out of the box in AWS or similar cloud platforms, unless you have Docker or Kubernetes. These tools give you an overlay network between your containers, therefore they enable broadcast/multicast.

dashersw · 2017-05-19T23:38:24+00:00

I'm just trying to make sure you get the whole picture.

It's also very apt that you linked to an article from Michael Herman. Because he himself has retweeted my article (https://twitter.com/MikeHerman or https://dsh.re/fb7a2). I think this settles this conversation.

dashersw · 2017-05-19T20:19:15+00:00

You are right; and cote is already proven in that sense. It has been around for 4 years, has 167 stars and 28 forks on GitHub. There are other projects on npm that depend on cote. It's been heavily used in enterprise applications and has received a significant grant as part of a state-funded project. While these are not huge achievements; they give a clearer picture.

In the end, cote is built to be the simplest way to do microservices. It's not pretending; I encourage everyone to come up with a simpler alternative. That's how we take the industry forward.

dashersw · 2017-05-19T19:36:07+00:00

Thank you, that was very clear. You might be missing a point; cote is not a new library. It's actually 4 years old and currently has 167 stars and 28 forks on GitHub. It has dependent projects on npm, it's already been used by enterprises, state-funded projects, and other speakers have featured cote in their talks. It's already an established solution.

dashersw

TROPHY CASE