Skip to content

Why Invisible UI

A design system: interface components (buttons, forms, dialogs, menus) for every technology your teams use. Experience, accessibility, usability and customization, tested deeply.

  • Components: every component, with a live demo on each page.
  • Naming map: coming from another library? Find things by the name you know.
  • Foundations: tokens, colour, typography.
  • API conventions: how the pieces fit, for every framework.

Usability, accessibility and clear wording are requirements of this design system, held to the same standard as performance or security. The decisions, applied consistently everywhere:

  • Buttons name outcomes. A dialog asking “Do you want to delete this file?” answers with Delete file / Keep file, each label readable on its own, by everyone, screen readers included.
  • Dialogs match jobs people already understand: confirm something, ask for a value, acknowledge an outcome.
  • An empty list gets its own design. “Nothing here yet” looks calm and offers the next step; “something went wrong” looks like what it is.
  • One selection colour everywhere, so state reads at a glance across checkboxes, tabs, lists and menus.
  • Touch works everywhere: menus, tooltips and pickers behave properly on phones.
  • The docs are designed too: components are named for humans, and a naming map welcomes people arriving from other libraries.

All of it is built into the components and locked in by their tests, so it arrives intact in your product, on every stack the adapters reach.

When a design works, it is hardly noticed. Interfaces get noticed when they fail: the button that ignores a press, the label read two ways, the popup that steals your focus. Invisible UI is named for the aim: removing the effort people spend decoding an interactive system.

The components follow the usability and accessibility principles defined by WCAG (the W3C accessibility guidelines) and by industry best practice. The experience of the product you build with them remains your design work. If a pattern looks wrong to you, report it.

Invisible UI is in alpha: the component set (81) and the Svelte adapter are complete and documented with live demos, and the React, Vue and web components adapters carry the same catalog. The Python adapter wraps the React one (see Framework support). Names and details may still change. If that trade-off suits you, this is a good moment to look around and tell us what’s missing.

The hard parts (keyboard behaviour, focus, what a screen reader announces) live in one shared core. Thin adapters expose it to Svelte, React, Python and plain HTML: same components, same behaviour, same look, whatever your stack. We measured the claim: when the last three adapters were added, the core needed zero changes.

Frameworks come and go: anyone who has been in software for a decade has watched yesterday’s standard become today’s migration project. The core is pure, framework-free code, and each adapter is a thin, replaceable layer. When a stack changes, you replace the adapter and keep the components, with all the accessibility work inside them.

It works where frameworks are out of reach

Section titled “It works where frameworks are out of reach”

Plenty of valuable software lives in portals built years ago, server-rendered tools, internal systems teams prefer to keep. For those, Invisible UI ships self-contained web components: one stylesheet, one script tag.

<script type="module" src=".../define.js"></script>
<ds-select label="Fruit" name="fruit">
<option value="apple">Apple</option>
</ds-select>

If a page can show HTML, it can use these components. That makes Invisible UI a practical tool for modernizing legacy software: a new, accessible interface on existing systems, while they keep running.

Where the web platform already provides something solid (a real <select>, a real <dialog>, a real checkbox) we use it. The result is fewer bugs, forms that just work, and details you get for free, like the native picker on phones. Custom behaviour appears only where the platform leaves a genuine gap, and there we follow the W3C standards (the organisation that defines how the web works).

Every component follows the international accessibility patterns (WAI-ARIA): full keyboard support, correct announcements for screen readers, visible focus. Every component carries an automated accessibility test, and the suite runs on every change: over 2,000 automated tests across the project, including real-browser and visual checks.

Colours, spacing, radii and typography all come from design tokens: a single set of values you change once to make everything yours. The default theme exists so you can start today; every value in it is yours to replace.

Why is the Select native while the Combobox is custom? Why did the dialogs move to the platform’s <dialog> element? Each significant choice is written down in a public architecture record, with the trade-offs stated honestly. Years later, your team can read why each choice was made and re-evaluate it with full context.