Gea: The JavaScript Framework That Eliminates the Framework

In the crowded landscape of JavaScript UI frameworks, a new contender has emerged that challenges the fundamental premise of what a framework should be. Gea isn't just another tool in the React-Svelte-Solid ecosystem—it's a philosophical statement that JavaScript itself is sufficient for building reactive applications.

The Problem with Modern UI Frameworks

The evolution of web development has led us down a peculiar path. We started with vanilla JavaScript, moved to jQuery for convenience, then to Angular for structure, and eventually to React's component model. Each step promised simplicity but delivered complexity. Today's developers juggle hooks, signals, dependency arrays, compiler directives, and an ever-expanding vocabulary of framework-specific concepts.

The irony is that we're writing more code than ever to achieve the same basic goal: updating the DOM when state changes. Virtual DOM diffing, reconciliation algorithms, and reactive systems add layers of abstraction that, while powerful, create cognitive overhead and performance costs.

Gea's Radical Simplicity

Gea's core insight is deceptively simple: what if we could compile away the framework entirely? Instead of running a reactive system at runtime, Gea's Vite plugin analyzes your JSX at build time, determines which DOM nodes depend on which state, and generates direct DOM mutations.

This approach means you write ordinary JavaScript classes and functions. Stores are just classes with state and methods. Components are either classes that extend a base Component or simple functions returning JSX. Computed values? Just use getters. No special syntax, no new primitives to learn—it's literally just JavaScript.

Performance That Speaks for Itself

The benchmark numbers are striking. In the js-framework-benchmark stress test, Gea scores 1.03, placing it ahead of Solid (1.12), Svelte 5 (1.14), Vue 3.6 (1.26), and React 19.2 (1.50). For context, lower scores are better, with vanilla JavaScript at 1.02 serving as the baseline.

This performance advantage comes from eliminating entire categories of overhead. No virtual DOM means no diffing. No runtime reactivity system means no dependency tracking at execution time. Updates go straight to the elements that changed, generated at compile time as surgical patches.

The Proxy-Based Store System

Gea's state management leverages JavaScript's Proxy API to create deep reactivity without special syntax. When you wrap a class with Store, every property access and mutation is intercepted. This means array methods work naturally—push, splice, sort all produce granular change events rather than triggering full rerenders.

Nested objects are handled transparently, and the system works with plain JavaScript objects, not some framework-specific data structure. You can mutate state exactly as you would in any other JavaScript code, and the reactivity just works.

Built-In Toolkit, Not Plugin Hell

One of Gea's most compelling aspects is its "batteries included" philosophy. The entire framework, including the client-side router and 35+ accessible UI components built on Zag.js, compresses to ~13 KB gzipped. There are zero runtime dependencies—no extra packages to install, no version conflicts to resolve.

The router includes RouterView, Link components, route parameters, wildcards, and programmatic navigation. The UI component library covers dialogs, menus, selects, tabs, tooltips, accordions, and comboboxes—all accessible and ready to style. Mobile primitives include ViewManager, sidebar, tab views, pull-to-refresh, infinite scroll, and swipe gestures.

Two-Way Props: JavaScript as Intended

Gea takes a refreshingly pragmatic approach to component communication. Instead of Vue's v-model or React's callback patterns, Gea passes objects and arrays by reference. When a child component mutates a prop, the parent sees the change immediately. This is simply how JavaScript works—no special syntax required.

This approach eliminates the ceremony around prop drilling and state lifting. If you pass an object to a child, and the child modifies it, both sides stay in sync. It's the natural behavior developers expect, but most frameworks actively prevent it in the name of "one-way data flow."

The Development Experience

Hot Module Replacement works out of the box with the Vite plugin, providing instant feedback as you edit stores and components. A VS Code extension (coming soon) promises component completion, prop inference, event attribute hints, and hover details.

The quick start experience is genuinely impressive—one command scaffolds a Vite project with TypeScript, stores, components, and the plugin pre-configured. No manual setup, no dependency hunting, no configuration files to tweak.

AI-Ready Development

Gea includes agent skills that teach AI assistants like Cursor and Codex the full Gea API. This means you can scaffold and iterate on Gea apps with complete AI assistance out of the box. The framework's simplicity and JavaScript-native approach make it particularly amenable to AI-powered development.

The Trade-offs

This radical simplicity comes with trade-offs. The compile-time approach means you need the Vite plugin—there's no framework you can just drop into any project. The ecosystem is nascent compared to React or Vue. And while the performance is excellent, the difference might not matter for many applications.

There's also the question of whether this approach scales to extremely complex applications. The simplicity that makes Gea accessible could become limiting as applications grow in complexity.

A New Direction for UI Frameworks

Gea represents a compelling alternative direction for UI framework design. Instead of adding more abstractions and concepts, it strips them away, arguing that JavaScript's native capabilities are sufficient when combined with smart compilation.

The success of tools like Svelte, which also compiles away the framework, suggests there's appetite for this approach. But Gea goes further, eliminating not just the virtual DOM but the entire reactive runtime.

Whether Gea becomes a major player or remains a fascinating experiment, it challenges us to reconsider what we actually need from a UI framework. Sometimes the most innovative approach isn't adding more features—it's removing them entirely.

For developers tired of framework churn, cognitive overhead, and the endless parade of new concepts to learn, Gea offers a compelling proposition: just write JavaScript, and let the compiler handle the rest.

Gea on GitHub | Gea on npm