Tokens in  ·  System out

From A to ZeusYour Fluid|Design System

Most frameworks ship you a design system. Zeus generates yours: semantic OKLCH color, fluid scale, spacing and components, all derived from a handful of tokens — and readable by your AI agent.

Documentation
Zeus CSS Planet
  • By install
    A framework, by install.629 utilities · 22 components — one stylesheet, zero dependencies.
  • By derivation
    A design system, by derivation.5 colors → 135 tokens — derived automatically from container bounds.
  • By consequence
    Machine-readable, by consequence.tokens.json · llms.txt — generated from CSS, impossible to drift.
  • Start
    npm i zeus-cssv1.0 · MIT · Pure SCSS · Modern browsers only.
Compatibility

Works with every Sass-compatible stack

React
Next.js
Astro
Vue
Nuxt
SvelteKit
Remix
Angular
AI-Native Core

The design system your AI agent can actually read.

No mainstream CSS framework ships a first-class, auto-generated pipeline from its CSS to AI tooling. Zeus does — so humans and agents build from the exact same source of truth.
zeus.tokens.json

W3C Design Tokens

Every token exported in the industry-standard DTCG format — the same language Figma variables and design tools speak.

llms.txt

Drop-in AI context

Place it in your repo and every AI tool knows your design system from the first prompt — no guessing colors or spacing.

cheatsheet.md

Auto-generated, drift-proof

The human + machine reference is generated straight from the compiled CSS — structurally impossible to fall out of sync.

zeus-mcpOn the roadmap

MCP server

Let the agent query the design system live instead of guessing — built on zeus.tokens.json.

Quick Start

Three steps. That's it.

Statically resolve responsive scaling at build time in under 60 seconds. Zero configuration dependencies.
1Install
Load the pure SCSS design package using npm, yarn, or pnpm.
$ npm i zeus-css
Prefer zero-build? Import the precompiled stylesheet directly in your entrypoint:
layout.tsx
import 'zeus-css/dist/zeus.css';
2Configure
Run the init command to get local config files — not buried in node_modules — you can edit directly.
$ npx zeus-css init
Edit your tokens in the generated zeus.customize.scss:
zeus.customize.scss
$zeus-colors: ( "primary": oklch(57.9% 0.232 259.6), "secondary": oklch(74.7% 0.174 60.6) );
ButtonButtonevery component using var(--color-primary) follows
Then compile and link its output instead of dist/zeus.css:
$ sass zeus.theme.scss zeus.theme.css
3Style
Three ways to reach the same tokens — pick whichever fits the file you're in.
Card.module.scss
// A. Utility class <div class="padding-lg color-primary"> // B. CSS custom variable .card { padding: var(--space-lg); } // C. Semantic mixin @use "zeus-css/scss/zeus.scss" as *; .card { @include padding("lg"); }
The Power of Choice

Choose Your Workflow

Zeus CSS doesn't lock you into a single workflow. It gives you the freedom to work the way you prefer — whether you write HTML, SCSS, or need full control with CSS variables.
Speed

Utility Classes

For maximum velocity. Thousands of utility classes generated from your design tokens give you instant styling power right in your HTML. Typography, spacing, colors, and more — zero extra CSS required.

<h1 class="text-h1 padding-lg border-radius-md shadow-md">Hello Zeus</h1>

⚡ Zero config, instant results.

Modularity

SCSS Mixins

For modular component architecture. Build robust, maintainable SCSS components by pulling tokens directly via powerful, pre-configured mixins. Keep your markup clean.

.button {
  @include text("h2");
  @include padding("md");
  @include border-radius("sm");
}

⚡ Reusable and maintainable.

Control

CSS Variables

For dynamic and flexible theming. Every token maps to a native CSS variable, empowering you to build responsive layouts, complex themes, and handle real-time state changes seamlessly.

.card {
  font: var(--text-body);
  border-radius: var(--border-radius-md);
  box-shadow: var(--shadow-md);
}

