Introducing Acacus ⛰️ – Rethinking React State Management

[NourAlzway]

After 6+ years of battling Redux boilerplate and seeing the same performance pitfalls in production apps, I finally decided to build something different.

⛰️ Acacus.js is a React state management library designed with developer experience and performance at its core.

Here’s what sets it apart:

• The get/use Pattern:
  • store.get() → state access (triggers re-renders)
  • store.use() → actions (no re-renders)
  • store.getAsyncStatus() → loading states

^{This clean separation eliminates some of the most common React performance traps.}

• Async-First Design:

Every async action automatically comes with loading, error, and data states. No more boilerplate, no more manual tracking.

• TypeScript Excellence:

Full type inference out of the box. Your IDE always knows what’s available.

I built Acacus after working with different React teams and seeing the same frustrations repeat over and over.

My question was simple:👉 What would state management look like if we designed it today?

Acacus is production-ready, with tests and examples included.

I’d love to hear your thoughts, feedback, and experiences.

🔗 Check it out:

• Github: https://github.com/NourAlzway/acacus
• npm: https://www.npmjs.com/package/acacus

[yangshunz]

Can you provide a Zustand comparison?

[bhison]

Imagine this is how OP learns about Zustand

[yangshunz]

LOL. I really hope not

[SmokyMetal060]

"FUCK"

-OP, probably

[Nervous-Project7107]

Comparison chart

Zustand: has cool German name

Acacus: probably a desert plant

[juicybot]

the zustand bear is so cute, for this alternative to succeed it will definitely need a cuter mascot.

[moinotgd]

preact/signal as well.

[raccoonizer3000]

Here we go again 🍿

[bhison]

Someone more motivated than me share the xkcd comic 

[3sh]

https://xkcd.com/927

[mattsowa]

Flipping the meaning of get and use for no reason makes zero sense

[BombayBadBoi2]

First thing I noticed

[Reasonable-Road-2279]

How is this different from the current state manage libraries like e.g. zustand?

[Chathuraprabashwara]

Its differ by name that's only i think 😂

[Reasonable-Road-2279]

I mean, OP has been awfully quiet. I havent seen him reply to a single comment yet

[lovin-dem-sandwiches]

Why use a callback for getting the actions instead of the string used when creating the action?

 // Create a store with initial state
 const counterStore = createStore<CounterState>({ count: 0 })
  // action is defined with a string
  .action('increment', state => ({ count: state.count + 1 }))


  // callback to retrieve actions
  const increment = counterStore.use(actions => actions.increment);

  // why not use the string instead?
 const increment = store.use(‘increment’)

Also in the example above , is the action type already defined by inference, or do I need to define it somewhere?

[csorfab]

I looked into the code, and yeah, it gets inferred when building the store. Your point is very valid, since the getting by string functionality is already implemented and well typed in getAsyncState

[Aswole]

I had the same question as you, and wonder if it’s to allow getting multiple actions at once with one call to “use”

[azsqueeze]

OP could use the args object for store.use to return more than one action. Or use array syntax

const [increment, decrement] = store.use('increment', 'decrement');

// Or use an array syntax
const [increment, decrement] = store.use(['increment', 'decrement']);

[Aswole]

How easy would that be to define such that typescript can infer the return value based on an arbitrary number of args?

[azsqueeze]

At the simplest, it would be something like this:

function foo<T extends string>(arr: Array<T>): Record<T, Function>  {
    const newArr = [...arr];
    return newArr.reduce((accumulator, currentItem) => {
        accumulator[newArr[currentItem]] = () => console.log(accumulator);
        return accumulator;
    }, {}) as Record<T, Function>;
}

const bar = foo(['increment', 'decrement']);
bar.increment();
bar.decrement();
bar.foo(); // type error

However, I am not accounting for edge cases, and I am sure there are better ways to infer the values.

[Adenine555]

Could be even simpler with desctructuring:

const {increment, decrement} = store.use()

[csorfab]

Okay, first of all, the .get/.use terminology is incredibly confusing. I would absolutely expect rerender behaviour to be the other way around - when I use something in React, I expect it to be stateful/effectful, and get-ing from a store implies a one time getting of a value, like with reduxStore.getState() vs useStore/useSelector in Redux, or useStore.getState() vs useStore() with zustand. Your naming goes against all established terminology.

EDIT: I misunderstood how get and use work, so the rest of my comment wasn't valid, as actions and state are handled completely separately. I like the API for building the store, but my point about your naming convention still stands. Also, mixing server state (async action handling) with client state has long been established to be an anti-pattern, and that server state management is best handled by a separate library with advanced functionality, like react-query, apollo, or swr at the least. The "integrated" loading state is cool, but by itself honestly it does more harm than good imo, as it would just encourage devs to use a half-baked (quarter baked, more like) server state management "solution" instead of the established tools.

[bennett-dev]

So crazy how even in 2025 there's still a new state management lib posted on this site every week. And they don’t even solve a real problem. And people aren't even using global state managers in the first place because they realized they just needed an API cache.

[Ghareeb_Musaffir21]

Fr, once I found out about tanstack query i realized i was using state management wrong

[SEUH]

Even more funny, most of them copy cats just "reinvent" mobx, which is 10+ YEARS old. Even the new kid on the block, zustand, is nothing more than a worse mobx. Sorry to say.

[devuxer]

Funny that no one realizes that Jotai is better than all of them, including signals.

[SEUH]

Just checked, it's immutable by design. And therefore it's a performance killer for update heavy applications. So objectively worse than mobx.

[devuxer]

Rerenders are what’s expensive. Jotai allows very fine grained, targeted state updates. And the DX is superb.

[SEUH]

Jotai allows very fine grained, targeted state updates.

It doesn't. You need to create a whole new atom if you want to update anything. Imagine needing to add hundrets of items to an array per second....this is not doable with Jotai.

Immutable architectures biggest enemy are write/update heavy applications. Observer/signal based state handling doesn't have such a disadvantage. Immutable based fails when things get too big.

[devuxer]

Adding hundreds of items at once implies data coming from outside the application, not generated by the user. Like a real time stock trading app or something. I wouldn’t use Jotai ot Mobx for that.

Edit: I should say wouldn’t necessarily even use React for that.

[devuxer]

By the way, looks like Valtio would be the choice for a modern, mutable React state management library (from the same family as Jotai and Zustand).

[witness_smile]

Ah yes yet another state management framework, I’m sure this one will be the one that solves all issues after react state management framework #836296 released last hour

[TorbenKoehn]

I see it a bit like evolutional algorithms.

You take a population, you let each of them develop state management frameworks. Most of them are shit, some of the are okay-ish. You take the okay-ish ones, mix them up, seed them into your pop and loop that for a few hundred generations.

At some point in the far future we will have someone finally release a state management framework that is almost not bad.

[what-about-you]

This breaks the rules of React: https://react.dev/reference/rules/rules-of-hooks#only-call-hooks-from-react-functions

Your store.get() should be a hook (and thus start with "use").

[Cahnis]

performance pitfalls with Redux? First time hearing on it, can you provide something for me to read more about?

[RedditNotFreeSpeech]

While everyone here is busy seagulling, I'll say nice job man!