👻 Primitive and flexible state management for React
Alternatives To Jotai
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Mobx26,4959,2673,7668 days ago236September 07, 202242mitTypeScript
Simple, scalable state management.
Jotai13,5801232 days ago121September 19, 20227mitTypeScript
👻 Primitive and flexible state management for React
Boardgame.io9,568321817 days ago200May 07, 202296mitTypeScript
State Management and Multiplayer Networking for Turn-Based Games
Awesome React Hooks8,307
10 months ago8cc0-1.0
Awesome React Hooks
Rematch8,1752101099 months ago76November 09, 202119mitTypeScript
The Redux Framework
React Final Form7,25750038417 days ago76April 01, 2022390mitJavaScript
🏁 High performance subscription-based form state management for React
Mobx State Tree6,6514792593 months ago107August 09, 2022201mitTypeScript
Full-featured reactive state management without the boilerplate
Easy Peasy4,96937505 days ago254September 17, 202218mitJavaScript
Vegetarian friendly state for React
Router4,79235a day ago127January 31, 202243mitTypeScript
🤖 Type-safe router w/ built-in caching & URL state management for JS/TS, React, Preact, Solid, Vue, Svelte and Angular
Effector4,21326109a day ago242April 15, 2022140mitTypeScript
Business logic with ease ☄️
Alternatives To Jotai
Select To Compare

Alternative Project Comparisons

Jotai (light mode) Jotai (dark mode)

visit or npm i jotai

Build Status Build Size Version Downloads Discord Shield Open Collective

Jotai scales from a simple useState replacement to an enterprise TypeScript application.

  • Minimal core API (2kb)
  • Many utilities and integrations
  • No string keys (compared to Recoil)

Examples: Demo 1 | Demo 2

First, create a primitive atom

An atom represents a piece of state. All you need is to specify an initial value, which can be primitive values like strings and numbers, objects, and arrays. You can create as many primitive atoms as you want.

import { atom } from 'jotai'

const countAtom = atom(0)
const countryAtom = atom('Japan')
const citiesAtom = atom(['Tokyo', 'Kyoto', 'Osaka'])
const mangaAtom = atom({ 'Dragon Ball': 1984, 'One Piece': 1997, Naruto: 1999 })

Use the atom in your components

It can be used like React.useState:

import { useAtom } from 'jotai'

function Counter() {
  const [count, setCount] = useAtom(countAtom)
  return (
      <button onClick={() => setCount((c) => c + 1)}>one up</button>

Create derived atoms with computed values

A new read-only atom can be created from existing atoms by passing a read function as the first argument. get allows you to fetch the contextual value of any atom.

const doubledCountAtom = atom((get) => get(countAtom) * 2)

function DoubleCounter() {
  const [doubledCount] = useAtom(doubledCountAtom)
  return <h2>{doubledCount}</h2>

Creating an atom from multiple atoms

You can combine multiple atoms to create a derived atom.

const count1 = atom(1)
const count2 = atom(2)
const count3 = atom(3)

const sum = atom((get) => get(count1) + get(count2) + get(count3))

Or if you like fp patterns ...

const atoms = [count1, count2, count3, ...otherAtoms]
const sum = atom((get) =>, count) => acc + count))

Derived async atoms needs suspense

You can make the read function an async function too.

const urlAtom = atom('')
const fetchUrlAtom = atom(async (get) => {
  const response = await fetch(get(urlAtom))
  return await response.json()

function Status() {
  // Re-renders the component after urlAtom is changed and the async function above concludes
  const [json] = useAtom(fetchUrlAtom)

You can create a writable derived atom

Specify a write function at the second argument. get will return the current value of an atom. set will update the value of an atom.

const decrementCountAtom = atom(
  (get) => get(countAtom),
  (get, set, _arg) => set(countAtom, get(countAtom) - 1)

function Counter() {
  const [count, decrement] = useAtom(decrementCountAtom)
  return (
      <button onClick={decrement}>Decrease</button>

Write only atoms

Just do not define a read function.

const multiplyCountAtom = atom(null, (get, set, by) =>
  set(countAtom, get(countAtom) * by)

function Controls() {
  const [, multiply] = useAtom(multiplyCountAtom)
  return <button onClick={() => multiply(3)}>triple</button>

Async actions

Just make the write function an async function and call set when you're ready.

const fetchCountAtom = atom(
  (get) => get(countAtom),
  async (_get, set, url) => {
    const response = await fetch(url)
    set(countAtom, (await response.json()).count)

function Controls() {
  const [count, compute] = useAtom(fetchCountAtom)
  return (
    <button onClick={() => compute('')}>compute</button>


Popular Reactjs Projects
Popular State Management Projects
Popular Web User Interface Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Atom Editor
State Management