diff --git a/modules/kernel/higherKind/src/main/scala/tofu/control/impl/BindInstanceChain.scala b/modules/kernel/higherKind/src/main/scala/tofu/control/impl/BindInstanceChain.scala
index fa7442fb5..fdf41f669 100644
--- a/modules/kernel/higherKind/src/main/scala/tofu/control/impl/BindInstanceChain.scala
+++ b/modules/kernel/higherKind/src/main/scala/tofu/control/impl/BindInstanceChain.scala
@@ -38,7 +38,7 @@ trait BindInstanceChain[TC[f[_, _]] >: Bind[f]] {
 
     override def handle[E, X, A](fa: Either[E, A], h: E => A): Either[X, A] = Right(fa.fold(h, identity))
 
-    override def monad[E]: Monad[Either[E, *]] = implicitly
+    override def monad[E]: Monad[Either[E, _]] = implicitly
 
     override def bifunctor: Bifunctor[Either] = implicitly
   }
diff --git a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/MonoidalK.scala b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/MonoidalK.scala
index ad5d5a317..05b8ef1f9 100644
--- a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/MonoidalK.scala
+++ b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/MonoidalK.scala
@@ -12,13 +12,13 @@ import tofu.internal.EffectCompHK
 trait MonoidalK[U[_[_]]] extends PureK[U] with ApplyK[U] {
   def zipWith2K[F[_], G[_], H[_]](af: U[F], ag: U[G])(f2: Function2K[F, G, H]): U[H]
 
-  override def map2K[F[_], G[_], H[_]](af: U[F], ag: U[G])(f: Tuple2K[F, G, *] ~> H): U[H] =
+  override def map2K[F[_], G[_], H[_]](af: U[F], ag: U[G])(f: Tuple2K[F, G, _] ~> H): U[H] =
     zipWith2K(af, ag)(Function2K.untupled(f))
 
   override def mapK[F[_], G[_]](af: U[F])(fk: F ~> G): U[G] =
     zipWith2K[F, UnitK, G](af, unitK)(Function2K[F, UnitK]((f, _) => fk(f)))
 
-  override def productK[F[_], G[_]](af: U[F], ag: U[G]): U[Tuple2K[F, G, *]] =
+  override def productK[F[_], G[_]](af: U[F], ag: U[G]): U[Tuple2K[F, G, _]] =
     zipWith2K(af, ag)(Function2K[F, G]((f, g) => Tuple2K(f, g)))
 }
 
