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 task | Recommended starting point |
|---|---|
| Build the first styled screen | |
| Give a workspace its navigation and layout | When neededYour router, real destinations and account actions |
| Collect and save information | 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.
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.
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.
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:
pnpm add @kamod-ch/hooks @kamod-ch/iconsUse a separate file for the feature so its ownership is easy to see:
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.
| Check | What 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.