# React Use: a TypeScript hook library with a copy-in CLI

> React Use publishes prebuilt React hooks as @siberiacancode/reactuse and ships a separate CLI that copies them into your source tree. The library is young and active, but the project docs offer no size numbers, no peer dependency range and no notes on how browser-only hooks behave during a server render.

**siberiacancode/reactuse** — 🌌 reactuse the largest and most useful hook library

- Repository: https://github.com/siberiacancode/reactuse
- Website: https://reactuse.org
- Stars: 573 · Forks: 81
- Language: TypeScript
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/siberiacancode-reactuse

## One published package inside a three-part pnpm workspace

React Use ships as a single npm package, @siberiacancode/reactuse, but the source is laid out as a pnpm workspace. The repository root holds pnpm-workspace.yaml and pnpm-lock.yaml next to a packages/ directory, and the root package.json is a container named @siberiacancode/root at version 0.0.0. Its scripts delegate to the real packages: core:build:js targets packages/core, docs:build targets packages/newdocs, and cli:build targets packages/cli and then regenerates that package's registry. The top-level listing also shows lefthook.yml, .prettierrc.mjs, .prettierignore, CONTRIBUTING.md and a LICENSE file. The library, the documentation site and the hook installer are therefore separate packages inside one repository, and a consumer only pulls the published library package from npm.

## Installing the package and calling useCounter

Start by installing the package into an existing React project. The README gives a single npm command and nothing else, so there is no separate setup step to follow:

```bash
npm install @siberiacancode/reactuse
```

The first real use is a counter. The example below is the one the project prints, and it shows the shape of the returned object: a value to render, plus inc and dec functions bound to onClick.

```tsx
import { useCounter } from '@siberiacancode/reactuse';

const App = () => {
  const counter = useCounter(0);

  return (
    <div>
      <h1>Count: {counter.value}</h1>
      <button onClick={() => counter.inc()}>+1</button>
      <button onClick={() => counter.dec()}>-1</button>
    </div>
  );
};
```

After those two additions, the button labelled +1 should raise the number in the heading and the button labelled -1 should lower it. The example never resets the counter and it does not list the other members of the returned object, so look up the full method set on the documentation site before you rely on one.

## The useverse CLI copies hook files into your project

A second install path puts hook source into your repository instead of importing it from npm. The project points at the useverse package for this and gives two commands:

```bash
npx useverse@latest init
```

```bash
npx useverse@latest add [hook]
```

The add command opens an interactive picker. The prompt reproduced in the docs lists the first entries of the catalogue:

```bash
Which hooks would you like to add? › Space to select. A to toggle all.
Enter to submit.
◯  useActiveElement
◯  useAsync
◯  useBattery
◯  useBluetooth
```

Space selects, A toggles everything, and Enter submits. The bracketed token in the add command stands for a hook name. Note the practical difference between the two paths: the npm package stays a dependency you upgrade with the lockfile, while the CLI route writes hook files that you then own and review line by line.

## TypeScript-first and tree-shaking ship without a single number

The README describes React Use as TypeScript-first, with SSR compatibility and tree-shaking optimization, and sends you to reactuse.org for the full documentation. Those three claims carry the entire performance argument, and the repository listing backs none of them with a measurement. There is no bundle size table, no benchmark and no tree-shaking report in what the docs print, and the package.json you can read is the workspace manifest, whose devDependencies are tooling entries such as @siberiacancode/tsconfig, typescript and prettier-plugin-tailwindcss. The peer dependency range of the published package is not shown at all. Read SSR compatibility as a documented intention rather than a verified property, and inspect the peerDependencies field of @siberiacancode/reactuse in the registry before you install it into a project that already pins React.

## The catalogue names device APIs the server never has

The picker is the only inventory the project publishes, and it is a partial one: useActiveElement, useAsync, useBattery, useBluetooth, useBoolean, useBreakpoints, useBrowserLanguage, useClickOutside, useClipboard and useConst. Two of those names, useBattery and useBluetooth, refer to device APIs that a browser exposes and a server does not. Whether those hooks return a safe default during a server render, or require a mounted check on the client, is not written down in the project notes, and the same gap applies to the broader SSR claim. The catalogue also mixes device hooks, document-level hooks and plain state helpers, so the same import can behave very differently depending on where your code runs. If your application renders on the server, the per-hook notes on the documentation site are the first place to read.

## Hooks you write versus hooks you import

There is a real alternative that costs nothing: keep a hooks folder inside your own application. The difference is in who owns the lifecycle code. A hook you write yourself lives in your repository, follows your lint rules and adds no dependency, but you write the subscription setup, the cleanup on unmount and the server guard for every hook, and you keep all of them aligned with your React version. Importing from the package moves that work to the library, where the hooks are versioned and released together, at the cost of a runtime dependency and a release cadence you do not control. For a counter the difference is visible in the example above: the package hands back value, inc and dec, while a hand-written equivalent has to express the increment logic and the typing yourself.

## Recent releases, local git hooks, and an MIT licence

The repository is not archived, and the last push was on 2026-09-20. The three most recent releases are v1.0.17 on 2026-09-01, v1.0.16 on 2026-08-25 and v1.0.15 on 2026-08-21, all within the 1.0.x line, so upgrades arrive as patch releases rather than major ones. The project uses pnpm with a workspace, formats with Prettier through a format script, and uses lefthook, whose prepare script runs lefthook install so the git hooks are set up during installation. The licence is MIT, as stated by the LICENSE file at the repository root and by the license field in the root package.json. What the listing does not show is a changelog file, a migration guide, a documented browser support range or a React version range, and the .github/ directory appears in the listing without its workflow contents, so the checks that run on each pull request cannot be confirmed from the files at hand.

## Conclusion

Adopt @siberiacancode/reactuse if you want ready-made hooks plus the useverse CLI to place them in your codebase, and stay with local hooks if your project pins an unusual React version or cannot take a new runtime dependency. Before installing, check the peerDependencies range of the published package and the server-render behaviour of browser-facing hooks such as useBattery and useBluetooth, which the docs do not explain. The last push was on 2026-09-20.

## FAQ

### How do I install React Use and add a hook to my React project?

Run npm install @siberiacancode/reactuse and then import the hook by name, for example useCounter from '@siberiacancode/reactuse'. The docs also cover a CLI route that copies hook source into your project, using npx useverse@latest init followed by npx useverse@latest add [hook].

### Does React Use work with server-side rendering?

The docs state that the library is built with SSR compatibility, but it does not explain how server rendering is configured or which hooks are safe to call on the server. Hooks named after device APIs such as useBattery and useBluetooth are the ones to check first on the documentation site.

### What does the useverse CLI do differently from installing the npm package?

The npm package keeps the hooks as an imported dependency, while the CLI writes hook files into your own source tree so you can read and edit them. The CLI presents a multi-select list of hook names and asks you to submit a selection.

### What licence is React Use released under?

MIT. A LICENSE file sits at the repository root and the license field in the root package.json reads MIT.

### Is React Use still being worked on?

The repository is not archived and the last push was on 2026-09-20. The listed releases v1.0.17, v1.0.16 and v1.0.15 were published on 2026-09-01, 2026-08-25 and 2026-08-21.

## Sources

- [License: MIT](https://github.com/siberiacancode/reactuse/blob/main/LICENSE)
- [Project website](https://reactuse.org)
- [README](https://github.com/siberiacancode/reactuse/blob/main/README.md)
- [Releases](https://github.com/siberiacancode/reactuse/releases)
- [siberiacancode/reactuse on GitHub](https://github.com/siberiacancode/reactuse)

---

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