Build the product. Keep the hard parts.

36 modular packagesView on GitHub

What you gain

Start with the whole product foundation, or take one proven layer at a time.

create-appkit

Fast path

Go from an empty directory to a branded, navigable application in one command.

  • Next.js 16, React 19, TypeScript, Tailwind v4, tokens, themes, and the application shell arrive wired together
  • Choose topbar or sidebar navigation without rebuilding the shell
  • Authentication, Postgres, queues, AI, and provider integrations stay optional
  • Workspace dependencies become normal npm ranges in generated applications
See the foundation in use

Modular by construction

Import the capability you need without accepting an all-or-nothing framework.

  • Dependency-light package roots keep React, Drizzle, browser automation, and provider SDKs out until requested
  • Explicit subpath exports make optional runtime and UI layers visible in the import itself
  • Application adapters preserve your domain model, routing, storage, credentials, and deployment choices
  • Packages share contracts and tokens, so independently adopted pieces still compose cleanly
Inspect an optional layer

Production guardrails

Inherit the constraints teams usually discover after launch.

  • Tenant isolation, wildcard RBAC, audit history, idempotent writes, sealed secrets, and replay-safe background work
  • Bounded graphs, queries, templates, uploads, user code, agent loops, retries, and provider responses
  • Semantic tokens, keyboard interaction, focus management, dark mode, and reduced-motion behavior
  • Fail-closed validation at persistence, execution, and external-delivery boundaries
Inspect the audit trail

A reference you can operate

Every linked surface is a working implementation, not a component screenshot.

  • Build dashboard cards, forms, reports, workflows, record layouts, and print designs directly in the demo
  • Exercise API docs, notifications, settings, audit history, sync, and integration configuration
  • The public demo runs without authentication and can use database-free adapters where persistence is unnecessary
  • Each screen shows the package composition an application can import and own
Build a workflow

Build the application

Interface, data, permissions, analytics, forms, and localization.

@appkit/tokens

Rebrand an entire application without hunting through component code.

  • Semantic color, typography, radius, elevation, and motion values
  • Tailwind v4 utilities generated from the same CSS variables
  • Light and dark themes, reduced motion, and one-file brand overrides
See the token system

@appkit/ui

Build consistent product screens with shared navigation, data-entry, feedback, and workspace components.

  • Inputs, feedback, dialogs, drawers, popovers, menus, tables, lists, and line editors
  • Direct file upload protocol, signature capture, and translated UI copy injection
  • Topbar/sidebar app shell, account launcher, search, notifications, theme, settings hub, and settings shell
  • Page layouts, route transitions, metrics, sparklines, and accessible interaction primitives
  • Tokenized light/dark styling, keyboard behavior, focus management, and reduced-motion support
View components

@appkit/analytics

Create governed reporting cards from approved data sources, measures, and dimensions.

  • Application-defined catalogues plus schema-discovered semantic entities
  • Parsed formula ASTs with a controlled function and field vocabulary
  • Tenant-bound, parameterized Postgres compilation and result contracts
  • Typed flat and pivot results, fifteen visualizations, chart specs, and conditional formatting
Build an insight card

@appkit/dashboard

Give people configurable dashboards and a governed way to build reusable insight cards.

  • Responsive 12-column layouts with drag, resize, add, remove, save, and reset controls
  • Flat, pivot, and heatmap result renderers plus the one-third/two-thirds card studio
  • Controlled dashboard metadata, autosave, publish, pin, delete, and role-default lifecycle
  • Framework-neutral layout and card contracts available without installing React Grid Layout
  • Optional React workspace and Drizzle persistence entry points for applications that need them
Use the dashboard

@appkit/reports

Define governed report queries, grouped results, page layouts, and schedules.

  • Nested filters, relationship refinement, custom fields, and tenant-bound row or summary SQL
  • Grouped results, fiscal breakouts, saved definitions, document layouts, and export contracts
  • DST-safe daily, weekly, monthly, quarterly, yearly, and nth-weekday schedules
  • Lease-based, idempotent run claiming plus injected execution, persistence, and delivery adapters
Open reports

@appkit/forms-core

Define forms, validation, scoring, and workflow automation through versioned schemas.

  • Plain and localized content supported by one versioned form contract
  • Field metadata, conditional logic, formulas, defaults, response validation, scoring, and normalization
  • Separate safety and business automation profiles with domain-specific actions
  • GL account, party, currency, percentage, inspection, and safety field types
Open form engine

@appkit/forms

Design, validate, preview, import, and export forms from one workspace.

  • Independently scrolling field library and sortable canvas with full drawer-based field and section properties
  • Tables, matrices, formulas, defaults, validation, conditional logic, data binding, repeating sections, and free-form layouts
  • Guided workflow steps, assignments, signatures, app pages, record editing/locking, list columns, and manual record actions
  • Native fill runtime plus typed adapters for application data, identity, uploads, camera/scanner, and address services
