diff --git a/build.sbt b/build.sbt
index 7977a15cfb..935d953264 100644
--- a/build.sbt
+++ b/build.sbt
@@ -148,8 +148,8 @@ lazy val catsJVM = project.in(file(".catsJVM"))
   .settings(moduleName := "cats")
   .settings(catsSettings)
   .settings(commonJvmSettings)
-  .aggregate(macrosJVM, kernelJVM, kernelLawsJVM, coreJVM, lawsJVM, freeJVM, testsJVM, jvm, docs, bench)
-  .dependsOn(macrosJVM, kernelJVM, kernelLawsJVM, coreJVM, lawsJVM, freeJVM, testsJVM % "test-internal -> test", jvm, bench % "compile-internal;test-internal -> test")
+  .aggregate(macrosJVM, kernelJVM, kernelLawsJVM, coreJVM, lawsJVM, freeJVM, testsJVM, docs, bench)
+  .dependsOn(macrosJVM, kernelJVM, kernelLawsJVM, coreJVM, lawsJVM, freeJVM, testsJVM % "test-internal -> test", bench % "compile-internal;test-internal -> test")
 
 lazy val catsJS = project.in(file(".catsJS"))
   .settings(moduleName := "cats")
@@ -247,13 +247,6 @@ lazy val tests = crossProject.crossType(CrossType.Pure)
 lazy val testsJVM = tests.jvm
 lazy val testsJS = tests.js
 
-// cats-jvm is JVM-only
-lazy val jvm = project
-  .dependsOn(macrosJVM, coreJVM, testsJVM % "test-internal -> test")
-  .settings(moduleName := "cats-jvm")
-  .settings(catsSettings:_*)
-  .settings(commonJvmSettings:_*)
-
 // bench is currently JVM-only
 lazy val bench = project.dependsOn(macrosJVM, coreJVM, freeJVM, lawsJVM)
   .settings(moduleName := "cats-bench")
@@ -338,7 +331,7 @@ lazy val publishSettings = Seq(
 ) ++ credentialSettings ++ sharedPublishSettings ++ sharedReleaseProcess
 
 // These aliases serialise the build for the benefit of Travis-CI.
-addCommandAlias("buildJVM", ";macrosJVM/compile;coreJVM/compile;kernelLawsJVM/compile;lawsJVM/compile;freeJVM/compile;kernelLawsJVM/test;coreJVM/test;testsJVM/test;freeJVM/test;jvm/test;bench/test")
+addCommandAlias("buildJVM", ";macrosJVM/compile;coreJVM/compile;kernelLawsJVM/compile;lawsJVM/compile;freeJVM/compile;kernelLawsJVM/test;coreJVM/test;testsJVM/test;freeJVM/test;bench/test")
 
 addCommandAlias("validateJVM", ";scalastyle;buildJVM;makeSite")
 
diff --git a/jvm/src/main/scala/cats/jvm/std/future.scala b/jvm/src/main/scala/cats/jvm/std/future.scala
deleted file mode 100644
index b01d8eb89b..0000000000
--- a/jvm/src/main/scala/cats/jvm/std/future.scala
+++ /dev/null
@@ -1,43 +0,0 @@
-package cats
-package jvm
-package std
-
-import scala.concurrent.{Await, Future}
-import scala.concurrent.{ExecutionContext => E}
-import scala.concurrent.duration.FiniteDuration
-
-import cats.std.FutureCoflatMap
-import cats.syntax.all._
-
-object future extends FutureInstances0
-
-private[std] sealed trait FutureInstances0 extends FutureInstances1 {
-  def futureComonad(atMost: FiniteDuration)(implicit ec: E): Comonad[Future] =
-    new FutureCoflatMap with Comonad[Future] {
-      def extract[A](x: Future[A]): A =
-        Await.result(x, atMost)
-    }
-
-  def futureOrder[A: Order](atMost: FiniteDuration)(implicit ec: E): Order[Future[A]] =
-    new Order[Future[A]] {
-      def compare(x: Future[A], y: Future[A]): Int =
-        Await.result((x zip y).map { case (x, y) => x compare y }, atMost)
-    }
-}
-
-private[std] sealed trait FutureInstances1 extends FutureInstances2 {
-  def futurePartialOrder[A: PartialOrder](atMost: FiniteDuration)(implicit ec: E): PartialOrder[Future[A]] =
-    new PartialOrder[Future[A]] {
-      def partialCompare(x: Future[A], y: Future[A]): Double =
-        Await.result((x zip y).map { case (x, y) => x partialCompare y }, atMost)
-    }
-
-}
-
-private[std] sealed trait FutureInstances2 {
-  def futureEq[A: Eq](atMost: FiniteDuration)(implicit ec: E): Eq[Future[A]] =
-    new Eq[Future[A]] {
-      def eqv(x: Future[A], y: Future[A]): Boolean =
-        Await.result((x zip y).map { case (x, y) => x === y }, atMost)
-    }
-}
diff --git a/jvm/src/test/scala/cats/tests/FutureTests.scala b/jvm/src/test/scala/cats/tests/FutureTests.scala
deleted file mode 100644
index 8fba502584..0000000000
--- a/jvm/src/test/scala/cats/tests/FutureTests.scala
+++ /dev/null
@@ -1,49 +0,0 @@
-package cats
-package jvm
-package tests
-
-import cats.data.Xor
-import cats.laws.discipline._
-import cats.laws.discipline.arbitrary.evalArbitrary
-import cats.jvm.std.future.futureComonad
-import cats.tests.CatsSuite
-
-import scala.concurrent.{Await, Future}
-import scala.concurrent.duration._
-import scala.concurrent.ExecutionContext.Implicits.global
-
-import org.scalacheck.Arbitrary
-import org.scalacheck.Arbitrary.arbitrary
-
-class FutureTests extends CatsSuite {
-  val timeout = 3.seconds
-
-  def futureXor[A](f: Future[A]): Future[Xor[Throwable, A]] =
-    f.map(Xor.right[Throwable, A]).recover { case t => Xor.left(t) }
-
-  implicit def eqfa[A: Eq]: Eq[Future[A]] =
-    new Eq[Future[A]] {
-      def eqv(fx: Future[A], fy: Future[A]): Boolean = {
-        val fz = futureXor(fx) zip futureXor(fy)
-        Await.result(fz.map { case (tx, ty) => tx === ty }, timeout)
-      }
-    }
-
-  implicit val throwableEq: Eq[Throwable] =
-    Eq.fromUniversalEquals
-
-  implicit val comonad: Comonad[Future] = futureComonad(timeout)
-
-  // Need non-fatal Throwables for Future recoverWith/handleError
-  implicit val nonFatalArbitrary: Arbitrary[Throwable] =
-    Arbitrary(arbitrary[Exception].map(identity))
-
-  checkAll("Future[Int]", MonadErrorTests[Future, Throwable].monadError[Int, Int, Int])
-  checkAll("Future[Int]", ComonadTests[Future].comonad[Int, Int, Int])
-
-  test("pureEval lifts a potentially lazy value into Future") {
-    forAll { e: Eval[Int] =>
-      e.pureEval[Future].extract should === (e.value)
-    }
-  }
-}