Synchronizing with External Stores using useSyncExternalStore

Anton Ioffe - November 20th 2023 - 9 minutes read

In the fluid and evolving landscape of React development, state management often emerges as a critical crossroad, one where efficiency and synchronization can significantly impact your application's architecture and user experience. Enter the terrain of useSyncExternalStore, a nuanced and powerful hook tailored for the modern era of React. Along our journey, we'll unpack the mechanics and finesse required to tap into its full potential, navigate through advanced patterns and performance optimization strategies, and engage with practical scenarios that will challenge and refine your approach to external store synchronization. Prepare to bolster your React applications with a newfound mastery of state coherence as we dissect, optimize, and elevate the art of seamless state management.

Understanding and Implementing useSyncExternalStore in React Applications

React's concurrent rendering capabilities are designed to optimize the user interface by breaking down rendering tasks into bite-sized chunks. This allows for user interactions to be prioritized without causing a block in the rendering pipeline. However, one challenge that arises in this paradigm is the potential for tearing. Tearing occurs when the state read from an external store is not consistent with the state in the React component tree, potentially leading to erratic UI behavior or rendering outdated information.

useSyncExternalStore was introduced to address this challenge. It allows React components to subscribe to an external store—be it Redux, MobX, or any custom store implementation—and to re-render in response to changes in that store. This hook takes a subscribe function that adds a listener to the store, a getSnapshot function that retrieves the current state, and an optional getServerSnapshot function for server-side rendering. The elegance of this hook lies in its ability to seamlessly integrate with React's concurrent mode, ensuring consistent state across renders.

In practice, when a component mounts, useSyncExternalStore calls mountSyncExternalStore(), which is responsible for setting up the subscription to the external store. As the store's state changes, the component re-renders with the latest state. But React takes special care under the hood—during concurrent rendering, it utilizes a consistency check to prevent tearing. This check compares the state snapshot from before the rendering began with the current snapshot, ensuring that no changes occurred during the render phase itself.

During re-renders, updateSyncExternalStore() is invoked. If the state of the external store has changed, it ensures that the component updates with the latest state. It's important to note that if changes to the external store are detected during the commit phase of a render, React will schedule a synchronous update to avoid painting inconsistent UI. This means that the external store and React state are kept in sync, but without causing undue performance hits or visual flickering that would occur if the update was handled asynchronously.

Finally, the useSyncExternalStore hook brings about a developer-friendly approach to dealing with the complex stipulations of modern React applications, specifically ones using server rendering. The optional getServerSnapshot function complements getSnapshot by providing a mechanism to retrieve the store's initial state when rendering on the server, ensuring a smooth transition when the React app hydrates on the client-side. This guarantees that users are met with the same UI they were served, maintaining visual and stateful consistency across server and client.

Deconstructing useSyncExternalStore's API and Mechanics

useSyncExternalStore harnesses the subscribe function to ensure that components stay updated with changes in the store. By passing a callback to subscribe, components subscribe to store updates. A common mistake is to define subscribe within the component, leading to a different instance on each render, causing unnecessary resubscriptions and performance degradation. To avoid this, subscribe should be memoized using useCallback with an appropriate dependency array, or defined outside the component scope.

getSnapshot is a pure function tasked with extracting the current state from the store. It must operate without side effects and return immutable state representations. Missteps occur when developers let getSnapshot mutate the store's state directly or use it to perform logic with side-effects, which undermines React's guarantees of predictable UI updates. To ensure purity, getSnapshot should treat the store's state as read-only, returning new objects only if the state has changed.

The optional getServerSnapshot serves the same purpose as getSnapshot but in a server-rendering context, providing the initial store state for hydration on the server. A common error is when getServerSnapshot yields a state incompatible with the client environment, causing hydration mismatches. Developers should verify that the state provided by the getServerSnapshot perfectly mirrors what getSnapshot would deliver on the client for the same point in the application's lifecycle.

useSyncExternalStore harmonizes the relationship between the store and React components. It ensures timely updates following store modifications, adhering to principles such as modularity and reusability. It presents an efficient state synchronization strategy particularly suited for the concurrent rendering capabilities of React, where correct timings and state congruency are critical.

