# shadcnspace: a shadcn/ui block catalogue you copy into your own repo

> shadcnspace is an open-source distribution of shadcn/ui components, blocks and dashboard layouts built on Base UI, installed through the shadcn CLI and copied as source into your project. It trades versioned npm packages for full code ownership, which is the point and also the catch.

**shadcnspace/shadcnspace** — Open-source shadcn/ui blocks, components, Templates and layouts built with React, Tailwind, Radix UI and Base UI.

- Repository: https://github.com/shadcnspace/shadcnspace
- Website: https://shadcnspace.com
- Stars: 785 · Forks: 71
- Language: TypeScript
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/shadcnspace-shadcnspace

## A distribution of source, not an npm package

The framing matters more than the component list. shadcnspace describes itself as not an install-from-npm UI library but an open source distribution, following the same philosophy as shadcn itself. What lands in your project is source code, which you can edit, restyle or throw away, and the README is explicit that there are no hidden abstractions or runtime dependencies and no vendor lock-in. Nothing from the catalogue is imported at runtime, so the dependency graph of your app does not grow when you adopt a block. The target user is a team working in React and Tailwind that keeps re-implementing the same twenty marketing and dashboard patterns, and that would rather start from a working composition than from a bare primitive. What you trade away is the thing npm libraries give you: a version number, a changelog and an upgrade path.

## Base UI underneath, Tailwind and CVA on the surface

The interaction layer is Base UI, which the project credits with interaction logic, accessibility and predictable behaviour, and the styling layer is utility-first CSS with Class Variance Authority handling controlled variants. Variants are the reason a shadcn style component can offer several appearances without branching logic in your screens. The catalogue mixes component level pieces such as buttons, badges and alerts with block level compositions, including hero and feature sections for marketing pages and dashboard sections and widgets for application shells, plus templates such as dashboard kits and landing pages. Sizes quoted in the README are 100 or more free components, 51 or more reusable blocks and layouts, and three or more templates and dashboard UI kits. Those counts come from the project itself, and the repository does not carry a manifest that a reader can check them against, so treat them as a description of the catalogue rather than a verified inventory.

## The registry behind the CLI, and the scripts behind the catalogue

Two files at the root of the repository explain how the distribution is wired. components.json is the standard shadcn configuration, and registry.json is the registry definition that lets the shadcn CLI resolve a namespaced item into source. The documented CLI entry point is a single command, and it names an item in the @shadcn-space namespace. The site's own package.json shows how a registry is maintained: a merge script pulls registry entries together and a build script then invokes shadcn build. The same file also lists a screenshot generation script, which is how the catalogue can display each block without a human rendering every preview. The dependency list is large and modern, with React 19, Next 16, Tailwind 4, motion, recharts, cmdk, vaul and a long tail of Radix packages, but those are the dependencies of the catalogue site, not of the code you copy.

## Adding a component to a project you already have

The intended flow is that you already have a shadcn/ui setup, that is, a React project with Tailwind configured and a components.json of your own. Then the CLI writes the source of the requested item into your tree:

```bash
npx shadcn@latest add @shadcn-space/button-06
```

The item identifier carries a variant suffix, so the catalogue exposes several versions of the same component rather than a single canonical one. That is a design decision with consequences. A team can pick button-06 without hunting through a single button component, but it also means the choice is baked into your imports, and picking the wrong variant later means editing imports in every file that uses it. The alternative path is manual: the README states that you can copy components, blocks or layouts straight from the repository, that no build step is required and that all code is transparent and editable. For teams that want to review code before it enters the repo, or that want three of the six hundred available components rather than a whole block, manual copying is the sane default. The documentation site linked from the README covers how to use the shadcn CLI against this catalogue.

## Blocks and layouts are where the value sits

