Ship the enterprise React app, skip the plumbing

Cliore is a production-ready React SPA starter with authentication, architecture, testing, and CI/CD already wired together and documented — so your first commit is a feature, not setup.

React 19MUI 9Router 7Keycloak 26TypeScript 6Vite 8~99% coverage300+ tests
demo.cliore.dev
Cliore demo dashboard overview with workspace metrics and navigation
The current demo app — workspace metrics, navigation and role-aware shell

What's inside

Everything an enterprise SPA needs

Nine pieces of foundation, each wired to real services and covered by tests — not placeholders you have to finish.

Keycloak auth + RBAC

OIDC login, silent token refresh, and route- and component-level role guards wired to a real Keycloak 26 realm — not a stub.

Feature-Sliced Design

A clear app → pages → widgets → features → entities → shared structure, with ESLint boundary rules that fail the build on illegal imports.

RTK Query + MSW

Typed data layer with caching and invalidation, plus Mock Service Worker handlers so the UI and tests run without a live backend.

i18n with react-intl

Message catalogs, locale switching, and formatting helpers set up end to end, ready for additional languages.

MUI theme

A centralized Material UI theme — tokens, typography, and component overrides — that the whole app reads from one source.

Tests + Storybook

Vitest and Testing Library at ~99% coverage with an enforced gate, Playwright E2E against a real Keycloak, and Storybook for component review.

CI/CD + gated release

GitHub Actions pipeline: lint, typecheck, test, and build on every PR, with a gated, versioned release workflow.

Deploy matrix

Documented paths for Vercel, Docker, and Netlify — pick a target and ship without reverse-engineering the build.

Observability, SEO & docs

Error boundaries and logging hooks, sensible SEO defaults, and written docs covering every layer of the starter.

See inside

A real app and a real codebase

Cliore is a running application and a documented source tree — not a folder of disconnected snippets. Here's what you get.

Who it's for

Built for people shipping real apps

Solo devs & founders

Skip weeks of setup and ship your MVP on a foundation that already handles auth, state, and CI.

Agencies & freelancers

Start every client project from the same audited baseline — consistent structure, faster delivery.

Teams standardizing

Adopt one enforced architecture (FSD + ESLint boundaries) so a growing codebase stays maintainable.

The stack

Built on the newest GA majors

Cliore targets current, supported versions so you inherit today's APIs and a long support window — not a migration backlog.

Reactv19
The latest GA with the new compiler-ready APIs and Actions.
MUIv9
Enterprise component library, themed from one token source.
React Routerv7
Modern data-router setup with typed routes.
Keycloakv26
Battle-tested OIDC auth with PKCE and silent SSO.
TypeScriptv6
Strict mode across every layer, no implicit any.
Vitev8
Rolldown-powered builds and instant HMR in dev.
~99%
test coverage
300+
unit tests
39
Storybook stories
22/24
Node CI matrix
en · es
i18n out of the box
22
docs pages

Architecture

Feature-Sliced Design, enforced

Layers flow in one direction — higher layers may import lower ones, never the reverse. ESLint boundary rules keep it that way as the codebase grows.

src/ — Feature-Sliced structure
src/
├─ app/       providers, router, store
├─ pages/     route-level screens
├─ widgets/   composed UI blocks
├─ features/  user actions + model
├─ entities/  domain models + api
└─ shared/    ui, config, lib
appProviders, routing, global config — the composition root.
↓ imports ↓
pagesRoute-level screens assembled from widgets and features.
↓ imports ↓
widgetsSelf-contained UI blocks composed for a page.
↓ imports ↓
featuresUser-facing actions with their own UI and logic.
↓ imports ↓
entitiesBusiness domain models and their data access.
↓ imports ↓
sharedReusable UI, config, and utilities with no upward imports.

The math

Cheaper than the time you'd spend

Wiring enterprise auth, architecture, and CI by hand is weeks of the least valuable, most error-prone work — before you ship a single feature. Here's the trade-off.

Build it yourselfStart with Cliore
Time to a working app3–6 weeks of plumbingRunning in minutes
Keycloak auth + RBACDIY, easy to get wrongWired to a real realm
ArchitectureEndless bikesheddingFSD, boundary-enforced
Tests & CISet up from zero~99% covered, gated
CostYour salaried weeksFrom $49, one-time

Pricing

One-time purchase, yours to keep

Buy once, download the full source, and use it across your projects. No subscription.

First 20Early adopter
$49 one-time

First 20 sales

  • Complete source code
  • Use in unlimited projects
  • Updates within the current major
PopularStandard
$79 one-time

Most teams

  • Everything in Early
  • 12 months of updates
  • Email support
Pro
$149 one-time

Studios & agencies

  • Everything in Standard
  • First premium theme free on release
  • Priority email support

Secure checkout via Lemon Squeezy · instant download · VAT handled · the full source is yours to keep

FAQ

Questions, answered

What license do I get?

A permissive license to use and modify the source in your own products. You may not resell or redistribute Cliore itself as a competing starter. Full terms ship with the download.

What's included?

The complete source for the starter: auth, Feature-Sliced structure, data layer, MUI theme, i18n, the test suite, the CI/CD pipeline, and written documentation for each layer.

Do I get updates?

Yes. Early and Standard include updates within the current major version; Standard adds a full year of updates and Pro extends coverage across your organization. You keep everything you have downloaded.

Which versions does it target?

The newest GA majors: React 19, MUI 9, React Router 7, Keycloak 26, and TypeScript 6 — so you start on current, supported foundations.

Can I get a refund?

Because this is downloadable source, sales are final. If something is broken or not as described, contact us and we will make it right.

Start on a foundation that's already done

See the running app, then get the source and build your product instead of its scaffolding.