diff --git a/build.sbt b/build.sbt
index 27a3fd056..0e470865e 100644
--- a/build.sbt
+++ b/build.sbt
@@ -6,7 +6,6 @@ lazy val scalachess = Project("scalachess", file(".")).settings(
     "org.scalameta"  %% "munit"            % "1.0.0-M8" % Test,
     "org.scalacheck" %% "scalacheck"       % "1.17.0"   % Test,
     "org.scalameta"  %% "munit-scalacheck" % "1.0.0-M8" % Test,
-    "com.github.lenguyenthanh" % "compression" % "aacf55bea2" % Test, // a fork of lichess compression which public everything so we can use it for testing.
     "com.disneystreaming" %% "weaver-cats"       % "0.8.3" % Test,
     "com.disneystreaming" %% "weaver-scalacheck" % "0.8.3" % Test,
     "co.fs2"              %% "fs2-core"          % "3.7.0" % Test,
diff --git a/src/test/scala/bitboard/BitboardTest.scala b/src/test/scala/bitboard/BitboardTest.scala
deleted file mode 100644
index 228d18604..000000000
--- a/src/test/scala/bitboard/BitboardTest.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-package chess
-package bitboard
-
-import munit.ScalaCheckSuite
-import org.lichess.compression.game.Bitboard as CBB
-import org.scalacheck.Prop
-import Square.*
-
-import Arbitraries.given
-
-class BitboardTest extends ScalaCheckSuite:
-
-  import scala.language.implicitConversions
-  given Conversion[Square, Int]    = _.value
-  given Conversion[Bitboard, Long] = _.value
-  import Bitboard.*
-
-  val allDeltas =
-    List(
-      KING_DELTAS,
-      KNIGHT_DELTAS,
-      BISHOP_DELTAS,
-      ROOK_DELTAS,
-      KING_DELTAS,
-      WHITE_PAWN_DELTAS,
-      BLACK_PAWN_DELTAS
-    )
-
-  def as(array: Array[Int]) = array.map(i => s"$i, ").mkString
-
-  test("single cases"):
-    val occupied = 20292374.bb
-    val deltas   = KING_DELTAS
-    val s        = Square.at(43).get
-    val result   = Bitboard.slidingAttacks(s, occupied, deltas)
-    val expected = CBB.slidingAttacks(s, occupied, deltas)
-    assertEquals(result, expected.bb)
-
-  test("slidingAttack with all occupied"):
-    val occupied = Bitboard(-1L)
-    for
-      i      <- 0 to 63
-      deltas <- allDeltas
-      s        = Square.at(i).get
-      result   = Bitboard.slidingAttacks(s, occupied, deltas)
-      expected = CBB.slidingAttacks(s, occupied, deltas)
-    yield assertEquals(result, expected.bb)
-
-  property("slidingAttack check"):
-    Prop.forAll: (occupied: Bitboard, s: Square) =>
-      val result = for
-        deltas <- allDeltas
-        result   = Bitboard.slidingAttacks(s, occupied, deltas)
-        expected = CBB.slidingAttacks(s, occupied, deltas)
-      yield result == expected.bb
-      result.forall(identity)
-
-  test("init function"):
-    assertEquals(Bitboard.KNIGHT_ATTACKS.toSeq, CBB.KNIGHT_ATTACKS.toSeq)
-    assertEquals(Bitboard.WHITE_PAWN_ATTACKS.toSeq, CBB.WHITE_PAWN_ATTACKS.toSeq)
-    assertEquals(Bitboard.BLACK_PAWN_ATTACKS.toSeq, CBB.BLACK_PAWN_ATTACKS.toSeq)
-    assertEquals(Bitboard.ATTACKS.toSeq, CBB.ATTACKS.toSeq)
-    (0 until 64).foreach { i =>
-      assertEquals(Bitboard.RAYS(i).toSeq, CBB.RAYS(i).toSeq)
-      assertEquals(Bitboard.BETWEEN(i).toSeq, CBB.BETWEEN(i).toSeq)
-    }
-
-  property("bishop attacks"):
-    Prop.forAll: (occupied: Bitboard, s: Square) =>
-      s.bishopAttacks(occupied) == CBB.bishopAttacks(s, occupied).bb
-
-  property("rook attacks"):
-    Prop.forAll: (occupied: Bitboard, s: Square) =>
-      s.rookAttacks(occupied) == CBB.rookAttacks(s, occupied).bb
-
-  property("queen attacks"):
-    Prop.forAll: (occupied: Bitboard, s: Square) =>
-      s.queenAttacks(occupied) == CBB.queenAttacks(s, occupied).bb
-
-  property("pawn attacks"):
-    Prop.forAll: (s: Square) =>
-      s.pawnAttacks(Color.White) == CBB.pawnAttacks(true, s).bb
-      s.pawnAttacks(Color.Black) == CBB.pawnAttacks(false, s).bb
diff --git a/src/test/scala/bitboard/BoardTest.scala b/src/test/scala/bitboard/BoardTest.scala
index e2f1c7dbf..f7062d73f 100644
--- a/src/test/scala/bitboard/BoardTest.scala
+++ b/src/test/scala/bitboard/BoardTest.scala
@@ -4,7 +4,6 @@ package bitboard
 import munit.FunSuite
 
 import Square.*
-import Helpers.*
 import Bitboard.*
 import chess.format.Fen
 import chess.format.EpdFen
@@ -13,28 +12,11 @@ class BoardTest extends FunSuite:
 
   import scala.language.implicitConversions
   given Conversion[Square, Int] = _.value
-  given Conversion[Int, Square] = Square.at(_).get
+  given Conversion[Int, Square] = Square(_)
 
   def parseFen(fen: EpdFen): Board =
     Fen.read(fen).map(_.board.board).getOrElse(throw RuntimeException("boooo"))
 
-  test("sliderBlockers"):
-    for
-      fen <- FenFixtures.fens
-      situation = Fen.read(fen).getOrElse(throw RuntimeException("boooo"))
-      king      = situation.ourKings.head
-      result    = situation.board.sliderBlockers(king, situation.color)
-      expected  = situation.cBoard.sliderBlockers(king)
-    yield assertEquals(result, Bitboard(expected))
-
-  test("generateMoves = generateMovesAt for all square"):
-    for
-      fen <- FenFixtures.fens
-      situation     = Fen.read(fen).getOrElse(throw RuntimeException("boooo"))
-      legalMoves    = situation.legalMoves
-      legalMovesAll = Square.all.flatMap(situation.generateMovesAt(_))
-    yield assertEquals(legalMoves.toSet, legalMovesAll.toSet)
-
   test("generateMovesAt(square) = generateMoves.filter(_.orig == square)"):
     for
       fen <- FenFixtures.fens
@@ -44,17 +26,6 @@ class BoardTest extends FunSuite:
       legalMovesAt = situation.generateMovesAt(sq)
     yield assertEquals(legalMoves.toSet, legalMovesAt.toSet)
 
-  test("attacksTo"):
-    for
-      str <- FenFixtures.fens
-      fen  = Fen.read(str).getOrElse(throw RuntimeException("boooo"))
-      king = fen.ourKings.head
-      sq    <- Square.all
-      color <- List(Color.White, Color.Black)
-      result   = fen.board.attackers(sq, color)
-      expected = fen.cBoard.attacksTo(sq, color.white)
-    yield assertEquals(result, Bitboard(expected))
-
   test("discard an empty square returns the same board"):
     for
       str <- FenFixtures.fens
diff --git a/src/test/scala/bitboard/Helpers.scala b/src/test/scala/bitboard/Helpers.scala
deleted file mode 100644
index 23f1d224e..000000000
--- a/src/test/scala/bitboard/Helpers.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-package chess
-package bitboard
-
-import scala.collection.mutable.ListBuffer
-
-import org.lichess.compression.game.{ Board as CBoard, Move as CMove, MoveList, Role as CRole } // scalafix:ok
-
-object Helpers:
-
-  import scala.language.implicitConversions
-
-  import Bitboard.*
-  given Conversion[Bitboard, Long] = _.value
-  given Conversion[Long, Bitboard] = _.bb
-
-  extension (f: Situation)
-    def cBoard: CBoard =
-      CBoard(
-        f.board.pawns,
-        f.board.knights,
-        f.board.bishops,
-        f.board.rooks,
-        f.board.queens,
-        f.board.kings,
-        f.board.white,
-        f.board.black,
-        f.isWhiteTurn,
-        f.potentialEpSquare.fold(0)(_.value),
-        f.history.castles.value
-      )
-
-  extension (ml: MoveList)
-    def uciSet: Set[String] =
-      val buffer = ListBuffer[String]()
-      (0 until ml.size).foreach(i => buffer.addOne(ml.get(i).uci))
-      buffer.toSet
-
-  extension (r: Role)
-    def cRole: CRole =
-      r match
-        case Pawn   => CRole.PAWN
-        case Knight => CRole.KNIGHT
-        case Bishop => CRole.BISHOP
-        case Rook   => CRole.ROOK
-        case Queen  => CRole.QUEEN
-        case King   => CRole.KING
-
-  extension (m: Move)
-    def cMove: CMove =
-      val cm = CMove()
-      cm.from = m.from.value
-      cm.to = m.to.value
-      cm.capture = m.isCapture
-      cm.role = m.role.cRole
-      m match
-        case Move.Normal(_, _, _, _) =>
-          cm.`type` = CMove.NORMAL
-        case Move.Promotion(_, _, p, _) =>
-          cm.`type` = CMove.NORMAL
-          cm.promotion = p.cRole
-        case Move.EnPassant(_, _) =>
-          cm.`type` = CMove.EN_PASSANT
-        case Move.Castle(_, _) =>
-          cm.`type` = CMove.CASTLING
-      cm
diff --git a/src/test/scala/bitboard/Move.scala b/src/test/scala/bitboard/Move.scala
deleted file mode 100644
index 6764c806b..000000000
--- a/src/test/scala/bitboard/Move.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-package chess
-package bitboard
-
-// case Capture(from: square, to: square, role: Role, capture: Role)???
-// case Drop/Put(role: Role, to: square)
-enum Move(val from: Square, val to: Square, val role: Role):
-  case Normal(override val from: Square, override val to: Square, override val role: Role, capture: Boolean)
-      extends Move(from, to, role)
-  case Castle(override val from: Square, override val to: Square)    extends Move(from, to, King)
-  case EnPassant(override val from: Square, override val to: Square) extends Move(from, to, Pawn)
-  case Promotion(override val from: Square, override val to: Square, promoted: Role, capture: Boolean)
-      extends Move(from, to, Pawn)
-
-  def isCapture: Boolean =
-    this match
-      case EnPassant(_, _)             => true
-      case Castle(_, _)                => false
-      case Promotion(_, _, _, capture) => capture
-      case Normal(_, _, _, capture)    => capture
-
-  def isHalfMove: Boolean =
-    role != Pawn && !isCapture
-
-  extension (square: Square)
-    def uci: String =
-      val f = square.file.char
-      val r = square.rank.char
-      s"$f$r"
-
-  def uci: String =
-    this match
-      case Promotion(from, to, role, _) => s"${from.uci}${to.uci}${role.forsyth}"
-      case Castle(from, to) =>
-        val k = from.withFile(if to < from then File.C else File.G)
-        s"${from.uci}${k.uci}"
-      case _ => s"${from.uci}${to.uci}"