Glossary
Vocabulary reference for the design-system, UI-kit, and CSS-framework space - both industry-standard concepts and the terms Semetrika adds on top.
How to use this glossary
This page is intentionally organized to disambiguate confusable concepts. Many of these terms are commonly mixed up - "design system" gets used for what is really a component library, "UI kit" gets used for what is really a styled component library, "variant" gets used for what is really a state. Each entry has:
- What it is - the working definition.
- What it is NOT - the most common confusion, called out explicitly.
The "what it is NOT" column is the heart of this glossary. Pay attention to it. If you only read one column, read that one.
Terms are grouped by topic. Within each group, related terms sit next to each other so the contrasts (value vs variant, primitive vs semantic, classless vs classless-first) are obvious.
Groups A through H are industry-wide concepts. Group I at the end captures Semetrika's own conventions. The Semetrika anchor below shows how those conventions look in practice.
The Semetrika anchor
One piece of HTML containing every Semetrika concept. Every term in Group I points back to this example.
<!-- Classless form -->
<button class="danger outline sm" aria-busy="true" data-tooltip="Launch sequence">Launch</button>
<!-- Class-based form - same visual output, semantic fallback element -->
<a class="btn danger outline sm" aria-busy="true" data-tooltip="Launch sequence"> Launch </a>
button,
.btn {
background: var(--btn-background-color); /* component token */
padding: var(--space-y-2) var(--space-x-4); /* primitive tokens */
transition-duration: calc(0.2s * var(--option-animations));
}
.danger {
/* Intent value from the vocabulary */
}
.outline {
/* Fill value from the vocabulary */
}
.sm {
/* Size value from the vocabulary */
}
[aria-busy='true'] {
/* loading state via Tier 2 ARIA attribute selector */
}
In that one example you can see: a component (button / .btn), rendered in both its classless form and its class-based form; the mirror class (.btn) sitting alongside the semantic element (<button>); three values from three different capabilities (Intent, Fill, Size); an ARIA attribute used for state (aria-busy="true"); a data attribute (data-tooltip); a component token (--btn-background-color); two primitive tokens (--space-y-2, --space-x-4); and an option (--option-animations).
Group A: Categories of products
The broad product types in the CSS / UI / design-system space. The boundaries between them are contested in industry usage; the definitions below pick the most-cited interpretation.
| Term | What it is | What it is NOT |
|---|---|---|
| Design system | A complete system of decisions, components, tokens, brand, governance, and documentation that defines how a product is designed and built. Often includes a coded UI kit but extends beyond code. | A component library alone, or a style guide alone - those are subsets of a design system, not the whole thing. |
| UI kit | A collection of UI assets - in industry usage, usually static design files (Figma, Sketch, Adobe XD). When used loosely it can also mean a coded component library. | Always coded - "UI kit" in canonical industry usage is the design-files layer, not the code. |
| CSS framework | Umbrella term for any reusable CSS code distributed as a unit. | A specific category - utility frameworks, classful CSS frameworks, and styled component libraries are all CSS frameworks. The umbrella term does not tell you which kind. |
| Utility framework | A CSS framework that provides single-purpose classes you compose into UI (text-center, p-4, bg-blue-500). Tailwind, Tachyons, Open Props (token-only). | A component library - utility frameworks have no pre-built components. You build components yourself by composing utility classes. |
| Classful CSS framework | A CSS framework that provides pre-styled component classes (btn, card, nav). Pico, Bulma, Bootstrap (the classful side). | A utility framework - classful frameworks ship complete pre-styled components, not single-purpose utilities. |
| Component library | A coded collection of pre-built, interactive UI components (Mantine, Chakra UI, MUI, Shoelace). | A UI kit (which usually means design files), or a design system (which is broader). Most "design system" products are really component libraries with documentation. |
| Headless component library | Unstyled, accessible component primitives that ship behavior and accessibility but no visual design (Radix Primitives, Headless UI, React Aria, Base UI). | A styled component library - headless components have no visual opinion. You bring your own CSS. |
| Skeleton design system | A complete-but-customizable design system structured to become someone else's design system. Neutral defaults, deep customization, ready to be branded. Synonyms: starter, white-label, adaptive, reference, generic. | A finished design system - those are brand-specific (Material Design, Polaris). CivicTheme is an example of the skeleton category. |
| Generic design system | The Semetrika-native term for what industry calls a skeleton or white-label design system: a complete, working, neutral substrate intended to be extended into a brand-specific design system. Semetrika is a generic design system. Synonymous with skeleton design system. | A finished, brand-applied design system. The whole point of a generic design system is that it makes no brand decisions and waits for the consumer to make them. |
| Brand-specific design system | A complete design system expressing one specific organization's brand (Material Design = Google, Polaris = Shopify, Carbon = IBM, GOV.UK = UK government). Synonyms: consumer design system. | A skeleton design system - brand-specific systems have brand opinions baked throughout and are hard to fully rebrand. |
| Consumer design system | The Semetrika-native term for a brand-specific design system built on top of a generic one. Owned by a single organization, product, or site team; carries brand-specific tokens, components, and patterns layered over the generic substrate's defaults. Synonymous with brand-specific design system. | A generic / skeleton design system - a consumer design system has brand opinions baked in. Also not the same as the consumer project that uses Semetrika directly without curating a system around it. |
| Pattern library | A documented collection of UX patterns (search-with-filters, multi-step form, login flow). Patterns describe how components combine to accomplish a task. | A component library - patterns are flows / behaviors / interactions; components are individual built things. They are parallel, not synonymous. |
| Style guide | A document describing visual and brand rules (typography, color, voice, photography). | A design system - a style guide is one subset of a design system, alongside components, governance, and code. A design system without a style guide is incomplete; a style guide alone is not a design system. |
Where Semetrika sits
Semetrika is a classless-first CSS framework that also ships a styled component library and a pattern library. It is not a brand-specific design system (it ships neutral defaults), and it is not a Figma UI kit (it ships code, not design files). On the layered hierarchy below it sits primarily at Layer 2 (classful CSS framework) with affordances pulled from Layer 4 (styled component library) and Layer 5 (skeleton design system).
In Semetrika's own vocabulary that maps directly to the generic / consumer distinction: Semetrika is a generic design system, and the brand-specific layer a consumer builds on top of it is a consumer design system. See Consumer vs generic design system in the introduction for the framing.
| Layer | Category | Examples |
|---|---|---|
| 0 | CSS reset / normalize | normalize.css, modern reset |
| 1 | Utility framework | Tailwind, Tachyons, Open Props |
| 2 | Classful CSS framework | Pico, Bulma, Bootstrap (classful side), Semetrika |
| 3 | Headless / primitive component library | Radix Primitives, Headless UI, React Aria, Base UI |
| 4 | Styled component library | Mantine, MUI, Chakra, Shoelace, Ant Design |
| 4a | UI kit (design files only) | Figma Community kits, Untitled UI |
| 5 | Skeleton / starter / white-label design system | CivicTheme |
| 6 | Brand-specific design system | Material Design, Carbon, Polaris, GOV.UK |
Group B: Component vocabulary
The most-confused area in design-system discussion. Read carefully.
| Term | What it is | What it is NOT |
|---|---|---|
| Component | A reusable UI artifact a framework ships (button, card, modal, accordion). Has one name, one implementation. | A pattern (which combines multiple components into a flow), or a primitive (which is unstyled). |
| Variant | A meta-word commonly used as a prop name to expose either a single configuration axis or a multi-axis preset under a generic label. The actual axes it controls vary widely across frameworks. See On the word variant below. | A precise term - there is no cross-framework consensus on what it covers. Not a state (variants persist per instance, states change at runtime). Not a single named capability like size or fill - variant may bundle multiple capabilities, or wrap a single capability under an opaque label. |
| Value | A single-axis adjective applied to a component that changes how it looks or behaves (.outline, .sm, .fluid). Each value lives on exactly one named capability. Values compose: multiple stack on one element. | A variant (which is a meta-wrapper over one or more capabilities; see below). A state (values are set when the component is authored; states change during interaction). |
| Capability | A category of values (Emphasis, Intent, Fill, Size, Shape, Layout, Elevation, etc.). Values in different capabilities combine freely; values in the same capability are mutually exclusive (a button cannot be both .sm and .lg). | A value itself - a capability is the category; values are the words in that category. Intent is a capability; .danger is a value on that capability. Not a variant - a variant may span multiple capabilities or hide a single capability behind an opaque prop name. |
| State | A transient visual or semantic condition - hovered, disabled, open, loading, selected, active. | A variant or value - state changes during interaction; variants and values are set when the component is authored. |
| Slot | A named position within a component where consumer content goes (card header slot, modal footer slot, layout main slot). Used heavily in web components, Vue, and Svelte. | A child class - slots describe where consumer content lives; child classes describe what the structural part is called. They are different concepts at different layers. |
| Compound component | A component with named slots that consumers fill with their own content. A card has header / body / footer slots; a modal has header / body / footer slots. The defining trait is that consumers compose content into the component's structure. | An atomic component. Compound is not about tag count - it is about whether the component exposes a composition surface for consumer-provided content. |
| Atomic component | A component without named slots for consumer content. Atomic components accept properties (label, icon, dismissible, disabled, intent, size) and render their own internal structure based on those properties. Button, badge, avatar, chip, icon, tag are atomic. | A component with a single HTML tag. Atomic refers to the lack of a consumer-facing composition surface, not literal tag count. Also not a compound component - compound components expose named slots for consumer content; atomics expose properties for component-controlled internals. |
| Headless component | A component that ships behavior and accessibility but no visual styling. Consumer brings the CSS. | A styled component - headless leaves the look entirely to the consumer. Radix's Dialog is a headless component. Mantine's Modal is a styled component. |
| Polymorphic component | A component whose root element can be swapped (e.g. a Button component that renders as <a> when given an href, <button> otherwise). | A compound component - polymorphism is about the root element, not internal structure. |
On the word variant
Variant warrants a longer note because it is the most contested term in component-design vocabulary. Different frameworks attach different meanings to the same word, and the word itself does no semantic work on its own.
Cross-framework interpretations
| Framework | What variant covers | Example values |
|---|---|---|
| MUI | Fill axis | text, contained, outlined |
| Mantine | Fill axis (different vocabulary) | filled, light, outline, subtle, transparent |
| Chakra UI | Per-component recipe (varies per component) | defined inside each component's recipe |
| shadcn/ui | Color + fill bundle | default, destructive, outline, secondary, ghost, link |
| Material Design 3 | Elevation + fill + theme-color bundle | elevated, filled, outlined, tonal, text |
| Bootstrap | Multi-axis preset (informal, via class names) | btn-primary, btn-outline-primary, btn-lg |
The same prop name covers at least five different things across major frameworks. A reader moving between frameworks has to relearn what variant controls in each one. There is no portable mental model.
Why variant is problematic as a capability name
Compare two prop signatures on the same component:
size="small"- the prop name is the capability; the value is the position on that capability. Self-describing. Even a reader unfamiliar with the framework can decode the intent immediately.variant="contained"- the prop name does not name a capability; it is a meta-wrapper. The reader has to know that this particular framework happens to usevariantto expose the fill axis, and thatcontainedhappens to mean solid fill. Neither word does any semantic work on its own.
The word "contained" alone could plausibly describe a size constraint, layout containment within a parent, content fitting within a box, filled with color, or constrained typography. It happens to mean the fourth interpretation in MUI, but only because the documentation says so.
Semetrika's approach
Semetrika names the capability directly in every class - .outline, .solid, .ghost (Fill), .sm, .md, .lg (Size), .danger, .warning, .success (Intent). A reader sees the capability and the value together. No variant prop, no meta-wrapper, no per-framework mapping to memorize.
Group C: Markup and rendering
How frameworks decide what HTML their components produce.
| Term | What it is | What it is NOT |
|---|---|---|
| Classless | Markup using only semantic HTML elements with no class names: <button>Submit</button>. The framework styles via element selectors. | Class-based markup - classless relies on the element selector, not classes. Pico CSS's classless mode is a clean example. |
| Classless-first | A framework where classless is the default rendering mode, and class-based is a fallback for cases where semantic HTML alone cannot carry the design. Semetrika is classless-first. | Classless-only - classless-first supports both modes simultaneously, while classless-only has no class fallback (Water.css). |
| Mirror class | A class that produces visually identical output to a semantic-element-styled component (.btn mirrors <button>; .card mirrors <article>). | An arbitrary helper class. A mirror class is a deliberately-paired class for the exact same component, used when the consumer needs a non-semantic element to be styled like the semantic one. |
| Semantic element | A native HTML element with built-in meaning to assistive technology and the browser: <button>, <article>, <details>, <table>, <dialog>, <nav>. | A <div> or <span> - those are non-semantic. Semantic markup is the practice of using these built-in elements over generic containers. |
| Progressive enhancement | An architecture where components render and remain accessible without JS; JS adds capability rather than being mandatory. Semetrika is progressive-enhanced. | JS-required architecture (where components do not render or function without JS). Progressive enhancement is a deliberate choice, not the default for most modern frameworks. |
| Server-side rendering (SSR) | Generating component HTML on the server per request before sending to the browser. Used by Rails, Next.js (server components), Astro (server output). | Client-side rendering - SSR delivers ready-to-display HTML on each request; CSR builds HTML in the browser at runtime. |
| Client-side rendering (CSR) | Generating component HTML in the browser at runtime via JavaScript. The server delivers a minimal HTML shell plus a JS bundle; the bundle constructs the page after page load. Used by classic single-page apps in React, Vue, Svelte, Angular without SSR or SSG. | SSR - in CSR the browser does the rendering, not the server. Without JS, a CSR page typically shows a blank shell. CSR is also not progressive enhancement. |
| Static-site generation (SSG) | Generating component HTML at build time and shipping pre-rendered HTML files to a CDN. The same files are served to every visitor. Used by Eleventy, Hugo, Astro (default), Next.js (SSG mode), Gatsby, Jekyll. | SSR - SSG renders once at build; SSR renders per request. CSR - SSG ships pre-built HTML; CSR builds HTML in the browser. |
Group D: Tokens and theming
The architecture for design decisions expressed as CSS custom properties.
| Term | What it is | What it is NOT |
|---|---|---|
| Design token | A design decision expressed as a CSS custom property: --color-primary: #0066cc. | A general CSS variable - design tokens are specifically the design-decision use case. Every design token is a CSS custom property; not every CSS custom property is a design token. |
| Primitive token | A flat, raw value on a defined scale (--font-size-md: 1rem, --color-primary-5: #0066cc). No var() references; no opinion about where it should be used. | A semantic token - primitives are inputs; semantic tokens are decisions made from those inputs. |
| Semantic token | A token expressing a UI decision that references primitives (--background-color-neutral: var(--color-primary-1)). Covers both the foundation and component tiers below. | A primitive token - semantic tokens carry context about where they apply (button, text, background). Components consume semantic tokens, not primitives. |
| Theme | A coordinated set of token values applied together (light theme, dark theme, brand-A theme). Switching theme switches all coordinated tokens at once. | A skin - theme implies a structured coordinated change to multiple tokens; a skin can mean a more ad-hoc visual change. |
| Color scheme | A browser-level concept indicating which visual modes a piece of content is designed to render in. Exposed via the CSS color-scheme property and the prefers-color-scheme media query. | A theme. Color scheme is a system-level mechanism owned by the browser and the user's OS preference; a theme is an application-level coordinated set of tokens. |
| Cascade layer | A CSS @layer block that establishes an explicit specificity tier. Consumer overrides slot in cleanly without specificity hacks or !important. | A specificity hack - cascade layers are an explicit, declared part of the cascade defined in CSS Layers spec, not an old-style override technique. |
Token tiers in Semetrika
Semetrika uses a three-tier model:
Primitive tokens raw values --color-primary-5, --space-x-4
↓
Foundation tokens shared --background-color-neutral, --component-padding-block-md
↓
Component tokens per-component --btn-background-color, --card-padding
Each tier references the one above it and never skips a level. A component slot names its own per-value token first and the foundation token as the fallback (var(--btn-neutral-background-color, var(--background-color-neutral))), so a component declares a token of its own only where it deviates from the convention. See Tokens for the contract and Vocabulary for the capability words.
Group E: CSS features
Foundational CSS concepts that recur in design-system architecture.
| Term | What it is | What it is NOT |
|---|---|---|
| Custom property (CSS variable) | A CSS-native variable defined with --name: value and consumed with var(--name). Resolves at runtime. | A Sass / Less / Stylus variable. CSS custom properties resolve in the browser; preprocessor variables resolve at build time and are gone by the time the browser sees the CSS. |
| Logical property | A direction-aware CSS property (margin-inline, padding-block, inset-inline-start) that adapts to writing direction (LTR vs RTL) and writing mode. | A physical property (margin-left, padding-top, left) - those are direction-fixed and break in RTL contexts. |
| LTR (left-to-right) | Writing direction in which text and layout flow from left to right. Default for Latin, Cyrillic, and many other scripts. | A locale or language. LTR is about direction, not which language is displayed. |
| RTL (right-to-left) | Writing direction in which text and layout flow from right to left. Default for Arabic, Hebrew, Persian / Farsi, Urdu. | A locale or language. Components built with physical CSS properties (margin-left) often break in RTL; logical properties adapt automatically. |
| OKLCH | A perceptually uniform color space (oklch(0.7 0.1 250)). Equal numerical changes map to equal perceived changes. | RGB, HSL, or hex - those are not perceptually uniform. A 50% lightness in OKLCH is genuinely "halfway dark"; in HSL it is not. |
| Container query | A CSS feature that lets an element respond to a containing element rather than the viewport. Two flavours: size queries (@container (min-width: 30rem)) and style queries (@container style(--option-loading: spinner)). | A media query - media queries respond to the viewport; container queries respond to a containing element. Also not a parent selector - container queries do not select the container itself, only descendants. |
Group F: Methodology and quality
Practices, not products.
| Term | What it is | What it is NOT |
|---|---|---|
| Atomic Design | A methodology for composing UI from atoms → molecules → organisms → templates → pages. Coined by Brad Frost. | A product category - Atomic Design is how you organize components; it is not a kind of framework. |
| Visual regression test | An automated test that compares a rendered screenshot against a committed baseline image, flagging visual diffs. | An interaction test - VR catches visual changes; interaction tests catch behavioural changes. |
| Interaction test | An automated test that simulates user interactions (clicks, keyboard, focus, hover, typing) on a rendered component and asserts behavior. Covers a single component at a time. | A unit test in the pure-logic sense (interaction tests run in a browser-equivalent). An end-to-end test - both use simulated user interactions, but interaction tests scope to one component while end-to-end tests scope to a flow across many. |
| End-to-end (E2E) test | An automated test that simulates user interactions across a flow spanning multiple components and / or pages. | An interaction test. The technique is identical; the difference is the scope of coverage. |
| WCAG | Web Content Accessibility Guidelines - international standard maintained by W3C, with conformance levels A, AA, AAA. Semetrika targets WCAG 2.2 AA. | A specific tool. WCAG is the standard; tools like axe-core, Pa11y, and Lighthouse check whether code conforms to it. |
| ARIA | Accessible Rich Internet Applications - a set of HTML attributes (role, aria-label, aria-busy, aria-expanded) that communicate semantics to assistive technology. | A replacement for semantic HTML. ARIA supplements semantic HTML where it cannot carry the meaning; the first rule of ARIA is "use semantic HTML first". |
Group G: AI compatibility
Recent additions to the design-system space, driven by the rise of LLM-powered developer tools.
| Term | What it is | What it is NOT |
|---|---|---|
llms.txt | An emerging convention - a discovery file at a project's docs root that points LLM tools to a curated set of context files. | robots.txt - llms.txt is opt-in for LLMs (here is what to read); robots.txt is access control against crawlers. |
| MCP server (Model Context Protocol) | A server implementing Anthropic's Model Context Protocol that AI agents can connect to for live queries (component lookup, token resolution, etc.). | A REST API or GraphQL endpoint - MCP is purpose-built for agentic LLM contexts and has its own protocol. |
| Agent Skill | A pre-packaged bundle of framework knowledge and instructions designed for AI agents to consume. | A general-purpose plugin - Agent Skills are agent-task-specific, often domain-specific knowledge bundles. |
| LLM-legibility | The property that a framework's architecture makes LLM output reliable - bounded vocabulary, predictable naming, semantic-first markup, small surface area. | AI tooling shipped (llms.txt / MCP / Agent Skills) - those are bolt-on. Legibility is structural - a property of the framework's design, present whether or not extra tooling is added. |
| AI-friendly | Loose marketing term meaning the framework makes AI-driven development easier. Can refer to either AI tooling shipped or LLM-legibility, or both. | A specific feature. "AI-friendly" alone tells you nothing - you need to know whether the framework ships AI tooling, has LLM-legible architecture, or both. |
Semetrika focuses on architectural LLM-legibility: bounded vocabulary, predictable naming, semantic-first markup, small surface area. Bolt-on AI tooling (llms.txt, MCP) is on the roadmap but not the core differentiator.
Group H: Distribution and lock-in
How frameworks ship and what it costs to leave them.
| Term | What it is | What it is NOT |
|---|---|---|
| Drop-in | A framework that works via a single CDN-style stylesheet link plus optional script tag, with no build pipeline at the consumer side. Semetrika supports drop-in. | A copy-paste model (shadcn/ui, Catalyst). Drop-in is one external link; copy-paste means cloning component source into the consumer's repo. |
| Bundle | The shipped, compiled output (typically .css and .js files) that consumers actually consume. | The source code - the bundle is the output of the build, not the input. Many frameworks ship vanilla CSS as the bundle even when their source is Sass. |
| Vanilla CSS | CSS that requires no preprocessor (no Sass, no PostCSS, no CSS-in-JS) at the consumer side. Semetrika ships vanilla CSS. | Compiled / preprocessed CSS at the framework side. A framework can use Sass internally and still ship vanilla CSS. |
| Vanilla JS | JavaScript that requires no specific framework (React, Vue, Svelte) at the consumer side. Semetrika ships vanilla JS. | Plain ES5 / pre-modules JavaScript - vanilla JS today means modern ES with native modules; what matters is the no-framework-required part. |
| Markup portability | The property that a consumer's HTML stays valid and meaningful if the framework is removed - because the framework styles raw semantic HTML rather than wrapping it in framework-specific tags or classes. Semetrika markup is portable (classless HTML is plain HTML when Semetrika is removed). | Component portability - markup portability is about the HTML layer surviving framework removal. |
| Lock-in | The cost of leaving a framework: how much rework is required if you stop using it. | Cost of using - lock-in is specifically about the cost to leave, not the cost to adopt. |
| Customization locality | The property that all customization can happen in the consumer's project - variables, tokens, classes, project CSS, component swaps - without forking or patching the framework upstream. Semetrika has high customization locality. | Pure configurability - customization locality includes project-level overrides and extensions, not just config-file knobs. |
Group I: Semetrika-specific terms and conventions
Semetrika builds on the industry vocabulary in Groups A through H. Where Semetrika's usage diverges or adds specificity, this section documents that.
Component class
The top-level class representing a component. For element-styled components, the component class is the mirror class (.btn, .card, .nav). For class-only components (no semantic element), it is the component's own class (.message, .badge, .carousel).
Class-only component
A component that has no semantic element equivalent and therefore no classless form. It is always written with its component class (.message, .badge, .carousel).
Child class
A named structural part of a compound component. Flat dash pattern: .{component}-{child} - .card-header, .card-body, .card-footer, .modal-body. Child classes only apply to components with named internal regions; atomic components (button, badge, avatar, chip) have no children. Child classes exist only in the class-based form; the classless form uses nested semantic elements instead.
Value composition
Values in Semetrika compose: you add multiple to one element, never combine them into compound names. .btn-subtle-sm is wrong; .btn.subtle.sm is right. Values in different capabilities are independent and can be freely combined; values within the same capability are mutually exclusive.
Capability list
Semetrika's named capabilities: Alignment, Elevation, Emphasis, Fill, Fit, Intent, Layout, Motion, Orientation, Position, Shape, Size, Visibility. The canonical list of allowed value words organized by capability lives on the Vocabulary page.
State (preference order)
In Semetrika, states are expressed in preference order:
- Native pseudo-class -
:hover,:focus-visible,:disabled,:checked,:invalid. Free from the browser. - ARIA attribute selector -
[aria-expanded="true"],[aria-busy="true"]. Used when ARIA carries the semantic truth. - State class -
.loading,.active,.open. Used only when neither pseudo-class nor ARIA fits. Theis-prefix is NOT used - state classes are bare names.
Token (three-tier model)
Semetrika uses a three-tier token model:
- Primitives - raw values on a scale:
--space-x-4,--font-size-lg,--color-primary-5. Novar()references, no opinion about usage. - Foundation tokens - shared UI decisions that reference primitives:
--text-color-neutral,--background-color-neutral, and the reserved--component-*family (--component-padding-block-md,--component-radius-pill). - Component tokens - per-component decisions declared in the component's own
{name}.variables.css:--btn-background-color,--card-padding.
Components consume foundation and component tokens, not primitives. See Tokens.
Option
A runtime feature flag exposed as a CSS custom property with the --option- prefix: --option-animations, --option-rounded-corners, --option-elevation, --option-card-elevation, --option-loading. Options are numeric scalars in [0, 1] consumed via calc() as multipliers, or enums resolved through @container style() queries on the options container. They toggle or scale framework-wide behavior without rebuilding the stylesheet. See Tokens.
Data attribute (three purposes)
A non-class, non-ARIA HTML attribute used for three purposes in Semetrika:
- CSS content and configuration - values CSS reads at runtime via
attr()or attribute selectors (data-color-scheme,data-placement). - JS behavior binding - hooks JS uses to initialize a component (
data-accordion,data-carousel,data-dismiss). - Cross-component attachment - adding one component's behavior to another (
data-tooltipon a button). Used sparingly.
Color scheme
The active light or dark variant of the design tokens. Semetrika defines two schemes: light (default) and dark. The scheme is selected only at page level via the data-color-scheme attribute on <html>. See Color schemes.