diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+# effectful-2.2.1.0 (2022-11-09)
+* Add `localSeqLift` and `localLift` to `Effectful.Dispatch.Dynamic`.
+
 # effectful-2.2.0.0 (2022-10-24)
 * Change `PrimState` for `Eff` from `RealWorld` to `PrimStateEff` to prevent the
   `Prim` effect from executing arbitrary `IO` actions via `ioToPrim`.
@@ -28,5 +31,5 @@
   `withEffToIO`.
 * Add `withReader`.
 
-# effectful-1.0.0.0 (2021-07-13)
+# effectful-1.0.0.0 (2022-07-13)
 * Initial release.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -40,10 +40,11 @@
 [polysemy](https://hackage.haskell.org/package/polysemy),
 [eff](https://github.com/hasura/eff) and probably a few more.
 
-Unfortunately, of all of them only `eff` is a promising proposition because of
-reasonable performance characteristics (see the talk [Effects for
-Less](https://www.youtube.com/watch?v=0jI-AlWEwYI) for more information) and
-potential for good interoperability with the existing ecosystem.
+It needs to be noted that of all of them only the work-in-progress `eff` library
+is a promising proposition because of reasonable performance characteristics
+(see the talk [Effects for Less](https://www.youtube.com/watch?v=0jI-AlWEwYI)
+for more information) and potential for good interoperability with the existing
+ecosystem.
 
 The second point is arguably the most important, because it allows focusing on
 things that matter instead of reinventing all kinds of wheels, hence being a
@@ -88,8 +89,8 @@
 
 What is more, the `Eff` monad is concrete, so GHC has many possibilities for
 optimization, which results in a very fast code at a default optimization
-level. There is no need to mark every function `INLINE` or enable additional
-optimization passes, it just works.
+level. There is no need to explicitly mark functions with `INLINE` pragmas or
+enable additional optimization passes, it just works.
 
 ### Any downsides?
 
@@ -117,36 +118,43 @@
 
 ### Summary
 
-`effectful` is an extensible effects library that aims to replace "boring"
-transformer stacks (which consist of a dozen of newtype'd `ExceptT`, `ReaderT`,
-`StateT` and `WriterT` transformers) and their derivatives by providing
-equivalent effects with improved semantics, performance and usability (it also
-makes it easy to reuse them for your own effects). It doesn't try to make monad
-transformers obsolete, so you're free to use it with `ConduitT`, `ContT`,
-`ListT` etc. when necessary.
+`effectful` is an extensible effects library that aims to be the replacement
+for:
 
+- The bare `ReaderT` pattern by being essentially its enriched version.
+
+- Monad transformer stacks typically encountered in the wild (i.e. consisting of
+  a dozen of newtype'd `ExceptT`, `ReaderT`, `StateT` and `WriterT` transformers
+  and their derivatives) by providing equivalent effects with improved
+  semantics, performance, usability and making it easy to reuse them for your
+  own effects.
+
+It doesn't try to make monad transformers obsolete, so you're free to
+use it with `ConduitT`, `ContT`, `ListT` etc. when necessary.
+
 ## Package structure
 
-The effect system is split among several libraries:
+The library is split among several packages:
 
 - The [`effectful-core`](https://hackage.haskell.org/package/effectful-core)
-  library contains the core of the effect system along with the basic
-  effects. It aims for a small dependency footprint and provides building blocks
-  for more advanced effects.
+  package contains the core of the library along with basic effects. It aims for
+  a small dependency footprint and provides building blocks for more advanced
+  effects.
 
 - The [`effectful-plugin`](https://hackage.haskell.org/package/effectful-plugin)
-  library provides an optional GHC plugin for improving disambiguation of
+  package provides an optional GHC plugin for improving disambiguation of
   effects (see
   [here](https://github.com/haskell-effectful/effectful/blob/master/effectful-plugin/README.md)
   for more information).
 
-- The [`effectful-th`](https://hackage.haskell.org/package/effectful-th) library
+- The [`effectful-th`](https://hackage.haskell.org/package/effectful-th) package
   provides utilities for generating bits of effect-related boilerplate via
   Template Haskell.
 
-- The [`effectful`](https://hackage.haskell.org/package/effectful) library
+- The [`effectful`](https://hackage.haskell.org/package/effectful) package
   re-exports public modules of `effectful-core` and additionally provides most
-  features of the `unliftio` library divided into appropriate effects.
+  features of the [`unliftio`](https://hackage.haskell.org/package/unliftio)
+  package divided into appropriate effects.
 
 ## Example
 
diff --git a/effectful.cabal b/effectful.cabal
--- a/effectful.cabal
+++ b/effectful.cabal
@@ -1,7 +1,7 @@
 cabal-version:      2.4
 build-type:         Simple
 name:               effectful
-version:            2.2.0.0
+version:            2.2.1.0
 license:            BSD-3-Clause
 license-file:       LICENSE
 category:           Control
@@ -67,7 +67,7 @@
                     , async               >= 2.2.2
                     , bytestring          >= 0.10
                     , directory           >= 1.3.2
-                    , effectful-core      >= 2.2.0.0   && < 2.2.1.0
+                    , effectful-core      >= 2.2.1.0   && < 2.2.2.0
                     , process             >= 1.6.9
 
                     , time                >= 1.9.2