diff --git a/library/src-non-bootstrapped/dotty/DottyPredef.scala b/library/src-non-bootstrapped/dotty/DottyPredef.scala
deleted file mode 100644
index 3b6d93f5b0fa..000000000000
--- a/library/src-non-bootstrapped/dotty/DottyPredef.scala
+++ /dev/null
@@ -1,47 +0,0 @@
-package dotty
-
-object DottyPredef {
-  import compiletime.summonFrom
-
-  inline def assert(inline assertion: Boolean, inline message: => Any): Unit =
-    if !assertion then scala.runtime.Scala3RunTime.assertFailed(message)
-
-  inline def assert(inline assertion: Boolean): Unit =
-    if !assertion then scala.runtime.Scala3RunTime.assertFailed()
-
-  /**
-   * Retrieve the single value of a type with a unique inhabitant.
-   *
-   * @example {{{
-   * object Foo
-   * val foo = valueOf[Foo.type]
-   * // foo is Foo.type = Foo
-   *
-   * val bar = valueOf[23]
-   * // bar is 23.type = 23
-   * }}}
-   * @group utilities
-   */
-  inline def valueOf[T]: T = summonFrom {
-    case ev: ValueOf[T] => ev.value
-  }
-
-  /** Summon a given value of type `T`. Usually, the argument is not passed explicitly.
-   *
-   *  @tparam T the type of the value to be summoned
-   *  @return the given value typed as the provided type parameter
-   */
-  inline def summon[T](using x: T): x.type = x
-
-  // Extension methods for working with explicit nulls
-
-  /** Strips away the nullability from a value.
-   *  e.g.
-   *    val s1: String|Null = "hello"
-   *    val s: String = s1.nn
-   *
-   *  Note that `.nn` performs a checked cast, so if invoked on a null value it'll throw an NPE.
-   */
-  extension [T](x: T | Null) inline def nn: x.type & T =
-    scala.runtime.Scala3RunTime.nn(x)
-}
diff --git a/library/src-non-bootstrapped/scala/Eql.scala b/library/src-non-bootstrapped/scala/Eql.scala
deleted file mode 100644
index 2874cc38a84b..000000000000
--- a/library/src-non-bootstrapped/scala/Eql.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-package scala
-
-import annotation.implicitNotFound
-import scala.collection.{Seq, Set}
-
-/** A marker trait indicating that values of type `L` can be compared to values of type `R`. */
-@implicitNotFound("Values of types ${L} and ${R} cannot be compared with == or !=")
-sealed trait Eql[-L, -R]
-
-type CanEqual[L, R] = Eql[L, R]
-
-lazy val CanEqual = Eql
-
-/** Companion object containing a few universally known `Eql` instances.
- *  Eql instances involving primitive types or the Null type are handled directly in
- *  the compiler (see Implicits.synthesizedEql), so they are not included here.
- */
-object Eql {
-  /** A universal `Eql` instance. */
-  object derived extends Eql[Any, Any]
-
-  /** A fall-back instance to compare values of any types.
-   *  Even though this method is not declared as given, the compiler will
-   *  synthesize implicit arguments as solutions to `Eql[T, U]` queries if
-   *  the rules of multiversal equality require it.
-   */
-  def eqlAny[L, R]: Eql[L, R] = derived
-
-  // Instances of `Eql` for common Java types
-  given eqlNumber as Eql[Number, Number] = derived
-  given eqlString as Eql[String, String] = derived
-
-  // The next three definitions can go into the companion objects of classes
-  // Seq and Set. For now they are here in order not to have to touch the
-  // source code of these classes
-  given eqlSeq[T, U](using eq: Eql[T, U]) as Eql[Seq[T], Seq[U]] = derived
-  given eqlSet[T, U](using eq: Eql[T, U]) as Eql[Set[T], Set[U]] = derived
-}
diff --git a/library/src-non-bootstrapped/scala/internal/MatchCase.scala b/library/src-non-bootstrapped/scala/internal/MatchCase.scala
deleted file mode 100644
index 8ae54768fe00..000000000000
--- a/library/src-non-bootstrapped/scala/internal/MatchCase.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-package scala.internal
-
-/** A type constructor for a case in a match type.
- */
-final abstract class MatchCase[Pat, +Body]
diff --git a/library/src-non-bootstrapped/scala/internal/TypeBox.scala b/library/src-non-bootstrapped/scala/internal/TypeBox.scala
deleted file mode 100644
index 1accb4da4c22..000000000000
--- a/library/src-non-bootstrapped/scala/internal/TypeBox.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-package scala.internal
-
-/** A type for skolems that are generated during capture conversion. Capture conversion
- *  narrows the type of a tree whose type has wildcard arguments. A typical situation
- *  is a tree `t` of type `C[_ >: L <: U]` and an expected type `C[X]` where `X` is an
- *  instantiatable type variable. To be able to instantiate `X`, we cast the tree to type
- *  `X[$n.CAP]` where `$n` is a fresh skolem type with underlying type `TypeBox[L, U]`.
- */
-final abstract class TypeBox[-L <: U, +U] {
-  type CAP >: L <: U
-}
diff --git a/library/src-non-bootstrapped/scala/internal/quoted/CompileTime.scala b/library/src-non-bootstrapped/scala/internal/quoted/CompileTime.scala
deleted file mode 100644
index 23377924ddc2..000000000000
--- a/library/src-non-bootstrapped/scala/internal/quoted/CompileTime.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-package scala.internal.quoted
-
-import scala.annotation.{Annotation, compileTimeOnly}
-import scala.quoted._
-
-@compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime`")
-object CompileTime {
-
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprQuote`")
-  def exprQuote[T](x: T): Quotes ?=> Expr[T] = ???
-
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprSplice`")
-  def exprSplice[T](x: Quotes ?=> Expr[T]): T = ???
-
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprNestedSplice`")
-  def exprNestedSplice[T](ctx: Quotes)(x: ctx.Nested ?=> Expr[T]): T = ???
-
-  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.quoteTypeTag`")
-  class quoteTypeTag extends Annotation
-
-}
diff --git a/library/src-non-bootstrapped/scala/quoted/Type.scala b/library/src-non-bootstrapped/scala/quoted/Type.scala
deleted file mode 100644
index 05daac01f659..000000000000
--- a/library/src-non-bootstrapped/scala/quoted/Type.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-package scala.quoted
-
-import scala.annotation.compileTimeOnly
-
-abstract class Type[T <: AnyKind] private[scala]:
-  type Underlying = T
-
-object Type:
-  @compileTimeOnly("Reference to `scala.quoted.Type.apply` was not handled by PickleQuotes")
-  given of[T <: AnyKind] as (Quotes ?=> Type[T]) = ???
-  given apply[T <: AnyKind] as (Quotes ?=> Type[T]) = ???
diff --git a/library/src-non-bootstrapped/scala/quoted/internal/Expr.scala b/library/src-non-bootstrapped/scala/quoted/internal/Expr.scala
deleted file mode 100644
index d70be07f8574..000000000000
--- a/library/src-non-bootstrapped/scala/quoted/internal/Expr.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-package scala.quoted
-package internal
-
-import scala.annotation.{Annotation, compileTimeOnly}
-
-@compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr`")
-object Expr:
-
-  /** A term quote is desugared by the compiler into a call to this method */
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr.quote`")
-  def quote[T](x: T): Quotes ?=> scala.quoted.Expr[T] = ???
-
-  /** A term splice is desugared by the compiler into a call to this method */
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr.splice`")
-  def splice[T](x: Quotes ?=> scala.quoted.Expr[T]): T = ???
-
-  /** A term splice nested within a quote is desugared by the compiler into a call to this method.
-  *  `ctx` is the `Quotes` that the quote of this splice uses.
-  */
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Expr.nestedSplice`")
-  def nestedSplice[T](ctx: Quotes)(x: ctx.Nested ?=> scala.quoted.Expr[T]): T = ???
diff --git a/library/src-non-bootstrapped/scala/quoted/internal/Patterns.scala b/library/src-non-bootstrapped/scala/quoted/internal/Patterns.scala
deleted file mode 100644
index 4466be13de4c..000000000000
--- a/library/src-non-bootstrapped/scala/quoted/internal/Patterns.scala
+++ /dev/null
@@ -1,28 +0,0 @@
-package scala.quoted.internal
-
-import scala.annotation.{Annotation, compileTimeOnly}
-
-@compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns`")
-object Patterns {
-
-  /** A splice in a quoted pattern is desugared by the compiler into a call to this method */
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns.patternHole`")
-  def patternHole[T]: T = ???
-
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns.patternHigherOrderHole`")
-  /** A higher order splice in a quoted pattern is desugared by the compiler into a call to this method */
-  def patternHigherOrderHole[U](pat: Any, args: Any*): U = ???
-
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns.higherOrderHole`")
-  /** A higher order splice in a quoted pattern is desugared by the compiler into a call to this method */
-  def higherOrderHole[U](args: Any*): U = ???
-
-  /** A splice of a name in a quoted pattern is that marks the definition of a type splice */
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns.patternType`")
-  class patternType extends Annotation
-
-  /** A type pattern that must be aproximated from above */
-  @compileTimeOnly("Illegal reference to `scala.quoted.internal.Patterns.fromAbove`")
-  class fromAbove extends Annotation
-
-}
diff --git a/library/src-non-bootstrapped/scala/quoted/internal/SplicedType.scala b/library/src-non-bootstrapped/scala/quoted/internal/SplicedType.scala
deleted file mode 100644
index 3dc0a6e7f4d0..000000000000
--- a/library/src-non-bootstrapped/scala/quoted/internal/SplicedType.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-package scala.quoted.internal
-
-import scala.annotation.{Annotation, compileTimeOnly}
-
-/** Artifact of pickled type splices
- *
- *  During quote reification a quote `'{ ... F[t.Underlying] ... }` will be transformed into
- *  `'{ @SplicedType type T$1 = t.Underlying ... F[T$1] ... }` to have a tree for `t.Underlying`.
- *  This artifact is removed during quote unpickling.
- *
- *  See PickleQuotes.scala and PickledQuotes.scala
- */
-@compileTimeOnly("Illegal reference to `scala.quoted.internal.SplicedType`")
-class SplicedType extends Annotation
diff --git a/library/src-non-bootstrapped/scalaShadowing/language.scala b/library/src-non-bootstrapped/scalaShadowing/language.scala
deleted file mode 100644
index 3e3886854bfa..000000000000
--- a/library/src-non-bootstrapped/scalaShadowing/language.scala
+++ /dev/null
@@ -1,257 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2015, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-package scalaShadowing
-
-/**
- *  The `scala.language` object controls the language features available to the programmer, as proposed in the
- *  [[https://docs.google.com/document/d/1nlkvpoIRkx7at1qJEZafJwthZ3GeIklTFhqmXMvTX9Q/edit '''SIP-18 document''']].
- *
- *  Each of these features has to be explicitly imported into the current scope to become available:
- *  {{{
- *     import language.postfixOps // or language._
- *     List(1, 2, 3) reverse
- *  }}}
- *
- *  The language features are:
- *   - [[dynamics            `dynamics`]]            enables defining calls rewriting using the [[scala.Dynamic `Dynamic`]] trait
- *   - [[postfixOps          `postfixOps`]]          enables postfix operators
- *   - [[reflectiveCalls     `reflectiveCalls`]]     enables using structural types
- *   - [[implicitConversions `implicitConversions`]] enables defining implicit methods and members
- *   - [[higherKinds         `higherKinds`]]         enables writing higher-kinded types
- *   - [[existentials        `existentials`]]        enables writing existential types
- *   - [[experimental        `experimental`]]        contains newer features that have not yet been tested in production
- *
- *  and, for dotty:
- *
- *   - [[Scala2              `Scala2`]]              backwards compatibility mode for Scala2
- *   - [[noAutoTupling       `noAutoTupling`]]       disable auto-tupling
- *   - [[strictEquality      `strictEquality`]]      enable strick equality
- *
- *  @groupname production   Language Features
- *  @groupname experimental Experimental Language Features
- *  @groupprio experimental 10
- *
- *  Dotty-specific features come at the end.
- *
- *  Note: Due to the more restricted language import mechanism in dotty (only
- *  imports count, implicits are disregarded) we don't need the constructions
- *  of the inherited language features. A simple object for each feature is
- *  sufficient.
- */
-object language {
-
-  import languageFeature._
-
-  /** Where enabled, direct or indirect subclasses of trait scala.Dynamic can
-   *  be defined. Unless dynamics is enabled, a definition of a class, trait,
-   *  or object that has Dynamic as a base trait is rejected. Dynamic member
-   *  selection of existing subclasses of trait Dynamic are unaffected;
-   *  they can be used anywhere.
-   *
-   *  '''Why introduce the feature?''' To enable flexible DSLs and convenient interfacing
-   *  with dynamic languages.
-   *
-   *  '''Why control it?''' Dynamic member selection can undermine static checkability
-   *  of programs. Furthermore, dynamic member selection often relies on reflection,
-   *  which is not available on all platforms.
-   *
-   *  @group production
-   */
-  implicit lazy val dynamics: dynamics = languageFeature.dynamics
-
-  /** Only where enabled, postfix operator notation `(expr op)` will be allowed.
-   *
-   *  '''Why keep the feature?''' Several DSLs written in Scala need the notation.
-   *
-   *  '''Why control it?''' Postfix operators interact poorly with semicolon inference.
-   *   Most programmers avoid them for this reason.
-   *
-   *  @group production
-   */
-  implicit lazy val postfixOps: postfixOps = languageFeature.postfixOps
-
-  /** Only where enabled, accesses to members of structural types that need
-   *  reflection are supported. Reminder: A structural type is a type of the form
-   *  `Parents { Decls }` where `Decls` contains declarations of new members that do
-   *  not override any member in `Parents`. To access one of these members, a
-   *  reflective call is needed.
-   *
-   *  '''Why keep the feature?''' Structural types provide great flexibility because
-   *  they avoid the need to define inheritance hierarchies a priori. Besides,
-   *  their definition falls out quite naturally from Scala’s concept of type refinement.
-   *
-   *  '''Why control it?''' Reflection is not available on all platforms. Popular tools
-   *  such as ProGuard have problems dealing with it. Even where reflection is available,
-   *  reflective dispatch can lead to surprising performance degradations.
-   *
-   *  @group production
-   */
-  implicit lazy val reflectiveCalls: reflectiveCalls = languageFeature.reflectiveCalls
-
-  /** Only where enabled, definitions of legacy implicit conversions and certain uses
-   *  of implicit conversions are allowed.
-   *
-   *  A legacy implicit conversion is an implicit value of unary function type `A => B`,
-   *  or an implicit method that has in its first parameter section a single,
-   *  non-implicit parameter. Examples:
-   *
-   *  {{{
-   *     implicit def stringToInt(s: String): Int = s.length
-   *     implicit val conv = (s: String) => s.length
-   *     implicit def listToX(xs: List[T])(implicit f: T => X): X = ...
-   *  }}}
-   *
-   *  Implicit values of other types are not affected, and neither are implicit
-   *  classes. In particular, given instances of the scala.Conversion class can be
-   *  defined without having to import the language feature.
-   *
-   *  The language import is also required to enable _uses_ of implicit conversions
-   *  unless the conversion in question is co-defined with the type to which it maps.
-   *  Co-defined means: defined in the companion object of the class of the result type.
-   *  Examples:
-   *
-   *  {{{
-   *      class A
-   *      class B
-   *      object B {
-   *        given a2b as Conversion[A, B] { ... }
-   *      }
-   *      object C {
-   *        given b2a as Conversion[B, A] { ... }
-   *      }
-   *      import given B._
-   *      import given C._
-   *      val x: A = new B     // language import required
-   *      val x: B = new A     // no import necessary since a2b is co-defined with B
-   *  }}}
-   *
-   *  '''Why keep the feature?''' Implicit conversions are central to many aspects
-   *  of Scala’s core libraries.
-   *
-   *  '''Why control it?''' Implicit conversions are known to cause many pitfalls
-   *  if over-used. This holds in particular for implicit conversions defined after
-   *  the fact between unrelated types.
-   *
-   *  @group production
-   */
-  implicit lazy val implicitConversions: implicitConversions = languageFeature.implicitConversions
-
-  /** Only where this flag is enabled, higher-kinded types can be written.
-   *
-   *  '''Why keep the feature?''' Higher-kinded types enable the definition of very general
-   *  abstractions such as functor, monad, or arrow. A significant set of advanced
-   *  libraries relies on them. Higher-kinded types are also at the core of the
-   *  scala-virtualized effort to produce high-performance parallel DSLs through staging.
-   *
-   *  '''Why control it?''' Higher kinded types in Scala lead to a Turing-complete
-   *  type system, where compiler termination is no longer guaranteed. They tend
-   *  to be useful mostly for type-level computation and for highly generic design
-   *  patterns. The level of abstraction implied by these design patterns is often
-   *  a barrier to understanding for newcomers to a Scala codebase. Some syntactic
-   *  aspects of higher-kinded types are hard to understand for the uninitiated and
-   *  type inference is less effective for them than for normal types. Because we are
-   *  not completely happy with them yet, it is possible that some aspects of
-   *  higher-kinded types will change in future versions of Scala. So an explicit
-   *  enabling also serves as a warning that code involving higher-kinded types
-   *  might have to be slightly revised in the future.
-   *
-   *  @group production
-   */
-  implicit lazy val higherKinds: higherKinds = languageFeature.higherKinds
-
-  /** Only where enabled, existential types that cannot be expressed as wildcard
-   *  types can be written and are allowed in inferred types of values or return
-   *  types of methods. Existential types with wildcard type syntax such as `List[_]`,
-   *  or `Map[String, _]` are not affected.
-   *
-   *  '''Why keep the feature?''' Existential types are needed to make sense of Java’s wildcard
-   *  types and raw types and the erased types of run-time values.
-   *
-   *  '''Why control it?''' Having complex existential types in a code base usually makes
-   *  application code very brittle, with a tendency to produce type errors with
-   *  obscure error messages. Therefore, going overboard with existential types
-   *  is generally perceived not to be a good idea. Also, complicated existential types
-   *  might be no longer supported in a future simplification of the language.
-   *
-   *  @group production
-   */
-  implicit lazy val existentials: existentials = languageFeature.existentials
-
-  /** The experimental object contains features that have been recently added but have not
-   *  been thoroughly tested in production yet.
-   *
-   *  Experimental features '''may undergo API changes''' in future releases, so production
-   *  code should not rely on them.
-   *
-   *  Programmers are encouraged to try out experimental features and
-   *  [[http://issues.scala-lang.org report any bugs or API inconsistencies]]
-   *  they encounter so they can be improved in future releases.
-   *
-   *  @group experimental
-   */
-  object experimental {
-
-    import languageFeature.experimental._
-
-    /** Where enabled, Scala 2 macro definitions are allowed. Scala 2 macro implementations and
-     *  macro applications are unaffected; they can be used anywhere. A Scala 2 macro definition
-     *  must be accompanied by a Scala 3 macro definition with the same signature.
-     *
-     *  '''Why introduce the feature?''' Scala 2 macros promise to make the language more regular,
-     *  replacing ad-hoc language constructs with a general powerful abstraction
-     *  capability that can express them. Macros are also a more disciplined and
-     *  powerful replacement for compiler plugins.
-     *
-     *  '''Why control it?''' For their very power, macros can lead to code that is hard
-     *  to debug and understand.
-     *
-     *  This is not required by Scala 3 macros as `inline` controls the basic generative macros.
-     *  More add-hoc macros must contain the import of reflection in thier code, making this import redundant.
-     */
-    implicit lazy val macros: macros = languageFeature.experimental.macros
-
-    /** Experimental support for richer dependent types */
-    object dependent
-
-    /** Experimental support for named type arguments */
-    object namedTypeArguments
-
-    /** Experimental support for generic number literals */
-    object genericNumberLiterals
-  }
-
-  /** Where imported, auto-tupling is disabled */
-  object noAutoTupling
-
-  /** Where imported, loose equality using eqAny is disabled */
-  object strictEquality
-
-  /** Where imported, ad hoc extensions of non-open classes in other
-   *  compilation units are allowed.
-   *
-   *  '''Why control the feature?''' Ad-hoc extensions should usually be avoided
-   *  since they typically cannot rely on an "internal" contract between a class
-   *  and its extensions. Only open classes need to specify such a contract.
-   *  Ad-hoc extensions might break for future versions of the extended class,
-   *  since the extended class is free to change its implementation without
-   *  being constrained by an internal contract.
-   *
-   *  '''Why allow it?''' An ad-hoc extension can sometimes be necessary,
-   *  for instance when mocking a class in a testing framework, or to work
-   *  around a bug or missing feature in the original class. Nevertheless,
-   *  such extensions should be limited in scope and clearly documented.
-   *  That's why the language import is required for them.
-   */
-  object adhocExtensions
-
-  /** Source version */
-  object `3.0-migration`
-  object `3.0`
-  object `3.1-migration`
-  object `3.1`
-}
diff --git a/library/src-bootstrapped/dotty/DottyPredef.scala b/library/src/dotty/DottyPredef.scala
similarity index 100%
rename from library/src-bootstrapped/dotty/DottyPredef.scala
rename to library/src/dotty/DottyPredef.scala
diff --git a/library/src-bootstrapped/scala/CanEqual.scala b/library/src/scala/CanEqual.scala
similarity index 100%
rename from library/src-bootstrapped/scala/CanEqual.scala
rename to library/src/scala/CanEqual.scala
diff --git a/library/src-bootstrapped/scala/quoted/ExprMap.scala b/library/src/scala/quoted/ExprMap.scala
similarity index 100%
rename from library/src-bootstrapped/scala/quoted/ExprMap.scala
rename to library/src/scala/quoted/ExprMap.scala
diff --git a/library/src-bootstrapped/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala
similarity index 100%
rename from library/src-bootstrapped/scala/quoted/Type.scala
rename to library/src/scala/quoted/Type.scala
diff --git a/library/src-bootstrapped/scala/runtime/MatchCase.scala b/library/src/scala/runtime/MatchCase.scala
similarity index 100%
rename from library/src-bootstrapped/scala/runtime/MatchCase.scala
rename to library/src/scala/runtime/MatchCase.scala
diff --git a/library/src-bootstrapped/scala/runtime/TypeBox.scala b/library/src/scala/runtime/TypeBox.scala
similarity index 100%
rename from library/src-bootstrapped/scala/runtime/TypeBox.scala
rename to library/src/scala/runtime/TypeBox.scala
diff --git a/library/src-bootstrapped/scalaShadowing/D_u_m_m_y.scala b/library/src/scalaShadowing/D_u_m_m_y.scala
similarity index 100%
rename from library/src-bootstrapped/scalaShadowing/D_u_m_m_y.scala
rename to library/src/scalaShadowing/D_u_m_m_y.scala
diff --git a/project/Build.scala b/project/Build.scala
index 9429c6813325..91741b458723 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -53,7 +53,7 @@ object MyScalaJSPlugin extends AutoPlugin {
 }
 
 object Build {
-  val referenceVersion = "3.0.0-M2-bin-20201112-462a72f-NIGHTLY"
+  val referenceVersion = "3.0.0-M2"
 
   val baseVersion = "3.0.0-RC1"
   val baseSbtDottyVersion = "0.4.7"