Skip to main content

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.

TermWhat it isWhat it is NOT
Design systemA 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 kitA 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 frameworkUmbrella 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 frameworkA 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 frameworkA 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 libraryA 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 libraryUnstyled, 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 systemA 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 systemThe 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 systemA 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 systemThe 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 libraryA 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 guideA 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.

LayerCategoryExamples
0CSS reset / normalizenormalize.css, modern reset
1Utility frameworkTailwind, Tachyons, Open Props
2Classful CSS frameworkPico, Bulma, Bootstrap (classful side), Semetrika
3Headless / primitive component libraryRadix Primitives, Headless UI, React Aria, Base UI
4Styled component libraryMantine, MUI, Chakra, Shoelace, Ant Design
4aUI kit (design files only)Figma Community kits, Untitled UI
5Skeleton / starter / white-label design systemCivicTheme
6Brand-specific design systemMaterial Design, Carbon, Polaris, GOV.UK

Group B: Component vocabulary​

The most-confused area in design-system discussion. Read carefully.

TermWhat it isWhat it is NOT
ComponentA 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).
VariantA 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.
ValueA 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).
CapabilityA 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.
StateA 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.
SlotA 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 componentA 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 componentA 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 componentA 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 componentA 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​

FrameworkWhat variant coversExample values
MUIFill axistext, contained, outlined
MantineFill axis (different vocabulary)filled, light, outline, subtle, transparent
Chakra UIPer-component recipe (varies per component)defined inside each component's recipe
shadcn/uiColor + fill bundledefault, destructive, outline, secondary, ghost, link
Material Design 3Elevation + fill + theme-color bundleelevated, filled, outlined, tonal, text
BootstrapMulti-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 use variant to expose the fill axis, and that contained happens 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.

TermWhat it isWhat it is NOT
ClasslessMarkup 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-firstA 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 classA 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 elementA 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 enhancementAn 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.

TermWhat it isWhat it is NOT
Design tokenA 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 tokenA 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 tokenA 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.
ThemeA 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 schemeA 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 layerA 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.

TermWhat it isWhat 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 propertyA 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.
OKLCHA 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 queryA 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.

TermWhat it isWhat it is NOT
Atomic DesignA 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 testAn 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 testAn 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) testAn 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.
WCAGWeb 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.
ARIAAccessible 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.

TermWhat it isWhat it is NOT
llms.txtAn 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 SkillA 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-legibilityThe 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-friendlyLoose 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.

TermWhat it isWhat it is NOT
Drop-inA 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.
BundleThe 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 CSSCSS 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 JSJavaScript 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 portabilityThe 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-inThe 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 localityThe 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:

  1. Native pseudo-class - :hover, :focus-visible, :disabled, :checked, :invalid. Free from the browser.
  2. ARIA attribute selector - [aria-expanded="true"], [aria-busy="true"]. Used when ARIA carries the semantic truth.
  3. State class - .loading, .active, .open. Used only when neither pseudo-class nor ARIA fits. The is- 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. No var() 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:

  1. CSS content and configuration - values CSS reads at runtime via attr() or attribute selectors (data-color-scheme, data-placement).
  2. JS behavior binding - hooks JS uses to initialize a component (data-accordion, data-carousel, data-dismiss).
  3. Cross-component attachment - adding one component's behavior to another (data-tooltip on 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.