Consider the application of useSyncExternalStore in your next project. Is your subscribe function outside your components and properly memoized to prevent performance hits from repeated resubscribing? Do your getSnapshot and getServerSnapshot enforce immutable, consistent state delivery, and reflect the current state accurately and efficiently? Fine-tuning these functions isn't just about adherence to best practices, it's central to building an application with a stable, predictable state management.

// Example of a correctly implemented subscribe function outside the component
const subscribeToStore = (callback) => {
  // Code to subscribe to the store updates
  return () => {
    // Code to unsubscribe from the store

// Example of using useSyncExternalStore with memoization
function MyComponent() {
  const storeState = useSyncExternalStore(
    useCallback(subscribeToStore, []), // subscribe function is stable and not recreated on re-renders
    getSnapshot // assumes getSnapshot is defined elsewhere and correctly implemented

  // Component logic and rendering

This simple example demonstrates how to prevent unnecessary resubscriptions and ensures that getSnapshot always retrieves the current state in a manner consistent with React's pure function expectations.

Performance and Optimization Strategies with useSyncExternalStore

To ensure optimal performance with useSyncExternalStore, it's crucial to carefully manage rerenders which are often triggered by store updates. An effective approach is to employ selectors to read the minimal state necessary for your component. By selecting only the pieces of state your component needs, you limit the scope of updates, preventing unwarranted rerenders. Consider using a memoization technique with selectors to return the same object reference whenever possible if the underlying state hasn't changed. This helps in avoiding shallow comparison pitfalls that trigger unnecessary rerenders.

Conditional subscriptions can vastly improve useSyncExternalStore performance in scenarios where your component's subscription to the store needs to change dynamically based on certain conditions. Use conditional logic inside the subscribe function to determine whether or not to perform an update. This strategy reduces the overhead of processing updates that aren't pertinent to the current rendering context, thereby enhancing performance.

For a fine-grained control over updates, selective updates can be implemented using a combination of useSyncExternalStore with multiple selectors or even distinct stores. If you're managing a complex state object that affects several components, consider breaking it down into smaller, more targeted stores or state slices that can be subscribed to individually. This modularity not only keeps your state management logic clearer but also means components selectively update only when the state slices they are interested in change.

On the server side, leverage the getServerSnapshot function to optimize the initial render of your components. This function should provide the most up-to-date state possible to align closely with the initial state on the client. Keeping server and client state synchronized plays a significant role in improving performance by reducing the likelihood of expensive rehydration and re-rendering cycles due to data mismatches.

Lastly, remember to manage subscriptions wisely to prevent memory leaks and unnecessary work. Always unsubscribe from store updates when the component unmounts and ensure the store's subscribe function does not cause state changes directly but instead triggers rerenders in a controlled manner. Through careful attention to memory and updates management, you ensure that useSyncExternalStore runs efficiently as part of your React application's overall performance strategy.

Advanced Patterns and Best Practices

Leveraging useSyncExternalStore with context provides a practical way to manage global state across an entire React application. When combining the hook with context, it's crucial to define a custom hook that encapsulates the store subscription and context consumption logic. This achieves a modular approach where components can effortlessly access global state without being tightly coupled to the store's implementation details. For instance, a useGlobalStore hook employs useContext within to hand components the state they need in a reusable and testable fashion.

const GlobalStoreContext = React.createContext(null);

function GlobalStoreProvider({ store, children }) {
    const state = useSyncExternalStore(store.subscribe, store.getSnapshot);
    return (
        <GlobalStoreContext.Provider value={state}>

export function useGlobalStore() {
    const state = React.useContext(GlobalStoreContext);
    if (state === null) {
        throw new Error('useGlobalStore must be used within a GlobalStoreProvider');
    return state;

Designing custom hooks that condense store synchronization promotes code clarity and maintenance. Hooks can present components with required data and actions, shielding against unnecessary updates. For performance enhancement, hooks may include optimized selector logic that triggers component re-renders solely when the piece of state they track is altered.

export function useStoreSelector(selector) {
    const store = useGlobalStore();
    const selectedState = React.useMemo(() => selector(store), [store]);
    // Using useSyncExternalStore’s snapshot to prevent extra calculations
    const stateSnapshot = useSyncExternalStore(store.subscribe, store.getSnapshot);
    return React.useMemo(() => selector(stateSnapshot), [stateSnapshot]);

Best practices for code organization emphasize keeping store logic distinct from UI components. Store-associated code, encompassing subscribe and getSnapshot functions, should occupy dedicated modules. This division eases code navigation and allows store logic and UI components to scale individually. Establishing coding standards for naming and organizing store files also benefits team coherency and a consistent, tidy codebase.

Reusable components gain from store independence. Favor props to infuse necessary data and callbacks, enhancing their testability, adaptability, and decoupling from particular store implementations.

function TodoList({ todos, onTodoToggle }) {
    // Component logic here

// In a parent component
const todos = useStoreSelector(state => state.todos);
<TodoList todos={todos} onTodoToggle={handleTodoToggle} />

While crafting hooks or context for abstracting store logic, developers should dodge over-complication. Commence with uncomplicated implementations, refining progressively alongside the application's growth. This iterative development safeguards against premature optimization and nurtures a codebase that scales with the application's maturation.

Anticipating and Solving Common Issues in Store Synchronization

As developers, we strive for seamless data flow between our React components and external stores. Yet, achieving this synchronicity can be fraught with challenges. When dealing with state desynchronization, it's imperative to embrace the principle of single source of truth. This ensures that all components consuming the state are referencing the same exact value at any given time. Let's consider a scenario where state updates might not be propagated reliably. The flawed execution might involve directly mutating the state within the store's subscription callback, which can lead to unpredictable UI updates and violates best practices:

// Incorrect way: Mutating state directly inside a subscription
store.subscribe(() => {
  this.state = store.getState(); // This direct mutation can cause issues.

Instead, the corrected approach is to treat this process as an indirect effect. Utilize useEffect to wrap your store subscription logic and employ useState or useReducer to manage your local component state, ensuring re-renders are handled appropriately:

function MyComponent() {
  const [state, setState] = useState(store.initialState);

  useEffect(() => {
    // Correct way: Using setState inside a subscription
    const unsubscribe = store.subscribe(() => {
    return () => unsubscribe(); // Clean up the subscription on component unmount
  }, []);

  // ...

Another ubiquitous issue is tearing in concurrent React environments, where a component's render might be based on an outdated state due to interrupted rendering. A naive solution may attempt to force an update within the render phase itself, which further exacerbates tearing by introducing more inconsistencies. Instead, a well-designed solution leverages a synchronization mechanism such as useSyncExternalStore to manage component updates:

function useSyncedStore(store) {
  return useSyncExternalStore(
    store.getSnapshot // Assume this function provides the current state

In this instance, React takes care of synchronizing the state within its rendering lifecycle, preserving data consistency across your application. Are your components relying on a single, reliable source for their state? Have you audited your subscription mechanisms to prevent direct state mutations and embraced React's own lifecycle to manage updates? Contemplating these questions can guide developers towards robust synchronization strategies.

Lastly, we can't overlook the memory management aspect of store synchronization. Poor unsubscribe patterns can lead to memory leaks, degrading application performance. Always ensure that your store provides a reliable clean-up function and pair it with React's useEffect for safe subscription handling. Evaluate your current clean-up code: does it handle all edge cases, including rapid mounting and unmounting of components? Are effects optimized to avoid unnecessary re-subscriptions? Consider the following implementation:

function useStoreData(store) {
  const [data, setData] = useState(store.getSnapshot());

  useEffect(() => {
    // Efficient memory and update management with unsubscribe pattern
    const checkForUpdates = () => {
      const snapshot = store.getSnapshot();
      if (data !== snapshot) {
    const unsubscribe = store.subscribe(checkForUpdates);
    return () => {
      if (unsubscribe) unsubscribe(); // Ensures we clean up the subscription correctly.
  }, [store, data]);

  return data;

This code snippet reveals a reusable pattern for subscribing and securely managing state synchronization without introducing avoidable overhead. By continually auditing and evolving our code with these techniques, we enhance our applications' stability, leading to a more reliable and maintainable codebase.


The article explores the use of useSyncExternalStore, a powerful hook in React, for synchronizing with external stores in modern web development. It explains the mechanics and implementation of the hook, provides tips for performance optimization, and highlights advanced patterns and best practices. The key takeaway is the importance of managing state coherence and offering a smooth user experience. The challenging task for the reader is to review their implementation of the subscribe, getSnapshot, and getServerSnapshot functions in their React applications, ensuring they are properly memoized, pure, and handle server-side rendering correctly.