If you only need a button, this project is overkill, because any component library will do. The interesting part is composition. A hero section or a dashboard widget is a set of decisions about spacing, hierarchy, responsive breakpoints and empty states that someone else has already argued about. Blocks here are structured for reuse across pages and projects, and the templates and dashboard layouts are positioned for long term use rather than a landing page demo. The project describes them as cohesive and extensible, and lists marketing, application and dashboard categories, including team sections and call to action sections alongside the hero sections. The dark pattern to watch for is the opposite of the one the project warns about: adopting a whole layout to get one widget, and then owning a page of code that was never tailored to your product. The blocks are starting points, and the copy-and-paste model means the cost of over-adopting is editing cost, not dependency cost.

## No releases, and one dependency that floats

Two things make the upgrade story thinner than it looks. First, the repository has no GitHub releases, and the package.json marks the project as private with version 0.1.0, which is the version of the catalogue site rather than a published distribution. The last push was on 2026-10-02, so the source is being worked on, but there is no tagged sequence of catalogue versions you can pin a component to. Second, the dependency list mixes caret ranges with a single floating entry, radix-ui is listed as latest while everything else carries an explicit range. For the catalogue site that is resolved by the committed pnpm-lock.yaml, but for you it matters in a different way. The code you copy is not compiled against a locked tree, so a component that imports a Radix package will resolve that package to whatever latest resolves to on the day you install it. That is a concrete reason to read the imports of anything you copy before committing to it.

## Ownership instead of a versioned package

The real alternative to this approach is an ordinary npm component library, and the difference is in where the fixes land. With an npm library, a bug fix arrives when you upgrade the package and the maintainers decide it is ready. With a copy-and-paste catalogue, the code sits in your repository, so the fix arrives when someone writes it, and the decision about whether a component is still worth keeping becomes yours. That is a good trade for interface code that you are going to restyle anyway, and a poor one for behaviour heavy widgets such as dialogs, comboboxes or drag and drop, where upstream fixes carry more weight than local styling does. The MIT licence keeps this simple for commercial use, with no copyleft obligation attached to the code you take. If you are willing to own the code, the catalogue saves the assembly time. If you want the maintainers to keep owning the hard parts, copy the blocks and keep a real library underneath.

## Conclusion

shadcnspace makes sense for teams that already ship React with Tailwind and want marketing sections or dashboard shells without assembling them from primitives, and it is the wrong tool for anyone who wants a versioned package, a support SLA or automatic fixes. Before you adopt it, check that the component you actually need is in the catalogue rather than only on the hosted site, and remember that once the code lands in your repository the upgrade path is manual, because the README documents no update command.

## FAQ

### How do I add a shadcnspace component to my React project?

With the shadcn CLI, using a namespaced item identifier such as @shadcn-space/button-06, which writes the component source directly into your project. If you already have a shadcn/ui setup with your own components.json, the CLI integrates with it, and you can also copy the code from the repository by hand with no build step.

### Does using shadcnspace add runtime dependencies to my app?

No. The project states that there are no hidden abstractions or runtime dependencies, and that all code lives in your project. What you get is source you own and can edit, styled with Tailwind CSS and Class Variance Authority for controlled variants.

### Is shadcnspace built on Radix UI or Base UI?

The components are described as built on shadcn/ui and Base UI primitives, with Base UI handling interaction logic and accessibility. The repository that hosts the catalogue also depends on radix-ui and @shadcn/react, but those are dependencies of the hosting site rather than of the code you copy.

### How do I update a shadcnspace component after copying it into my repo?

You update it by hand, since the copied code becomes part of your project. The README documents adding components with the CLI and copying them manually, but it does not document an update or sync command for code already copied into a repository.

## Sources

- [Issues](https://github.com/shadcnspace/shadcnspace/issues)
- [License: MIT](https://github.com/shadcnspace/shadcnspace/blob/main/LICENSE)
- [Project website](https://shadcnspace.com)
- [README](https://github.com/shadcnspace/shadcnspace/blob/main/README.md)
- [shadcnspace/shadcnspace on GitHub](https://github.com/shadcnspace/shadcnspace)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/shadcnspace-shadcnspace