diff --git a/.scala-steward.conf b/.scala-steward.conf
index 007ff84..d22459a 100644
--- a/.scala-steward.conf
+++ b/.scala-steward.conf
@@ -3,3 +3,6 @@ updates.ignore = [
   {groupId = "org.scala-lang", artifactId = "scala-compiler", version = "2.13."},
   {groupId = "org.scala-lang", artifactId = "scala-compiler", version = "3."}
 ]
+updates.pin = [
+  {groupId = "org.scala-lang", artifactId = "scala3-library", version = "3.9."}
+]
diff --git a/build.sbt b/build.sbt
index 88a2ad3..ac76f02 100644
--- a/build.sbt
+++ b/build.sbt
@@ -3,7 +3,7 @@ import com.softwaremill.Publish.ossPublishSettings
 
 val scala212 = "2.12.19"
 val scala213 = "2.13.18"
-val scala30 = "3.4.1"
+val scala3 = "3.9.0"
 
 commonSmlBuildSettings
 ossPublishSettings
@@ -28,13 +28,13 @@ lazy val retry = (projectMatrix in file("retry"))
       )
   )
   .jvmPlatform(
-    scalaVersions = List(scala212, scala213, scala30),
+    scalaVersions = List(scala212, scala213, scala3),
     settings = Seq(
-      scalacOptions ++= (if (ScalaArtifacts.isScala3(scalaVersion.value)) Seq.empty else Seq("-release", "8"))
+      scalacOptions ++= (if (ScalaArtifacts.isScala3(scalaVersion.value)) Seq("-release", "17") else Seq("-release", "8"))
     )
   )
   .jsPlatform(
-    scalaVersions = List(scala212, scala213, scala30),
+    scalaVersions = List(scala212, scala213, scala3),
     settings = Seq(
       libraryDependencies += "io.github.cquiroz" %% "scala-java-time" % "2.5.0"
     )
diff --git a/retry/src/main/scala/Policy.scala b/retry/src/main/scala/Policy.scala
index 6fa4d5d..fd1ae57 100644
--- a/retry/src/main/scala/Policy.scala
+++ b/retry/src/main/scala/Policy.scala
@@ -272,13 +272,17 @@ trait CountingPolicy extends Policy {
     // consider this successful if our predicate says so _or_
     // we've reached the end out our countdown
     val countedSuccess = success.or(max < 1)
-    retry(
-      promise,
-      () => orElse(max - 1),
-      { (f: Future[T]) =>
-        if (max < 1) f else orElse(max - 1)
-      }
-    )(countedSuccess, executor)
+    locally {
+      // for scala 2 compatibility
+      implicit val success: Success[T] = countedSuccess
+      retry(
+        promise,
+        () => orElse(max - 1),
+        { (f: Future[T]) =>
+          if (max < 1) f else orElse(max - 1)
+        }
+      )
+    }
   }
 }
 
diff --git a/retry/src/test/scala/PolicySpec.scala b/retry/src/test/scala/PolicySpec.scala
index 6dd8c69..0926d69 100644
--- a/retry/src/test/scala/PolicySpec.scala
+++ b/retry/src/test/scala/PolicySpec.scala
@@ -11,6 +11,8 @@ import scala.collection.compat.immutable.LazyList
 import scala.concurrent.Future
 import scala.concurrent.duration._
 
+case class RetryAfter(duration: FiniteDuration) extends RuntimeException
+
 abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
 
   // needed so we do not get a scalatest EC error
@@ -42,7 +44,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
     it("should retry a future for a specified number of times") {
       implicit val success = Success[Int](_ == 3)
       val tries = forwardCountingFutureStream().iterator
-      Directly(3)(tries.next).map(result => assert(success.predicate(result) === true))
+      Directly(3)(tries.next()).map(result => assert(success.predicate(result) === true))
     }
 
     it("should fail when expected") {
@@ -114,7 +116,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
       val marker_base = System.currentTimeMillis
       val marker = new AtomicLong(0)
 
-      val runF = policy({ marker.set(System.currentTimeMillis); tries.next })
+      val runF = policy({ marker.set(System.currentTimeMillis); tries.next() })
       runF.map { result =>
         val delta = marker.get() - marker_base
         assert(success.predicate(result) === true && delta >= 90) // was 110, depends on how hot runtime is
@@ -147,7 +149,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
       val policy = Backoff(2, 30.millis)
       val marker_base = System.currentTimeMillis
       val marker = new AtomicLong(0)
-      val runF = policy({ marker.set(System.currentTimeMillis); tries.next })
+      val runF = policy({ marker.set(System.currentTimeMillis); tries.next() })
       runF.map { result =>
         val delta = marker.get() - marker_base
         assert(success.predicate(result) === true && delta >= 90) // was 110
@@ -181,7 +183,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         implicit val algo: Jitter = algoCreator(10.millis)
         val tries = forwardCountingFutureStream().iterator
         val policy = JitterBackoff(3, 1.milli)
-        policy(tries.next).map(result => assert(success.predicate(result) === true))
+        policy(tries.next()).map(result => assert(success.predicate(result) === true))
       }
 
       it("should fail when expected") {
@@ -228,7 +230,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         val marker_base = System.currentTimeMillis
         val marker = new AtomicLong(0)
 
-        policy({ marker.set(System.currentTimeMillis); tries.next }).map { result =>
+        policy({ marker.set(System.currentTimeMillis); tries.next() }).map { result =>
           val delta = marker.get() - marker_base
           assert(success.predicate(result) === true && delta >= 0)
         }
@@ -242,7 +244,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         val marker_base = System.currentTimeMillis
         val marker = new AtomicLong(0)
 
-        policy({ marker.set(System.currentTimeMillis); tries.next }).map { result =>
+        policy({ marker.set(System.currentTimeMillis); tries.next() }).map { result =>
           val delta = marker.get() - marker_base
           assert(success.predicate(result) === true && delta >= 0)
         }
@@ -286,7 +288,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
             Pause(delay = 2.seconds)
           }
       }
-      val future = policy(tries.next)
+      val future = policy(tries.next())
       future.map(result => assert(success.predicate(result) === true))
     }
 
@@ -299,13 +301,12 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
         case 1 => Directly()
       }
 
-      val future = policy(tries.next)
+      val future = policy(tries.next())
       future.map(result => assert(success.predicate(result) === false))
     }
 
     it("should handle future failures") {
       implicit val success = Success[Boolean](identity)
-      case class RetryAfter(duration: FiniteDuration) extends RuntimeException
       val retried = new AtomicBoolean
       def run() =
         if (retried.get()) Future(true)
@@ -430,7 +431,7 @@ abstract class PolicySpec extends AsyncFunSpec with BeforeAndAfterAll {
       val innerPolicy = Directly(3)
       val future = FailFast(innerPolicy) { case _ =>
         false
-      }(tries.next)
+      }(tries.next())
       future.map(result => assert(success.predicate(result) === true))
     }