diff --git a/.github/workflows/test-multiple-versions.yml b/.github/workflows/test-multiple-versions.yml
index 63a4dc50ce..2e3fde13bd 100644
--- a/.github/workflows/test-multiple-versions.yml
+++ b/.github/workflows/test-multiple-versions.yml
@@ -24,7 +24,11 @@ jobs:
       - name: Test Default without Provider
         run: yarn test:ci
         env:
-          PROVIDER_LESS_MODE: 'true'
+          PROVIDER_MODE: 'PROVIDER_LESS'
+      - name: Test Default with Versioned Write
+        run: yarn test:ci
+        env:
+          PROVIDER_MODE: 'VERSIONED_WRITE'
 
   test_matrix:
     runs-on: ubuntu-latest
@@ -37,9 +41,10 @@ jobs:
           - 17.0.0
           - 18.0.0-rc.0
           - 0.0.0-experimental-aa8f2bdbc-20211215
-        mode: [withProvider, withoutProvider]
+        mode: [NORMAL, PROVIDER_LESS, VERSIONED_WRITE]
         testing: [default, alpha]
         exclude:
+          - { react: 16.8.6, mode: VERSIONED_WRITE }
           - { react: 16.8.6, testing: alpha }
           - { react: 16.9.0, testing: alpha }
           - { react: 17.0.0, testing: alpha }
@@ -71,4 +76,4 @@ jobs:
           yarn add -D react@${{ matrix.react }} react-dom@${{ matrix.react }}
           yarn test:ci
         env:
-          PROVIDER_LESS_MODE: ${{ matrix.mode == 'withoutProvider' }}
+          PROVIDER_MODE: ${{ matrix.mode }}
diff --git a/package.json b/package.json
index 9b49ac9283..c0f8c3c634 100644
--- a/package.json
+++ b/package.json
@@ -127,7 +127,7 @@
     "eslint": "eslint --fix '*.{js,json}' '{src,tests,benchmarks}/**/*.{ts,tsx}'",
     "eslint:ci": "eslint '*.{js,json}' '{src,tests,benchmarks}/**/*.{ts,tsx}'",
     "pretest": "tsc --noEmit",
-    "test": "jest && jest --setupFiles ./tests/setProviderLessMode.ts",
+    "test": "jest && jest --setupFiles ./tests/setProviderLessMode.ts && jest --setupFiles ./tests/setVersionedWriteMode.ts",
     "test:ci": "jest",
     "test:dev": "jest --watch --no-coverage",
     "test:coverage:watch": "jest --watch",
diff --git a/src/core/Provider.ts b/src/core/Provider.ts
index 3f344bd0ec..9e4fe18160 100644
--- a/src/core/Provider.ts
+++ b/src/core/Provider.ts
@@ -10,25 +10,55 @@ import type { Atom, Scope } from './atom'
 import { createScopeContainer, getScopeContext } from './contexts'
 import type { ScopeContainer } from './contexts'
 import {
+  COMMIT_ATOM,
   DEV_GET_ATOM_STATE,
   DEV_GET_MOUNTED,
   DEV_GET_MOUNTED_ATOMS,
   DEV_SUBSCRIBE_STATE,
 } from './store'
