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.

Tools that Work Together

The Kamod Ecosystem

Build a complete Preact interface with a small, deliberate toolkit. Start with Components and Shared Styles, then add icons, reusable behavior, persistence or translations where your feature needs them. Each project has a clear responsibility and a source you can inspect.

This is your map from A Working Screen to a Well Connected App. Compare the Starting Points, explore the project cards, and follow a Small Integration. The Package Guides carry the detailed installation steps and APIs.


Choose a Starting Point

Start with Something a Person Can Do: change a preference, submit a form, find a record or compare a result. Choose the tools that make that task work. The ecosystem gives you several levels of composition, from a single button to a complete application layout, without asking every project to adopt the same structure.

UI Components render controls and manage their interactions. Blocks arrange those controls into useful layouts. Themes give both the same colors, spacing and focus language. Companion Packages add specific behavior or data handling. Your application still owns routes, services, records and permissions.

Your next taskRecommended starting point
Build the first styled screen
When neededThemes and Icons
Give a workspace its navigation and layout
When neededYour router, real destinations and account actions
Collect and save information
Forms and the relevant Fields
When neededValidation, a submit service and useful recovery messages
Reuse a small interaction
When neededA component that exposes the current value and its actions
Remember a harmless preference
When neededA storage driver, a stable key and validation for saved data
Coordinate several screens
When neededExplicit actions, transitions and request ownership
Support several languages
When neededTranslated messages and locale-aware formatting

For a new integration, follow the Getting Started Guide. For an existing application, begin at the responsibility you are changing. A working feature is a better reason to add a dependency than the fact that another package is available.

Build the Interface Foundation

These projects define how the interface is put together and how it feels. Use the same styling foundation throughout the app so a copied block, a form control and a documentation panel can share the same theme. Check a component's supported API before adapting an example.

UI Components

Individual controls

Compose buttons, fields, menus and overlays from focused components. Start with their supported props and keyboard behavior, then supply the labels and content your feature needs. Each control follows the same semantic theme.

You own
Labels, validation and what each action does.
@kamod-ch/uiPackage
Preact native

Complete Blocks

Complete compositions

Give a workspace its shell, sidebar or authentication layout. Bring the supporting files with the block and connect your own routes, account actions and data. The source stays in your project, ready to adapt.

You own
Routes, account actions and application data.
@kamod-ch/blocksLocal source
Copy & adapt

Themes & Tokens

Shared visual tokens

Keep surfaces, text, accents and focus rings consistent. Choose a preset or adjust semantic tokens so light and dark modes remain part of one interface. Change a role once and let the components follow.

You own
Brand colors and the modes your app exposes.
@kamod-ch/themesTheme CSS
Light + dark

Content Typography

Reading and content

Style articles, rich text and Markdown through CSS typography. Use a content wrapper when the hierarchy belongs to prose, while keeping interactive controls under their component styles. Reading presets and opt-outs keep that boundary explicit.

You own
Your HTML, Markdown renderer and content hierarchy.
@kamod-ch/typesetContent CSS
CSS only

Keep Styles at the Application Boundary

Load the global stylesheet from the app's entry point. Keep Tailwind Source Detection aware of the components and blocks you actually use. If a control behaves correctly but looks unstyled, check the stylesheet and generated utilities before changing its implementation. The CSS Setup Guide explains that boundary in detail.

Use --background, --foreground, --muted and related semantic tokens to express a surface's purpose. The Theme Reference shows how those values change together. Test the same control in both color modes, including focus, disabled, selected and error states.

Add Focused Capabilities

These companion projects solve problems around the controls. Each has a guide here and its own source repository. Start with the small example, inspect the returned values or supported exports, then connect it to the feature you already have.

Icons

A consistent visual language

@kamod-ch/icons

Give actions recognizable SVG shapes. Choose one icon family for related controls, import named icons and let them inherit the control's color.

Reusable Hooks

Local reusable behavior

@kamod-ch/hooks