⚡ Native power for dynamic themes.

>_ Developer Experience

Simple &
Intuitive

Build beautiful cards with semantic HTML and Zeus utility classes. Combine shadows, borders, spacing, and typography tokens for consistent UI.
  • Zero ConfigurationWorks out of the box, no setup required
  • Framework AgnosticWorks seamlessly with React, Vue, HTML & more
  • PurgeCSS ReadyKeep your bundle size minimal by purging unused classes
Card.html
1<div class="padding-lg border-radius-md shadow-card"
2 style="background: var(--color-surface);
3 border: 1px solid var(--color-border-strong);">
4
5 <p class="text-overline color-secondary margin-bottom-xs">
6 Featured
7 </p>
8
9 <h3 class="text-h4 margin-bottom-sm">
10 Design Tokens
11 </h3>
12
13 <p class="text-body color-secondary margin-bottom-lg">
14 Centralized system with colors, typography,
15 spacing and more.
16 </p>
17
18 <button class="btn-primary btn-sm">
19 Learn More →
20 </button>
21
22</div>

Featured

Design Tokens

Centralized system with colors, typography, spacing and more.

4-Layer Architecture

From Config to Compiled CSS

Zeus CSS operates as a deterministic build pipeline. It ingests your configuration, generates a strict set of design tokens, builds the math engine, and exposes a clean API — emitting a complete utility system.
Config

Config

zeus.config.scss

Defines global framework rules, feature flags, breakpoints, and fluid engine bounds.

Toggle prefixes, fluid typography, feature flags, and responsive breakpoints — all before the compiler runs. Zero side-effects: pure configuration.

Customize

Customize

zeus.customize.scss

The single place to override all design tokens — colors, typography, spacing — for your brand.

Change the entire color palette, border radiuses, font stacks, and spacing scale without touching core framework code. One file, full brand control.

Layer 1

Design Tokens

core/design/

Base semantic primitives: colors, typography scale, spacing, borders, shadows, grid — as Sass maps.

15 token files covering every visual dimension. Zeus stores OKLCH colors and fluid (floor, ceil) ranges in Sass maps — the semantic bedrock for all utilities. Feeds the $zeus-design-system master dictionary.

Layer 2

Engine

core/engine/

13 mixin & function files that transform token maps into CSS-ready logic.

Pure Sass: fluid clamp() math, color mixing, responsive helpers, theme builder, animation scaffolding. No CSS output — only callable tools for the layers above.

Layer 3

API

core/_api.scss

The public interface that exposes a curated subset of Engine utilities to component authors.

Clean commands like @include text(h1) or @include screen-above(md) that abstract engine complexity. Re-exports helpers, color-api, typography-calc, and sizing.

Layer 4

Views

views/render/ · components/ · patterns/

The only layer that emits CSS: Render globals + 20 utility modules, Components (card, modal), Patterns (hero, sidebar).

Outputs @property Houdini registrations, :root CSS variables, reset, typography base, and a complete utility system. Components and Patterns add pre-built BEM blocks on top.

Framework Perspectives

Six Angles. One Fluid Core.

Explore how Zeus CSS redefines front-end architecture — from single-source tokens to machine-readable JSON.
The principle

Built for engineers.
Understood by AI.

A clean, semantic token foundation that front-end teams write with clarity and AI coding assistants inspect without ambiguity.

The pipeline

One config file.
A complete design system.

Define your colors once; Zeus generates everything that follows from them.

The parallel

Utilities to build with.
A system to build on.
Tokens to build from.

One stylesheet, three depths — use as much of it as you need.

The formats

Write it in SCSS.
Run it as CSS.
Read it as JSON.

The same system, in the language each reader already speaks.

The category

Every framework ships a design system.
Zeus generates yours.

Not someone else's decisions to override — your tokens, derived.

The AI contract