Open the form builder

@appkit/editor

Add the same bounded rich-text authoring control to forms, notes, and document fields.

  • TipTap paragraph, heading, list, emphasis, and link authoring
  • Host-provided link normalization and shared translated control labels
  • Separate install keeps the base UI primitive package free of editor dependencies
Use rich text in a form

@appkit/workflows

Run durable event, decision, approval, and action workflows.

  • Multi-flow library with enable, rename, delete, and subject-compatible templates
  • Full graph canvas, typed node toolbar, drawer inspector, branch handles, and live validation
  • Application-supplied subject profiles, trigger/action registries, and persistence adapters
  • Replay-safe action ledger, pause/resume gates, and any/all approval quorums
  • HMAC email approvals plus optional Drizzle schema/store and React visual builder
Open workflow builder

@appkit/sync

Bring external records into application-owned models through a safe connector spine.

  • Production scheduled, manual, and preview orchestration over an app-defined connector registry
  • 250-row transactions, per-record savepoints, complete run logs, and before/after change ledgers
  • Cursors advance only on clean runs; partial pulls are safely covered again on the next run
  • Authoritative snapshots fail closed on empty pulls, missing authority, or any processing failure
  • Crosswalk ownership and injected target adapters keep application record models outside the package
  • Optional hardened HTTPS egress and TLS PostgreSQL, MySQL, MariaDB, and SQL Server drivers
Configure data connections

@appkit/integrations

Send application events to external services without coupling product code to vendors.

  • Application-defined trigger catalogue and independently installable destination registry
  • Token mapping, sealed-secret seam, deterministic delivery references, and send-once policy
  • Partial retries resume completed items; reversible SQL exports replace prior rows safely
  • Optional HTTP, Slack/Teams, Google Sheets, email, SQL, and Drizzle persistence entries
Open integrations

@appkit/customization

Ship record customization as a native application capability instead of rebuilding an admin editor.

  • Application-bound record catalogue shared by defaults, designers, runtime tables, API validation, and persistence
  • Production form designer with ordered header groups, editable line columns, and record actions
  • Saved list-view designer and runtime record table with views, subtabs, search, filters, sorting, paging, and drill-through
  • Custom-field authoring plus versioned schemas, parsing, validation, linting, and refresh behavior
Open customization studio

@appkit/i18n

Apply one tenant-aware locale policy to application copy and user-authored multilingual content.

  • Supported-locale parsing, Accept-Language negotiation, and stable policy normalization
  • Tenant default and per-user override resolution with disabled-locale rejection
  • Localized authoring-copy fallback that preserves older English and plain-string records
See localized schemas

@appkit/db

Start with tenant isolation and identity persistence already shaped for production.

  • Postgres RLS executor with tenant-scoped and BYPASSRLS handles
  • Canonical tenants, users, memberships, roles, and API-key schemas
  • Schema helpers and an installer for repeatable row-level-security policies
See an RLS-scoped list

@appkit/tenant

Carry one resolved request context through database access, authorization, and auditing.

  • Wildcard RBAC, read tiers, visibility scopes, and per-user grant/deny overrides
  • Membership resolution, permission assertions, and super-admin behavior
  • One trust boundary shared by routes, actions, agent tools, and background work
Inspect the RBAC flow

@appkit/auth

Optional

Add a complete identity-provider runtime when an app needs one while keeping public and externally managed apps auth-free.

  • Durable sessions, password sign-in and resets, hashed one-time magic links, and OAuth accounts
  • Membership-bound invitation grants with atomic activation and audit
  • React forms, framework-neutral delivery, and memory, Postgres, and Next.js adapters

Extend the runtime

Audit history, APIs, governed user code, and AI-assisted workflows.

@appkit/events

Make material application changes traceable and reliably hand work to asynchronous consumers.

  • Structured audit records and JSON before/after diffs
  • Transactional outbox writes alongside the business mutation
  • Recipient resolution, leased claims, durable retries, and an effects ledger
  • Stable deduplication keys and authenticated relay calls for safe downstream delivery
View live audit history

@appkit/notifications

Publish one event to an in-app inbox, email, web push, and critical SMS.

  • Responsive three-pane inbox with search, folders, to-dos, reading actions, snooze, and paging
  • Tenant routing cockpit for audiences, channels, quiet hours, digests, schedules, and escalation
  • Per-user preference matrix, real browser push enrollment, deterministic delivery, and Drizzle stores
Open notifications

@appkit/api

Ship consistent external APIs with authorization and documentation built into the route contract.

  • API-key parsing, scoped authorization, and typed public errors
  • Idempotent mutation helpers that safely replay prior results
  • Route-shaped descriptions and generated OpenAPI documents
Use the API reference