Reuse state, lifecycle, browser and async patterns close to the component that owns them. A hook supplies behavior; the visible control still needs a label and predictable states.

Persisted Signals

Reactive persistence

@kamod-ch/signals

Keep small preferences across reloads with a chosen storage driver. Decide who owns the value, how it is validated and when the saved value should replace the initial default.

State & Transitions

Explicit shared transitions

@kamod-ch/state

Model related changes with typed actions and reducers. Use it when several consumers need one understandable state model rather than separate copies of the same value.

Language & Formatting

Messages and formatting

@kamod-ch/i18n

Connect translated messages and locale-aware values. Keep the default language as a useful reference, then test longer translations in the same layouts and controls.

Give Every Value One Owner

Local state works well for a control that changes independently. A shared model belongs above the consumers that need it. Persistence belongs to values that should survive a visit, such as a compact layout preference. Sharing, Saving and Reacting Are Different Decisions; they do not require the same solution in every feature.

The Package Selection Guide compares these boundaries. If hooks, signals and state appear together, keep one source of truth. A screen should not maintain a second writable copy simply to display a value another part of the app already owns.

Explore the Wider Toolkit

Some projects become useful as the application grows beyond its first controls. Treat each as a deliberate integration: inspect its README, supported exports and installed version before adapting source. The links below distinguish the project's own reference from the UI guides on this site.

Motion

Animation primitives

@kamod-ch/motion

Add purposeful transitions and feedback to Preact interfaces. Use movement to explain a change, respect reduced motion and keep animation away from unrelated page work.

Animated UI Variants

Animated UI variants

@kamod-ch/ui-motion

Explore motion alongside familiar Kamod component contracts. Compare the animated variant with its base component and keep keyboard behavior and accessible names intact.

Data Visualization

SVG data visualization

@kamod-ch/charts

Explore charts for trends and comparisons. Check release availability and supported APIs, then provide meaningful labels and a text or table summary alongside the visual result.

PreactPress

Documentation sites

@kamod-ch/preactpress

Publish Preact-oriented documentation with Markdown, code examples and static output. Use it when the project needs a maintained reference site, as this documentation does.

OpenUI Integration

Generative UI integration

@kamod-ch/openui

Explore a defined component library for generated interfaces. Keep allowed components, data validation and application actions explicit rather than treating generated content as trusted application logic.

A Repository Is a Reference, Not a Promise That Every Example Matches Your Installation. Read its release notes and package exports together. Avoid copying an import from an unreleased branch into a project that cannot resolve it. The Integration Checks below give you a small verification sequence.

Build One Small Feature

Try a Details Toggle before connecting a larger workspace. It combines one behavior from @kamod-ch/hooks, one control from @kamod-ch/ui and a named SVG from @kamod-ch/icons. The visible panel explains the current state; the button's accessible attributes keep the relationship explicit.

In an existing styled Preact app, add the two optional companion packages:

Install PackagesTerminal
pnpm add @kamod-ch/hooks @kamod-ch/icons

Use a separate file for the feature so its ownership is easy to see:

src/components/DetailsToggle.tsx23 lines
import { useToggle } from "@kamod-ch/hooks";
import { InfoIcon } from "@kamod-ch/icons/lucide";
import { Button } from "@kamod-ch/ui/button";
import { useId } from "preact/hooks";

export function DetailsToggle() {
  const [open, { toggle }] = useToggle(false);
  const panelId = useId();

  return (
    <section class="space-y-3" aria-label="Workspace details">
      <Button type="button" onClick={toggle} aria-expanded={open} aria-controls={panelId}>
        <InfoIcon size={16} aria-hidden="true" />
        {open ? "Hide details" : "Show details"}
      </Button>
      <div id={panelId} hidden={!open}>
        <p class="text-muted-foreground">
          Your workspace keeps related tools and content together.
        </p>
      </div>
    </section>
  );
}

Read the Three Responsibilities