diff --git a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Post.scala b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Post.scala
index 69a9c98eb..613cd772a 100644
--- a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Post.scala
+++ b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Post.scala
@@ -6,7 +6,7 @@ import cats.{Applicative, Apply, FlatMap, Monoid, MonoidK, Semigroup, SemigroupK
 import tofu.syntax.funk.funK
 import tofu.syntax.monadic.*
 
-/** A function `[F[_], A] =>> A => F[Unit]` An algebra `U[Post[F, *]]` is an algebra which translates all actions to `A
+/** A function `[F[_], A] =>> A => F[Unit]` An algebra `U[Post[F, _]]` is an algebra which translates all actions to `A
   * \=> F[Unit]`. This is useful to represent actions succeeding main logic.
   */
 trait Post[F[_], A] {
diff --git a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Pre.scala b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Pre.scala
index 35a71b3a5..07b635190 100644
--- a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Pre.scala
+++ b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/Pre.scala
@@ -6,7 +6,7 @@ import cats.{Applicative, Apply, Monoid, MonoidK, Semigroup, SemigroupK, ~>}
 import tofu.syntax.funk.funK
 import tofu.syntax.monadic.*
 
-/** Newtype for `[F[_], A] =>> F[Unit]`. An algebra `U[Pre[F, *]]` is an algebra which translates all actions to
+/** Newtype for `[F[_], A] =>> F[Unit]`. An algebra `U[Pre[F, _]]` is an algebra which translates all actions to
   * `F[Unit]`. This is useful to represent actions preceding main logic.
   */
 object Pre extends PreInstances {
diff --git a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/bi/BiRepresentableK.scala b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/bi/BiRepresentableK.scala
index b7d999836..4bfa1393b 100644
--- a/modules/kernel/higherKind/src/main/scala/tofu/higherKind/bi/BiRepresentableK.scala
+++ b/modules/kernel/higherKind/src/main/scala/tofu/higherKind/bi/BiRepresentableK.scala
@@ -4,7 +4,7 @@ import tofu.control.Bind
 import tofu.higherKind.bi.RepresentableB.Tab
 
 trait RepresentableB[U[f[_, _]]] extends MonoidalBK[U] with EmbedBK[U] {
-  def bitabulate[F[_, _]](repr: RepBK[U, *, *] FunBK F): U[F]
+  def bitabulate[F[_, _]](repr: RepBK[U, _, _] FunBK F): U[F]
 
   final def tab[F[_, _]]: Tab[U, F] = new Tab(this)
 
diff --git a/modules/kernel/higherKind/src/test/scala/tofu/control/CatsInstancesFromBindSuite.scala b/modules/kernel/higherKind/src/test/scala/tofu/control/CatsInstancesFromBindSuite.scala
index 603f15f39..6bd072a2c 100644
--- a/modules/kernel/higherKind/src/test/scala/tofu/control/CatsInstancesFromBindSuite.scala
+++ b/modules/kernel/higherKind/src/test/scala/tofu/control/CatsInstancesFromBindSuite.scala
@@ -5,8 +5,8 @@ import tofu.instances.bind._
 
 class CatsInstancesFromBindSuite {
   def summonBindInstances[F[+_, +_]](implicit bind: Bind[F]): Unit = {
-    requireApplicative[F[Throwable, *]]
-    requireFlatMap[F[Nothing, *]]
+    requireApplicative[F[Throwable, _]]
+    requireFlatMap[F[Nothing, _]]
   }
 
   def requireApplicative[F[_]](implicit applicative: Applicative[F]): Unit = ()
diff --git a/modules/kernel/src/main/scala/tofu/Context.scala b/modules/kernel/src/main/scala/tofu/Context.scala
index 1baaa0723..1a505ec2f 100644
--- a/modules/kernel/src/main/scala/tofu/Context.scala
+++ b/modules/kernel/src/main/scala/tofu/Context.scala
@@ -169,7 +169,7 @@ object Local {
   * that can use `F[Ctx]` inside.
   *
   * @tparam F
-  *   context-aware effect e.g.`ReaderT[Lower, Ctx, *]`
+  *   context-aware effect e.g.`ReaderT[Lower, Ctx, _]`
   */
 @deprecated("Migrate to With* typeclasses", "0.10.3")
 trait Provide[F[_]] extends ContextBase {
@@ -205,10 +205,10 @@ trait Provide[F[_]] extends ContextBase {
     *
     * @example
     *   {{{ trait ProcessHandler[G[_]] { def mapK[M[_]](fk: G ~> M): ProcessHandler[M] = ??? //...other methods } type
-    *   WithMyContext[F[_], A] = ReaderT[F, MyCtx, A] val contextualProcessHandler: ProcessHandler[IO WithMyContext *] =
+    *   WithMyContext[F[_], A] = ReaderT[F, MyCtx, A] val contextualProcessHandler: ProcessHandler[IO WithMyContext _] =
     *   ???
     *
-    * val processHandler: ProcessHandler[IO] = processHandler.mapK( WithProvide[IO WithMyContext *, IO,
+    * val processHandler: ProcessHandler[IO] = processHandler.mapK( WithProvide[IO WithMyContext _, IO,
     * MyCtx].runContextK ) }}}
     */
   def runContextK(ctx: Ctx): F ~> Lower = funK[F, Lower](a => runContext(a)(ctx))
@@ -244,7 +244,7 @@ object Provide {
 /** Combination of [[Local]] and [[Provide]]
   *
   * @tparam F
-  *   context-aware effect e.g.`ReaderT[Lower, Ctx, *]`
+  *   context-aware effect e.g.`ReaderT[Lower, Ctx, _]`
   */
 @deprecated("Migrate to With* typeclasses", "0.10.3")
 trait RunContext[F[_]] extends Local[F] with Provide[F] {
@@ -256,9 +256,9 @@ trait RunContext[F[_]] extends Local[F] with Provide[F] {
     *
     * type WithMyContext[F[_], A] = ReaderT[F, MyCtx, A]
     *
-    * val processHandler: ProcessHandler[IO WithMyContext *] = ???
+    * val processHandler: ProcessHandler[IO WithMyContext _] = ???
     *
-    * val contextualHandler: IO WithMyContext ProcessHandler[IO] = processHandler.mapK( WithRun[WithMyContext[IO, *],
+    * val contextualHandler: IO WithMyContext ProcessHandler[IO] = processHandler.mapK( WithRun[WithMyContext[IO, _],
     * IO, MyCtx].unlift.map(fk => processHandler.mapK(fk)) ) //now it is able to process MyCtx but is wrapped in IO
     * WithMyContext * }}}
     * @return
diff --git a/modules/kernel/src/main/scala/tofu/Errors.scala b/modules/kernel/src/main/scala/tofu/Errors.scala
index c1b49397c..ae34dbf9b 100644
--- a/modules/kernel/src/main/scala/tofu/Errors.scala
+++ b/modules/kernel/src/main/scala/tofu/Errors.scala
@@ -130,8 +130,8 @@ object Errors extends DataEffectComp[Errors] {
 trait ErrorBase
 object ErrorBase extends ErrorsBaseInstances {
 
-  final implicit def readerTErrors[F[_], R, E](implicit F: Errors[F, E]): Errors[ReaderT[F, R, *], E] =
-    new Errors[ReaderT[F, R, *], E] {
+  final implicit def readerTErrors[F[_], R, E](implicit F: Errors[F, E]): Errors[ReaderT[F, R, _], E] =
+    new Errors[ReaderT[F, R, _], E] {
       def raise[A](err: E): ReaderT[F, R, A] =
         ReaderT.liftF(F.raise(err))
 
@@ -177,12 +177,12 @@ class ErrorsBaseInstances2 extends ErrorsBaseInstances3 {
 
 class ErrorsBaseInstances3 {
 
-  final implicit def eitherTIntance[F[_], E](implicit F: Monad[F]): ErrorsTo[EitherT[F, E, *], F, E] =
+  final implicit def eitherTIntance[F[_], E](implicit F: Monad[F]): ErrorsTo[EitherT[F, E, _], F, E] =
     new EitherTErrorsTo[F, E]
 
-  final implicit def optionTIntance[F[_]](implicit F: Monad[F]): ErrorsTo[OptionT[F, *], F, Unit] =
+  final implicit def optionTIntance[F[_]](implicit F: Monad[F]): ErrorsTo[OptionT[F, _], F, Unit] =
     new OptionTErrorsTo[F]
 
-  final implicit def eitherIntance[E]: ErrorsTo[Either[E, *], Id, E] = new EitherErrorsTo[E]
+  final implicit def eitherIntance[E]: ErrorsTo[Either[E, _], Id, E] = new EitherErrorsTo[E]
   final implicit val optionTIntance: ErrorsTo[Option, Id, Unit]      = OptionErrorsTo
 }
diff --git a/modules/kernel/src/main/scala/tofu/Perform.scala b/modules/kernel/src/main/scala/tofu/Perform.scala
index 3851a4505..70d62d3f7 100644
--- a/modules/kernel/src/main/scala/tofu/Perform.scala
+++ b/modules/kernel/src/main/scala/tofu/Perform.scala
@@ -22,7 +22,7 @@ trait Performer[F[_], -Cont[_], Cancel] {
 }
 
 object Performer {
-  type OfExit[F[_], E] = Performer[F, PerformOf.ExitCont[E, *], Unit]
+  type OfExit[F[_], E] = Performer[F, PerformOf.ExitCont[E, _], Unit]
 
   implicit def contravariantK[F[_], Cancel]: ContravariantK[({ type L[x[_]] = Performer[F, x, Cancel] })#L] =
     new PerformerContravariantK[F, Cancel]
@@ -49,7 +49,7 @@ object PerformVia extends PerformInstance with PerformInstance1 {
 trait PerformInstance1 {
   implicit def performReader[F[_]: Functor, Cont[_], R, Cancel](implicit
       RP: PerformVia[F, Cont, Cancel]
-  ): PerformVia[ReaderT[F, R, *], Cont, Cancel] = new PerformViaReader(RP)
+  ): PerformVia[ReaderT[F, R, _], Cont, Cancel] = new PerformViaReader(RP)
 }
 
 object PerformOf extends Effect2Comp[PerformOf] {
diff --git a/modules/kernel/src/main/scala/tofu/Scoped.scala b/modules/kernel/src/main/scala/tofu/Scoped.scala
index 2bcfe4666..99adeeb38 100644
--- a/modules/kernel/src/main/scala/tofu/Scoped.scala
+++ b/modules/kernel/src/main/scala/tofu/Scoped.scala
@@ -29,7 +29,7 @@ trait Scoped[Tag, F[_]] {
 
   final def tagged[NewTag]: Scoped[NewTag, F] = this.asInstanceOf[Scoped[NewTag, F]]
 
-  final def midPoint: Point[Mid[F, *]] = new Point[Mid[F, *]] {
+  final def midPoint: Point[Mid[F, _]] = new Point[Mid[F, _]] {
     def point[A]: Mid[F, A] = runScoped(_)
   }
 }
@@ -78,7 +78,7 @@ object Scoped extends ScopedInstance with ScopedInstancesMacro {
   }
 
   /** helpful method to create middleware that executes all proceses in the given scope */
-  def mid[Tag, U[_[_]], F[_]](implicit U: PureK[U], F: Scoped[Tag, F]): U[Mid[F, *]] = U.pureK(F.midPoint)
+  def mid[Tag, U[_[_]], F[_]](implicit U: PureK[U], F: Scoped[Tag, F]): U[Mid[F, _]] = U.pureK(F.midPoint)
 }
 
 trait ScopedExecute[Tag, F[_]] extends Scoped[Tag, F] {
diff --git a/modules/kernel/src/main/scala/tofu/WithProvide.scala b/modules/kernel/src/main/scala/tofu/WithProvide.scala
index d41c745bb..1179f171e 100644
--- a/modules/kernel/src/main/scala/tofu/WithProvide.scala
+++ b/modules/kernel/src/main/scala/tofu/WithProvide.scala
@@ -7,7 +7,7 @@ import tofu.syntax.funk.funK
 
 /** Synonym for [[Provide]] with explicit `C` as `Ctx` and `G` as `Lower` for better type inference
   *
-  * Can be seen as transformation `F[*] = C => G[*]`
+  * Can be seen as transformation `F[_] = C => G[_]`
   */
 trait WithProvide[F[_], G[_], C] extends Provide[F] with Lift[G, F] {
   override type Lower[A] = G[A]
@@ -40,10 +40,10 @@ trait WithProvide[F[_], G[_], C] extends Provide[F] with Lift[G, F] {
     *
     * @example
     *   {{{ trait ProcessHandler[G[_]] { def mapK[M[_]](fk: G ~> M): ProcessHandler[M] = ??? //...other methods } type
-    *   WithMyContext[F[_], A] = ReaderT[F, MyCtx, A] val contextualProcessHandler: ProcessHandler[IO WithMyContext *] =
+    *   WithMyContext[F[_], A] = ReaderT[F, MyCtx, A] val contextualProcessHandler: ProcessHandler[IO WithMyContext _] =
     *   ???
     *
-    * val processHandler: ProcessHandler[IO] = processHandler.mapK( WithProvide[IO WithMyContext *, IO,
+    * val processHandler: ProcessHandler[IO] = processHandler.mapK( WithProvide[IO WithMyContext _, IO,
     * MyCtx].runContextK ) }}}
     */
   override def runContextK(ctx: Ctx): F ~> Lower = funK[F, Lower](runContext(_)(ctx))
diff --git a/modules/kernel/src/main/scala/tofu/WithRun.scala b/modules/kernel/src/main/scala/tofu/WithRun.scala
index 2348bfebf..6454b7cb6 100644
--- a/modules/kernel/src/main/scala/tofu/WithRun.scala
+++ b/modules/kernel/src/main/scala/tofu/WithRun.scala
@@ -8,7 +8,7 @@ import tofu.syntax.funk.funK
 /** Synonym for both [[RunContext]] and [[Unlift]] with explicit `C` as `Ctx` and `G` as `Lower` for better type
   * inference
   *
-  * Can be seen as transformation `F[*] = C => G[*]`
+  * Can be seen as transformation `F[_] = C => G[_]`
   */
 trait WithRun[F[_], G[_], C] extends WithProvide[F, G, C] with WithLocal[F, C] with RunContext[F] with Unlift[G, F] {
   override type Ctx = C
@@ -20,9 +20,9 @@ trait WithRun[F[_], G[_], C] extends WithProvide[F, G, C] with WithLocal[F, C] w
     *
     * type WithMyContext[F[_], A] = ReaderT[F, MyCtx, A]
     *
-    * val processHandler: ProcessHandler[IO WithMyContext *] = ???
+    * val processHandler: ProcessHandler[IO WithMyContext _] = ???
     *
-    * val contextualHandler: IO WithMyContext ProcessHandler[IO] = processHandler.mapK( WithRun[WithMyContext[IO, *],
+    * val contextualHandler: IO WithMyContext ProcessHandler[IO] = processHandler.mapK( WithRun[WithMyContext[IO, _],
     * IO, MyCtx].unlift.map(fk => processHandler.mapK(fk)) ) //now it is able to process MyCtx but is wrapped in IO
     * WithMyContext * }}}
     * @return
diff --git a/modules/kernel/src/main/scala/tofu/concurrent/Atom.scala b/modules/kernel/src/main/scala/tofu/concurrent/Atom.scala
index 585c2c483..48e30e54f 100644
--- a/modules/kernel/src/main/scala/tofu/concurrent/Atom.scala
+++ b/modules/kernel/src/main/scala/tofu/concurrent/Atom.scala
@@ -62,9 +62,9 @@ object Atom extends AtomInstances {
     }
   }
 
-  def stateTAtom[F[_]: Applicative, A]: Atom[StateT[F, A, *], A] = StateTAtom()
+  def stateTAtom[F[_]: Applicative, A]: Atom[StateT[F, A, _], A] = StateTAtom()
 
-  private case class StateTAtom[F[_]: Applicative, A]() extends Atom[StateT[F, A, *], A] {
+  private case class StateTAtom[F[_]: Applicative, A]() extends Atom[StateT[F, A, _], A] {
     override def get: StateT[F, A, A]                       = StateT.get
     override def set(a: A): StateT[F, A, Unit]              = StateT.set(a)
     override def getAndSet(a: A): StateT[F, A, A]           = StateT(a1 => (a, a1).pure[F])
@@ -72,10 +72,10 @@ object Atom extends AtomInstances {
     override def modify[B](f: A => (A, B)): StateT[F, A, B] = StateT(a => f(a).pure[F])
   }
 
-  def calcMAtom[F[+_, +_], R, S, E]: Atom[CalcM[F, R, S, S, E, *], S] =
-    calcMAtomAny.asInstanceOf[Atom[CalcM[F, R, S, S, E, *], S]]
+  def calcMAtom[F[+_, +_], R, S, E]: Atom[CalcM[F, R, S, S, E, _], S] =
+    calcMAtomAny.asInstanceOf[Atom[CalcM[F, R, S, S, E, _], S]]
 
-  private class CalcMAtom[F[+_, +_], R, S, E]() extends Atom[CalcM[F, R, S, S, E, *], S] {
+  private class CalcMAtom[F[+_, +_], R, S, E]() extends Atom[CalcM[F, R, S, S, E, _], S] {
     def get: CalcM[F, R, S, S, E, S]                       = CalcM.get
     def set(a: S): CalcM[F, R, S, S, E, Unit]              = CalcM.set(a).void
     def getAndSet(a: S): CalcM[F, R, S, S, E, S]           = CalcM.get[S] << CalcM.set(a)
diff --git a/modules/kernel/src/main/scala/tofu/concurrent/Exit.scala b/modules/kernel/src/main/scala/tofu/concurrent/Exit.scala
index 2773a49af..e6cc90543 100644
--- a/modules/kernel/src/main/scala/tofu/concurrent/Exit.scala
+++ b/modules/kernel/src/main/scala/tofu/concurrent/Exit.scala
@@ -40,7 +40,7 @@ object Exit {
     case util.Success(res) => Completed(res)
   }
 
-  private[this] object exitInstanceAny extends Traverse[Exit[Any, *]] with ApplicativeZip[Exit[Any, *]] {
+  private[this] object exitInstanceAny extends Traverse[Exit[Any, _]] with ApplicativeZip[Exit[Any, _]] {
     def traverse[G[_], A, B](fa: Exit[Any, A])(f: A => G[B])(implicit G: Applicative[G]): G[Exit[Any, B]] =
       fa match {
         case Canceled     => G.pure(Canceled)
@@ -78,8 +78,8 @@ object Exit {
     def pure[A](x: A): Exit[Any, A]                                                        = Completed(x)
   }
 
-  implicit def exitInstance[E]: Traverse[Exit[E, *]] with Applicative[Exit[E, *]] =
-    exitInstanceAny.asInstanceOf[Traverse[Exit[E, *]] with Applicative[Exit[E, *]]]
+  implicit def exitInstance[E]: Traverse[Exit[E, _]] with Applicative[Exit[E, _]] =
+    exitInstanceAny.asInstanceOf[Traverse[Exit[E, _]] with Applicative[Exit[E, _]]]
 
   object CanceledException extends InterruptedException
 }
diff --git a/modules/kernel/src/main/scala/tofu/control/Selective.scala b/modules/kernel/src/main/scala/tofu/control/Selective.scala
index c5dcf2d0a..742e1d0ef 100644
--- a/modules/kernel/src/main/scala/tofu/control/Selective.scala
+++ b/modules/kernel/src/main/scala/tofu/control/Selective.scala
@@ -43,9 +43,9 @@ trait SelectiveInstances extends SelectiveInstances2 {
   final implicit def selectiveOverMonad[F[_]: Monad]: SelectiveOverMonad[F] = new SelectiveOverMonad[F]
 }
 trait SelectiveInstances2 {
-  final implicit def selectiveOptionT[F[_]: Selective]: Selective[OptionT[F, *]]               = new SelectiveOptionT[F]
-  final implicit def selectiveEitherT[F[_]: Selective, E]: Selective[EitherT[F, E, *]]         = new SelectiveEitherT[F, E]
-  final implicit def selectiveReaderT[F[_]: Selective, R]: Selective[ReaderT[F, R, *]]         = new SelectiveReaderT[F, R]
-  final implicit def selectiveWriterT[F[_]: Selective, W: Monoid]: Selective[WriterT[F, W, *]] =
+  final implicit def selectiveOptionT[F[_]: Selective]: Selective[OptionT[F, _]]               = new SelectiveOptionT[F]
+  final implicit def selectiveEitherT[F[_]: Selective, E]: Selective[EitherT[F, E, _]]         = new SelectiveEitherT[F, E]
+  final implicit def selectiveReaderT[F[_]: Selective, R]: Selective[ReaderT[F, R, _]]         = new SelectiveReaderT[F, R]
+  final implicit def selectiveWriterT[F[_]: Selective, W: Monoid]: Selective[WriterT[F, W, _]] =
     new SelectiveWriterT[F, W]
 }
diff --git a/modules/kernel/src/main/scala/tofu/control/impl/SelectiveInstances.scala b/modules/kernel/src/main/scala/tofu/control/impl/SelectiveInstances.scala
index 1092c98a3..36332dec8 100644
--- a/modules/kernel/src/main/scala/tofu/control/impl/SelectiveInstances.scala
+++ b/modules/kernel/src/main/scala/tofu/control/impl/SelectiveInstances.scala
@@ -42,7 +42,7 @@ trait SelectiveWithMap[F[_]] extends Selective[F] {
   override def map[A, B](fa: F[A])(f: A => B): F[B] = smap(fa)(f)
 }
 
-class SelectiveOptionT[F[_]](implicit F: Selective[F]) extends Selective[OptionT[F, *]] {
+class SelectiveOptionT[F[_]](implicit F: Selective[F]) extends Selective[OptionT[F, _]] {
   def selectAp[A, B](fe: OptionT[F, Either[A, B]])(ff: => OptionT[F, A => B]): OptionT[F, B] =
     OptionT(F.selectAp(fe.value.map {
       case Some(Left(a))  => Left(a)
@@ -59,7 +59,7 @@ class SelectiveOptionT[F[_]](implicit F: Selective[F]) extends Selective[OptionT
   def pure[A](x: A): OptionT[F, A] = OptionT.pure(x)
 }
 
-class SelectiveEitherT[F[_], L](implicit F: Selective[F]) extends Selective[EitherT[F, L, *]] {
+class SelectiveEitherT[F[_], L](implicit F: Selective[F]) extends Selective[EitherT[F, L, _]] {
   def selectAp[A, B](fe: EitherT[F, L, Either[A, B]])(ff: => EitherT[F, L, A => B]): EitherT[F, L, B] =
     EitherT(F.selectAp[A, Either[L, B]](fe.value.map {
       case Right(Left(a))       => Left(a)
@@ -77,16 +77,16 @@ class SelectiveEitherT[F[_], L](implicit F: Selective[F]) extends Selective[Eith
 }
 
 class SelectiveReaderT[F[_], R](implicit FS: Selective[F])
-    extends Selective[ReaderT[F, R, *]] with ApplicativeDelegate[ReaderT[F, R, *]] {
-  val F: Applicative[ReaderT[F, R, *]] = implicitly
+    extends Selective[ReaderT[F, R, _]] with ApplicativeDelegate[ReaderT[F, R, _]] {
+  val F: Applicative[ReaderT[F, R, _]] = implicitly
 
   def selectAp[A, B](fe: ReaderT[F, R, Either[A, B]])(ff: => ReaderT[F, R, A => B]): ReaderT[F, R, B] =
     ReaderT(r => FS.selectAp(fe.run(r))(ff.run(r)))
 }
 
 class SelectiveWriterT[F[_], W: Monoid](implicit FS: Selective[F])
-    extends Selective[WriterT[F, W, *]] with ApplicativeDelegate[WriterT[F, W, *]] {
-  val F: Applicative[WriterT[F, W, *]] = implicitly
+    extends Selective[WriterT[F, W, _]] with ApplicativeDelegate[WriterT[F, W, _]] {
+  val F: Applicative[WriterT[F, W, _]] = implicitly
 
   def selectAp[A, B](fe: WriterT[F, W, Either[A, B]])(ff: => WriterT[F, W, A => B]): WriterT[F, W, B] =
     WriterT(FS.selectAp[(W, A), (W, B)](FS.map(fe.run) {
diff --git a/modules/kernel/src/main/scala/tofu/data/Calc.scala b/modules/kernel/src/main/scala/tofu/data/Calc.scala
index 3ca971d68..ed29241a8 100644
--- a/modules/kernel/src/main/scala/tofu/data/Calc.scala
+++ b/modules/kernel/src/main/scala/tofu/data/Calc.scala
@@ -163,8 +163,8 @@ object Calc {
   implicit def calcInstance[R, S, E]: CalcFunctorInstance[R, S, E] = new CalcFunctorInstance[R, S, E]
 
   class CalcFunctorInstance[R, S, E]
-      extends MonadError[Calc[R, S, S, E, *], E] with cats.Defer[Calc[R, S, S, E, *]]
-      with StackSafeMonad[Calc[R, S, S, E, *]] with Guarantee[Calc[R, S, S, E, *]] {
+      extends MonadError[Calc[R, S, S, E, _], E] with cats.Defer[Calc[R, S, S, E, _]]
+      with StackSafeMonad[Calc[R, S, S, E, _]] with Guarantee[Calc[R, S, S, E, _]] {
     def defer[A](fa: => Calc[R, S, S, E, A]): Calc[R, S, S, E, A]                                     = Calc.defer(fa)
     def raiseError[A](e: E): Calc[R, S, S, E, A]                                                      = Calc.raise(e)
     def handleErrorWith[A](fa: Calc[R, S, S, E, A])(f: E => Calc[R, S, S, E, A]): Calc[R, S, S, E, A] = fa.handleWith(f)
diff --git a/modules/kernel/src/main/scala/tofu/data/Embedded.scala b/modules/kernel/src/main/scala/tofu/data/Embedded.scala
index 2fd3d17da..4d7fb01ac 100644
--- a/modules/kernel/src/main/scala/tofu/data/Embedded.scala
+++ b/modules/kernel/src/main/scala/tofu/data/Embedded.scala
@@ -30,14 +30,14 @@ trait ExceptTInstances extends ExceptTInstances1 {
   implicit def exceptTVeryParallel[G[+_], E](implicit
       G: Parallel[G],
       E: Semigroup[E]
-  ): Parallel.Aux[ExceptT[G, E, *], ExceptTPar[G.F, E, *]] =
-    new Parallel[ExceptT[G, E, *]] {
+  ): Parallel.Aux[ExceptT[G, E, _], ExceptTPar[G.F, E, _]] =
+    new Parallel[ExceptT[G, E, _]] {
       type F[A] = ExceptTPar[G.F, E, A]
 
-      @inline private def par1 = funk.funKFrom[ExceptT[G, E, *]](fx => toPar(G.parallel(fx.value)))
+      @inline private def par1 = funk.funKFrom[ExceptT[G, E, _]](fx => toPar(G.parallel(fx.value)))
 
       def parallel   = par1
-      def sequential = funk.funKFrom[ExceptTPar[G.F, E, *]](fx => Embedded(G.sequential(fromPar(fx))))
+      def sequential = funk.funKFrom[ExceptTPar[G.F, E, _]](fx => Embedded(G.sequential(fromPar(fx))))
 
       def monad: Monad[ExceptT[G, E, _]] = exceptTMonad[G, E](G.monad)
 
@@ -45,8 +45,8 @@ trait ExceptTInstances extends ExceptTInstances1 {
     }
 }
 trait ExceptTInstances1 {
-  implicit def exceptTMonad[F[+_], E](implicit F: Monad[F]): MonadError[ExceptT[F, E, *], E] =
-    new MonadError[ExceptT[F, E, *], E] {
+  implicit def exceptTMonad[F[+_], E](implicit F: Monad[F]): MonadError[ExceptT[F, E, _], E] =
+    new MonadError[ExceptT[F, E, _], E] {
       override def map[A, B](fa: ExceptT[F, E, A])(f: A => B): ExceptT[F, E, B] =
         Embedded(fa.value.map(_.map(f)))
 
@@ -78,8 +78,8 @@ trait ExceptTInstances1 {
       def raiseError[A](e: E): ExceptT[F, E, A] = Embedded(e.asLeftF[F, A])
     }
 
-  implicit def exceptTBind[F[+_]](implicit F: Monad[F]): Bind[ExceptT[F, *, *]] =
-    new Bind[ExceptT[F, *, *]] {
+  implicit def exceptTBind[F[+_]](implicit F: Monad[F]): Bind[ExceptT[F, _, _]] =
+    new Bind[ExceptT[F, _, _]] {
       def pure[E, A](a: A): ExceptT[F, E, A] = Embedded(a.asRightF[F, E])
 
       def raise[E, A](e: E): ExceptT[F, E, A] = Embedded(e.asLeftF[F, A])
@@ -112,12 +112,12 @@ trait ExceptTInstances1 {
 
   implicit def exceptTParallel[G[+_], E: Semigroup](implicit
       G: Monad[G]
-  ): Parallel.Aux[ExceptT[G, E, *], ExceptTPar[G, E, *]] =
-    new Parallel[ExceptT[G, E, *]] {
+  ): Parallel.Aux[ExceptT[G, E, _], ExceptTPar[G, E, _]] =
+    new Parallel[ExceptT[G, E, _]] {
       type F[A] = ExceptTPar[G, E, A]
 
-      def parallel   = funk.funKFrom[ExceptT[G, E, *]](fx => toPar(fx.value))
-      def sequential = funk.funK[ExceptTPar[G, E, *], ExceptT[G, E, *]](fx => fromPartoExcept(fx))
+      def parallel   = funk.funKFrom[ExceptT[G, E, _]](fx => toPar(fx.value))
+      def sequential = funk.funK[ExceptTPar[G, E, _], ExceptT[G, E, _]](fx => fromPartoExcept(fx))
 
       def monad: Monad[ExceptT[G, E, _]] = exceptTMonad[G, E]
 
@@ -131,7 +131,7 @@ private[tofu] object ExceptTInstances1 {
   @inline final def fromPar[F[_], E, A](et: ExceptTPar[F, E, A])          = et.asInstanceOf[F[Either[E, A]]]
   @inline final def fromPartoExcept[F[+_], E, A](et: ExceptTPar[F, E, A]) = et.asInstanceOf[ExceptT[F, E, A]]
 
-  class ParApplicative[F[_]: Applicative, E: Semigroup] extends Applicative[ExceptTPar[F, E, *]] {
+  class ParApplicative[F[_]: Applicative, E: Semigroup] extends Applicative[ExceptTPar[F, E, _]] {
     def pure[A](x: A): ExceptTPar[F, E, A] = toPar(x.asRightF[F, E])
 
     def ap[A, B](ff: ExceptTPar[F, E, A => B])(fa: ExceptTPar[F, E, A]): ExceptTPar[F, E, B] = map2(ff, fa)(_(_))
diff --git a/modules/kernel/src/main/scala/tofu/data/Flux.scala b/modules/kernel/src/main/scala/tofu/data/Flux.scala
index aaf4e4e76..af7f58aeb 100644
--- a/modules/kernel/src/main/scala/tofu/data/Flux.scala
+++ b/modules/kernel/src/main/scala/tofu/data/Flux.scala
@@ -25,7 +25,7 @@ object Flux extends FluxInstances {
 
   type Infinite[+F[_], A]   = Flux[F, Identity, A]
   type Stream[+F[_], +A]    = Flux[F, Option, A]
-  type Accum[+F[_], +R, +A] = Flux[F, Either[R, +*], A]
+  type Accum[+F[_], +R, +A] = Flux[F, Either[R, +_], A]
 
   final implicit def toFluxOps[F[_], G[_], A](flux: Flux[F, G, A]): FluxOps[F, G, A]     = new FluxOps(flux.value)
   final implicit def toStreamOps[F[_], A](flux: Flux[F, Option, A]): FluxStreamOps[F, A] =
@@ -85,8 +85,8 @@ class FluxOps[F[_], G[_], A](private val value: F[G[(A, Flux[F, G, A])]]) extend
 }
 
 trait FluxInstances extends FluxInstances1 { self: Flux.type =>
-  implicit def streamMonad[F[_]: Monad]: Monad[Stream[F, *]] with Alternative[Stream[F, *]] =
-    new FluxFunctor[F, Option] with StackSafeMonad[Stream[F, *]] with Alternative[Stream[F, *]] {
+  implicit def streamMonad[F[_]: Monad]: Monad[Stream[F, _]] with Alternative[Stream[F, _]] =
+    new FluxFunctor[F, Option] with StackSafeMonad[Stream[F, _]] with Alternative[Stream[F, _]] {
       def pure[A](x: A) = Flux((x, empty[A]).some.pure[F])
 
       def flatMap[A, B](fa: Stream[F, A])(f: A => Stream[F, B]): Stream[F, B] =
@@ -104,8 +104,8 @@ trait FluxInstances extends FluxInstances1 { self: Flux.type =>
         })
     }
 
-  implicit def accumMonad[F[_]: Monad, R: Monoid]: Monad[Accum[F, R, *]] with Alternative[Accum[F, R, *]] =
-    new FluxFunctor[F, Either[R, +*]] with StackSafeMonad[Accum[F, R, *]] with Alternative[Accum[F, R, *]] {
+  implicit def accumMonad[F[_]: Monad, R: Monoid]: Monad[Accum[F, R, _]] with Alternative[Accum[F, R, _]] =
+    new FluxFunctor[F, Either[R, +_]] with StackSafeMonad[Accum[F, R, _]] with Alternative[Accum[F, R, _]] {
       private def add[A](r: R, f: Accum[F, R, A]): Accum[F, R, A] =
         Flux(f.value.map {
           case Left(r1)            => Left(r |+| r1)
@@ -126,8 +126,8 @@ trait FluxInstances extends FluxInstances1 { self: Flux.type =>
         })
     }
 
-  implicit def infiniteApplicative[F[_]: Applicative: Defer]: Applicative[Infinite[F, *]] =
-    new Applicative[Infinite[F, *]] {
+  implicit def infiniteApplicative[F[_]: Applicative: Defer]: Applicative[Infinite[F, _]] =
+    new Applicative[Infinite[F, _]] {
       def pure[A](x: A): Infinite[F, A] = {
         lazy val result: Infinite[F, A] = Flux[F, Identity, A](Defer[F].defer((x, result).pure[F]))
         result
@@ -140,10 +140,10 @@ trait FluxInstances extends FluxInstances1 { self: Flux.type =>
     }
 }
 trait FluxInstances1 { self: Flux.type =>
-  implicit def fluxFunctor[F[_]: Functor, G[_]: Functor]: Functor[Flux[F, G, *]] = new FluxFunctor[F, G]
+  implicit def fluxFunctor[F[_]: Functor, G[_]: Functor]: Functor[Flux[F, G, _]] = new FluxFunctor[F, G]
 }
 
-class FluxFunctor[F[_]: Functor, G[_]: Functor] extends Functor[Flux[F, G, *]] {
+class FluxFunctor[F[_]: Functor, G[_]: Functor] extends Functor[Flux[F, G, _]] {
   override def map[A, B](fa: Flux[F, G, A])(f: A => B): Flux[F, G, B] =
     Flux(fa.value.map(_.map { case (head, tail) => (f(head), map(tail)(f)) }))
 }
diff --git a/modules/kernel/src/main/scala/tofu/data/calc/CalcMInstances.scala b/modules/kernel/src/main/scala/tofu/data/calc/CalcMInstances.scala
index e84be64d8..c9cba1f3b 100644
--- a/modules/kernel/src/main/scala/tofu/data/calc/CalcMInstances.scala
+++ b/modules/kernel/src/main/scala/tofu/data/calc/CalcMInstances.scala
@@ -24,18 +24,18 @@ trait CalcMInstances extends CalcMInstances1 {
 }
 
 trait CalcMInstances1 {
-  final implicit def calcMBitraverse[F[+_, +_]: Bitraverse, S]: Bitraverse[CalcM[F, Any, Any, S, *, *]] =
+  final implicit def calcMBitraverse[F[+_, +_]: Bitraverse, S]: Bitraverse[CalcM[F, Any, Any, S, _, _]] =
     new CalcMBitraverse
 }
 
 trait CalcMInstances2 {
-  final implicit def calcMBifoldable[F[+_, +_]: Bifoldable, S]: Bifoldable[CalcM[F, Any, Any, S, *, *]] =
+  final implicit def calcMBifoldable[F[+_, +_]: Bifoldable, S]: Bifoldable[CalcM[F, Any, Any, S, _, _]] =
     new CalcMBifoldable
 }
 
 class CalcMonadInstance[F[+_, +_], R, S, E]
-    extends MonadError[CalcM[F, R, S, S, E, *], E] with cats.Defer[CalcM[F, R, S, S, E, *]]
-    with StackSafeMonad[CalcM[F, R, S, S, E, *]] {
+    extends MonadError[CalcM[F, R, S, S, E, _], E] with cats.Defer[CalcM[F, R, S, S, E, _]]
+    with StackSafeMonad[CalcM[F, R, S, S, E, _]] {
   def defer[A](fa: => CalcM[F, R, S, S, E, A]): CalcM[F, R, S, S, E, A]                                         = CalcM.defer(fa)
   def raiseError[A](e: E): CalcM[F, R, S, S, E, A]                                                              = CalcM.raise(e)
   def handleErrorWith[A](fa: CalcM[F, R, S, S, E, A])(f: E => CalcM[F, R, S, S, E, A]): CalcM[F, R, S, S, E, A] =
@@ -45,7 +45,7 @@ class CalcMonadInstance[F[+_, +_], R, S, E]
   def pure[A](x: A): CalcM[F, R, S, S, E, A]                                                                    = CalcM.pure(x)
 }
 
-class CalcBindInstance[F[+_, +_], R, S] extends StackSafeBind[CalcM[F, R, S, S, *, *]] {
+class CalcBindInstance[F[+_, +_], R, S] extends StackSafeBind[CalcM[F, R, S, S, _, _]] {
   override def pure[E, A](a: A): CalcM[F, R, S, S, E, A] = CalcM.pure(a)
 
   override def raise[E, A](e: E): CalcM[F, R, S, S, E, A] = CalcM.raise(e)
@@ -56,9 +56,9 @@ class CalcBindInstance[F[+_, +_], R, S] extends StackSafeBind[CalcM[F, R, S, S,
   ): CalcM[F, R, S, S, X, B] = fa.foldWith(f, h)
 }
 
-class CalcContextInstance[F[+_, +_], R, S, E] extends WithRun[CalcM[F, R, S, S, E, *], CalcM[F, Any, S, S, E, *], R] {
+class CalcContextInstance[F[+_, +_], R, S, E] extends WithRun[CalcM[F, R, S, S, E, _], CalcM[F, Any, S, S, E, _], R] {
   override val context: CalcM[F, R, S, S, E, R]          = CalcM.read
-  override val functor: Functor[CalcM[F, R, S, S, E, *]] = CalcM.calcFunctorInstance
+  override val functor: Functor[CalcM[F, R, S, S, E, _]] = CalcM.calcFunctorInstance
 
   override def runContext[A](fa: CalcM[F, R, S, S, E, A])(ctx: R): CalcM[F, Any, S, S, E, A]   = fa.provide(ctx)
   override def local[A](fa: CalcM[F, R, S, S, E, A])(project: R => R): CalcM[F, R, S, S, E, A] =
@@ -67,8 +67,8 @@ class CalcContextInstance[F[+_, +_], R, S, E] extends WithRun[CalcM[F, R, S, S,
 }
 
 class CalcBiContextInstance[F[+_, +_], R, S]
-    extends BiRun[CalcM[F, R, S, S, +*, +*], CalcM[F, Any, S, S, +*, +*], Nothing, R] {
-  override def bifunctor: Bind[CalcM[F, R, S, S, *, *]] = CalcM.calcBindInstance
+    extends BiRun[CalcM[F, R, S, S, +_, +_], CalcM[F, Any, S, S, +_, +_], Nothing, R] {
+  override def bifunctor: Bind[CalcM[F, R, S, S, _, _]] = CalcM.calcBindInstance
 
   override def lift[E, A](fa: CalcM[F, Any, S, S, E, A]): CalcM[F, R, S, S, E, A] = fa
 
@@ -83,11 +83,11 @@ class CalcBiContextInstance[F[+_, +_], R, S]
   )(lproj: Nothing => Nothing, rproj: R => R): CalcM[F, R, S, S, E, A] = fea.local(rproj)
 
   override def disclose[E, A](
-      k: FunBK[CalcM[F, R, S, S, *, *], CalcM[F, Any, S, S, *, *]] => CalcM[F, R, S, S, E, A]
-  ): CalcM[F, R, S, S, E, A] = CalcM.read[S, R].flatMap(r => k(FunBK.apply[CalcM[F, R, S, S, *, *]](_.provide(r))))
+      k: FunBK[CalcM[F, R, S, S, _, _], CalcM[F, Any, S, S, _, _]] => CalcM[F, R, S, S, E, A]
+  ): CalcM[F, R, S, S, E, A] = CalcM.read[S, R].flatMap(r => k(FunBK.apply[CalcM[F, R, S, S, _, _]](_.provide(r))))
 }
 
-class CalcMBifoldable[F[+_, +_], S](implicit F: Bifoldable[F]) extends Bifoldable[CalcM[F, Any, Any, S, *, *]] {
+class CalcMBifoldable[F[+_, +_], S](implicit F: Bifoldable[F]) extends Bifoldable[CalcM[F, Any, Any, S, _, _]] {
   private[this] val MaxDepth = 256
 
   def bifoldLeft1Slow[E, A, B](
@@ -145,7 +145,7 @@ class CalcMBifoldable[F[+_, +_], S](implicit F: Bifoldable[F]) extends Bifoldabl
 }
 
 class CalcMBitraverse[F[+_, +_], S](implicit F: Bitraverse[F])
-    extends CalcMBifoldable[F, S] with Bitraverse[CalcM[F, Any, Any, S, *, *]] {
+    extends CalcMBifoldable[F, S] with Bitraverse[CalcM[F, Any, Any, S, _, _]] {
 
   def bitraverse1[G[_]: Applicative, A, B, C, D](
       fab: StepResult[F, S, A, B]
diff --git a/modules/kernel/src/main/scala/tofu/data/calc/CalcT.scala b/modules/kernel/src/main/scala/tofu/data/calc/CalcT.scala
index 6cfe0fbb9..b78213bc9 100644
--- a/modules/kernel/src/main/scala/tofu/data/calc/CalcT.scala
+++ b/modules/kernel/src/main/scala/tofu/data/calc/CalcT.scala
@@ -2,5 +2,5 @@ package tofu.data
 package calc
 
 object CalcT {
-  def lift[F[+_], S, A](fa: F[A]): CalcT[F, Any, S, S, Nothing, A] = CalcM.lift[UnaryM[F, +*, +*], S, Nothing, A](fa)
+  def lift[F[+_], S, A](fa: F[A]): CalcT[F, Any, S, S, Nothing, A] = CalcM.lift[UnaryM[F, +_, +_], S, Nothing, A](fa)
 }
diff --git a/modules/kernel/src/main/scala/tofu/data/calc/Translator.scala b/modules/kernel/src/main/scala/tofu/data/calc/Translator.scala
index 3d4fba90a..089ba0ccd 100644
--- a/modules/kernel/src/main/scala/tofu/data/calc/Translator.scala
+++ b/modules/kernel/src/main/scala/tofu/data/calc/Translator.scala
@@ -24,7 +24,7 @@ object Translator {
   type Uno[F[_], E, A] = F[A]
 
   def apply[F[_, _], R, S]: Applied[F, R, S]       = new Applied
-  def uno[F[_], R, S]: Applied[Uno[F, *, *], R, S] = new Applied[Uno[F, *, *], R, S]
+  def uno[F[_], R, S]: Applied[Uno[F, _, _], R, S] = new Applied[Uno[F, _, _], R, S]
 
   class Applied[F[_, _], R, ST] {
     type E
diff --git a/modules/kernel/src/main/scala/tofu/data/data.scala b/modules/kernel/src/main/scala/tofu/data/data.scala
index 01c6b49c8..d57f20710 100644
--- a/modules/kernel/src/main/scala/tofu/data/data.scala
+++ b/modules/kernel/src/main/scala/tofu/data/data.scala
@@ -8,7 +8,7 @@ package object data {
   type PArray[+A]                   = PArray.Type[A]
   type ICalc[-R, S, +E, +A]         = Calc[R, S, S, E, A]
   type Embedded[+F[+_], +G[+_], +A] = Embedded.T[F, G, A]
-  type ExceptT[+F[+_], +E, +A]      = Embedded[F, Either[E, +*], A]
+  type ExceptT[+F[+_], +E, +A]      = Embedded[F, Either[E, +_], A]
 
   type ∘[+F[+_], +G[+_], +A]  = Embedded.T[F, G, A]
   type Flux[+F[_], +G[_], +A] = Flux.FluxRepr[F, G, A]
diff --git a/modules/kernel/src/main/scala/tofu/errorInstances/package.scala b/modules/kernel/src/main/scala/tofu/errorInstances/package.scala
index 81de953db..7e17932b8 100644
--- a/modules/kernel/src/main/scala/tofu/errorInstances/package.scala
+++ b/modules/kernel/src/main/scala/tofu/errorInstances/package.scala
@@ -47,7 +47,7 @@ private[tofu] trait HandlePrism[F[_], E, E1] extends Handle[F, E1] {
   def lift[A](fa: F[A]): F[A] = fa
 }
 
-private[tofu] class EitherTErrorsTo[F[_]: Monad, E] extends ErrorsTo[EitherT[F, E, *], F, E] {
+private[tofu] class EitherTErrorsTo[F[_]: Monad, E] extends ErrorsTo[EitherT[F, E, _], F, E] {
   def handleWith[A](fa: EitherT[F, E, A])(f: E => F[A]): F[A] = fa.valueOrF(f)
 
   // Members declared in tofu.Raise
@@ -60,7 +60,7 @@ private[tofu] class EitherTErrorsTo[F[_]: Monad, E] extends ErrorsTo[EitherT[F,
   def lift[A](fa: F[A]): EitherT[F, E, A] = EitherT.liftF(fa)
 }
 
-private[tofu] class OptionTErrorsTo[F[_]: Monad] extends ErrorsTo[OptionT[F, *], F, Unit] {
+private[tofu] class OptionTErrorsTo[F[_]: Monad] extends ErrorsTo[OptionT[F, _], F, Unit] {
   def handleWith[A](fa: OptionT[F, A])(f: Unit => F[A]): F[A] = fa.getOrElseF(f(()))
 
   // Members declared in tofu.Raise
@@ -73,7 +73,7 @@ private[tofu] class OptionTErrorsTo[F[_]: Monad] extends ErrorsTo[OptionT[F, *],
   def lift[A](fa: F[A]): OptionT[F, A] = OptionT.liftF(fa)
 }
 
-private[tofu] class EitherErrorsTo[E] extends ErrorsTo[Either[E, *], Id, E] {
+private[tofu] class EitherErrorsTo[E] extends ErrorsTo[Either[E, _], Id, E] {
   def handleWith[A](fa: Either[E, A])(f: E => A): A = fa.fold(f, identity)
 
   // Members declared in tofu.Raise
diff --git a/modules/kernel/src/main/scala/tofu/internal/instances/perform.scala b/modules/kernel/src/main/scala/tofu/internal/instances/perform.scala
index 4ee18fba2..fa1b01e5a 100644
--- a/modules/kernel/src/main/scala/tofu/internal/instances/perform.scala
+++ b/modules/kernel/src/main/scala/tofu/internal/instances/perform.scala
@@ -37,9 +37,9 @@ class PerformViaMappedPerformer[F[_], C1[_], C2[_], Cancel](
 class PerformOfMappedPerformer[F[_], Ex1[_], Ex2[_]](
     af: PerformOf[F, Ex1],
     fk: Ex1 ~> Ex2,
-) extends PerformViaMappedPerformer[F, Cont[Ex1, *], Cont[Ex2, *], Unit](
+) extends PerformViaMappedPerformer[F, Cont[Ex1, _], Cont[Ex2, _], Unit](
       af,
-      funK[Cont[Ex2, *], Cont[Ex1, *]](c1 => ex1 => c1(fk(ex1))),
+      funK[Cont[Ex2, _], Cont[Ex1, _]](c1 => ex1 => c1(fk(ex1))),
     ) with PerformOf[F, Ex2]
 
 final class PerformOfFunctorK[F[_]] extends FunctorK[({ type L[x[_]] = PerformOf[F, x] })#L] {
@@ -48,7 +48,7 @@ final class PerformOfFunctorK[F[_]] extends FunctorK[({ type L[x[_]] = PerformOf
 }
 
 final class ReaderTPerformer[F[_], R, C[_], Cancel](p: Performer[F, C, Cancel], r: R)
-    extends Performer[ReaderT[F, R, *], C, Cancel] {
+    extends Performer[ReaderT[F, R, _], C, Cancel] {
   def perform[A](cont: C[A])(f: Kleisli[F, R, A]): Kleisli[F, R, Cancel] =
     ReaderT.liftF(p.perform(cont)(f.run(r)))
 }
@@ -59,10 +59,10 @@ final class UnliftPerformer[F[_], B[_], C[_], Cancel](p: Performer[B, C, Cancel]
 }
 class PerformViaReader[F[_]: Functor, R, C[_], Cancel](
     p: PerformVia[F, C, Cancel]
-) extends PerformVia[ReaderT[F, R, *], C, Cancel] {
-  val functor: Functor[ReaderT[F, R, *]] = implicitly
+) extends PerformVia[ReaderT[F, R, _], C, Cancel] {
+  val functor: Functor[ReaderT[F, R, _]] = implicitly
 
-  def performer: ReaderT[F, R, Performer[ReaderT[F, R, *], C, Cancel]] =
+  def performer: ReaderT[F, R, Performer[ReaderT[F, R, _], C, Cancel]] =
     ReaderT(r => p.performer.map(new ReaderTPerformer(_, r)))
 }
 
diff --git a/modules/kernel/src/main/scala/tofu/lift/Unlift.scala b/modules/kernel/src/main/scala/tofu/lift/Unlift.scala
index 760045eab..373ea8527 100644
--- a/modules/kernel/src/main/scala/tofu/lift/Unlift.scala
+++ b/modules/kernel/src/main/scala/tofu/lift/Unlift.scala
@@ -32,7 +32,7 @@ object Lift extends LiftInstances1 {
   }
   implicit def liftIdentity[F[_]]: Lift[F, F]   = liftIdentityAny.asInstanceOf[Lift[F, F]]
 
-  private val unliftReaderTAny: Unlift[hktAny.AnyK, ReaderT[hktAny.AnyK, Any, *]] = {
+  private val unliftReaderTAny: Unlift[hktAny.AnyK, ReaderT[hktAny.AnyK, Any, _]] = {
     type RT[a] = ReaderT[hktAny.AnyK, Any, a]
     new Unlift[hktAny.AnyK, RT] {
       def lift[A](fa: hktAny.AnyK[A]): RT[A] = ReaderT.liftF(fa)
@@ -40,8 +40,8 @@ object Lift extends LiftInstances1 {
       val unlift: RT[RT ~> AnyK] = ReaderT[AnyK, Any, RT ~> AnyK](r => funK[RT, AnyK](f => f.run(r)))
     }
   }
-  implicit def liftReaderT[F[_], R]: Lift[F, ReaderT[F, R, *]]                    =
-    unliftReaderTAny.asInstanceOf[Unlift[F, ReaderT[F, R, *]]]
+  implicit def liftReaderT[F[_], R]: Lift[F, ReaderT[F, R, _]]                    =
+    unliftReaderTAny.asInstanceOf[Unlift[F, ReaderT[F, R, _]]]
 }
 
 private[lift] trait LiftInstances1 extends LiftInstances2 {
diff --git a/modules/kernel/src/test/scala/tofu/ContextSummonSuite.scala b/modules/kernel/src/test/scala/tofu/ContextSummonSuite.scala
index db3ba8a86..61abea07e 100644
--- a/modules/kernel/src/test/scala/tofu/ContextSummonSuite.scala
+++ b/modules/kernel/src/test/scala/tofu/ContextSummonSuite.scala
@@ -10,27 +10,27 @@ object ContextSummonSuite {
   type R[F[_], x] = ReaderT[F, Ctx, x]
 
   def summonReaderTComposeInstances[F[_], G[_]: Monad](implicit U: Unlift[F, G]): Any = {
-    implicitly[Unlift[F, R[G, *]]]
+    implicitly[Unlift[F, R[G, _]]]
   }
 
   def summonReaderTWrappedInstances1[F[_], G[_], C](implicit WR: WithRun[G, F, C]): Any = {
-    implicitly[WithContext[R[G, *], C]]
-    implicitly[WithLocal[R[G, *], C]]
-    implicitly[WithRun[R[G, *], R[F, *], C]]
-    implicitly[Unlift[R[F, *], R[G, *]]]
+    implicitly[WithContext[R[G, _], C]]
+    implicitly[WithLocal[R[G, _], C]]
+    implicitly[WithRun[R[G, _], R[F, _], C]]
+    implicitly[Unlift[R[F, _], R[G, _]]]
   }
 
   def summonReaderTWrappedInstances2[F[_], G[_], C](implicit WP: WithProvide[G, F, C]): Any = {
-    implicitly[WithProvide[R[G, *], R[F, *], C]]
+    implicitly[WithProvide[R[G, _], R[F, _], C]]
   }
 
   def summonReaderTWrappedInstances3[F[_], C](implicit WL: WithLocal[F, C]): Any = {
-    implicitly[WithContext[R[F, *], C]]
-    implicitly[WithLocal[R[F, *], C]]
+    implicitly[WithContext[R[F, _], C]]
+    implicitly[WithLocal[R[F, _], C]]
   }
 
   def summonReaderTWrappedInstances4[F[_], C](implicit WC: WithContext[F, C]): Any = {
-    implicitly[WithContext[R[F, *], C]]
+    implicitly[WithContext[R[F, _], C]]
   }
 
 }
diff --git a/modules/logging/structured/src/main/scala/tofu/logging/LoggingMid.scala b/modules/logging/structured/src/main/scala/tofu/logging/LoggingMid.scala
index 07effbb37..c0e2318eb 100644
--- a/modules/logging/structured/src/main/scala/tofu/logging/LoggingMid.scala
+++ b/modules/logging/structured/src/main/scala/tofu/logging/LoggingMid.scala
@@ -20,7 +20,7 @@ object LoggingMid extends builder.LoggingMidBuilder.DefaultImpl with LoggingMidM
   type Of[U[_[_]]] = U[LoggingMid]
 }
 
-/** Logging middleware supporting error reporting Alg[LoggingErrMid[E, *]] is a special form of implicit evidence of
+/** Logging middleware supporting error reporting Alg[LoggingErrMid[E, _]] is a special form of implicit evidence of
   * injectable logging support generally you don't need `Logging` instance to derive this so choice of logging postponed
   * until this middleware is attached to the core instance
   */
diff --git a/modules/logging/structured/src/main/scala/tofu/logging/internal/LogsInvariantSyntax.scala b/modules/logging/structured/src/main/scala/tofu/logging/internal/LogsInvariantSyntax.scala
index d36cb1221..ca3b9b719 100644
--- a/modules/logging/structured/src/main/scala/tofu/logging/internal/LogsInvariantSyntax.scala
+++ b/modules/logging/structured/src/main/scala/tofu/logging/internal/LogsInvariantSyntax.scala
@@ -34,13 +34,13 @@ object LogsInvariantSyntax {
     ): I[Logs.Universal[F]] = cached.map(_.universal)
 
     /** Collection of useful methods for creating middleware
-      * {{{logs.logged[Service].mid(implicit l => new Service[Mid[F, *]]{... })}}}
+      * {{{logs.logged[Service].mid(implicit l => new Service[Mid[F, _]]{... })}}}
       */
     final def logged[U[_[_]]](implicit c: ClassTag[U[HKAny]]): LogWares[U, I, F] =
       new LogWares(logs.forService[U[HKAny]])
 
     /** Collection of useful methods for creating middleware
-      * {{{logs.nameLogged[Service]("service").mid(implicit l => new Service[Mid[F, *]]{... })}}}
+      * {{{logs.nameLogged[Service]("service").mid(implicit l => new Service[Mid[F, _]]{... })}}}
       */
     final def nameLogged[U[_[_]]](name: String): LogWares[U, I, F] =
       new LogWares(logs.byName(name))