diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog for `in-other-words`
 
+## 0.2.1.1 (2022-06-15)
+### Non-breaking Changes
+* GHC 9.2.3 compatiblity
+
 ## 0.2.1.0 (2021-11-05)
 ### Non-breaking Changes
 * Added `hoistSteps`
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -3,7 +3,8 @@
 [![build GHC 8.6](https://github.com/KingoftheHomeless/in-other-words/workflows/build%20GHC%208.6/badge.svg)](https://github.com/KingoftheHomeless/in-other-words/actions?query=workflow%3A%22build+GHC+8.6%22)
 [![build GHC 8.8](https://github.com/KingoftheHomeless/in-other-words/workflows/build%20GHC%208.8/badge.svg)](https://github.com/KingoftheHomeless/in-other-words/actions?query=workflow%3A%22build+GHC+8.8%22)
 [![build GHC 8.10](https://github.com/KingoftheHomeless/in-other-words/workflows/build%20GHC%208.10/badge.svg)](https://github.com/KingoftheHomeless/in-other-words/actions?query=workflow%3A%22build+GHC+8.10%22)
-[![build GHC 9.0.1](https://github.com/KingoftheHomeless/in-other-words/workflows/build%20GHC%209.0.1/badge.svg)](https://github.com/KingoftheHomeless/in-other-words/actions?query=workflow%3A%22build+GHC+9.0.1%22)
+[![build GHC 9.0.2](https://github.com/KingoftheHomeless/in-other-words/workflows/build%20GHC%209.0.2/badge.svg)](https://github.com/KingoftheHomeless/in-other-words/actions?query=workflow%3A%22build+GHC+9.0.2%22)
+[![build GHC 9.2.3](https://github.com/KingoftheHomeless/in-other-words/workflows/build%20GHC%209.2.3/badge.svg)](https://github.com/KingoftheHomeless/in-other-words/actions?query=workflow%3A%22build+GHC+9.2.3%22)
 
 - [Overview][]
 - [Features][]
diff --git a/in-other-words.cabal b/in-other-words.cabal
--- a/in-other-words.cabal
+++ b/in-other-words.cabal
@@ -4,16 +4,16 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 63c053f88fc44761f95d97eedcd3be8a6130b0202778be539bab361549d74523
+-- hash: cb8b99f7f5a97bd2225716b40c6c61d182c84c8f61b047561eff935b7da2e482
 
 name:           in-other-words
-version:        0.2.1.0
+version:        0.2.1.1
 synopsis:       A higher-order effect system where the sky's the limit
 description:    A low-boilerplate effect system with easy higher-order effects and very high expressive power
 category:       Control
 homepage:       https://github.com/KingoftheHomeless/in-other-words#readme
 author:         Love Waern
-maintainer:     combiner8761@gmail.com
+maintainer:     love.waern@gmail.com
 copyright:      BSD3
 license:        BSD3
 license-file:   LICENSE
diff --git a/src/Control/Effect/Carrier/Internal/Compose.hs b/src/Control/Effect/Carrier/Internal/Compose.hs
--- a/src/Control/Effect/Carrier/Internal/Compose.hs
+++ b/src/Control/Effect/Carrier/Internal/Compose.hs
@@ -16,7 +16,7 @@
 import Unsafe.Coerce
 
 -- | Composition of monad/carrier transformers.
-newtype ComposeT t (u :: (* -> *) -> * -> *) m a = ComposeT {
+newtype ComposeT t (u :: (Type -> Type) -> Type -> Type) m a = ComposeT {
     getComposeT :: t (u m) a
   }
   deriving ( Functor, Applicative, Monad
@@ -135,13 +135,13 @@
 -- such as InterpretSimpleC.
 --
 -- So only with a left fold can we guarantee that the unsafeCoerce in runComposition is safe.
-type family CompositionBaseT' acc ts :: (* -> *) -> * -> * where
+type family CompositionBaseT' acc ts :: (Type -> Type) -> Type -> Type where
   CompositionBaseT' acc '[] = acc
   CompositionBaseT' acc (t ': ts) = CompositionBaseT' (ComposeT acc t) ts
 
 type CompositionBaseT ts = CompositionBaseT' IdentityT ts
 
-type family CompositionBaseM (ts :: [(* -> *) -> * -> *]) (m :: * -> *) where
+type family CompositionBaseM (ts :: [(Type -> Type) -> Type -> Type]) (m :: Type -> Type) where
   CompositionBaseM '[] m = m
   CompositionBaseM (t ': ts) m = t (CompositionBaseM ts m)
 
diff --git a/src/Control/Effect/Carrier/Internal/Interpret.hs b/src/Control/Effect/Carrier/Internal/Interpret.hs
--- a/src/Control/Effect/Carrier/Internal/Interpret.hs
+++ b/src/Control/Effect/Carrier/Internal/Interpret.hs
@@ -32,11 +32,11 @@
 
 newtype
     HandlerC
-      (sHandler :: *)
-      (sReform :: *)
+      (sHandler :: Type)
+      (sReform :: Type)
       (r :: [Effect])
       (p :: [Effect])
-      (m :: * -> *) z (a :: *)
+      (m :: Type -> Type) z (a :: Type)
   = HandlerC { unHandlerC :: z a }
   deriving (Functor, Applicative, Monad) via z
 
@@ -94,7 +94,7 @@
       HandlerC (n m)
   {-# INLINE liftBase #-}
 
-newtype InterpretPrimC (s :: *) (e :: Effect) (m :: * -> *) a =
+newtype InterpretPrimC (s :: Type) (e :: Effect) (m :: Type -> Type) a =
   InterpretPrimC {
       unInterpretPrimC :: m a
     }
@@ -125,7 +125,7 @@
 class ( RepresentationalEff e
       , Carrier m
       )
-   => Handler (h :: *) e m where
+   => Handler (h :: Type) e m where
   effHandler :: EffHandler e m
 
 
@@ -204,7 +204,7 @@
 -- See 'EffPrimHandler'.
 class ( RepresentationalEff e
       , Carrier m
-      ) => PrimHandler (h :: *) e m where
+      ) => PrimHandler (h :: Type) e m where
   effPrimHandler :: EffPrimHandler e m
 
 instance ( Carrier m
@@ -229,7 +229,7 @@
     InterpretC $ unItself $ runEffly $ effHandler @h @e (coerce e)
   {-# INLINEABLE algDerivs #-}
 
-newtype InterpretC (h :: *) (e :: Effect) (m :: * -> *) a = InterpretC {
+newtype InterpretC (h :: Type) (e :: Effect) (m :: Type -> Type) a = InterpretC {
       unInterpretC :: m a
     }
   deriving ( Functor, Applicative, Monad
@@ -275,7 +275,7 @@
       (coerceHandler (effPrimHandler @h @e @m))
   {-# INLINEABLE algDerivs #-}
 
-data ViaReifiedH (s :: *)
+data ViaReifiedH (s :: Type)
 
 instance ( RepresentationalEff e
          , Carrier m
@@ -303,7 +303,7 @@
    . ReifiesPrimHandler s e m
   => InterpretPrimC (ViaReifiedH s) e m a
 
-newtype InterpretSimpleC (e :: Effect) (m :: * -> *) a = InterpretSimpleC {
+newtype InterpretSimpleC (e :: Effect) (m :: Type -> Type) a = InterpretSimpleC {
       unInterpretSimpleC :: ReaderT (ReifiedHandler e m) m a
     }
   deriving ( Functor, Applicative, Monad
@@ -337,7 +337,7 @@
         handler (coerce e)
   {-# INLINEABLE reformulate #-}
 
-newtype InterpretPrimSimpleC (e :: Effect) (m :: * -> *) a =
+newtype InterpretPrimSimpleC (e :: Effect) (m :: Type -> Type) a =
     InterpretPrimSimpleC {
       unInterpretPrimSimpleC :: ReaderT (ReifiedPrimHandler e m) m a
     }
diff --git a/src/Control/Effect/Carrier/Internal/Intro.hs b/src/Control/Effect/Carrier/Internal/Intro.hs
--- a/src/Control/Effect/Carrier/Internal/Intro.hs
+++ b/src/Control/Effect/Carrier/Internal/Intro.hs
@@ -18,7 +18,7 @@
 
 newtype IntroC (top :: [Effect])
                (new :: [Effect])
-               (m :: * -> *)
+               (m :: Type -> Type)
                a
     = IntroC { runIntroC :: m a }
   deriving ( Functor, Applicative, Monad
diff --git a/src/Control/Effect/Debug.hs b/src/Control/Effect/Debug.hs
--- a/src/Control/Effect/Debug.hs
+++ b/src/Control/Effect/Debug.hs
@@ -2,11 +2,12 @@
 module Control.Effect.Debug where
 
 import Control.Effect.Carrier
+import Data.Kind (Type)
 import GHC.TypeLits
 
 -- Type family needed to delay the TypeError until when 'debugEffects'
 -- is used.
-type family DebugEffects (m :: * -> *) :: k where
+type family DebugEffects (m :: Type -> Type) :: k where
   DebugEffects m = TypeError (     'Text "Control.Effect.Debug.debugEffects"
                              ':$$: 'Text "Derivs: " ':<>: 'ShowType (Derivs m)
                              ':$$: 'Text "Prims:  " ':<>: 'ShowType (Prims m)
diff --git a/src/Control/Effect/Internal.hs b/src/Control/Effect/Internal.hs
--- a/src/Control/Effect/Internal.hs
+++ b/src/Control/Effect/Internal.hs
@@ -142,7 +142,7 @@
 send = algDerivs . inj
 {-# INLINE send #-}
 
-deriving via (m :: * -> *) instance Carrier m => Carrier (IdentityT m)
+deriving via (m :: Type -> Type) instance Carrier m => Carrier (IdentityT m)
 
 -- | A constraint that @'Prims' m@ satisfies all the constraints in the list
 -- @cs@.
diff --git a/src/Control/Effect/Internal/Exceptional.hs b/src/Control/Effect/Internal/Exceptional.hs
--- a/src/Control/Effect/Internal/Exceptional.hs
+++ b/src/Control/Effect/Internal/Exceptional.hs
@@ -71,7 +71,7 @@
 which is just noise in this case.
 -}
 
-newtype ExceptionallyC (eff :: Effect) (exc :: *) m a = ExceptionallyC {
+newtype ExceptionallyC (eff :: Effect) (exc :: Type) m a = ExceptionallyC {
     unExceptionallyC :: m a
   }
   deriving ( Functor, Applicative, Monad
diff --git a/src/Control/Effect/Internal/Newtype.hs b/src/Control/Effect/Internal/Newtype.hs
--- a/src/Control/Effect/Internal/Newtype.hs
+++ b/src/Control/Effect/Internal/Newtype.hs
@@ -27,7 +27,7 @@
 newtype WrapC (e :: Effect)
               (e' :: Effect)
               m
-              (a :: *) = WrapC { unWrapC :: m a }
+              (a :: Type) = WrapC { unWrapC :: m a }
   deriving ( Functor, Applicative, Monad
            , Alternative, MonadPlus
            , MonadFix, MonadFail, MonadIO
@@ -89,7 +89,7 @@
 
 newtype UnwrapC (e :: Effect)
                 m
-                (a :: *) = UnwrapC { unUnwrapC :: m a }
+                (a :: Type) = UnwrapC { unUnwrapC :: m a }
   deriving ( Functor, Applicative, Monad
            , Alternative, MonadPlus
            , MonadFix, MonadFail, MonadIO
@@ -119,7 +119,7 @@
 
 newtype UnwrapTopC (e :: Effect)
                 m
-                (a :: *) = UnwrapTopC { unUnwrapTopC :: m a }
+                (a :: Type) = UnwrapTopC { unUnwrapTopC :: m a }
   deriving ( Functor, Applicative, Monad
            , Alternative, MonadPlus
            , MonadFix, MonadFail, MonadIO
diff --git a/src/Control/Effect/Internal/Optional.hs b/src/Control/Effect/Internal/Optional.hs
--- a/src/Control/Effect/Internal/Optional.hs
+++ b/src/Control/Effect/Internal/Optional.hs
@@ -12,6 +12,7 @@
 
 import Control.Effect.Type.Optional
 
+import Data.Kind (Type)
 
 newtype HoistOptionCall b a = HoistOptionCall (forall x. (a -> x) -> b x -> b x)
   deriving (Functor)
@@ -19,7 +20,7 @@
 -- | A useful specialization of 'Optional' where the functor is
 -- @'HoistOptionCall' b@. From this, you can derive
 -- 'Control.Effect.Optional.hoistOption'.
-type HoistOption (b :: * -> *) = Optional (HoistOptionCall b)
+type HoistOption (b :: Type -> Type) = Optional (HoistOptionCall b)
 
 data HoistOptionH
 
diff --git a/src/Control/Effect/Internal/Reflection.hs b/src/Control/Effect/Internal/Reflection.hs
--- a/src/Control/Effect/Internal/Reflection.hs
+++ b/src/Control/Effect/Internal/Reflection.hs
@@ -8,6 +8,7 @@
   ) where
 
 import Unsafe.Coerce
+import Data.Kind (Type)
 import Data.Proxy
 
 newtype Tagged s a = Tagged { getTagged :: a }
@@ -24,10 +25,10 @@
 newtype Magic a r = Magic (Reifies Skolem a => Tagged Skolem r)
 
 
-reifyTagged :: forall a r. a -> (forall (s :: *). Reifies s a => Tagged s r) -> r
+reifyTagged :: forall a r. a -> (forall (s :: Type). Reifies s a => Tagged s r) -> r
 reifyTagged a k = unsafeCoerce (Magic k :: Magic a r) a
 {-# INLINE reifyTagged #-}
 
-reify :: forall a r. a -> (forall (s :: *) pr. (pr ~ Proxy, Reifies s a) => pr s -> r) -> r
+reify :: forall a r. a -> (forall (s :: Type) pr. (pr ~ Proxy, Reifies s a) => pr s -> r) -> r
 reify a k = reifyTagged a (unproxy k)
 {-# INLINE reify #-}
diff --git a/src/Control/Effect/Internal/Regional.hs b/src/Control/Effect/Internal/Regional.hs
--- a/src/Control/Effect/Internal/Regional.hs
+++ b/src/Control/Effect/Internal/Regional.hs
@@ -11,12 +11,14 @@
 
 import Control.Monad.Trans.Control
 
+import Data.Kind (Type)
+
 newtype HoistCall b = HoistCall (forall x. b x -> b x)
 
 -- | A useful specialization of 'Regional' where the
 -- constant type is @'HoistCall' b@. From this,
 -- you can derive 'Control.Effect.Regional.hoist'.
-type Hoist (b :: * -> *) = Regional (HoistCall b)
+type Hoist (b :: Type -> Type) = Regional (HoistCall b)
 
 data HoistH
 
diff --git a/src/Control/Effect/Internal/Union.hs b/src/Control/Effect/Internal/Union.hs
--- a/src/Control/Effect/Internal/Union.hs
+++ b/src/Control/Effect/Internal/Union.hs
@@ -21,7 +21,7 @@
 --   Output :: o -> InOut i o m ()
 -- @
 --
-type Effect = (* -> *) -> * -> *
+type Effect = (Type -> Type) -> Type -> Type
 
 -- | An effect for collecting multiple effects into one effect.
 --
diff --git a/src/Control/Effect/Internal/Utils.hs b/src/Control/Effect/Internal/Utils.hs
--- a/src/Control/Effect/Internal/Utils.hs
+++ b/src/Control/Effect/Internal/Utils.hs
@@ -1,6 +1,10 @@
-module Control.Effect.Internal.Utils where
+module Control.Effect.Internal.Utils
+  ( Type,
+    module Control.Effect.Internal.Utils
+  ) where
 
 import Data.Coerce
+import Data.Kind (Type)
 
 infixr 9 #.
 (#.) :: Coercible c b => (b -> c) -> (a -> b) -> (a -> c)
diff --git a/src/Control/Effect/Internal/ViaAlg.hs b/src/Control/Effect/Internal/ViaAlg.hs
--- a/src/Control/Effect/Internal/ViaAlg.hs
+++ b/src/Control/Effect/Internal/ViaAlg.hs
@@ -1,11 +1,12 @@
 module Control.Effect.Internal.ViaAlg where
 
-import Data.Coerce
 import Control.Effect.Internal.Union
+import Data.Coerce
+import Data.Kind (Type)
 
 type RepresentationalT = RepresentationalEff
 
-newtype ViaAlg (s :: *) (e :: Effect) m a = ViaAlg {
+newtype ViaAlg (s :: Type) (e :: Effect) m a = ViaAlg {
     unViaAlg :: m a
   }
   deriving (Functor, Applicative, Monad)
diff --git a/src/Control/Effect/Type/Alt.hs b/src/Control/Effect/Type/Alt.hs
--- a/src/Control/Effect/Type/Alt.hs
+++ b/src/Control/Effect/Type/Alt.hs
@@ -1,6 +1,8 @@
 {-# OPTIONS_HADDOCK not-home #-}
 module Control.Effect.Type.Alt where
 
+import Data.Kind (Type)
+
 -- | An effect corresponding to the
 -- 'Control.Applicative.Alternative' type class.
 --
@@ -14,6 +16,6 @@
 -- how it interprets 'Alt'. This means you can use
 -- an 'Alt' interpreter to locally gain access to an 'Control.Applicative.Alternative'
 -- instance inside of application code.
-data Alt (m :: * -> *) a where
+data Alt (m :: Type -> Type) a where
   Empty :: Alt m a
   Alt   :: m a -> m a -> Alt m a
diff --git a/src/Control/Effect/Type/Embed.hs b/src/Control/Effect/Type/Embed.hs
--- a/src/Control/Effect/Type/Embed.hs
+++ b/src/Control/Effect/Type/Embed.hs
@@ -1,6 +1,8 @@
 {-# OPTIONS_HADDOCK not-home #-}
 module Control.Effect.Type.Embed where
 
+import Data.Kind (Type)
+
 -- | An effect for embedding actions of a base monad into the current one.
-newtype Embed b (m :: * -> *) a where
+newtype Embed b (m :: Type -> Type) a where
   Embed :: { unEmbed :: b a } -> Embed b m a
diff --git a/src/Control/Effect/Type/ErrorIO.hs b/src/Control/Effect/Type/ErrorIO.hs
--- a/src/Control/Effect/Type/ErrorIO.hs
+++ b/src/Control/Effect/Type/ErrorIO.hs
@@ -2,8 +2,9 @@
 module Control.Effect.Type.ErrorIO where
 
 import Control.Exception
+import Data.Kind (Type)
 
 -- | An effect for throwing and catching 'IO'-based exceptions.
-data ErrorIO (m :: * -> *) a where
+data ErrorIO (m :: Type -> Type) a where
   ThrowIO :: Exception e => e -> ErrorIO m a
   CatchIO :: Exception e => m a -> (e -> m a) -> ErrorIO m a
diff --git a/src/Control/Effect/Type/Fail.hs b/src/Control/Effect/Type/Fail.hs
--- a/src/Control/Effect/Type/Fail.hs
+++ b/src/Control/Effect/Type/Fail.hs
@@ -1,6 +1,8 @@
 {-# OPTIONS_HADDOCK not-home #-}
 module Control.Effect.Type.Fail where
 
+import Data.Kind (Type)
+
 -- | An effect corresponding to the 'Control.Monad.Fail.MonadFail' type class.
 --
 -- 'Control.Effect.Effly''s 'Control.Monad.Fail.MonadFail' instance is based
@@ -12,5 +14,5 @@
 -- how it interprets 'Fail'. This means you can use
 -- an 'Fail' interpreter to locally gain access to an 'Control.Monad.Fail.MonadFail'
 -- instance inside of application code.
-newtype Fail (m :: * -> *) (a :: *) where
+newtype Fail (m :: Type -> Type) (a :: Type) where
   Fail :: String -> Fail m a
diff --git a/src/Control/Effect/Type/Throw.hs b/src/Control/Effect/Type/Throw.hs
--- a/src/Control/Effect/Type/Throw.hs
+++ b/src/Control/Effect/Type/Throw.hs
@@ -1,7 +1,9 @@
 {-# OPTIONS_HADDOCK not-home #-}
 module Control.Effect.Type.Throw where
 
+import Data.Kind (Type)
+
 -- | An effect for throwing exceptions of type @e@.
-newtype Throw e (m :: * -> *) (a :: *) where
+newtype Throw e (m :: Type -> Type) (a :: Type) where
   Throw :: e -> Throw e m a
 
diff --git a/src/Control/Monad/Trans/Free/Church/Alternate.hs b/src/Control/Monad/Trans/Free/Church/Alternate.hs
--- a/src/Control/Monad/Trans/Free/Church/Alternate.hs
+++ b/src/Control/Monad/Trans/Free/Church/Alternate.hs
@@ -14,7 +14,7 @@
 import Control.Effect.Type.Optional
 import Control.Monad.Catch hiding (handle)
 
-newtype FreeT f (m :: * -> *) a = FreeT {
+newtype FreeT f (m :: Type -> Type) a = FreeT {
     unFreeT :: forall r
              . (forall x. f x -> (x -> m r) -> m r)
             -> (a -> m r) -> m r
diff --git a/src/Control/Monad/Trans/List/Church.hs b/src/Control/Monad/Trans/List/Church.hs
--- a/src/Control/Monad/Trans/List/Church.hs
+++ b/src/Control/Monad/Trans/List/Church.hs
@@ -7,6 +7,8 @@
 import qualified Control.Monad.Catch as C
 import qualified Control.Monad.Fail as Fail
 
+import Data.Kind (Type)
+
 import Control.Effect.Carrier
 
 import Control.Effect.Type.ListenPrim
@@ -16,7 +18,7 @@
 import Control.Effect.Type.Unravel
 import Control.Effect.Type.ReaderPrim
 
-newtype ListT (m :: * -> *) a = ListT {
+newtype ListT (m :: Type -> Type) a = ListT {
   unListT :: forall r
            . (a -> m r -> m r)
           -> m r -- lose