The hook owns the boolean and its toggle action. The button owns activation and visible feedback. The application owns the panel's content and where the feature appears. useId keeps the panel relationship distinct if you render the feature more than once.

Try it with Enter and Space, check both themes, and confirm the text explains the result. Then decide what the next requirement actually is. A saved compact-layout preference may call for Persisted Signals. A multi-step account workflow may call for State. Translated button labels belong in i18n.

For the exact contracts, follow Button Props, Hooks Usage and Icon Integration. Keep those references close while replacing this example's content with your own feature.

Connect the Feature to Your App

Keep the Interface, Application State and Services easy to distinguish. Components render a useful state and accept user actions. Your application decides what those actions mean. Services load or save records and verify access. A block can arrange all three without choosing your router or backend for you.

A Workspace or Dashboard

Start with an Application Shell, connect real destinations and supply the current path. Add Icons to recognizable actions and Hooks where behavior repeats. Keep account permissions and data loading at the application boundary. A hidden navigation item does not replace a service's authorization check.

A Settings or Account Form

Use the Form Guides for fields, labels, validation and submission. Let the route own a durable draft if layout changes can unmount the form. Add i18n when labels and feedback need translation; reserve Signals for preferences whose storage policy you have chosen. Sensitive records belong in the service, not automatically in browser storage.

A Content or Reference Site

Use Typeset for a readable article hierarchy and PreactPress for the documentation pipeline. Keep live examples near the explanation they support. Load a large demo when readers open it rather than importing the entire catalog into every page.

Across these flows, handle Loading, Empty, Failed and Successful Results with useful messages. A good pending state explains what is happening without replacing content that can remain usable. A good error tells the person what they can do next.

Check the Integration

Verify one complete journey before adding more packages. This catches a missing stylesheet, a mismatched import or a misplaced state owner while the feature is still small enough to understand.

CheckWhat to verify
Installation
Read the app's package.json, resolved versions and peer requirements.
Look forThe workspace that imports the package declares it, and the build resolves its public exports.
Styling
Open the feature in both themes and at a narrow width.
Look forText remains readable, controls fit and selected or focused states remain recognizable.
Keyboard
Reach the control, activate it and close any overlay it opens.
Look forFocus is visible, actions have names and focus returns to a sensible control.
Ownership
Change a value, navigate or alter the surrounding layout.
Look forState survives where expected, resets where intended and has one writable owner.
Persistence
Reload with fresh, saved and invalid storage data.
Look forDefaults and validation produce a usable screen; server and browser output agree during hydration.
Performance
Build for production and inspect a realistic interaction.
Look forUnused demos stay out of the route, repeated listeners are avoided and reading controls respond immediately.
Upgrades
Compare the installed release with the example and changelog.
Look forImports and contracts match the release you use; copied local changes are reviewed before replacement.

For deeper checks, continue with Package Integration, Persistence and Lifecycle or the Whole Journey Review. Measure a representative screen before adding caching, memoization or a new state layer.

Find the Source and Keep Going

The ecosystem spans One UI Workspace and Several Focused Repositories. UI components, blocks, themes, Typeset, UI Motion and OpenUI live in the Kamod UI Repository. The companion projects link to their own repositories in the cards above. Use the repository that owns the behavior when looking for a declaration, changelog or issue.

Before reporting a problem, include the package version, import path, a small reproduction and what you expected to happen. For a visual issue, include the theme and available width. For a state issue, include the action sequence and whether a reload changes the result. That context makes an issue useful without requiring someone else to reconstruct your whole application.

Browse Kamod on GitHub

Source, releases and conversations

Follow a working example back to its source. Read the UI README, explore packages/core/src, and compare release notes before bringing an update into your app. Keep the example open as you browse: seeing the code beside its behavior helps you understand a pattern, choose what to reuse and adapt it with confidence.

Your next move

Put the Toolkit to Work

Choose one useful task: a preference to save, a panel to open or a form to submit. Bring together the pieces it needs, connect your real data, and make loading, recovery and keyboard use part of the same finished screen.