Your next page is taking shape...

Opening Your Next Page…

Loading the guide and preparing its examples for you to explore. The page will appear here automatically when it’s ready, so you can keep this view open without refreshing.

Made for Preact. Built to be yours.

Kamod UIThe Documentation

Preact UI components
with clear foundations.
Build your next project with Kamod UI.

Kamod UI is a Preact UI library of components, complete blocks, and a shared design language. Explore working examples, understand the code, and shape an interface that feels like your product.

A practical home for TypeScript, Tailwind CSS and the Kamod stack. Start small. Learn each piece. Build with confidence.

Open Source Preact Native Yours to Adapt

Component Composition Live Preview
Open
Setting the scene...

Interactive preview

Built With

Try the controls, explore the code, or reset and start again. Theme changes stay in this preview.


Loading kitchen sink…

01Components

Start Small. Make It Work.

A good interface begins with a clear action. Use Button for the next step, Input for a value, and Dialog when a decision needs focus. Kamod gives these pieces a consistent foundation while Your Application Owns the Behavior.

Each component guide brings together Live Variants, Copyable Source and an API Reference. Try the interaction first, then inspect the props and adapt the example to your data.

The example beside this text keeps the save operation in the parent. When that operation becomes asynchronous, add pending and error feedback at the same boundary; the State Ownership Guide explains the pattern.

Explore the Button Guide
A Small, Reusable ActionYour Save LogicPreactTypeScript
src/components/SaveAction.tsx11 lines
Opening the source

src/components/SaveAction.tsx

After Setting Up Your App, import a component and give it one useful job. Use type="submit" when the action submits a form.

Just a few familiar faces. Meet the whole collection

02A Shared Foundation

One Theme. Every Piece Belongs.

Give the first component a home before adding the next. Load Shared Styles and Semantic Tokens once, then let buttons, form fields and whole layouts speak the same visual language.

Use roles such as bg-background, text-foreground and border-border instead of repeating fixed colors. Pair a primary action’s background with text-primary-foreground, and let the theme supply the values.

Try a Different Palette Here. This page and its examples follow the selected preset and color scheme. The Appearance Controls Guide covers saved choices and system preferences.

Semantic Tokens Color by Responsibility
--background
--card
--muted
--primary

A Theme Is More than an Accent

Keep surfaces, text, borders and focus feedback in balance. Review the same screen in both modes, including its empty, disabled and error states.

03Complete Blocks

Give Your Feature a Place to Live.

Move from individual controls to a complete screen. Start with an Application Shell, explore Sidebar Layouts, or build an entry point with Login and Signup Blocks. The detail pages connect each live preview to its Source Files, Setup Instructions and Integration Guidance.

Browse Block Collections
Application ShellNavigation & Layout
Live Preview

Loading the application shell playground…

A responsive application frame with navigation, account controls and room for your feature.

Explore This Block
01 / Explore

Try the Whole Interaction

Open navigation, resize the screen and follow the keyboard path. Choose a layout for its behavior as well as its appearance.

02 / Understand

Read the Supporting Files

A block can include data, helpers and shared components. Use the file tree to understand the composition before copying it.

03 / Adapt

Connect Your Application

Replace example routes and content, wire your service boundaries, then follow the Block Setup Guide to verify the result.

04Forms & Feedback

Make Every Step Understandable.

Forms connect the interface to a real task. Start with A Label, a Value and a Clear Next Action. Native required and type="email" constraints are a useful first layer; useful errors and predictable submission complete the journey.

As rules grow, add a reusable schema. The Formisch Guide connects valibot schemas to field values, validation and submission while Kamod supplies the controls.

Keep Field Validation distinct from Service Feedback. Preserve entered values when a save fails and give people a way to try again. Learn more about Submission and Recovery.

Build a Better Form
Native Form ExampleInput + Label

Start with One Field

Try an invalid address, correct it, then submit. The browser checks the field before the local success message appears.

Try a sample address. This demo sends and saves nothing.

Ready to check your input.

05Practical References

The Details That Make It Fit Together.

The special guides explain decisions shared by every component and block. Read them when you reach that step, then return to your feature with a clearer model of Setup, Composition and Appearance.

Follow the Complete Guide
Set Up

Install & Connect CSS

Load the shared stylesheet and make Tailwind source detection explicit. Check one styled component before building the rest of the screen.

Theme

Choose Tokens & Presets

Pair backgrounds with foregrounds, refine your theme centrally, and keep the same interface readable in light and dark mode.

Refine

Compose Component Styles

Choose a clear hierarchy of actions, consistent spacing and useful surfaces. Change the composition before adding one-off overrides.

Compose

Combine Classes with cn

Combine base styles, conditional state and consumer overrides. Learn how clsx and tailwind-merge work together in the utility.

Integrate

Bring a Block into Your App

Read the full file tree, copy supporting files, and replace example navigation and data with your application's own boundaries.

Connect

Theme a Complete Layout

Carry the same tokens into sidebars, overlays and copied source. Check the finished screen rather than an isolated component.

06The Kamod Ecosystem

A Focused Tool for the Next Responsibility.

Keep the UI at the center and add the capabilities your feature needs. These companion projects cover Behavior, State, Language and Visual Communication. Each has its own source and documentation; you do not need to install the entire stack.

Explore the Package Guides

For the interface itself, @kamod-ch/ui and @kamod-ch/themes provide the core components and theme foundation. Before sharing state or persisting a value, read about Package Responsibilities and The Server and First Render. Find more projects in All Kamod Repositories.

Start with one responsibility and one clear owner. Keep temporary input close to its component, persist only the preferences that should survive a visit, and introduce shared state when multiple parts of your feature need it. The Getting Started package examples show these choices in small, working compositions. Before adding a dependency, check its Versions and Peer Dependencies, then verify the behavior in your own application—including keyboard use, light and dark themes, and the first server-rendered page.

07Your Next Step

One Useful Screen.
A Foundation You Understand.

You have the map: Components for the Interaction, Blocks for the Layout, Forms for the Task and Packages for the Supporting Behavior. Bring them together one decision at a time.

The Getting Started guide takes you from installing the foundation to your first working screen, then through integration and delivery. Keep it nearby while you build.

Open the Getting Started Guide
  1. 01

    Make One Thing Work

    Load the styles, render a control and connect a local interaction.

    Your First Working Screen
  2. 02

    Build the Complete Journey

    Add navigation, useful feedback and recovery around the happy path.

    Ship a Complete Feature
  3. 03

    Check What People Will Use

    Review keyboard access, narrow layouts, both color schemes and failure states.

    Verify the Whole Journey