diff --git a/README.md b/README.md
index 373601f867..e402c11ad4 100644
--- a/README.md
+++ b/README.md
@@ -8,9 +8,9 @@ Scala CLI is a command-line tool to interact with the Scala language. It lets yo
 Scala code. (and more!) It shares some similarities with build tools, but it doesn't aim at supporting multi-module
 projects, nor to be extended via a task system.
 
-As of [SIP-46](https://github.com/scala/improvement-proposals/pull/46), Scala CLI has been accepted as the new `scala`
-command and is currently in the experimental phase. If you want to try it out, check for more
-details [here](https://scala-cli.virtuslab.org/docs/reference/scala-command/).
+As of Scala 3.5.0, Scala CLI has become the official `scala` runner of the language (for more information 
+refer to [SIP-46](https://github.com/scala/improvement-proposals/pull/46)). For more details on using Scala CLI
+via the `scala` command, refer to [this doc](https://scala-cli.virtuslab.org/docs/reference/scala-command/).
 
 ## Docs
 - user-facing documentation: [scala-cli.virtuslab.org](https://scala-cli.virtuslab.org/)
diff --git a/build.sc b/build.sc
index 36936669af..29f92121c0 100644
--- a/build.sc
+++ b/build.sc
@@ -172,6 +172,26 @@ trait DocsTests extends CrossSbtModule with ScalaCliScalafixModule with HasTests
   }
   def forkEnv = super.forkEnv() ++ extraEnv()
 
+  def constantsFile = T.persistent {
+    val dir  = T.dest / "constants"
+    val dest = dir / "Constants.scala"
+    val code =
+      s"""package sclicheck
+         |
+         |/** Build-time constants. Generated by mill. */
+         |object Constants {
+         |  def coursierOrg = "${Deps.coursier.dep.module.organization.value}"
+         |  def coursierCliModule = "${Deps.coursierCli.dep.module.name.value}"
+         |  def coursierCliVersion = "${Deps.Versions.coursierCli}"
+         |  def defaultScalaVersion = "${Scala.defaultUser}"
+         |}
+         |""".stripMargin
+    if (!os.isFile(dest) || os.read(dest) != code)
+      os.write.over(dest, code, createFolders = true)
+    PathRef(dir)
+  }
+  def generatedSources = super.generatedSources() ++ Seq(constantsFile())
+
   object test extends ScalaCliTests with ScalaCliScalafixModule {
     def forkEnv = super.forkEnv() ++ extraEnv() ++ Seq(
       "SCALA_CLI_EXAMPLES"                -> (os.pwd / "examples").toString,
diff --git a/modules/docs-tests/src/main/scala/sclicheck/sclicheck.scala b/modules/docs-tests/src/main/scala/sclicheck/sclicheck.scala
index b48cb42e02..60c5283ffd 100644
--- a/modules/docs-tests/src/main/scala/sclicheck/sclicheck.scala
+++ b/modules/docs-tests/src/main/scala/sclicheck/sclicheck.scala
@@ -13,7 +13,7 @@ import scala.util.matching.Regex
 val SnippetBlock = """ *(`{2}`+)[^ ]+ title=([\w\d.\-/_]+) *""".r
 val CompileBlock = """ *(`{2}`+) *(\w+) +(compile|fail) *(?:title=([\w\d.\-/_]+))? *(power)? *""".r
 def compileBlockEnds(backticks: String) = s""" *$backticks *""".r
-val BashCommand                         = """ *```bash *(fail|run-fail)? *""".r
+val BashCommand                         = """ *```bash *(fail|run-fail)? *(clean)? *""".r
 val CheckBlock                          = """ *\<\!-- Expected(-regex)?: *""".r
 val CheckBlockEnd                       = """ *\--> *""".r
 val Clear                               = """ *<!--+ *clear *-+-> *""".r
@@ -35,8 +35,12 @@ enum Commands:
     case Check(patterns, regex, _) =>
       val kind = if regex then "regexes" else "patterns"
       s"last output matches $kind: ${patterns.map(p => s"'$p'").mkString(", ")}"
-    case Run(cmd, shouldFail, _) =>
-      val prefix = if shouldFail then "[failure expected] " else ""
+    case Run(cmd, shouldFail, shouldClean, _) =>
+      val prefix = shouldFail -> shouldClean match
+        case (true, true)  => "[failure expected, clean]"
+        case (true, false) => "[failure expected]"
+        case (false, true) => "[clean]"
+        case _             => ""
       cmd.mkString(prefix, " ", "")
     case Write(name, _, _) =>
       name
@@ -53,7 +57,7 @@ enum Commands:
     shouldFail: Boolean,
     power: Boolean
   )
-  case Run(scriptLines: Seq[String], shouldFail: Boolean, context: Context)
+  case Run(scriptLines: Seq[String], shouldFail: Boolean, shouldClean: Boolean, context: Context)
   case Check(patterns: Seq[String], regex: Boolean, context: Context)
   case Clear(context: Context)
 
@@ -100,8 +104,8 @@ def parse(content: Seq[String], currentCommands: Seq[Commands], context: Context
         compileBlockEnds(backticks)
       )
 
-    case BashCommand(failGroup) :: tail =>
-      parseMultiline(tail, Commands.Run(_, failGroup != null, context))
+    case BashCommand(failGroup, clean) :: tail =>
+      parseMultiline(tail, Commands.Run(_, failGroup != null, clean != null, context))
 
     case CheckBlock(regexOpt) :: tail =>
       val isRegex = regexOpt == "-regex"
@@ -187,15 +191,50 @@ def checkFile(file: os.Path, options: Options): Unit =
   val binDir = {
     val binDir0 = out / ".scala-cli"
     os.makeDir.all(binDir0)
-    val escapedCommand = options.scalaCliCommand
-      .map(arg => "\"" + arg.replace("\"", "\\\"") + "\"")
-      .mkString(" ")
-    val helperScript =
-      s"""#!/usr/bin/env bash
-         |exec $escapedCommand "$$@"
-         |""".stripMargin
-    os.write(binDir0 / "scala-cli", helperScript)
-    os.perms.set(binDir0 / "scala-cli", "rwxr-xr-x")
+
+    def createHelperScript(command: Seq[String], scriptName: String): Unit = {
+      val escapedCommand = command
+        .map(arg => "\"" + arg.replace("\"", "\\\"") + "\"")
+        .mkString(" ")
+      val scriptCode =
+        s"""#!/usr/bin/env bash
+           |exec $escapedCommand "$$@"
+           |""".stripMargin
+      os.write(binDir0 / scriptName, scriptCode)
+      os.perms.set(binDir0 / scriptName, "rwxr-xr-x")
+    }
+    createHelperScript(options.scalaCliCommand, "scala-cli")
+    createHelperScript(options.scalaCliCommand, "scala")
+    val coursierCliDep =
+      s"${Constants.coursierOrg}:${Constants.coursierCliModule}:${Constants.coursierCliVersion}"
+    createHelperScript(
+      options.scalaCliCommand ++ Seq(
+        "run",
+        "--dep",
+        coursierCliDep,
+        "--",
+        "launch",
+        s"scala:${Constants.defaultScalaVersion}",
+        "-M",
+        "dotty.tools.MainGenericRunner",
+        "--"
+      ),
+      "scala_legacy"
+    )
+    createHelperScript(
+      options.scalaCliCommand ++ Seq(
+        "run",
+        "--dep",
+        coursierCliDep,
+        "--",
+        "launch",
+        s"scala:${Constants.defaultScalaVersion}",
+        "-M",
+        "dotty.tools.dotc.Main",
+        "--"
+      ),
+      "scalac"
+    )
     binDir0
   }
   val extraEnv = {
@@ -239,7 +278,15 @@ def checkFile(file: os.Path, options: Options): Unit =
       res.exitCode
 
     cmd match
-      case Commands.Run(cmds, shouldFail, _) =>
+      case Commands.Run(cmds, shouldFail, shouldClean, _) =>
+        if shouldClean then
+          os.list(out)
+            .filterNot(_ == binDir)
+            .filterNot(_.last.endsWith(".scala"))
+            .filterNot(_.last.endsWith(".sc"))
+            .filterNot(_.last.endsWith(".java"))
+            .filterNot(_.last.endsWith(".md"))
+            .foreach(os.remove.all)
         val script = out / ".scala-build" / "run.sh"
         os.write.over(script, mkBashScript(cmds), createFolders = true)
         os.perms.set(script, "rwxr-xr-x")
diff --git a/project/deps.sc b/project/deps.sc
index 681076a4af..0647ea5691 100644
--- a/project/deps.sc
+++ b/project/deps.sc
@@ -145,7 +145,8 @@ object Deps {
   def caseApp          = ivy"com.github.alexarchambault::case-app:2.1.0-M28"
   def collectionCompat = ivy"org.scala-lang.modules::scala-collection-compat:2.12.0"
   // Force using of 2.13 - is there a better way?
-  def coursier = ivy"io.get-coursier:coursier_2.13:${Versions.coursier}"
+  def coursier    = ivy"io.get-coursier:coursier_2.13:${Versions.coursier}"
+  def coursierCli = ivy"io.get-coursier:coursier-cli_2.13:${Versions.coursierCli}"
   def coursierJvm = ivy"io.get-coursier:coursier-jvm_2.13:${Versions.coursier}"
     .exclude(("com.github.plokhotnyuk.jsoniter-scala", "jsoniter-scala-core_2.13"))
   def coursierLauncher = ivy"io.get-coursier:coursier-launcher_2.13:${Versions.coursier}"
diff --git a/website/docs/_advanced_install.mdx b/website/docs/_advanced_install.mdx
index 9bc762820c..b5439c6b4f 100644
--- a/website/docs/_advanced_install.mdx
+++ b/website/docs/_advanced_install.mdx
@@ -4,6 +4,17 @@ import SectionAbout from "../src/components/SectionAbout"
 import DownloadButton from "../src/components/DownloadButton"
 import {currentOs} from "../src/components/osUtils";
 
+
+<SectionAbout title="Scala 3 installation"/>
+<div className="row">
+    <div className="col col--9 col--offset-1 padding--lg">
+        If you install Scala 3.5.0 or newer on your machine, you can use Scala CLI under the `scala` command. <br/>
+        For Scala 3 installation instructions refer <a  className="no_monospace" href="https://www.scala-lang.org/download/">here</a>.
+
+        Note that even when installing the latest Scala 3 version, its `scala` command may refer to an older Scala CLI version.
+        For the latest stable Scala CLI release it usually is necessary to install it separately.
+    </div>
+</div>
 <SectionAbout title="Advanced Installation">
     <div className="margin--lg"/>
     <Tabs
@@ -550,7 +561,7 @@ Scala Native page contains detailed [installation guide](https://scala-native.re
 </div></div>
 
 
-<SectionAbout title="Uninstall scala CLI">
+<SectionAbout title="Uninstall Scala CLI">
     <div className="margin--lg"/>
     <Tabs
         groupId="uninstall-specific"
diff --git a/website/docs/guides/introduction/old-runner-migration.md b/website/docs/guides/introduction/old-runner-migration.md
index bd84ccc722..c3ebbfe10e 100644
--- a/website/docs/guides/introduction/old-runner-migration.md
+++ b/website/docs/guides/introduction/old-runner-migration.md
@@ -19,10 +19,23 @@ If you merely want to get started with Scala CLI, you might want to first look
 at [the Getting started page](../../getting_started.md).
 :::
 
-## How to test Scala CLI as the new `scala` command?
+## How to start using Scala CLI as the new `scala` command?
 
-There is a dedicated `scala-experimental` distribution of Scala CLI, which can install it as `scala` on your machine.
-For instructions on how to try it out, refer to [the relevant doc](../../reference/scala-command/index.md).
+Refer to the [official instructions for installing Scala](https://www.scala-lang.org/download/). 
+Scala CLI is available as the `scala` command alongside the Scala distribution in Scala 3.5.0 and later.
+
+## Can I still use the old `scala` runner with Scala 3.5+?
+
+Yes, even though its usage has been deprecated, it is still available under the `scala_legacy` command. 
+However, it is likely to be dropped in a future version.
+
+```bash
+scala_legacy -version
+# [warning] MainGenericRunner class is deprecated since Scala 3.5.0, and Scala CLI features will not work.
+# [warning] Please be sure to update to the Scala CLI launcher to use the new features.
+# [warning] Check the Scala 3.5.0 release notes to troubleshoot your installation.
+# Scala code runner version 3.5.0 -- Copyright 2002-2024, LAMP/EPFL
+```
 
 ## How has the passing of arguments been changed from the old `scala` runner to Scala CLI?
 
@@ -30,18 +43,22 @@ Let us take a closer look on how the old runner handled arguments when compared
 
 ### The old ways
 
-In the old `scala` runner, the first argument was treated as the input source, while the second and following arguments
+In the old runner, the first argument was treated as the input source, while the second and following arguments
 were considered program arguments.
 
-```bash ignore
-scala Source.scala programArg1 programArg2
+```scala title=Source.scala
+@main def main(args: String*): Unit = println(args.mkString(" "))
+```
+
+```bash
+scala_legacy Source.scala programArg1 programArg2
 ```
 
 Since everything after the first argument had to be arbitrarily read as a program argument, regardless of format, all
 runner options had to be passed before the source input.
 
-```bash ignore
-scala -save script.sc programArg1 programArg2
+```bash
+scala_legacy -save Source.scala programArg1 programArg2
 ```
 
 ### The ways of Scala CLI
@@ -49,15 +66,19 @@ scala -save script.sc programArg1 programArg2
 With Scala CLI's default way of handling arguments, inputs and program arguments have to be
 divided by `--`. There is no limit for the number of either.
 
+```scala title=Source2.scala
+def placeholder = println("Example extra source")
+```
+
 ```bash ignore
-scala-cli Source1.scala Source2.scala -- programArg1 programArg2
+scala Source.scala Source2.scala -- programArg1 programArg2
 ```
 
 Additionally, a Scala CLI sub-command can be passed before the inputs section.
 For example, to call the above example specifying the `run` sub-command explicitly, pass it like this:
 
-```bash ignore
-scala-cli run Source1.scala Source2.scala -- programArg1 programArg2
+```bash
+scala run Source.scala Source2.scala -- programArg1 programArg2
 ```
 
 More on sub-commands can be found [here](../../commands/basics.md).
@@ -65,20 +86,20 @@ More on sub-commands can be found [here](../../commands/basics.md).
 Runner options can be passed on whatever position in the inputs section (before `--`).
 For example, all the following examples are correct ways to specify the Scala version explicitly as `3.2`
 
-```bash ignore
-scala-cli -S 3.2 Source1.scala Source2.scala -- programArg1 programArg2
-scala-cli Source1.scala -S 3.2 Source2.scala -- programArg1 programArg2
-scala-cli Source1.scala Source2.scala -S 3.2 -- programArg1 programArg2
+```bash
+scala -S 3.2 Source.scala Source2.scala -- programArg1 programArg2
+scala Source.scala -S 3.2 Source2.scala -- programArg1 programArg2
+scala Source.scala Source2.scala -S 3.2 -- programArg1 programArg2
 ```
 
 :::note
 The exception to this rule are the launcher options, like `--cli-version` or `--cli-scala-version`.
 Those have to be passed before the inputs section (before any source inputs).
 
-For example, to explicitly specify the launcher should run Scala CLI `v0.1.20`, pass it like this:
+For example, to explicitly specify the launcher should run Scala CLI `v1.5.0`, pass it like this:
 
-```bash ignore
-scala-cli --cli-version 0.1.20 Source1.scala Source2.scala -- programArg1 programArg2
+```bash
+scala --cli-version 1.5.0 Source.scala Source2.scala -- programArg1 programArg2
 ```
 
 Also, if a Scala CLI sub-command is being passed explicitly, all launcher options have to be passed before the
@@ -87,7 +108,7 @@ sub-command.
 For example, to call [the `package` sub-command](../../commands/package.md) using the nightly CLI version, do it like this:
 
 ```bash ignore
-scala-cli --cli-version nightly package --help
+scala --cli-version nightly package --help
 ```
 
 :::
@@ -98,8 +119,8 @@ To provide better support for shebang scripts, Scala CLI
 has [a dedicated `shebang` sub-command](../../commands/shebang.md), which handles arguments similarly to the old `scala`
 script.
 
-```bash ignore
-scala-cli shebang Source.scala programArg1 programArg2
+```bash
+scala shebang Source.scala programArg1 programArg2
 ```
 
 The purpose of the `shebang` sub-command is essentially to only be used in a shebang header (more
@@ -215,12 +236,12 @@ object Main {
 
 <ChainedSnippets>
 
-```bash ignore
-scala Main.scala Hello world
+```bash
+scala_legacy Main.scala Hello world
 ```
 
 ```bash
-scala-cli Main.scala -- Hello world
+scala Main.scala -- Hello world
 ```
 
 ```text
@@ -243,7 +264,7 @@ In other words, when explicitly declaring a main class when working with Scala C
 file.
 
 ```bash
-scala-cli main-in-script.sc -- Hello world 
+scala main-in-script.sc -- Hello world 
 # no output will be printed
 ```
 
@@ -264,7 +285,7 @@ However, it is supported by Scala CLI.
 <ChainedSnippets>
 
 ```bash
-scala-cli script.sc -- Hello world
+scala script.sc -- Hello world
 ```
 
 ```text
@@ -287,7 +308,7 @@ However, both the old Scala `3.x` runner as well as Scala CLI do not support it.
 <ChainedSnippets>
 
 ```bash fail
-scala-cli script.scala -- Hello world
+scala script.scala -- Hello world
 ```
 
 ```text
@@ -331,15 +352,15 @@ That is, all arguments starting with the second were treated as program args, ra
 This is in contrast with the Scala CLI default way of handling arguments, where inputs and program arguments have to be
 divided by `--`.
 
-```bash ignore
-scala-cli Source1.scala Source2.scala -- programArg1 programArg2
+```bash
+scala Source.scala Source2.scala -- programArg1 programArg2
 ```
 
 To better support shebang scripts, Scala CLI has a dedicated `shebang` sub-command, which handles arguments similarly to
 the old `scala` script.
 
-```bash ignore
-scala-cli shebang Source.scala programArg1 programArg2
+```bash
+scala shebang Source.scala programArg1 programArg2
 ```
 
 For more concrete examples on how to change the shebang header in your existing scripts, look below.
@@ -381,3 +402,71 @@ println("Args: " + args.mkString(" "))
 
 For more information about the `shebang` sub-command, refer to [the appropriate doc](../../commands/shebang.md).
 For more details on how to use Scala CLI in shebang scripts, refer to [the relevant guide](../scripting/shebang.md).
+
+## How to run a main class from compiled sources with Scala CLI?
+
+With the old `scala` runner, running a main class from compiled sources was as simple as passing the main class name 
+as an argument. The old runner would then assume that the current working directory is to be added to the classpath and could 
+implicitly run any compiled class files it would find.
+
+```scala title=hello.scala
+@main def hello = println("Hello")
+```
+
+This syntax has been dropped and is no longer supported with the new `scala` runner.
+```bash
+scalac hello.scala
+scala_legacy hello # NOTE: this syntax is not supported by Scala CLI
+# Hello
+```
+
+With Scala CLI, all inputs have to be passed explicitly, so any compiled classes in the current working directory 
+would be ignored unless passed explicitly. 
+```bash clean
+scalac hello.scala
+scala run -cp .
+# Hello
+```
+
+:::note
+If only the classpath is passed with `-cp`, then the `run` sub-command can't be skipped, as otherwise Scala CLI 
+will default to the REPL (as there are no explicit source file inputs present).
+
+```bash ignore
+scalac hello.scala
+scala -cp .
+# Welcome to Scala 3.5.0 (17, Java OpenJDK 64-Bit Server VM).
+# Type in expressions for evaluation. Or try :help.
+#                                                                                                                  
+# scala> 
+```
+:::
+
+It is possible to explicitly specify the main class to be run (for example, if there are multiple main classes 
+in the build). The `run` sub-command becomes optional then, as passing `-M` indicates the intention to run something.
+```bash clean
+scalac hello.scala
+scala -cp . -M hello
+# Hello
+```
+
+:::note
+If you want to compile your sources with a separate command, and then run them later, you can also do it 
+with the `compile` sub-command, rather than the `scalac` script.
+
+You don't have to specify the class files location, Scala CLI won't recompile them if they are up to date.
+```bash clean
+scala compile hello.scala
+scala hello.scala
+# Hello
+```
+
+Alternatively, you can also specify the location for the compiled classes explicitly, and then add them 
+to the classpath, as you would with `scalac`.
+```bash
+scala compile hello.scala -d compiled_classes
+scala run -cp compiled_classes
+# Hello
+```
+:::
+
diff --git a/website/docs/reference/scala-command/index.md b/website/docs/reference/scala-command/index.md
index 9358ff6da3..2e3f1fb1f8 100644
--- a/website/docs/reference/scala-command/index.md
+++ b/website/docs/reference/scala-command/index.md
@@ -2,48 +2,90 @@
 title: Scala CLI as scala
 ---
 
-# Scala CLI as implementation for `scala` command
+# Scala CLI as an implementation of the `scala` command
 
-Scala CLI is designed to be a replacement for script that is currently installed as `scala`. Since Scala CLI is
-feature-packed we do not want to expose all the features and options to the whole Scala public at the very start. Why is
-that?
+As of Scala 3.5.0, Scala CLI has become the official runner for the language,
+replacing the old runner implementation under the `scala` script.
 
-- We want to make sure that the options / commands are stable
-- We do not want to overwhelm users with multiple options and commands
-- We want to make sure that the commands we add to `scala` are stable so once we commited to supporting given option it
-  may be hard to remove it later
+Since Scala CLI is quite feature-packed, we do not want to expose all the features and options to all the Scala users
+from the very beginning. Why is that?
+
+- We want to make sure that the options / commands are stable.
+- We do not want to overwhelm users with multiple options and commands.
 
 That is why we built in a mechanism to limit the commands, options, directives in Scala CLI by default. However, it's
 still possible to enable all features by explicitly passing the `--power` flag on the command line, or by setting it
 globally running:
 
 ```bash ignore
-scala-cli config power true
+scala config power true
+```
+
+Alternatively, it is also possible to rely on the `SCALA_CLI_POWER` environment variable to achieve the same:
+
+```bash ignore
+export SCALA_CLI_POWER=true
 ```
 
 To check which options, commands and directives are supported when running Scala CLI with limited functionalities, refer
 to [options](./cli-options.md), [commands](./commands.md) and [using directives](./directives.md), respectively.
 
-## Testing Scala CLI as `scala`
+## Installing Scala CLI as `scala`
 
-There are two recommended ways to test and use Scala CLI:
+Refer to the [official instructions for installing Scala](https://www.scala-lang.org/download/).
 
-- with brew:
+:::note
+A given Scala version has a paired Scala CLI version which is used by the `scala` command installed alongside it, as per
+the [official instructions](https://www.scala-lang.org/download/).
+This means that even when installing the latest Scala version, its `scala` command may refer to an older Scala CLI
+version.
 
-```bash ignore
-brew install virtuslab/scala-experimental/scala
+To get the latest stable Scala CLI launcher, refer to the [separate
+`scala-cli` installation instructions](../../../install).
+
+Alternatively, you can use the `--cli-version` launcher option to specify the Scala CLI version to use.
+This will run the JVM launcher of the specified Scala CLI version under the hood, so do keep in mind that it may be a
+bit slower than a native launcher.
+Also, the specified version (and potentially any of its dependencies, if they are not already installed) would be
+downloaded if it's not available in the local cache, so it may require additional setup for isolated environments.
+
+```bash
+scala --cli-version 1.5.0 version
+# Scala CLI version: 1.5.0
+# Scala version (default): 3.5.0
 ```
 
-- with coursier:
+If the bleeding edge is what you are after, you can use the nightly version this way.
+Just keep in mind that there are no guarantees about the stability of nightly versions.
 
 ```bash ignore
-cs setup
-cs install scala-experimental ← this command will replace the default scala runner
+scala --cli-version nightly version
+# Scala CLI version: 1.5.0-17-g00e4c88c1-SNAPSHOT
+# Scala version (default): 3.5.0
 ```
 
-Alternatively, you can rename your `scala-cli` executable or alias it as `scala`.
+:::
 
 ## Migrating from the old `scala` runner to Scala CLI
 
 If you have been using the old `scala` runner and want to migrate to Scala CLI, refer
 to [the migration guide](../../guides/introduction/old-runner-migration.md).
+
+## Using the old (deprecated) `scala` runner with Scala 3.5+
+
+You can still use the (deprecated as of Scala 3.5.0) legacy runner with Scala 3.5+ installed. It is available under
+the `scala_legacy` command.
+
+:::caution
+Even though this enables usage of the old runner under a new alias, it is recommended to
+migrate any existing scripts and automations to Scala CLI under either `scala` or `scala-cli`, as the `scala_legacy`
+command may be dropped at some point in the future.
+:::
+
+```bash
+scala_legacy -version
+# [warning] MainGenericRunner class is deprecated since Scala 3.5.0, and Scala CLI features will not work.
+# [warning] Please be sure to update to the Scala CLI launcher to use the new features.
+# [warning] Check the Scala 3.5.0 release notes to troubleshoot your installation.
+# Scala code runner version 3.5.0 -- Copyright 2002-2024, LAMP/EPFL
+```
diff --git a/website/src/components/BasicInstall.js b/website/src/components/BasicInstall.js
index 5fac9238f8..77d500af43 100644
--- a/website/src/components/BasicInstall.js
+++ b/website/src/components/BasicInstall.js
@@ -7,23 +7,24 @@ import {currentOs} from "./osUtils";
 export default function BasicInstall(props){
   return  <BrowserOnly>{() =>
       <div>
-        <Tabs 
+        <Tabs
           groupId="operating-systems"
           defaultValue={currentOs()}
           values={[
-          {label: 'Windows', value: 'windows'},
           {label: 'macOS', value: 'mac'},
           {label: 'Linux', value: 'linux'},
+          {label: 'Windows', value: 'windows'},
           {label: 'GitHub Actions', value: 'gha'}
         ]}>
-          
+
           <TabItem value="windows">
-            <a className="no_monospace" href="https://github.com/Virtuslab/scala-cli/releases/latest/download/scala-cli-x86_64-pc-win32.msi">
-              Download Scala CLI for Windows
-            </a>
+            <p>Install Scala CLI with <a className="no_monospace" href="https://learn.microsoft.com/en-us/windows/package-manager/winget/#install-winget">WinGet</a> by running the following one-line command in your terminal:</p>
+            <code>
+              winget install virtuslab.scalacli
+            </code>
           </TabItem>
 
-          <TabItem value="linux" >
+          <TabItem value="linux">
             <p>Run the following one-line command in your terminal:</p>
             <code>
               curl -sSLf https://scala-cli.virtuslab.org/get | sh
@@ -31,7 +32,7 @@ export default function BasicInstall(props){
           </TabItem>
 
           <TabItem value="mac">
-            <p>Run the following one-line command in your terminal:</p>
+            <p>Install Scala CLI with <a className="no_monospace" href="https://brew.sh/">Homebrew</a> by running the following one-line command in your terminal:</p>
             <code>
               brew install Virtuslab/scala-cli/scala-cli
             </code>
@@ -47,6 +48,6 @@ export default function BasicInstall(props){
           </TabItem>
 
         </Tabs>
-      </div>          
+      </div>
   }</BrowserOnly>
 }