-import type { AtomState, Store } from './store'
+import type { AtomState, Store, VersionObject } from './store'
 
 export const Provider = ({
+  children,
   initialValues,
   scope,
-  children,
+  unstable_enableVersionedWrite,
 }: PropsWithChildren<{
   initialValues?: Iterable<readonly [Atom<unknown>, unknown]>
   scope?: Scope
+  /**
+   * This is an unstable experimental feature for React 18.
+   * When this is enabled, a) write function must be pure
+   * (read function must be pure regardless of this),
+   * b) React will show warning in DEV mode,
+   * c) then state branching works.
+   */
+  unstable_enableVersionedWrite?: boolean
 }>) => {
+  const [version, setVersion] = useState<VersionObject>()
+  useEffect(() => {
+    if (version) {
+      ;(scopeContainerRef.current as ScopeContainer).s[COMMIT_ATOM](
+        null,
+        version
+      )
+      delete version.p
+    }
+  }, [version])
+
   const scopeContainerRef = useRef<ScopeContainer>()
   if (!scopeContainerRef.current) {
     // lazy initialization
     scopeContainerRef.current = createScopeContainer(initialValues)
+    if (unstable_enableVersionedWrite) {
+      scopeContainerRef.current.w = (write) => {
+        setVersion((parentVersion) => {
+          const nextVersion = parentVersion ? { p: parentVersion } : {}
+          write(nextVersion)
+          return nextVersion
+        })
+      }
+    }
   }
 
   if (
@@ -79,7 +109,7 @@ const stateToPrintable = ([store, atoms]: [Store, Atom<unknown>[]]) =>
 // We keep a reference to the atoms in Provider's registeredAtoms in dev mode,
 // so atoms aren't garbage collected by the WeakMap of mounted atoms
 const useDebugState = (scopeContainer: ScopeContainer) => {
-  const store = scopeContainer.s
+  const { s: store } = scopeContainer
   const [atoms, setAtoms] = useState<Atom<unknown>[]>([])
   useEffect(() => {
     const callback = () => {
diff --git a/src/core/contexts.ts b/src/core/contexts.ts
index b6ffd541cc..e3feba2b05 100644
--- a/src/core/contexts.ts
+++ b/src/core/contexts.ts
@@ -4,8 +4,11 @@ import type { Atom, Scope } from './atom'
 import { createStore } from './store'
 import type { Store } from './store'
 
+type VersionedWrite = (write: (version?: object) => void) => void
+
 export type ScopeContainer = {
   s: Store
+  w?: VersionedWrite
 }
 
 export const createScopeContainer = (
diff --git a/src/core/store.ts b/src/core/store.ts
index 52e5978eec..986984fbc9 100644
--- a/src/core/store.ts
+++ b/src/core/store.ts
@@ -33,7 +33,9 @@ export type AtomState<Value = unknown> = {
   d: ReadDependencies
 } & ({ e: ReadError } | { p: SuspensePromise } | { v: ResolveType<Value> })
 
-type Listeners = Set<() => void>
+export type VersionObject = { p?: VersionObject } // "p"arent version
+
+type Listeners = Set<(version?: VersionObject) => void>
 type Dependents = Set<AnyAtom>
 type Mounted = {
   l: Listeners
@@ -61,7 +63,7 @@ export const DEV_GET_MOUNTED = 'm'
 export const createStore = (
   initialValues?: Iterable<readonly [AnyAtom, unknown]>
 ) => {
-  const atomStateMap = new WeakMap<AnyAtom, AtomState>()
+  const committedAtomStateMap = new WeakMap<AnyAtom, AtomState>()
   const mountedMap = new WeakMap<AnyAtom, Mounted>()
   const pendingMap = new Map<
     AnyAtom,
@@ -89,37 +91,119 @@ export const createStore = (
           )
         }
       }
-      atomStateMap.set(atom, atomState)
+      committedAtomStateMap.set(atom, atomState)
+    }
+  }
+
+  type SuspensePromiseCache = Map<VersionObject | undefined, SuspensePromise>
+  const suspensePromiseCacheMap = new WeakMap<AnyAtom, SuspensePromiseCache>()
+  const addSuspensePromiseToCache = (
+    version: VersionObject | undefined,
+    atom: AnyAtom,
+    suspensePromise: SuspensePromise
+  ): void => {
+    let cache = suspensePromiseCacheMap.get(atom)
+    if (!cache) {
+      cache = new Map()
+      suspensePromiseCacheMap.set(atom, cache)
+    }
+    suspensePromise.then(() => {
+      if ((cache as SuspensePromiseCache).get(version) === suspensePromise) {
+        ;(cache as SuspensePromiseCache).delete(version)
+        if (!(cache as SuspensePromiseCache).size) {
+          suspensePromiseCacheMap.delete(atom)
+        }
+      }
+    })
+    cache.set(version, suspensePromise)
+  }
+  const cancelAllSuspensePromiseInCache = (
+    atom: AnyAtom
+  ): Set<VersionObject | undefined> => {
+    const versionSet = new Set<VersionObject | undefined>()
+    const cache = suspensePromiseCacheMap.get(atom)
+    if (cache) {
+      suspensePromiseCacheMap.delete(atom)
+      cache.forEach((suspensePromise, version) => {
+        cancelSuspensePromise(suspensePromise)
+        versionSet.add(version)
+      })
+    }
+    return versionSet
+  }
+
+  const versionedAtomStateMapMap = new WeakMap<
+    VersionObject,
+    Map<AnyAtom, AtomState>
+  >()
+  const getVersionedAtomStateMap = (version: VersionObject) => {
+    let versionedAtomStateMap = versionedAtomStateMapMap.get(version)
+    if (!versionedAtomStateMap) {
+      versionedAtomStateMap = new Map()
+      versionedAtomStateMapMap.set(version, versionedAtomStateMap)
     }
+    return versionedAtomStateMap
   }
 
-  const getAtomState = <Value>(atom: Atom<Value>) =>
-    atomStateMap.get(atom) as AtomState<Value> | undefined
+  const getAtomState = <Value>(
+    version: VersionObject | undefined,
+    atom: Atom<Value>
+  ): AtomState<Value> | undefined => {
+    if (version) {
+      const versionedAtomStateMap = getVersionedAtomStateMap(version)
+      let atomState = versionedAtomStateMap.get(atom) as
+        | AtomState<Value>
+        | undefined
+      if (!atomState) {
+        atomState = getAtomState(version.p, atom)
+        if (atomState) {
+          if ('p' in atomState) {
+            atomState.p.then(() => versionedAtomStateMap.delete(atom))
+          }
+          versionedAtomStateMap.set(atom, atomState)
+        }
+      }
+      return atomState
+    }
+    return committedAtomStateMap.get(atom) as AtomState<Value> | undefined
+  }
 
   const setAtomState = <Value>(
+    version: VersionObject | undefined,
     atom: Atom<Value>,
     atomState: AtomState<Value>
   ): void => {
     if (typeof process === 'object' && process.env.NODE_ENV !== 'production') {
       Object.freeze(atomState)
     }
-    const prevAtomState = atomStateMap.get(atom)
-    atomStateMap.set(atom, atomState)
-    if (!pendingMap.has(atom)) {
-      pendingMap.set(atom, prevAtomState)
+    if (version) {
+      const versionedAtomStateMap = getVersionedAtomStateMap(version)
+      versionedAtomStateMap.set(atom, atomState)
+    } else {
+      const prevAtomState = committedAtomStateMap.get(atom)
+      committedAtomStateMap.set(atom, atomState)
+      if (!pendingMap.has(atom)) {
+        pendingMap.set(atom, prevAtomState)
+      }
     }
   }
 
-  const getReadDependencies = (dependencies: Set<AnyAtom>): ReadDependencies =>
-    new Map(Array.from(dependencies).map((a) => [a, getAtomState(a)?.r || 0]))
+  const getReadDependencies = (
+    version: VersionObject | undefined,
+    dependencies: Set<AnyAtom>
+  ): ReadDependencies =>
+    new Map(
+      Array.from(dependencies).map((a) => [a, getAtomState(version, a)?.r || 0])
+    )
 
   const setAtomValue = <Value>(
+    version: VersionObject | undefined,
     atom: Atom<Value>,
     value: ResolveType<Value>,
     dependencies?: Set<AnyAtom>,
     suspensePromise?: SuspensePromise
   ): AtomState<Value> => {
-    const atomState = getAtomState(atom)
+    const atomState = getAtomState(version, atom)
     if (atomState) {
       if (
         suspensePromise &&
@@ -137,7 +221,7 @@ export const createStore = (
       v: value,
       r: atomState?.r || 0,
       d: dependencies
-        ? getReadDependencies(dependencies)
+        ? getReadDependencies(version, dependencies)
         : atomState?.d || new Map(),
     }
     if (
@@ -150,17 +234,18 @@ export const createStore = (
         nextAtomState.d.set(atom, nextAtomState.r)
       }
     }
-    setAtomState(atom, nextAtomState)
+    setAtomState(version, atom, nextAtomState)
     return nextAtomState
   }
 
   const setAtomReadError = <Value>(
+    version: VersionObject | undefined,
     atom: Atom<Value>,
     error: ReadError,
     dependencies?: Set<AnyAtom>,
     suspensePromise?: SuspensePromise
   ): AtomState<Value> => {
-    const atomState = getAtomState(atom)
+    const atomState = getAtomState(version, atom)
     if (atomState) {
       if (
         suspensePromise &&
@@ -178,19 +263,20 @@ export const createStore = (
       e: error, // set read error
       r: atomState?.r || 0,
       d: dependencies
-        ? getReadDependencies(dependencies)
+        ? getReadDependencies(version, dependencies)
         : atomState?.d || new Map(),
     }
-    setAtomState(atom, nextAtomState)
+    setAtomState(version, atom, nextAtomState)
     return nextAtomState
   }
 
   const setAtomSuspensePromise = <Value>(
+    version: VersionObject | undefined,
     atom: Atom<Value>,
     suspensePromise: SuspensePromise,
     dependencies?: Set<AnyAtom>
   ): AtomState<Value> => {
-    const atomState = getAtomState(atom)
+    const atomState = getAtomState(version, atom)
     if (atomState && 'p' in atomState) {
       if (isEqualSuspensePromise(atomState.p, suspensePromise)) {
         // the same promise, not updating
@@ -198,18 +284,20 @@ export const createStore = (
       }
       cancelSuspensePromise(atomState.p)
     }
+    addSuspensePromiseToCache(version, atom, suspensePromise)
     const nextAtomState: AtomState<Value> = {
       p: suspensePromise,
       r: atomState?.r || 0,
       d: dependencies
-        ? getReadDependencies(dependencies)
+        ? getReadDependencies(version, dependencies)
         : atomState?.d || new Map(),
     }
-    setAtomState(atom, nextAtomState)
+    setAtomState(version, atom, nextAtomState)
     return nextAtomState
   }
 
   const setAtomPromiseOrValue = <Value>(
+    version: VersionObject | undefined,
     atom: Atom<Value>,
     promiseOrValue: Value,
     dependencies?: Set<AnyAtom>
@@ -218,8 +306,8 @@ export const createStore = (
       const suspensePromise = createSuspensePromise(
         promiseOrValue
           .then((value: ResolveType<Value>) => {
-            setAtomValue(atom, value, dependencies, suspensePromise)
-            flushPending()
+            setAtomValue(version, atom, value, dependencies, suspensePromise)
+            flushPending(version)
           })
           .catch((e) => {
             if (e instanceof Promise) {
@@ -229,31 +317,40 @@ export const createStore = (
               ) {
                 // schedule another read later
                 // FIXME not 100% confident with this code
-                e.then(() => readAtomState(atom, true))
+                e.then(() => readAtomState(version, atom, true))
               }
               return e
             }
-            setAtomReadError(atom, e, dependencies, suspensePromise)
-            flushPending()
+            setAtomReadError(version, atom, e, dependencies, suspensePromise)
+            flushPending(version)
           })
       )
-      return setAtomSuspensePromise(atom, suspensePromise, dependencies)
+      return setAtomSuspensePromise(
+        version,
+        atom,
+        suspensePromise,
+        dependencies
+      )
     }
     return setAtomValue(
+      version,
       atom,
       promiseOrValue as ResolveType<Value>,
       dependencies
     )
   }
 
-  const setAtomInvalidated = <Value>(atom: Atom<Value>): void => {
-    const atomState = getAtomState(atom)
+  const setAtomInvalidated = <Value>(
+    version: VersionObject | undefined,
+    atom: Atom<Value>
+  ): void => {
+    const atomState = getAtomState(version, atom)
     if (atomState) {
       const nextAtomState: AtomState<Value> = {
         ...atomState, // copy everything
         i: atomState.r, // set invalidated revision
       }
-      setAtomState(atom, nextAtomState)
+      setAtomState(version, atom, nextAtomState)
     } else if (
       typeof process === 'object' &&
       process.env.NODE_ENV !== 'production'
@@ -263,31 +360,32 @@ export const createStore = (
   }
 
   const readAtomState = <Value>(
+    version: VersionObject | undefined,
     atom: Atom<Value>,
     force?: boolean
   ): AtomState<Value> => {
     if (!force) {
-      const atomState = getAtomState(atom)
+      const atomState = getAtomState(version, atom)
       if (atomState) {
         atomState.d.forEach((_, a) => {
           if (a !== atom) {
             if (!mountedMap.has(a)) {
               // not mounted
-              readAtomState(a)
+              readAtomState(version, a)
             } else {
-              const aState = getAtomState(a)
+              const aState = getAtomState(version, a)
               if (
                 aState &&
                 aState.r === aState.i // revision is invalidated
               ) {
-                readAtomState(a)
+                readAtomState(version, a)
               }
             }
           }
         })
         if (
           Array.from(atomState.d.entries()).every(([a, r]) => {
-            const aState = getAtomState(a)
+            const aState = getAtomState(version, a)
             return (
               aState &&
               !('e' in aState) && // no read error
@@ -305,7 +403,9 @@ export const createStore = (
       const promiseOrValue = atom.read(<V>(a: Atom<V>) => {
         dependencies.add(a)
         const aState =
-          (a as AnyAtom) === atom ? getAtomState(a) : readAtomState(a)
+          (a as AnyAtom) === atom
+            ? getAtomState(version, a)
+            : readAtomState(version, a)
         if (aState) {
           if ('e' in aState) {
             throw aState.e // read error
@@ -321,18 +421,26 @@ export const createStore = (
         // NOTE invalid derived atoms can reach here
         throw new Error('no atom init')
       })
-      return setAtomPromiseOrValue(atom, promiseOrValue, dependencies)
+      return setAtomPromiseOrValue(version, atom, promiseOrValue, dependencies)
     } catch (errorOrPromise) {
       if (errorOrPromise instanceof Promise) {
         const suspensePromise = createSuspensePromise(errorOrPromise)
-        return setAtomSuspensePromise(atom, suspensePromise, dependencies)
+        return setAtomSuspensePromise(
+          version,
+          atom,
+          suspensePromise,
+          dependencies
+        )
       }
-      return setAtomReadError(atom, errorOrPromise, dependencies)
+      return setAtomReadError(version, atom, errorOrPromise, dependencies)
     }
   }
 
-  const readAtom = <Value>(readingAtom: Atom<Value>): AtomState<Value> => {
-    const atomState = readAtomState(readingAtom)
+  const readAtom = <Value>(
+    readingAtom: Atom<Value>,
+    version?: VersionObject
+  ): AtomState<Value> => {
+    const atomState = readAtomState(version, readingAtom)
     return atomState
   }
 
@@ -356,20 +464,25 @@ export const createStore = (
     }
   }
 
-  const invalidateDependents = <Value>(atom: Atom<Value>): void => {
+  const invalidateDependents = <Value>(
+    version: VersionObject | undefined,
+    atom: Atom<Value>
+  ): void => {
     const mounted = mountedMap.get(atom)
     mounted?.d.forEach((dependent) => {
       if (dependent !== atom) {
-        setAtomInvalidated(dependent)
-        invalidateDependents(dependent)
+        setAtomInvalidated(version, dependent)
+        invalidateDependents(version, dependent)
       }
     })
   }
 
   const writeAtomState = <Value, Update, Result extends void | Promise<void>>(
+    version: VersionObject | undefined,
     atom: WritableAtom<Value, Update, Result>,
     update: Update
   ): void | Promise<void> => {
+    let isSync = true
     const writeGetter: WriteGetter = <V>(
       a: Atom<V>,
       options?: {
@@ -380,7 +493,7 @@ export const createStore = (
         console.warn('[DEPRECATED] Please use { unstable_promise: true }')
         options = { unstable_promise: options }
       }
-      const aState = readAtomState(a)
+      const aState = readAtomState(version, a)
       if ('e' in aState) {
         throw aState.e // read error
       }
@@ -425,24 +538,35 @@ export const createStore = (
           // NOTE technically possible but restricted as it may cause bugs
           throw new Error('atom not writable')
         }
-        setAtomPromiseOrValue(a, v)
-        invalidateDependents(a)
-        flushPending()
+        const versionSet = cancelAllSuspensePromiseInCache(a)
+        versionSet.forEach((cancelledVersion) => {
+          if (cancelledVersion !== version) {
+            setAtomPromiseOrValue(cancelledVersion, a, v)
+          }
+        })
+        setAtomPromiseOrValue(version, a, v)
+        invalidateDependents(version, a)
       } else {
-        promiseOrVoid = writeAtomState(a as AnyWritableAtom, v)
+        promiseOrVoid = writeAtomState(version, a as AnyWritableAtom, v)
+      }
+      if (!isSync) {
+        flushPending(version)
       }
       return promiseOrVoid
     }
     const promiseOrVoid = atom.write(writeGetter, setter, update)
-    flushPending()
+    isSync = false
+    version = undefined
     return promiseOrVoid
   }
 
   const writeAtom = <Value, Update, Result extends void | Promise<void>>(
     writingAtom: WritableAtom<Value, Update, Result>,
-    update: Update
+    update: Update,
+    version?: VersionObject
   ): void | Promise<void> => {
-    const promiseOrVoid = writeAtomState(writingAtom, update)
+    const promiseOrVoid = writeAtomState(version, writingAtom, update)
+    flushPending(version)
     return promiseOrVoid
   }
 
@@ -463,7 +587,7 @@ export const createStore = (
       mountedAtoms.add(atom)
     }
     // mount read dependencies before onMount
-    const atomState = readAtomState(atom)
+    const atomState = readAtomState(undefined, atom)
     atomState.d.forEach((_, a) => {
       if (a !== atom) {
         const aMounted = mountedMap.get(a)
@@ -496,7 +620,7 @@ export const createStore = (
       mountedAtoms.delete(atom)
     }
     // unmount read dependencies afterward
-    const atomState = getAtomState(atom)
+    const atomState = getAtomState(undefined, atom)
     if (atomState) {
       atomState.d.forEach((_, a) => {
         if (a !== atom) {
@@ -547,11 +671,21 @@ export const createStore = (
     })
   }
 
-  const flushPending = (): void => {
+  const flushPending = (version: VersionObject | undefined): void => {
+    if (version) {
+      const versionedAtomStateMap = getVersionedAtomStateMap(version)
+      versionedAtomStateMap.forEach((atomState, atom) => {
+        if (atomState !== committedAtomStateMap.get(atom)) {
+          const mounted = mountedMap.get(atom)
+          mounted?.l.forEach((listener) => listener(version))
+        }
+      })
+      return
+    }
     const pending = Array.from(pendingMap)
     pendingMap.clear()
     pending.forEach(([atom, prevAtomState]) => {
-      const atomState = getAtomState(atom)
+      const atomState = getAtomState(undefined, atom)
       if (atomState && atomState.d !== prevAtomState?.d) {
         mountDependencies(atom, atomState, prevAtomState?.d || new Map())
       }
@@ -566,11 +700,30 @@ export const createStore = (
     })
   }
 
-  const commitAtom = (_atom: AnyAtom) => {
-    flushPending()
+  const commitVersionedAtomStateMap = (version: VersionObject) => {
+    const versionedAtomStateMap = getVersionedAtomStateMap(version)
+    versionedAtomStateMap.forEach((atomState, atom) => {
+      const prevAtomState = committedAtomStateMap.get(atom)
+      if (atomState.r > (prevAtomState?.r || 0)) {
+        committedAtomStateMap.set(atom, atomState)
+        if (atomState.d !== prevAtomState?.d) {
+          mountDependencies(atom, atomState, prevAtomState?.d || new Map())
+        }
+      }
+    })
+  }
+
+  const commitAtom = (_atom: AnyAtom | null, version?: VersionObject) => {
+    if (version) {
+      commitVersionedAtomStateMap(version)
+    }
+    flushPending(undefined)
   }
 
-  const subscribeAtom = (atom: AnyAtom, callback: () => void) => {
+  const subscribeAtom = (
+    atom: AnyAtom,
+    callback: (version?: VersionObject) => void
+  ) => {
     const mounted = addAtom(atom)
     const listeners = mounted.l
     listeners.add(callback)
@@ -581,15 +734,16 @@ export const createStore = (
   }
 
   const restoreAtoms = (
-    values: Iterable<readonly [AnyAtom, unknown]>
+    values: Iterable<readonly [AnyAtom, unknown]>,
+    version?: VersionObject
   ): void => {
     for (const [atom, value] of values) {
       if (hasInitialValue(atom)) {
-        setAtomPromiseOrValue(atom, value)
-        invalidateDependents(atom)
+        setAtomPromiseOrValue(version, atom, value)
+        invalidateDependents(version, atom)
       }
     }
-    flushPending()
+    flushPending(version)
   }
 
   if (typeof process === 'object' && process.env.NODE_ENV !== 'production') {
@@ -606,7 +760,7 @@ export const createStore = (
         }
       },
       [DEV_GET_MOUNTED_ATOMS]: () => mountedAtoms.values(),
-      [DEV_GET_ATOM_STATE]: (a: AnyAtom) => atomStateMap.get(a),
+      [DEV_GET_ATOM_STATE]: (a: AnyAtom) => committedAtomStateMap.get(a),
       [DEV_GET_MOUNTED]: (a: AnyAtom) => mountedMap.get(a),
     }
   }
diff --git a/src/core/suspensePromise.ts b/src/core/suspensePromise.ts
index 76245c3845..b64804eb6b 100644
--- a/src/core/suspensePromise.ts
+++ b/src/core/suspensePromise.ts
@@ -42,12 +42,12 @@ export const createSuspensePromise = (
     o: promise, // original promise
     c: null as (() => void) | null, // cancel promise
   }
-  const suspensePromise = new Promise<void>((resolve, reject) => {
+  const suspensePromise = new Promise<void>((resolve) => {
     objectToAttach.c = () => {
       objectToAttach.c = null
       resolve()
     }
-    promise.then(objectToAttach.c, reject)
+    promise.then(objectToAttach.c, objectToAttach.c)
   }) as SuspensePromise
   suspensePromise[SUSPENSE_PROMISE] = objectToAttach
   return suspensePromise
diff --git a/src/core/useAtom.ts b/src/core/useAtom.ts
index 10ec7c007c..b44312b8bf 100644
--- a/src/core/useAtom.ts
+++ b/src/core/useAtom.ts
@@ -5,9 +5,11 @@ import {
   useEffect,
   useReducer,
 } from 'react'
+import type { Reducer } from 'react'
 import type { Atom, Scope, SetAtom, WritableAtom } from './atom'
 import { getScopeContext } from './contexts'
 import { COMMIT_ATOM, READ_ATOM, SUBSCRIBE_ATOM, WRITE_ATOM } from './store'
+import type { VersionObject } from './store'
 
 type ResolveType<T> = T extends Promise<infer V> ? V : T
 
@@ -38,63 +40,76 @@ export function useAtom<Value, Update, Result extends void | Promise<void>>(
   }
 
   const ScopeContext = getScopeContext(scope)
-  const store = useContext(ScopeContext).s
+  const { s: store, w: versionedWrite } = useContext(ScopeContext)
 
-  const getAtomValue = useCallback(() => {
-    const atomState = store[READ_ATOM](atom)
-    if ('e' in atomState) {
-      throw atomState.e // read error
-    }
-    if ('p' in atomState) {
-      throw atomState.p // read promise
-    }
-    if ('v' in atomState) {
-      return atomState.v as ResolveType<Value>
-    }
-    throw new Error('no atom value')
-  }, [store, atom])
+  const getAtomValue = useCallback(
+    (version?: VersionObject) => {
+      const atomState = store[READ_ATOM](atom, version)
+      if ('e' in atomState) {
+        throw atomState.e // read error
+      }
+      if ('p' in atomState) {
+        throw atomState.p // read promise
+      }
+      if ('v' in atomState) {
+        return atomState.v as ResolveType<Value>
+      }
+      throw new Error('no atom value')
+    },
+    [store, atom]
+  )
 
-  const [[value, atomFromUseReducer], forceUpdate] = useReducer(
+  const [[version, value, atomFromUseReducer], dispatch] = useReducer<
+    Reducer<
+      readonly [VersionObject | undefined, ResolveType<Value>, Atom<Value>],
+      VersionObject | undefined
+    >,
+    undefined
+  >(
     useCallback(
-      (prev) => {
-        const nextValue = getAtomValue()
-        if (Object.is(prev[0], nextValue) && prev[1] === atom) {
+      (prev, nextVersion) => {
+        const nextValue = getAtomValue(nextVersion)
+        if (Object.is(prev[1], nextValue) && prev[2] === atom) {
           return prev // bail out
         }
-        return [nextValue, atom]
+        return [nextVersion, nextValue, atom]
       },
       [getAtomValue, atom]
     ),
     undefined,
     () => {
-      const initialValue = getAtomValue()
-      return [initialValue, atom]
+      // NOTE should/could branch on mount?
+      const initialVersion = undefined
+      const initialValue = getAtomValue(initialVersion)
+      return [initialVersion, initialValue, atom]
     }
   )
 
   if (atomFromUseReducer !== atom) {
-    forceUpdate()
+    dispatch(undefined)
   }
 
   useEffect(() => {
-    const unsubscribe = store[SUBSCRIBE_ATOM](atom, forceUpdate)
-    forceUpdate()
+    const unsubscribe = store[SUBSCRIBE_ATOM](atom, dispatch)
+    dispatch(undefined)
     return unsubscribe
   }, [store, atom])
 
   useEffect(() => {
-    store[COMMIT_ATOM](atom)
+    store[COMMIT_ATOM](atom, version)
   })
 
   const setAtom = useCallback(
     (update: Update) => {
       if (isWritable(atom)) {
-        return store[WRITE_ATOM](atom, update)
+        const write = (version?: VersionObject) =>
+          store[WRITE_ATOM](atom, update, version)
+        return versionedWrite ? versionedWrite(write) : write()
       } else {
         throw new Error('not writable atom')
       }
     },
-    [store, atom]
+    [store, versionedWrite, atom]
   )
 
   useDebugValue(value)
diff --git a/src/utils/useUpdateAtom.ts b/src/utils/useUpdateAtom.ts
index 23dbf874b4..0e92e89d0d 100644
--- a/src/utils/useUpdateAtom.ts
+++ b/src/utils/useUpdateAtom.ts
@@ -3,6 +3,7 @@ import { SECRET_INTERNAL_getScopeContext as getScopeContext } from 'jotai'
 import type { WritableAtom } from 'jotai'
 import type { Scope, SetAtom } from '../core/atom'
 import { WRITE_ATOM } from '../core/store'
+import type { VersionObject } from '../core/store'
 
 export function useUpdateAtom<
   Value,
@@ -10,10 +11,14 @@ export function useUpdateAtom<
   Result extends void | Promise<void>
 >(anAtom: WritableAtom<Value, Update, Result>, scope?: Scope) {
   const ScopeContext = getScopeContext(scope)
-  const store = useContext(ScopeContext).s
+  const { s: store, w: versionedWrite } = useContext(ScopeContext)
   const setAtom = useCallback(
-    (update: Update) => store[WRITE_ATOM](anAtom, update),
-    [store, anAtom]
+    (update: Update) => {
+      const write = (version?: VersionObject) =>
+        store[WRITE_ATOM](anAtom, update, version)
+      return versionedWrite ? versionedWrite(write) : write()
+    },
+    [store, versionedWrite, anAtom]
   )
   return setAtom as SetAtom<Update, Result>
 }
diff --git a/tests/async.test.tsx b/tests/async.test.tsx
index af69f77332..26f15c18a7 100644
--- a/tests/async.test.tsx
+++ b/tests/async.test.tsx
@@ -2,7 +2,7 @@ import { StrictMode, Suspense, useEffect, useRef } from 'react'
 import { fireEvent, render, waitFor } from '@testing-library/react'
 import { atom, useAtom } from 'jotai'
 import type { Atom } from 'jotai'
-import { getTestProvider } from './testUtils'
+import { getTestProvider, itSkipIfVersionedWrite } from './testUtils'
 
 const Provider = getTestProvider()
 
@@ -14,7 +14,7 @@ const useCommitCount = () => {
   return commitCountRef.current
 }
 
-it('does not show async stale result', async () => {
+itSkipIfVersionedWrite('does not show async stale result', async () => {
   const countAtom = atom(0)
   const asyncCountAtom = atom(async (get) => {
     await new Promise((r) => setTimeout(r, 100))
@@ -397,7 +397,8 @@ it('updates an async atom in child useEffect on remount', async () => {
   await findByText('count: 2')
 })
 
-it('async get and useEffect on parent', async () => {
+// It passes with React 18 though
+itSkipIfVersionedWrite('async get and useEffect on parent', async () => {
   const countAtom = atom(0)
   const asyncAtom = atom(async (get) => {
     const count = get(countAtom)
@@ -441,56 +442,60 @@ it('async get and useEffect on parent', async () => {
   })
 })
 
-it('async get with another dep and useEffect on parent', async () => {
-  const countAtom = atom(0)
-  const derivedAtom = atom((get) => get(countAtom))
-  const asyncAtom = atom(async (get) => {
-    const count = get(derivedAtom)
-    if (!count) return 'none'
-    return count
-  })
+// It passes with React 18 though
+itSkipIfVersionedWrite(
+  'async get with another dep and useEffect on parent',
+  async () => {
+    const countAtom = atom(0)
+    const derivedAtom = atom((get) => get(countAtom))
+    const asyncAtom = atom(async (get) => {
+      const count = get(derivedAtom)
+      if (!count) return 'none'
+      return count
+    })
 
-  const AsyncComponent = () => {
-    const [count] = useAtom(asyncAtom)
-    return <div>async: {count}</div>
-  }
+    const AsyncComponent = () => {
+      const [count] = useAtom(asyncAtom)
+      return <div>async: {count}</div>
+    }
 
-  const Parent = () => {
-    const [count, setCount] = useAtom(countAtom)
-    useEffect(() => {
-      setCount((c) => c + 1)
-    }, [setCount])
-    return (
+    const Parent = () => {
+      const [count, setCount] = useAtom(countAtom)
+      useEffect(() => {
+        setCount((c) => c + 1)
+      }, [setCount])
+      return (
+        <>
+          <div>count: {count}</div>
+          <button onClick={() => setCount((c) => c + 1)}>button</button>
+          <AsyncComponent />
+        </>
+      )
+    }
+
+    const { getByText, findByText } = render(
       <>
-        <div>count: {count}</div>
-        <button onClick={() => setCount((c) => c + 1)}>button</button>
-        <AsyncComponent />
+        <Provider>
+          <Suspense fallback="loading">
+            <Parent />
+          </Suspense>
+        </Provider>
       </>
     )
-  }
 
-  const { getByText, findByText } = render(
-    <>
-      <Provider>
-        <Suspense fallback="loading">
-          <Parent />
-        </Suspense>
-      </Provider>
-    </>
-  )
-
-  await findByText('loading')
-  await waitFor(() => {
-    getByText('count: 1')
-    getByText('async: 1')
-  })
+    await findByText('loading')
+    await waitFor(() => {
+      getByText('count: 1')
+      getByText('async: 1')
+    })
 
-  fireEvent.click(getByText('button'))
-  await waitFor(() => {
-    getByText('count: 2')
-    getByText('async: 2')
-  })
-})
+    fireEvent.click(getByText('button'))
+    await waitFor(() => {
+      getByText('count: 2')
+      getByText('async: 2')
+    })
+  }
+)
 
 it('set promise atom value on write (#304)', async () => {
   const countAtom = atom(Promise.resolve(0))
@@ -840,7 +845,8 @@ it('combine two promise atom values (#442)', async () => {
   await findByText('count: 3')
 })
 
-it('set two promise atoms at once', async () => {
+// FIXME will revisit this after react 18, feel free to tackle this
+itSkipIfVersionedWrite('set two promise atoms at once', async () => {
   const count1Atom = atom(new Promise<number>(() => {}))
   const count2Atom = atom(new Promise<number>(() => {}))
   const derivedAtom = atom((get) => get(count1Atom) + get(count2Atom))
diff --git a/tests/error.test.tsx b/tests/error.test.tsx
index ac5cba988d..5befd3749a 100644
--- a/tests/error.test.tsx
+++ b/tests/error.test.tsx
@@ -1,7 +1,7 @@
 import { Component, Suspense, useEffect, useState } from 'react'
 import { fireEvent, render, waitFor } from '@testing-library/react'
 import { atom, useAtom } from 'jotai'
-import { getTestProvider } from './testUtils'
+import { getTestProvider, itSkipIfVersionedWrite } from './testUtils'
 
 const Provider = getTestProvider()
 
@@ -231,7 +231,7 @@ it('can throw an error in async read function', async () => {
   await findByText('errored')
 })
 
-it('can throw an error in write function', async () => {
+itSkipIfVersionedWrite('can throw an error in write function', async () => {
   const countAtom = atom(0)
   const errorAtom = atom(
     (get) => get(countAtom),
@@ -271,97 +271,103 @@ it('can throw an error in write function', async () => {
   expect(errorMessages).toContain('Error: error_in_write_function')
 })
 
-it('can throw an error in async write function', async () => {
-  const countAtom = atom(0)
-  const errorAtom = atom(
-    (get) => get(countAtom),
-    async () => {
-      throw new Error('error_in_async_write_function')
-    }
-  )
-
-  const Counter = () => {
-    const [count, dispatch] = useAtom(errorAtom)
-    const onClick = async () => {
-      try {
-        await dispatch()
-      } catch (e) {
-        console.error(e)
+itSkipIfVersionedWrite(
+  'can throw an error in async write function',
+  async () => {
+    const countAtom = atom(0)
+    const errorAtom = atom(
+      (get) => get(countAtom),
+      async () => {
+        throw new Error('error_in_async_write_function')
       }
-    }
-    return (
-      <>
-        <div>count: {count}</div>
-        <div>no error</div>
-        <button onClick={onClick}>button</button>
-      </>
     )
-  }
 
-  const { getByText, findByText } = render(
-    <Provider>
-      <Suspense fallback={null}>
-        <Counter />
-      </Suspense>
-    </Provider>
-  )
+    const Counter = () => {
+      const [count, dispatch] = useAtom(errorAtom)
+      const onClick = async () => {
+        try {
+          await dispatch()
+        } catch (e) {
+          console.error(e)
+        }
+      }
+      return (
+        <>
+          <div>count: {count}</div>
+          <div>no error</div>
+          <button onClick={onClick}>button</button>
+        </>
+      )
+    }
 
-  await findByText('no error')
-  expect(errorMessages).not.toContain('Error: error_in_async_write_function')
+    const { getByText, findByText } = render(
+      <Provider>
+        <Suspense fallback={null}>
+          <Counter />
+        </Suspense>
+      </Provider>
+    )
 
-  fireEvent.click(getByText('button'))
-  await waitFor(() => {
-    expect(errorMessages).toContain('Error: error_in_async_write_function')
-  })
-})
+    await findByText('no error')
+    expect(errorMessages).not.toContain('Error: error_in_async_write_function')
 
-it('can throw a chained error in write function', async () => {
-  const countAtom = atom(0)
-  const errorAtom = atom(
-    (get) => get(countAtom),
-    () => {
-      throw new Error('chained_err_in_write')
-    }
-  )
-  const chainedAtom = atom(
-    (get) => get(errorAtom),
-    (_get, set) => {
-      set(errorAtom, null)
-    }
-  )
+    fireEvent.click(getByText('button'))
+    await waitFor(() => {
+      expect(errorMessages).toContain('Error: error_in_async_write_function')
+    })
+  }
+)
+
+itSkipIfVersionedWrite(
+  'can throw a chained error in write function',
+  async () => {
+    const countAtom = atom(0)
+    const errorAtom = atom(
+      (get) => get(countAtom),
+      () => {
+        throw new Error('chained_err_in_write')
+      }
+    )
+    const chainedAtom = atom(
+      (get) => get(errorAtom),
+      (_get, set) => {
+        set(errorAtom, null)
+      }
+    )
 
-  const Counter = () => {
-    const [count, dispatch] = useAtom(chainedAtom)
-    const onClick = () => {
-      try {
-        dispatch()
-      } catch (e) {
-        console.error(e)
+    const Counter = () => {
+      const [count, dispatch] = useAtom(chainedAtom)
+      const onClick = () => {
+        try {
+          dispatch()
+        } catch (e) {
+          console.error(e)
+        }
       }
+      return (
+        <>
+          <div>count: {count}</div>
+          <div>no error</div>
+          <button onClick={onClick}>button</button>
+        </>
+      )
     }
-    return (
-      <>
-        <div>count: {count}</div>
-        <div>no error</div>
-        <button onClick={onClick}>button</button>
-      </>
-    )
-  }
 
-  const { getByText, findByText } = render(
-    <Provider>
-      <Counter />
-    </Provider>
-  )
+    const { getByText, findByText } = render(
+      <Provider>
+        <Counter />
+      </Provider>
+    )
 
-  await findByText('no error')
-  expect(errorMessages).not.toContain('Error: chained_err_in_write')
+    await findByText('no error')
+    expect(errorMessages).not.toContain('Error: chained_err_in_write')
 
-  fireEvent.click(getByText('button'))
-  expect(errorMessages).toContain('Error: chained_err_in_write')
-})
+    fireEvent.click(getByText('button'))
+    expect(errorMessages).toContain('Error: chained_err_in_write')
+  }
+)
 
-it('throws an error while updating in effect', async () => {
+itSkipIfVersionedWrite('throws an error while updating in effect', async () => {
   const countAtom = atom(0)
 
   const Counter = () => {
@@ -428,7 +434,7 @@ describe('throws an error while updating in effect cleanup', () => {
     )
   }
 
-  it('single setCount', async () => {
+  itSkipIfVersionedWrite('single setCount', async () => {
     const { getByText, findByText } = render(
       <Provider>
         <ErrorBoundary>
@@ -448,7 +454,7 @@ describe('throws an error while updating in effect cleanup', () => {
     )
   })
 
-  it('dobule setCount', async () => {
+  itSkipIfVersionedWrite('dobule setCount', async () => {
     doubleSetCount = true
 
     const { getByText, findByText } = render(
diff --git a/tests/provider.test.tsx b/tests/provider.test.tsx
index 868139a6c3..f7225ea764 100644
--- a/tests/provider.test.tsx
+++ b/tests/provider.test.tsx
@@ -1,7 +1,8 @@
 import { render, waitFor } from '@testing-library/react'
-import { Provider, atom, useAtom } from 'jotai'
+import { atom, useAtom } from 'jotai'
+import { getTestProvider } from './testUtils'
 
-// No PROVIDER_LESS_MODE test for this file, obviously.
+const Provider = getTestProvider(true)
 
 it('uses initial values from provider', async () => {
   const countAtom = atom(1)
diff --git a/tests/setProviderLessMode.ts b/tests/setProviderLessMode.ts
index ba5fab156c..38014b4ceb 100644
--- a/tests/setProviderLessMode.ts
+++ b/tests/setProviderLessMode.ts
@@ -1 +1 @@
-process.env.PROVIDER_LESS_MODE = 'true'
+process.env.PROVIDER_MODE = 'PROVIDER_LESS'
diff --git a/tests/setVersionedWriteMode.ts b/tests/setVersionedWriteMode.ts
new file mode 100644
index 0000000000..15afd37c01
--- /dev/null
+++ b/tests/setVersionedWriteMode.ts
@@ -0,0 +1 @@
+process.env.PROVIDER_MODE = 'VERSIONED_WRITE'
diff --git a/tests/testUtils.ts b/tests/testUtils.ts
index f51e269afb..81052f7133 100644
--- a/tests/testUtils.ts
+++ b/tests/testUtils.ts
@@ -1,11 +1,29 @@
+import { createElement } from 'react'
 import { Provider } from 'jotai'
 
-export function getTestProvider() {
-  if (process.env.PROVIDER_LESS_MODE === 'true') {
+export function getTestProvider(requiresProvider?: boolean) {
+  if (!requiresProvider && process.env.PROVIDER_MODE === 'PROVIDER_LESS') {
     if (process.env.CI) {
-      console.log('TESTING WITH PROVIDER_LESS_MODE')
+      console.log('TESTING WITH PROVIDER_LESS MODE')
     }
-    return (props: any) => props.children
+    return ({ children }: any) => children
+  }
+  if (process.env.PROVIDER_MODE === 'VERSIONED_WRITE') {
+    if (process.env.CI) {
+      console.log('TESTING WITH VERSIONED_WRITE MODE')
+    }
+    return ({ children, ...props }: any) =>
+      createElement(
+        Provider,
+        {
+          ...props,
+          unstable_enableVersionedWrite: true,
+        },
+        children
+      )
   }
   return Provider
 }
+
+export const itSkipIfVersionedWrite =
+  process.env.PROVIDER_MODE === 'VERSIONED_WRITE' ? it.skip : it