Track shipped client output and page assets for equivalent implementations without folding unrelated application code into the comparison.
Zenith builds the contract before the browser sees it.
A compiler-first web framework for explicit routing, deterministic DOM ownership, and runtime behavior that can be proved instead of smoothed over.
Current posture
Proof before polish.
Framework work lands with diagnostics, route truth, and package surface checks before presentation gets to claim stability.
Compiler
Foreign syntax fails before emission.
Targets
Node locally. Vercel in deployment. Same contract.
Site
Routes and docs stay on explicit ownership lines.
Next Proof Layer
Benchmarking is the next validation pass.
Zenith is being hardened through real framework and product work first. The next phase is measured comparison under public, repeatable conditions rather than advance performance claims.
That work will compare equivalent pages against established frameworks and publish the methodology alongside the results so bundle size, build behavior, startup cost, and runtime cost are interpreted in context.
The goal is to prove where Zenith is competitive, where tradeoffs exist, and where a different tool may be better suited.
Measure clean builds to show how the compiler and bundling path behave before caches or warmed state reduce the workload.
Record the time required to boot a fresh development session so local iteration cost is visible alongside production output.
Measure change response during active development to show how quickly edits propagate and where rebuild overhead appears.
Inspect the browser-side work required to make equivalent pages interactive, including hydration scope and runtime execution surface.
Use comparable page shapes and feature sets so the benchmark measures framework behavior rather than mismatched workloads.
Compare Zenith against widely used frameworks with methodology and environment details published beside the results.
Zenith identity
Structural control with runtime honesty.
Zenith is designed for teams that want compiler-owned rules, deterministic refs, and routing that stays truthful across development, preview, and deployment.
It is deliberately opinionated about DOM ownership, route contracts, and authoring discipline so product code can stay smaller, more explicit, and easier to debug.
Core philosophy
The rules are the product.
Zenith uses a small set of hard constraints to keep compiler behavior, runtime behavior, and author intent aligned.
Signals
Reactivity is explicit, not guessed. Signals keep identity stable and make read/write flow observable instead of implicit.
References
Zenith targets the browser directly. Components bind through deterministic refs rather than broad DOM scans or diff-heavy abstractions.
Server truth
Guards and loaders keep security at the server boundary, with compiler and runtime contracts preserving that meaning across navigation.
Runtime proof
Built in Rust. Measured in behavior.
The CLI and compiler infrastructure are written in Rust so author intent can be normalized into precise runtime instructions before the browser ever sees the page.
source
compiler
output
runtime
Compiler integrity
The compiler targets actual DOM nodes and attributes instead of treating rendering as an opaque rerender loop.
Internal hardening
Zenith is exercised through its own site, docs, CLI, and release flow so framework rules are proven under product pressure.
Community collective
Hardened by people using the work.
Zenith is hardened in public. The framework evolves through contributors, issue reports, release work, and product-facing verification rather than isolated theory.
Join Discord
Sustain the work
Support the compiler, docs, and release surface together.
Sponsorship helps Zenith keep shipping compiler hardening, runtime verification, docs upkeep, and public release discipline without splitting those concerns across separate priorities.
Compiler and diagnostic hardening
Site and docs verification against real framework releases
Deterministic release and deployment validation