Human-designed in SCSS.
Machine-verified by schema.
AI-native by architecture.

Tokens and components expose JSON-schema metadata, letting AI code assistants inspect, extend, and generate UI safely.

Fluid Engine

Everything scales. By default.

One math engine (_fluid-core.scss) powers ALL fluid scaling — typography, spacing, borders, icon sizes. No manual breakpoints.
slope = (maxmin) ÷ (c-ceilc-floor)
intercept = min − slope × c-floor
→ clamp(min·unit, round(calc(intercept·unit + slope·cqi), 0.1unit), max·unit)
📐
Container bounds: 375–1920 (343–1792)
Derived in basic.scss from Figma viewports & outer padding. Scales via CQI in any context.
⚙️
Unit-agnostic engine
Same zeus-cqi-fluid(), $unit param 'rem' or 'px'. Typography → rem, sizing → px.
🎯
Precision: round-to($value, 1)
Clean 1-decimal CSS calc output with CSS round() for zero subpixel noise.
🔌
Two consumers, one formula
useclamp-typography('h1') reads tokens → rem → zeus-cqi-fluid(). useclamp-sizing(12, 24) raw px → zeus-cqi-fluid().
_fluid-core.scss → typography-calc.scss → root-generator.scss
// ── _fluid-core.scss (the engine) ── @function zeus-cqi-fluid($min, $max, $c-floor, $c-ceil, $unit, $accuracy: 1) { $slope: math.div($max - $min, $c-ceil - $c-floor); $slope-cqi: round-to($slope * 100, $accuracy); $intercept: round-to($min - ($slope-cqi / 100) * $c-floor, $accuracy); @return clamp(#{$min}#{$unit}, round(calc(#{$intercept}#{$unit} + #{$slope-cqi}cqi), 0.1#{$unit}), #{$max}#{$unit}); } // ── typography-calc.scss (the consumer) ── @function useclamp-typography($typeface, $precision: 1) { $min-rem: _px-to-rem($min-px, 2); $max-rem: _px-to-rem($max-px, 2); @return fc.zeus-cqi-fluid($min-rem, $max-rem, $c-floor, $c-ceil, "rem", $precision); } // ── root-generator.scss (the output) ── @each $type, $config in $typography { --text-#{$type}: #{useclamp-typography($type)}; } // ── Compiled output for "h1" (min:36, max:52) ── --text-h1: clamp(2.25rem, round(calc(2rem + 1.1cqi), 0.1rem), 3.25rem);
Interactive Calculator

Try the fluid math live.

Drag sliders to adjust sizes. Zeus converts pixel inputs into highly optimized, unit-pure CSS clamp() declarations dynamically at build time.
Minimum Size (px)16px
Maximum Size (px)48px
Viewport Floor Boundary (px)320px
Viewport Ceiling Boundary (px)2560px
Interpolation Decimal Precision3
Hello Zeus ⚡
clamp(1.000rem, calc(0.714rem + 1.429cqi), 3.000rem)

This is the exact linear CSS expression generated by the Sass compiler.

Design Tokens

Edit maps. Everything updates.