@appkit/sandbox

Run authored JavaScript without granting it ambient access to the host process.

  • Fresh QuickJS WASM runtime with no Node, filesystem, module loader, network, or database globals
  • Bounded memory, stack, wall-clock execution, and governance units
  • Deep-frozen inputs, structured host faults, logs, and explicit async capability injection
  • One execution kernel shared by programmable endpoints, scripts, and installed app backends
Run a governed script

@appkit/endpoints

Offer user-defined handlers while keeping host access and resource consumption under application control.

  • QuickJS isolation with memory, execution-time, and unit budgets
  • Governed storage, record, and host-call capabilities
  • Deterministic limits that stop over-budget programs
Call a live app backend

@appkit/scripts

Give builders governed automation code without exposing the application process.

  • Ordered event hooks with explicit vetoes and application-whitelisted field changes
  • Scheduled, bulk, HTTP endpoint, and opaque-origin browser-validation runtimes
  • Read-only query, record, and governed host-function adapters supplied by the application
  • Timezone-aware cron scheduling, queue-neutral jobs, durable results, logs, units, and timing
Open script authoring

@appkit/apps

Add an installable app platform with a real builder, runtime, permissions, and distribution lifecycle.

  • Validated manifests and ZIPs, immutable versions, editable files, app storage, and declared object provisioning
  • Opaque-origin iframe frontends with CSP, inlined assets, and a permission-checked message bridge
  • QuickJS backend endpoints whose effective capabilities are the app grant intersected with the invoking user
  • Install, upgrade, enable, author, preview, audit, publish, browse, and reinstall marketplace snapshots
Build and run an app

@appkit/ai

Connect an agent to approved tools, models, prompts, and tenant policy.

  • Provider-neutral, bounded multi-step tool loop with abort and redacted errors
  • Streaming UI-message protocol, markdown, tool cards, cancellation, and thread composer
  • Production analysis, extraction, document chat, vision, writing, digest, prompt, and model helpers
  • Injected provider credentials, persistence transport, system prompt, and request-scoped tools

Protect and deliver

One encrypted credential path feeding provider-neutral email and SMS delivery, without leaking secrets through application errors.

@appkit/crypto

Store provider and integration credentials through one authenticated-encryption contract.

  • AES-256-GCM sealed secrets with a fresh nonce for every write
  • HKDF-derived application keys and authenticated tamper rejection
  • Shared ciphertext contract for every package that persists credentials

@appkit/email-render

Turn authored workflow email content into safe provider-ready HTML, text, subjects, recipients, and attachments.

  • Template AST, interpolation, loops, conditionals, and plain-text rendering
  • Save-time HTML sanitization and escaped untrusted merge values
  • Strict subject, output, recipient, attachment, and resource ceilings
  • Provider-neutral delivery normalization shared by web and worker processes

@appkit/design-studio

Compose print designs from positioned text, fields, shapes, images, and QR codes.

  • Bounded multi-artboard document model with application-defined data fields
  • Letter, A4-style, card, label, and custom physical formats
  • Safe normalization, catalogue validation, HTML rendering, and print-provider profiles
  • Interactive Fabric artboard with selection, move, resize, rotate, layers, zoom, and the full property inspector
Open design studio

@appkit/pdf

Render report documents, tables, statements, and authored templates to PDF.

  • Pure-JS PDFKit renderer with manual pagination, repeated headers, and page totals
  • Formal and modern financial-statement output
  • Optional template and Chromium entries keep browser automation out of the core renderer
Download a report PDF

@appkit/forms-documents

Turn a form schema into localized document fields, stable print styles, and an authored PDF template.

  • Companion text, image, photo, and repeating-section fields generated from the form contract
  • Localized labels and shared document styling for consistent downstream output
  • Generated bounded templates that can be edited before PDF rendering
Inspect the form contract

@appkit/forms-pdf

Print form summaries, repeating sections, photos, authored templates, and design documents.

  • Branded key-value summaries with repeating tables and photo grids
  • Bounded resource loading, PNG conversion, reusable browser lifecycle, and template profiles
  • Record/report printers and full-bleed multi-artboard design runs through optional runtime entries
Preview document output

@appkit/emails

Change outbound email providers without rewriting product workflows or credential handling.

  • 5 provider specifications: Resend, SendGrid, Mailgun, Postmark, and secure SMTP
  • Tenant/platform policy resolution from one provider catalogue
  • Credential-safe validation, transport construction, and failure reporting

@appkit/sms

Send transactional messages through a stable application contract across common SMS vendors.

  • 5 providers: Twilio, Vonage, MessageBird, Plivo, and Telnyx
  • Strict E.164 address validation and fetch-based transports
  • The same fail-closed tenant policy and sealed-secret path as email

Run outside the request

Queues, workers, retries, and binary object storage.