Introducing Gea: A Compile-Time Reactive UI Framework That's Just JavaScript

Background

I started writing type-safe, component-driven web applications in JavaScript 16 years ago, thanks to Google Closure Library. It led to the creation of tartJS, which went on to power the world’s first client-side rendered, single-page e-commerce application. Yes, Google didn’t have the Play Store brand back then.

tartJS was so systematic to write that 11 years ago I had an idea: what if we could capture all the boilerplate in a compiler and write completely reactive JavaScript, like writing OOP code? It was a crazy idea at the time — React was just picking up, and no one thought it would be feasible. In the meantime, frameworks like Svelte came onto the field that fulfilled some of the promise.

In 2017 I released erste, a modernized version of tartJS that simplified event-handling and much of the boilerplate. Between 2012 and 2019, tartJS and erste enabled me and my teams to write a handful of mobile applications that felt truly native in a Cordova shell, thanks to 0-overhead performance. And ever since I released the first version of erste, I wanted to write my dream framework: the truly compiled, truly reactive, zero-concept framework.

Introducing Gea

Fast-forward 7 years and I am proud to introduce Gea: a compile-time UI framework that turns ordinary classes and functions into surgical DOM updates. No virtual DOM. No hooks. No signals. Just your code — made reactive at build time. And it turned out to be the fastest compiled UI framework ever benchmarked — one percent behind hand-written vanilla JS.

Here’s a complete counter component in Gea:

class Counter extends Component {
  count = 0

  increment() { this.count++ }
  decrement() { this.count-- }

  template() {
    return (
      <div class="counter">
        <span>{this.count}</span>
        <button click={this.increment}>+</button>
        <button click={this.decrement}>-</button>
      </div>
    )
  }
}

That’s it. State is a class property. Methods mutate it directly. The template reads it. this.count++ triggers a DOM update. No useState, no signals, no dependency arrays, no wrappers. Just a JavaScript class.

The Vite plugin analyzes your JSX at build time, figures out which DOM nodes depend on which piece of state, and generates surgical patches that update only what changed. No diffing, no reconciliation, no runtime overhead. Just direct DOM mutations, wired up at compile time.

Stores work the same way for shared state:

class CounterStore extends Store {
  count = 0

  increment() { this.count++ }
  decrement() { this.count-- }
}

Plain classes with properties and methods. Computed values are getters. Arrays are intercepted so push, splice, and sort produce fine-grained change events. The framework doesn’t fight the language. It uses the language.

Benchmarks

I benchmarked Gea against major frameworks using js-framework-benchmark, the industry-standard stress test. The results surprised even me:

Framework	Score
Vanilla JS	1.02
Gea	1.03

Lower is better. Gea is one hundredth behind hand-written vanilla JavaScript, and ahead of every compiled framework. And Gea achieves this without inventing a single new programming concept.

Batteries Included, Zero Decision Fatigue

But performance wasn’t the actual goal. I wanted batteries included with zero decision fatigue. Gea ships with:

• A built-in client-side router
• A built-in store for state management
• 35+ accessible UI components built on Zag.js
• Mobile primitives with iOS-style navigation and gestures (based on erste)
• A VS Code/Cursor extension for code intelligence (coming soon)
• A project scaffolder that lets you start a new Gea project in seconds

The whole runtime is ~13 kb gzipped with the router. Zero runtime dependencies.

AI-Native from the Start

Gea also ships with agent skills — structured documentation that teaches Cursor, Codex, and other AI assistants the full Gea API. Point your AI editor at a Gea project and it understands stores, components, JSX conventions, and the reactivity model out of the box. You can scaffold and iterate on Gea apps with complete AI assistance from the start.

15 Years in the Making

This framework is the distillation of 15 years of building component-driven applications in JavaScript — from the early days of Google Closure, through tartJS and erste, to Gea. Every lesson, every frustration, every “why does the framework make me do this?” moment went into making Gea a place where you just write JavaScript and everything works.

Get Started

npm create gea@latest my-app

MIT licensed. Fully open source. Available on GitHub at: github.com/dashersw/gea