Every visual property is a Sass map with (min, max) values. Change one number → CSS variables, @property, utility classes, and components all update.
🎨 Color Palette
colors/base-colors.scss
18 tokens · Semantic OKLCH-based color definitions
primary
primary-light
primary-dark
secondary
secondary-light
secondary-dark
accent
accent-light
accent-dark
text
text-muted
background
surface
border
border-strong
success
warning
error
API: color-mix(in oklch, var(--color-primary), transparent 50%)
🔤 Typography Scale
typography.scss
41 variants · 5 roles: heading, body, ui, interactive, code
Display XL56–96px · w800 · lh 1.1
Heading 136–58px · w700 · lh 1.2
Heading 326–44px · w600 · lh 1.25
Body text16–18px · w400 · lh 1.6
OVERLINE14–16px · w600 · ls 0.14em
Mixin: @include text("h1") → full font shorthand + text-wrap: balance
📐 Spacing Scale
spaces.scss
11 steps · 4xs → 4xl · All fluid clamp()
4xs
1–2
xs
6–8
sm
8–12
md
12–16
lg
16–24
xl
24–32
2xl
32–48
3xl
48–64
4xl
64–96
Mixin: @include padding("lg", "x") → padding-inline: var(--space-lg)
✨ Shadows
effects/shadows.scss
22 tokens · Elevation · Semantic · Glow · Card · Modal · Inner
sm
md
lg
primary
success
glow
Mixins: @include elevation(3) · shadow("lg")
📱 Breakpoints
layout/grid.scss
7 breakpoints · Fully fluid and mobile-first
xs
0
sm
576
md
768
ml
1024
lg
1280
xl
1920
xxl
2560
@include screen-above("lg") { } — mobile-first min-width query
🔲 Borders
borders/
Radius: 6 fluid steps · Line: 4 fluid steps
xs
sm
md
Mixin: @include border-radius("md") → border-radius: var(--border-radius-md)
At a Glance

Hundreds of Utilities. One Token System.

Every token — color, spacing, typography, shadows, borders — already has a matching utility class and CSS variable. Add your own tokens in zeus.customize.scss, and matching utilities generate automatically — no custom CSS required.
FAQ

Frequently Asked Questions

Everything you need to know about Zeus CSS — from tokens to theming, performance to accessibility.

Tailwind is utility-first — your design system ends up scattered across HTML classes, and fluid sizing needs manual config. Open Props gives you tokens, but not an engine: no derivation, no fluid math, no components. Rolling your own SCSS means rebuilding tokens and OKLCH color logic from scratch on every project. Zeus CSS sits in between: define a handful of tokens, and the engine derives semantic colors, fluid typography and spacing, and a full utility system — consumable as classes, CSS variables, or SCSS mixins, whichever fits your workflow.

Every token is exported automatically from the compiled CSS into zeus.tokens.json (the W3C DTCG standard — the same format Figma variables use) and llms.txt, a plain-language manifest built for AI tools. Drop either into an AI coding agent's context and it reads your actual colors, spacing, and typography scale instead of guessing generic values. A Zeus MCP server that lets agents query the system live is on the roadmap. It's a build step, not a prompt trick.

Zeus CSS is authored in Sass because that's the right tool for a compile-time token engine — but the output is plain, modern native CSS: cascade layers, OKLCH, container-query units, @property. Using the SCSS entry point gets you the full engine: mixins, config-driven customization, the theme-builder API. The project also ships a precompiled stylesheet for teams that would rather skip the Sass pipeline entirely — same underlying CSS, no build step required.

Zeus CSS is the free, open-source engine — tokens, fluid scaling, utilities, and the AI-native manifest. Zeus UI is a separate, premium component library: production-ready, accessible blocks (navbars, dashboards, forms, marketing sections) in plain, framework-agnostic HTML, built on top of Zeus CSS. Think of Zeus CSS as the foundation everyone gets for free, and Zeus UI as pre-built rooms you can buy instead of framing them yourself.

Yes. OKLCH-based semantic tokens mean you set five base colors once, and their light, muted, surface and border variants derive automatically — in CSS, via relative color syntax, so they stay live even if a color changes at runtime. For multi-brand needs, zeus-theme() lets you define named themes (an "ocean" palette, for example) that swap in behind a [data-theme] attribute, using the exact same derivation math as the defaults. Focus-visible states and prefers-reduced-motion are respected throughout the render layer by default. Override anything in one place — zeus.customize.scss — and it cascades everywhere, no hunting through component code.

Ready to build?

Forge the Future with Zeus

One import. Zero runtime. Everything fluid. Every token overridable. Install the most advanced CSS framework and start building today.
$npm i zeus-cssclick to copy