diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 92df4a190ec7..cad7caec490d 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -141,7 +141,8 @@ jobs:
 
       - name: Cmd Tests
         run: |
-          ./project/scripts/sbt ";dist/pack; scala3-bootstrapped/compile; scala3-bootstrapped/test ;sbt-test/scripted scala2-compat/*; scala3-compiler-bootstrapped/scala3CompilerCoursierTest:test"
+          ./project/scripts/buildScalaBinary
+          ./project/scripts/sbt ";scala3-bootstrapped/compile ;scala3-bootstrapped/test ;sbt-test/scripted scala2-compat/* ;scala3-compiler-bootstrapped/scala3CompilerCoursierTest:test"
           ./project/scripts/cmdTests
           ./project/scripts/bootstrappedOnlyCmdTests
 
@@ -221,7 +222,7 @@ jobs:
         shell: cmd
 
       - name: build binary
-        run: sbt "dist/pack" & bash -version
+        run: sbt "dist-win-x86_64/pack" & bash -version
         shell: cmd
 
       - name: cygwin tests
@@ -254,8 +255,12 @@ jobs:
       - name: Git Checkout
         uses: actions/checkout@v4
 
+      - name: build binary
+        run: sbt "dist-win-x86_64/pack"
+        shell: cmd
+
       - name: Test
-        run: sbt ";dist/pack ;scala3-bootstrapped/compile ;scala3-bootstrapped/test"
+        run: sbt ";scala3-bootstrapped/compile ;scala3-bootstrapped/test"
         shell: cmd
 
       - name: Scala.js Test
@@ -581,7 +586,8 @@ jobs:
 
       - name: Test
         run: |
-          ./project/scripts/sbt ";dist/pack ;scala3-bootstrapped/compile ;scala3-bootstrapped/test ;sbt-test/scripted scala2-compat/*"
+          ./project/scripts/buildScalaBinary
+          ./project/scripts/sbt ";scala3-bootstrapped/compile ;scala3-bootstrapped/test ;sbt-test/scripted scala2-compat/*"
           ./project/scripts/cmdTests
           ./project/scripts/bootstrappedOnlyCmdTests
 
diff --git a/.github/workflows/launchers.yml b/.github/workflows/launchers.yml
new file mode 100644
index 000000000000..818e3b72b06b
--- /dev/null
+++ b/.github/workflows/launchers.yml
@@ -0,0 +1,96 @@
+name: Test CLI Launchers on all the platforms
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  linux-x86_64:
+    name: Deploy and Test on Linux x64 architecture
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'sbt'
+      - name: Build and test launcher command
+        run: ./project/scripts/native-integration/bashTests
+        env:
+          LAUNCHER_EXPECTED_PROJECT: "dist-linux-x86_64"
+
+  linux-aarch64:
+    name: Deploy and Test on Linux ARM64 architecture
+    runs-on: macos-latest
+    if: ${{ false }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'sbt'
+      # https://github.com/actions/runner-images/issues/9369
+      - name: Install sbt
+        run: brew install sbt
+      - name: Build and test launcher command
+        run: ./project/scripts/native-integration/bashTests
+        env:
+          LAUNCHER_EXPECTED_PROJECT: "dist-linux-aarch64"
+
+  mac-x86_64:
+    name: Deploy and Test on Mac x64 architecture
+    runs-on: macos-13
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'sbt'
+      # https://github.com/actions/runner-images/issues/9369
+      - name: Install sbt
+        run: brew install sbt
+      - name: Build and test launcher command
+        run: ./project/scripts/native-integration/bashTests
+        env:
+          LAUNCHER_EXPECTED_PROJECT: "dist-mac-x86_64"
+
+  mac-aarch64:
+    name: Deploy and Test on Mac ARM64 architecture
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'sbt'
+      # https://github.com/actions/runner-images/issues/9369
+      - name: Install sbt
+        run: brew install sbt
+      - name: Build and test launcher command
+        run: ./project/scripts/native-integration/bashTests
+        env:
+          LAUNCHER_EXPECTED_PROJECT: "dist-mac-aarch64"
+
+  win-x86_64:
+    name: Deploy and Test on Windows x64 architecture
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'sbt'
+      - name: Build the launcher command
+        run: sbt "dist-win-x86_64/pack"
+      - name: Run the launcher command tests
+        run: './project/scripts/native-integration/winTests.bat'
+        shell: cmd
diff --git a/bin/common b/bin/common
index 7d3aa7148265..37b2ebd1ff93 100755
--- a/bin/common
+++ b/bin/common
@@ -9,15 +9,18 @@ target="$1"
 
 shift # Mutates $@ by deleting the first element ($1)
 
+# set the $DIST_PROJECT and $DIST_DIR variables
+source "$ROOT/bin/common-platform"
+
 # Marker file used to obtain the date of latest call to sbt-back
-version="$ROOT/dist/target/pack/VERSION"
+version="$ROOT/$DIST_DIR/target/pack/VERSION"
 
 # Create the target if absent or if file changed in ROOT/compiler
 new_files="$(find "$ROOT/compiler" \( -iname "*.scala" -o -iname "*.java" \) -newer "$version" 2> /dev/null)"
 
 if [ ! -f "$version" ] || [ ! -z "$new_files" ]; then
   echo "Building Dotty..."
-  (cd $ROOT && sbt "dist/pack")
+  (cd $ROOT && sbt "$DIST_PROJECT/pack")
 fi
 
-"$target" "$@"
+"$ROOT/$DIST_DIR/target/pack/bin/$target" "$@"
diff --git a/bin/common-platform b/bin/common-platform
new file mode 100755
index 000000000000..648e0195e7e6
--- /dev/null
+++ b/bin/common-platform
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+
+unset cygwin mingw msys darwin
+
+# COLUMNS is used together with command line option '-pageWidth'.
+if command -v tput >/dev/null 2>&1; then
+  export COLUMNS="$(tput -Tdumb cols)"
+fi
+
+case "`uname`" in
+  CYGWIN*) cygwin=true
+          ;;
+  MINGW*) mingw=true
+          ;;
+  MSYS*) msys=true
+          ;;
+  Darwin*) darwin=true
+           ;;
+esac
+
+unset DIST_PROJECT DIST_DIR
+
+if [[ ${cygwin-} || ${mingw-} || ${msys-} ]]; then
+  DIST_PROJECT="dist-win-x86_64"
+  DIST_DIR="dist/win-x86_64"
+else
+  # OS and arch logic taken from https://github.com/VirtusLab/scala-cli/blob/main/scala-cli.sh
+  unset arch ARCH_NORM
+  arch=$(uname -m)
+  if [[ "$arch" == "aarch64" ]] || [[ "$arch" == "x86_64" ]]; then
+    ARCH_NORM="$arch"
+  elif [[ "$arch" == "amd64" ]]; then
+    ARCH_NORM="x86_64"
+  elif [[ "$arch" == "arm64" ]]; then
+    ARCH_NORM="aarch64"
+  else
+    ARCH_NORM="unknown"
+  fi
+
+  if [ "$(expr substr $(uname -s) 1 5 2>/dev/null)" == "Linux" ]; then
+    if [[ "$ARCH_NORM" == "unknown" ]]; then
+      echo >&2 "unknown Linux CPU architecture, defaulting to JVM launcher"
+      DIST_PROJECT="dist"
+      DIST_DIR="dist"
+    else
+      DIST_PROJECT="dist-linux-$ARCH_NORM"
+      DIST_DIR="dist/linux-$ARCH_NORM"
+    fi
+  elif [ "$(uname)" == "Darwin" ]; then
+    if [[ "$ARCH_NORM" == "unknown" ]]; then
+      echo >&2 "unknown Darwin CPU architecture, defaulting to JVM launcher"
+      DIST_PROJECT="dist"
+      DIST_DIR="dist"
+    else
+      DIST_PROJECT="dist-mac-$ARCH_NORM"
+      DIST_DIR="dist/mac-$ARCH_NORM"
+    fi
+  else
+    echo >&2 "unknown OS, defaulting to JVM launcher"
+    DIST_PROJECT="dist"
+    DIST_DIR="dist"
+  fi
+fi
diff --git a/bin/scala b/bin/scala
index 85c1ac91d08f..e87c4391806b 100755
--- a/bin/scala
+++ b/bin/scala
@@ -2,4 +2,37 @@
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >& /dev/null && pwd)/.."
 
-"$ROOT/bin/common" "$ROOT/dist/target/pack/bin/scala" "--power" "$@" "--offline" "--server=false"
+scala_args() {
+
+  declare -a CLI_ARGS
+  declare -a SCRIPT_ARGS
+  declare DISABLE_BLOOP=1
+
+  while (( "$#" )); do
+    case "$1" in
+      "--")
+        shift
+        SCRIPT_ARGS+=("--")
+        SCRIPT_ARGS+=("$@")
+        break
+        ;;
+      "clean" | "version" | "--version" | "-version" | "help" | "--help" | "-help")
+        CLI_ARGS+=("$1")
+        DISABLE_BLOOP=0 # clean command should not add --offline --server=false
+        shift
+        ;;
+      *)
+        CLI_ARGS+=("$1")
+        shift
+        ;;
+    esac
+  done
+
+  if [ $DISABLE_BLOOP -eq 1 ]; then
+    CLI_ARGS+=("--offline" "--server=false")
+  fi
+
+  echo "--power ${CLI_ARGS[@]} ${SCRIPT_ARGS[@]}"
+}
+
+"$ROOT/bin/common" "scala" $(scala_args "$@")
diff --git a/bin/scalac b/bin/scalac
index faeb48d92d87..d141b9a6c6bb 100755
--- a/bin/scalac
+++ b/bin/scalac
@@ -2,4 +2,4 @@
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >& /dev/null && pwd)/.."
 
-"$ROOT/bin/common" "$ROOT/dist/target/pack/bin/scalac" "$@"
+"$ROOT/bin/common" "scalac" "$@"
diff --git a/bin/scaladoc b/bin/scaladoc
index 11a754c6579f..02decabb9ae3 100755
--- a/bin/scaladoc
+++ b/bin/scaladoc
@@ -2,4 +2,4 @@
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >& /dev/null && pwd)/.."
 
-"$ROOT/bin/common" "$ROOT/dist/target/pack/bin/scaladoc" "$@"
+"$ROOT/bin/common" "scaladoc" "$@"
diff --git a/build.sbt b/build.sbt
index 1bc74e5e23fb..f357044c91ca 100644
--- a/build.sbt
+++ b/build.sbt
@@ -28,6 +28,11 @@ val `scaladoc-js-main` = Build.`scaladoc-js-main`
 val `scaladoc-js-contributors` = Build.`scaladoc-js-contributors`
 val `scala3-bench-run` = Build.`scala3-bench-run`
 val dist = Build.dist
+val `dist-mac-x86_64` = Build.`dist-mac-x86_64`
+val `dist-mac-aarch64` = Build.`dist-mac-aarch64`
+val `dist-win-x86_64` = Build.`dist-win-x86_64`
+val `dist-linux-x86_64` = Build.`dist-linux-x86_64`
+val `dist-linux-aarch64` = Build.`dist-linux-aarch64`
 val `community-build` = Build.`community-build`
 val `sbt-community-build` = Build.`sbt-community-build`
 val `scala3-presentation-compiler` = Build.`scala3-presentation-compiler`
diff --git a/compiler/src/dotty/tools/MainGenericRunner.scala b/compiler/src/dotty/tools/MainGenericRunner.scala
index 5b238693a135..bf477f019cba 100644
--- a/compiler/src/dotty/tools/MainGenericRunner.scala
+++ b/compiler/src/dotty/tools/MainGenericRunner.scala
@@ -270,7 +270,7 @@ object MainGenericRunner {
 
     val ranByCoursierBootstrap =
       sys.props.isDefinedAt("coursier.mainJar")
-      || sys.props.get("bootstrap.mainClass").filter(_ == "dotty.tools.MainGenericRunner").isDefined
+      || sys.props.get("bootstrap.mainClass").contains("dotty.tools.MainGenericRunner")
 
     val silenced = sys.props.get("scala.use_legacy_launcher") == Some("true")
 
diff --git a/compiler/test-resources/scripting/argfileClasspath.sc b/compiler/test-resources/scripting/argfileClasspath.sc
deleted file mode 100755
index c31371ba8934..000000000000
--- a/compiler/test-resources/scripting/argfileClasspath.sc
+++ /dev/null
@@ -1,9 +0,0 @@
-#!dist/target/pack/bin/scala @compiler/test-resources/scripting/cpArgumentsFile.txt
-
-import java.nio.file.Paths
-
-def main(args: Array[String]): Unit =
-  val cwd = Paths.get(".").toAbsolutePath.toString.replace('\\', '/').replaceAll("/$", "")
-  printf("cwd: %s\n", cwd)
-  printf("classpath: %s\n", sys.props("java.class.path"))
-
diff --git a/compiler/test-resources/scripting/classpathReport.sc b/compiler/test-resources/scripting/classpathReport_scalacli.sc
similarity index 91%
rename from compiler/test-resources/scripting/classpathReport.sc
rename to compiler/test-resources/scripting/classpathReport_scalacli.sc
index cc68c4b1d52e..0b2552b3ac84 100755
--- a/compiler/test-resources/scripting/classpathReport.sc
+++ b/compiler/test-resources/scripting/classpathReport_scalacli.sc
@@ -1,5 +1,5 @@
 #!/usr/bin/env bin/scala
-
+// This file is a Scala CLI script.
 import java.nio.file.Paths
 
 // def main(args: Array[String]): Unit = // MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
diff --git a/compiler/test-resources/scripting/cpArgumentsFile.txt b/compiler/test-resources/scripting/cpArgumentsFile.txt
deleted file mode 100755
index 73037eb7d9bc..000000000000
--- a/compiler/test-resources/scripting/cpArgumentsFile.txt
+++ /dev/null
@@ -1 +0,0 @@
--classpath dist/target/pack/lib/*
diff --git a/compiler/test-resources/scripting/envtest.sc b/compiler/test-resources/scripting/envtest.sc
index b2fde1b32339..724580449229 100755
--- a/compiler/test-resources/scripting/envtest.sc
+++ b/compiler/test-resources/scripting/envtest.sc
@@ -1,2 +1,4 @@
+// this file is intended to be ran as an argument to the dotty.tools.scripting.ScriptingDriver class
+
 def main(args: Array[String]): Unit =
   println("Hello " + util.Properties.propOrNull("key"))
diff --git a/compiler/test-resources/scripting/envtest_scalacli.sc b/compiler/test-resources/scripting/envtest_scalacli.sc
new file mode 100755
index 000000000000..993ea1691640
--- /dev/null
+++ b/compiler/test-resources/scripting/envtest_scalacli.sc
@@ -0,0 +1,3 @@
+// This file is a Scala CLI script.
+
+println("Hello " + util.Properties.propOrNull("key"))
diff --git a/compiler/test-resources/scripting/hashBang.sc b/compiler/test-resources/scripting/hashBang.sc
index d767bd1a1592..98884bc050c0 100755
--- a/compiler/test-resources/scripting/hashBang.sc
+++ b/compiler/test-resources/scripting/hashBang.sc
@@ -1,4 +1,4 @@
-#!/usr/bin/env scala
+#!/usr/bin/env fake-program-to-test-hashbang-removal
 # comment
 STUFF=nada
 !#
diff --git a/compiler/test-resources/scripting/hashBang.scala b/compiler/test-resources/scripting/hashBang.scala
index 1aab26269f86..b7bf6b541854 100755
--- a/compiler/test-resources/scripting/hashBang.scala
+++ b/compiler/test-resources/scripting/hashBang.scala
@@ -1,8 +1,8 @@
-#!/usr/bin/env scala
+#!/usr/bin/env fake-program-to-test-hashbang-removal
 # comment
 STUFF=nada
 !#
-
+// everything above this point should be ignored by the compiler
 def main(args: Array[String]): Unit =
   System.err.printf("mainClassFromStack: %s\n",mainFromStack)
   assert(mainFromStack.contains("hashBang"),s"fromStack[$mainFromStack]")
diff --git a/compiler/test-resources/scripting/scriptName.scala b/compiler/test-resources/scripting/scriptName.scala
index 21aec32fe0bb..7e479197d567 100755
--- a/compiler/test-resources/scripting/scriptName.scala
+++ b/compiler/test-resources/scripting/scriptName.scala
@@ -1,4 +1,4 @@
-#!/usr/bin/env scala
+// this file is intended to be ran as an argument to the dotty.tools.scripting.ScriptingDriver class
 
   def main(args: Array[String]): Unit =
     val name = Option(sys.props("script.name")) match {
diff --git a/compiler/test-resources/scripting/scriptPath.sc b/compiler/test-resources/scripting/scriptPath.sc
index 46cd5e8a7385..e29e659d09d4 100755
--- a/compiler/test-resources/scripting/scriptPath.sc
+++ b/compiler/test-resources/scripting/scriptPath.sc
@@ -1,4 +1,4 @@
-#!dist/target/pack/bin/scala
+// this file is intended to be ran as an argument to the dotty.tools.scripting.ScriptingDriver class
 
   def main(args: Array[String]): Unit =
     args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
diff --git a/compiler/test-resources/scripting/scriptPath_scalacli.sc b/compiler/test-resources/scripting/scriptPath_scalacli.sc
new file mode 100755
index 000000000000..c13888d0e4b1
--- /dev/null
+++ b/compiler/test-resources/scripting/scriptPath_scalacli.sc
@@ -0,0 +1,13 @@
+#!/usr/bin/env bin/scala
+
+// THIS FILE IS RAN WITH SCALA CLI, which wraps scripts exposing scriptPath and args variables
+
+args.zipWithIndex.foreach { case (arg,i) => printf("arg %d: [%s]\n",i,arg) }
+
+if !scriptPath.endsWith("scriptPath_scalacli.sc") then
+  printf( s"incorrect script.path defined as [$scriptPath]")
+else
+  printf("scriptPath: %s\n", scriptPath) // report the value
+
+extension(s: String)
+  def norm: String = s.replace('\\', '/')
diff --git a/compiler/test-resources/scripting/showArgs.sc b/compiler/test-resources/scripting/showArgs.sc
index 8ef08f8962b0..69d552b9cf5f 100755
--- a/compiler/test-resources/scripting/showArgs.sc
+++ b/compiler/test-resources/scripting/showArgs.sc
@@ -1,4 +1,4 @@
-#!/usr/bin/env bin/scala
+// this file is intended to be ran as an argument to the dotty.tools.scripting.ScriptingDriver class
 
 // precise output format expected by BashScriptsTests.scala
 def main(args: Array[String]): Unit =
diff --git a/compiler/test-resources/scripting/showArgs_scalacli.sc b/compiler/test-resources/scripting/showArgs_scalacli.sc
new file mode 100755
index 000000000000..4591ac159345
--- /dev/null
+++ b/compiler/test-resources/scripting/showArgs_scalacli.sc
@@ -0,0 +1,7 @@
+#!/usr/bin/env bin/scala
+
+// This file is a Scala CLI script.
+
+// precise output format expected by BashScriptsTests.scala
+for (a,i) <- args.zipWithIndex do
+  printf(s"arg %2d:[%s]\n",i,a)
diff --git a/compiler/test-resources/scripting/sqlDateError.sc b/compiler/test-resources/scripting/sqlDateError.sc
index 35160fd6fcd5..e7c3a623c6c1 100755
--- a/compiler/test-resources/scripting/sqlDateError.sc
+++ b/compiler/test-resources/scripting/sqlDateError.sc
@@ -1,4 +1,4 @@
-#!/usr/bin/env bin/scala
+// this file is intended to be ran as an argument to the dotty.tools.scripting.ScriptingDriver class
 
 def main(args: Array[String]): Unit = {
   println(new java.sql.Date(100L))
diff --git a/compiler/test-resources/scripting/sqlDateError_scalacli.sc b/compiler/test-resources/scripting/sqlDateError_scalacli.sc
new file mode 100755
index 000000000000..10b58821a6e4
--- /dev/null
+++ b/compiler/test-resources/scripting/sqlDateError_scalacli.sc
@@ -0,0 +1,6 @@
+#!/usr/bin/env bin/scala
+
+// This file is a Scala CLI script.
+
+println(new java.sql.Date(100L))
+System.err.println("SCALA_OPTS="+Option(System.getenv("SCALA_OPTS")).getOrElse(""))
diff --git a/compiler/test-resources/scripting/touchFile.sc b/compiler/test-resources/scripting/touchFile.sc
index 974f8a64d192..b46b3c99d786 100755
--- a/compiler/test-resources/scripting/touchFile.sc
+++ b/compiler/test-resources/scripting/touchFile.sc
@@ -1,4 +1,4 @@
-#!/usr/bin/env scala
+// this file is intended to be ran as an argument to the dotty.tools.scripting.ScriptingDriver class
 
 import java.io.File
 
diff --git a/compiler/test-resources/scripting/unglobClasspath.sc b/compiler/test-resources/scripting/unglobClasspath.sc
deleted file mode 100755
index deab2b8982ac..000000000000
--- a/compiler/test-resources/scripting/unglobClasspath.sc
+++ /dev/null
@@ -1,6 +0,0 @@
-// won't compile unless classpath is set correctly
-import dotty.tools.tasty.TastyFormat
-
-// def main(args: Array[String]) = // MIGRATION: Scala CLI expects `*.sc` files to be straight-line code
-  val cp = sys.props("java.class.path")
-  printf("unglobbed classpath: %s\n", cp)
diff --git a/compiler/test-resources/scripting/unglobClasspath_scalacli.sc b/compiler/test-resources/scripting/unglobClasspath_scalacli.sc
new file mode 100755
index 000000000000..ccc4cf667085
--- /dev/null
+++ b/compiler/test-resources/scripting/unglobClasspath_scalacli.sc
@@ -0,0 +1,9 @@
+// This file is a Scala CLI script.
+
+import dotty.tools.tasty.TastyFormat
+//     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//     not visible on default classpath, "compiler/test/dotty/tools/scripting/ClasspathTests.scala"
+//     adds it to classpath via a compiler argument `-classpath 'org/scala-lang/tasty-core_3/$VERSION/*'`
+
+val cp = sys.props("java.class.path")
+printf("unglobbed classpath: %s\n", cp)
diff --git a/compiler/test/dotty/tools/io/ClasspathTest.scala b/compiler/test/dotty/tools/io/ClasspathTest.scala
index a0fef65afdec..333f2b8062b0 100755
--- a/compiler/test/dotty/tools/io/ClasspathTest.scala
+++ b/compiler/test/dotty/tools/io/ClasspathTest.scala
@@ -15,6 +15,8 @@ class ClasspathTest {
 
   def pathsep = sys.props("path.separator")
 
+  def isWindows: Boolean = scala.util.Properties.isWin
+
   //
   // Cope with wildcard classpath entries, exercised with -classpath <cp>
   //
@@ -23,7 +25,7 @@ class ClasspathTest {
   @Test def testWildcards(): Unit =
     val outDir = Files.createTempDirectory("classpath-test")
     try
-      val compilerLib = "dist/target/pack/lib"
+      val compilerLib = s"${if isWindows then "dist-win-x86_64" else "dist"}/target/pack/lib"
       val libdir = Paths.get(compilerLib).toFile
       if libdir.exists then
         val libjarFiles = libdir.listFiles.toList.take(5)
diff --git a/compiler/test/dotty/tools/scripting/BashExitCodeTests.scala b/compiler/test/dotty/tools/scripting/BashExitCodeTests.scala
index 90a8d80330b4..857f5ef378e7 100644
--- a/compiler/test/dotty/tools/scripting/BashExitCodeTests.scala
+++ b/compiler/test/dotty/tools/scripting/BashExitCodeTests.scala
@@ -16,7 +16,11 @@ import ScriptTestEnv.*
 class BashExitCodeTests:
   private var myTmpDir: String | Null = null
   private lazy val tmpDir = { myTmpDir = Files.createTempDirectory("exit-code-tests").toFile.absPath; myTmpDir }
-  @After def cleanup(): Unit = if myTmpDir != null then io.Directory(myTmpDir).deleteRecursively()
+  @After def cleanup(): Unit = {
+    if myTmpDir != null then io.Directory(myTmpDir).deleteRecursively()
+
+    cleanupScalaCLIDirs()
+  }
 
   /** Verify the exit code of running `cmd args*`. */
   def verifyExit(cmd: String, args: String*)(expectedExitCode: Int): Unit =
@@ -28,8 +32,8 @@ class BashExitCodeTests:
         s"expected $expectedExitCode but got $exitCode${pp("out", stdout)}${pp("err", stderr)}"
       }, expectedExitCode, exitCode)
 
-  // Helpers for running scala, scalac, and scalac without the the output directory ("raw")
-  def scala(args: String*)     = verifyExit(scalaPath, ("--power" +: "--offline" +: "--server=false" +: args)*)
+  // Helpers for running scala, scalac, and scalac without the output directory ("raw")
+  def scala(args: String*)     = verifyExit(scalaPath, ("--power" +: args :+ "--offline" :+ "--server=false")*)
   def scalacRaw(args: String*) = verifyExit(scalacPath, args*)
   def scalac(args: String*)    = scalacRaw(("-d" +: tmpDir +: args)*)
 
diff --git a/compiler/test/dotty/tools/scripting/BashScriptsTests.scala b/compiler/test/dotty/tools/scripting/BashScriptsTests.scala
index 25bc54e2dcbe..6af863f0fccd 100644
--- a/compiler/test/dotty/tools/scripting/BashScriptsTests.scala
+++ b/compiler/test/dotty/tools/scripting/BashScriptsTests.scala
@@ -25,11 +25,13 @@ object BashScriptsTests:
   def testFiles = scripts("/scripting")
 
   @AfterClass def cleanup: Unit = {
+    cleanupScalaCLIDirs()
+
     val af = argsfile.toFile
-    if (af.exists) {
+    if af.exists then
       af.delete()
-    }
   }
+
   printf("osname[%s]\n", osname)
   printf("uname[%s]\n", ostypeFull)
   printf("using JAVA_HOME=%s\n", envJavaHome)
@@ -50,7 +52,7 @@ object BashScriptsTests:
   val testScriptArgs = Seq(
     "a", "b", "c", "-repl", "-run", "-script", "-debug"
   )
-  val Seq(showArgsScript, showArgsScalaCli) = Seq("showArgs.sc", "showArgsNu.sc").map { name =>
+  val Seq(showArgsScript, showArgsScalaCli) = Seq("showArgs.sc", "showArgs_scalacli.sc").map { name =>
     testFiles.find(_.getName == name).get.absPath
   }
 
@@ -66,7 +68,7 @@ object BashScriptsTests:
     }
     file
 
-  val Seq(envtestNuSc, envtestScala) = Seq("envtestNu.sc", "envtest.scala").map { testFile(_) }
+  val Seq(envtestNuSc, envtestScala) = Seq("envtest_scalacli.sc", "envtest.scala").map { testFile(_) }
 
   // create command line with given options, execute specified script, return stdout
   def callScript(tag: String, script: String, keyPre: String): String =
@@ -173,13 +175,13 @@ class BashScriptsTests:
         assert(stdout == expectedOutput)
 
   /*
-   * verify that scriptPathNu.sc sees a valid script.path property,
-   * and that it's value is the path to "scriptPathNu.sc".
+   * verify that scriptPath_scalacli.sc sees a valid script.path property,
+   * and that it's value is the path to "scriptPath_scalacli.sc".
    */
   @Category(Array(classOf[BootstrappedOnlyTests]))
   @Test def verifyScriptPathProperty =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val scriptFile = testFiles.find(_.getName == "scriptPathNu.sc").get
+    val scriptFile = testFiles.find(_.getName == "scriptPath_scalacli.sc").get
     val expected = s"${scriptFile.getName}"
     printf("===> verify valid system property script.path is reported by script [%s]\n", scriptFile.getName)
     printf("calling scriptFile: %s\n", scriptFile)
@@ -196,7 +198,7 @@ class BashScriptsTests:
    */
   @Test def verifyScalaOpts =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val scriptFile = testFiles.find(_.getName == "classpathReport.sc").get
+    val scriptFile = testFiles.find(_.getName == "classpathReport_scalacli.sc").get
     printf("===> verify SCALA_OPTS='@argsfile' is properly handled by `dist/bin/scala`\n")
     val envPairs = List(("SCALA_OPTS", s"@$argsfile"))
     val (validTest, exitCode, stdout, stderr) = bashCommand(scriptFile.absPath, envPairs)
@@ -219,7 +221,7 @@ class BashScriptsTests:
    */
   @Test def sqlDateTest =
     assumeFalse("Scripts do not yet support Scala 2 library TASTy", Properties.usingScalaLibraryTasty)
-    val scriptBase = "sqlDateErrorNu"
+    val scriptBase = "sqlDateError_scalacli"
     val scriptFile = testFiles.find(_.getName == s"$scriptBase.sc").get
     val testJar = testFile(s"$scriptBase.jar") // jar should not be created when scriptFile runs
     val tj = Paths.get(testJar).toFile
diff --git a/compiler/test/dotty/tools/scripting/ClasspathTests.scala b/compiler/test/dotty/tools/scripting/ClasspathTests.scala
index 24c6c297a777..a946e509aeb3 100755
--- a/compiler/test/dotty/tools/scripting/ClasspathTests.scala
+++ b/compiler/test/dotty/tools/scripting/ClasspathTests.scala
@@ -11,8 +11,12 @@ import org.junit.{Test, Ignore, AfterClass}
 import vulpix.TestConfiguration
 import ScriptTestEnv.*
 
-/** Test java command line generated by bin/scala and bin/scalac */
+object ClasspathTests:
+  @AfterClass def cleanup: Unit = {
+    cleanupScalaCLIDirs()
+  }
 
+/** Test java command line generated by bin/scala and bin/scalac */
 class ClasspathTests:
   /*
    * Test disabled (temporarily).
@@ -24,7 +28,7 @@ class ClasspathTests:
   @Ignore
   @Test def hashbangClasspathVerifyTest = {
     // only interested in classpath test scripts
-    val testScriptName = "classpathReport.sc"
+    val testScriptName = "classpathReport_scalacli.sc"
     val testScript = scripts("/scripting").find { _.getName.matches(testScriptName) } match
       case None => sys.error(s"test script not found: ${testScriptName}")
       case Some(file) => file
@@ -39,7 +43,7 @@ class ClasspathTests:
 
       cmd.foreach { printf("[%s]\n", _) }
 
-      // classpathReport.sc is expected to produce two lines:
+      // classpathReport_scalacli.sc is expected to produce two lines:
       // cwd: <current-working-directory-seen-by-the-script>
       // classpath: <classpath-seen-by-the-script>
 
@@ -51,10 +55,10 @@ class ClasspathTests:
       // convert scriptCp to a list of files
       val hashbangJars: List[File] = scriptCp.split(psep).map { _.toFile }.toList
       val hashbangClasspathJars = hashbangJars.map { _.name }.sorted.distinct // get jar basenames, remove duplicates
-      val packlibDir: String = ??? /* ??? was s"$scriptCwd/$packLibDir" */ // classpathReport.sc specifies a wildcard classpath in this directory
+      val packlibDir: String = ??? /* ??? was s"$scriptCwd/$packLibDir" */ // classpathReport_scalacli.sc specifies a wildcard classpath in this directory
       val packlibJars: List[File] = listJars(packlibDir) // classpath entries expected to have been reported by the script
 
-      printf("%d jar files in dist/target/pack/lib\n", packlibJars.size)
+      printf(s"%d jar files in $packDir/lib\n", packlibJars.size)
       printf("%d test script jars in classpath\n", hashbangClasspathJars.size)
 
       val (diff: Set[File], msg: String) = if (packlibJars.size > hashbangClasspathJars.size) {
@@ -63,7 +67,7 @@ class ClasspathTests:
         (hashbangJars.toSet -- packlibJars.toSet , "only in hashbang classpath")
       }
       // verify that the script hasbang classpath setting was effective at supplementing the classpath
-      // (a minimal subset of jars below dist/target/pack/lib are always be in the classpath)
+      // (a minimal subset of jars below dist*/target/pack/lib are always be in the classpath)
       val missingClasspathEntries = if hashbangClasspathJars.size != packlibJars.size then
         printf("packlib dir [%s]\n", packlibDir)
         printf("hashbangClasspathJars: %s\n", hashbangJars.map { _.relpath.norm }.mkString("\n ", "\n ", ""))
@@ -79,7 +83,7 @@ class ClasspathTests:
    */
   @Ignore
   @Test def unglobClasspathVerifyTest = {
-    val testScriptName = "unglobClasspath.sc"
+    val testScriptName = "unglobClasspath_scalacli.sc"
     val testScript = scripts("/scripting").find { _.name.matches(testScriptName) } match
       case None => sys.error(s"test script not found: ${testScriptName}")
       case Some(file) => file
diff --git a/compiler/test/dotty/tools/scripting/ExpressionTest.scala b/compiler/test/dotty/tools/scripting/ExpressionTest.scala
index 02963f50ee52..bc42860253b0 100755
--- a/compiler/test/dotty/tools/scripting/ExpressionTest.scala
+++ b/compiler/test/dotty/tools/scripting/ExpressionTest.scala
@@ -55,6 +55,10 @@ class ExpressionTest:
 
 object ExpressionTest:
 
+  @AfterClass def cleanup(): Unit = {
+    cleanupScalaCLIDirs()
+  }
+
   def main(args: Array[String]): Unit =
     val tests = new ExpressionTest
     println("\n=== verifyCommandLineExpression ===")
diff --git a/compiler/test/dotty/tools/scripting/ScriptTestEnv.scala b/compiler/test/dotty/tools/scripting/ScriptTestEnv.scala
index a52014f14704..dd1cc04bb58a 100644
--- a/compiler/test/dotty/tools/scripting/ScriptTestEnv.scala
+++ b/compiler/test/dotty/tools/scripting/ScriptTestEnv.scala
@@ -5,6 +5,7 @@ package scripting
 import scala.language.unsafeNulls
 
 import java.io.File
+import java.util.Locale
 import java.nio.file.{Path, Paths, Files}
 
 import dotty.tools.dotc.config.Properties.*
@@ -15,7 +16,7 @@ import scala.jdk.CollectionConverters.*
 /**
  * Common Code for supporting scripting tests.
  * To override the path to the bash executable, set TEST_BASH=<path-to-bash.exe>
- * To specify where `dist/target/pack/bin` resides, set TEST_CWD=<working-directory>
+ * To specify where `dist[*]/target/pack/bin` resides, set TEST_CWD=<working-directory>
  * Test scripts run in a bash env, so paths are converted to forward slash via .norm.
  */
 object ScriptTestEnv {
@@ -28,6 +29,44 @@ object ScriptTestEnv {
   def whichJava: String = whichExe("java")
   def whichBash: String = whichExe("bash")
 
+  def cleanupScalaCLIDirs(): Unit = {
+    val scriptingDir = io.Directory(scriptsDir("/scripting").getPath)
+    val dottyDir = io.Directory(workingDirectory)
+
+    val residueDirs = Seq(
+      (scriptingDir / ".bsp"),
+      (scriptingDir / ".scala-build"),
+      (dottyDir / ".scala-build")
+    )
+
+    for f <- residueDirs do
+      f.deleteRecursively()
+
+    val bspDir = dottyDir / ".bsp"
+    (bspDir / "scala.json").delete()
+    if bspDir.isEmpty then bspDir.delete()
+  }
+
+  lazy val nativePackDir: Option[String] = {
+    def nativeDir(os: String, arch: String) = Some(s"dist/$os-$arch/target/pack")
+    def nativeOs(os: String) = archNorm match
+      case arch @ ("aarch64" | "x86_64") => nativeDir(os, arch)
+      case _ => None
+
+    if winshell then nativeDir("win", "x86_64") // assume x86_64 for now
+    else if linux then nativeOs("linux")
+    else if mac then nativeOs("mac")
+    else None
+  }
+
+  def jvmPackDir() =
+    println("warning: unknown OS architecture combination, defaulting to JVM launcher.")
+    "dist/target/pack"
+
+  def packDir: String = nativePackDir.getOrElse(jvmPackDir())
+
+  def packBinDir: String = s"$packDir/bin"
+
   lazy val workingDirectory: String = {
     val dirstr = if testCwd.nonEmpty then
       if verbose then printf("TEST_CWD set to [%s]\n", testCwd)
@@ -36,7 +75,7 @@ object ScriptTestEnv {
       userDir // userDir, if TEST_CWD not set
 
     // issue warning if things don't look right
-    val test = Paths.get(s"$dirstr/dist/target/pack/bin").normalize
+    val test = Paths.get(s"$dirstr/$packBinDir").normalize
     if !test.isDirectory then
       printf("warning: not found below working directory: %s\n", test.norm)
 
@@ -46,7 +85,7 @@ object ScriptTestEnv {
 
   def envPath: String = envOrElse("PATH", "")
   // remove duplicate entries in path
-  def supplementedPath: String = s"dist/target/pack/bin$psep$envJavaHome/bin$psep$envScalaHome/bin$psep$envPath".norm
+  def supplementedPath: String = s"$packBinDir$psep$envJavaHome/bin$psep$envScalaHome/bin$psep$envPath".norm
   def adjustedPathEntries: List[String] = supplementedPath.norm.split(psep).toList.distinct
   def adjustedPath: String = adjustedPathEntries.mkString(psep)
   def envPathEntries: List[String] = envPath.split(psep).toList.distinct
@@ -55,11 +94,18 @@ object ScriptTestEnv {
 
   def unameExe = which("uname")
   def ostypeFull = if unameExe.nonEmpty then exec(unameExe).mkString else ""
-  def ostype = ostypeFull.toLowerCase.takeWhile{ cc => cc >= 'a' && cc <='z' || cc >= 'A' && cc <= 'Z' }
+  def ostype = ostypeFull.toLowerCase(Locale.ROOT).takeWhile{ cc => cc >= 'a' && cc <='z' || cc >= 'A' && cc <= 'Z' }
+  def archFull = if unameExe.nonEmpty then exec(unameExe, "-m").mkString else ""
+  def archNorm = archFull match
+    case "arm64" => "aarch64"
+    case "amd64" => "x86_64"
+    case id => id
 
   def cygwin = ostype == "cygwin"
   def mingw = ostype == "mingw"
   def msys = ostype == "msys"
+  def linux = ostype == "linux"
+  def mac = ostype == "darwin"
   def winshell: Boolean = cygwin || mingw || msys
 
   def which(str: String) =
@@ -124,10 +170,9 @@ object ScriptTestEnv {
     } yield line
 
 
-  def packBinDir = "dist/target/pack/bin"
-  // def packLibDir = "dist/target/pack/lib" // replaced by packMavenDir
-  def packMavenDir = "dist/target/pack/maven2"
-  def packVersionFile = "dist/target/pack/VERSION"
+  // def packLibDir = s"$packDir/lib" // replaced by packMavenDir
+  def packMavenDir = s"$packDir/maven2"
+  def packVersionFile = s"$packDir/VERSION"
   def packBinScalaExists: Boolean = Files.exists(Paths.get(s"$packBinDir/scala"))
 
   def packScalaVersion: String = {
@@ -248,8 +293,8 @@ object ScriptTestEnv {
   lazy val cwd: Path = Paths.get(".").toAbsolutePath.normalize
 
   lazy val (scalacPath: String, scalaPath: String) = {
-    val scalac = s"$workingDirectory/dist/target/pack/bin/scalac".toPath.normalize
-    val scala = s"$workingDirectory/dist/target/pack/bin/scala".toPath.normalize
+    val scalac = s"$workingDirectory/$packBinDir/scalac".toPath.normalize
+    val scala = s"$workingDirectory/$packBinDir/scala".toPath.normalize
     (scalac.norm, scala.norm)
   }
 
@@ -257,7 +302,7 @@ object ScriptTestEnv {
   // use optional TEST_BASH if defined, otherwise, bash must be in PATH
 
   // envScalaHome is:
-  //    dist/target/pack, if present
+  //    dist[*]/target/pack, if present
   //    else, SCALA_HOME if defined
   //    else, not defined
   lazy val envScalaHome =
diff --git a/compiler/test/dotty/tools/scripting/ScriptingTests.scala b/compiler/test/dotty/tools/scripting/ScriptingTests.scala
index 713695b62f4a..4dc193f0efe4 100644
--- a/compiler/test/dotty/tools/scripting/ScriptingTests.scala
+++ b/compiler/test/dotty/tools/scripting/ScriptingTests.scala
@@ -17,7 +17,11 @@ import org.junit.Assume.assumeFalse
 /** Runs all tests contained in `compiler/test-resources/scripting/` */
 class ScriptingTests:
   // classpath tests managed by scripting.ClasspathTests.scala
-  def testFiles = scripts("/scripting").filter { ! _.getName.toLowerCase.contains("classpath") }
+  def testFiles = scripts("/scripting").filter { sc =>
+    val name = sc.getName.toLowerCase
+    !name.contains("classpath")
+    && !name.contains("_scalacli")
+  }
 
   /*
    * Call .scala scripts without -save option, verify no jar created
diff --git a/compiler/test/dotty/tools/utils.scala b/compiler/test/dotty/tools/utils.scala
index a8c480088e08..d17edbaa855e 100644
--- a/compiler/test/dotty/tools/utils.scala
+++ b/compiler/test/dotty/tools/utils.scala
@@ -20,14 +20,19 @@ import dotc.config.CommandLineParser
 object Dummy
 
 def scripts(path: String): Array[File] = {
-  val dir = new File(Dummy.getClass.getResource(path).getPath)
-  assert(dir.exists && dir.isDirectory, "Couldn't load scripts dir")
+  val dir = scriptsDir(path)
   dir.listFiles.filter { f =>
     val path = if f.isDirectory then f.getPath + "/" else f.getPath
     Properties.testsFilter.isEmpty || Properties.testsFilter.exists(path.contains)
   }
 }
 
+def scriptsDir(path: String): File = {
+  val dir = new File(Dummy.getClass.getResource(path).getPath)
+  assert(dir.exists && dir.isDirectory, "Couldn't load scripts dir")
+  dir
+}
+
 extension (f: File) def absPath =
   f.getAbsolutePath.replace('\\', '/')
 
@@ -101,10 +106,10 @@ def toolArgsParse(lines: List[String], filename: Option[String]): List[(String,S
     case toolArg(name, args) => List((name, args))
     case _ => Nil
   } ++
-  lines.flatMap { 
+  lines.flatMap {
     case directiveOptionsArg(args) => List(("scalac", args))
     case directiveJavacOptions(args) => List(("javac", args))
-    case _ => Nil 
+    case _ => Nil
   }
 
 import org.junit.Test
diff --git a/dist/bin-native-overrides/cli-common-platform b/dist/bin-native-overrides/cli-common-platform
new file mode 100644
index 000000000000..1a11c770f91a
--- /dev/null
+++ b/dist/bin-native-overrides/cli-common-platform
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+if [[ ${cygwin-} || ${mingw-} || ${msys-} ]]; then
+    SCALA_CLI_VERSION=""
+    # iterate through lines in VERSION_SRC
+    while IFS= read -r line; do
+    # if line starts with "version:=" then extract the version
+    if [[ "$line" == cli_version:=* ]]; then
+        SCALA_CLI_VERSION="${line#cli_version:=}"
+        break
+    fi
+    done < "$PROG_HOME/EXTRA_PROPERTIES"
+    SCALA_CLI_CMD_BASH=("\"$PROG_HOME/bin/scala-cli\"" "--cli-version \"$SCALA_CLI_VERSION\"")
+else
+    SCALA_CLI_CMD_BASH=("\"$PROG_HOME/bin/scala-cli\"")
+fi
diff --git a/dist/bin-native-overrides/cli-common-platform.bat b/dist/bin-native-overrides/cli-common-platform.bat
new file mode 100644
index 000000000000..e0cfa40692b5
--- /dev/null
+++ b/dist/bin-native-overrides/cli-common-platform.bat
@@ -0,0 +1,18 @@
+@echo off
+
+setlocal enabledelayedexpansion
+
+set "_SCALA_CLI_VERSION="
+@rem read for cli_version:=_SCALA_CLI_VERSION in EXTRA_PROPERTIES file
+FOR /F "usebackq delims=" %%G IN ("%_PROG_HOME%\EXTRA_PROPERTIES") DO (
+  SET "line=%%G"
+  IF "!line:~0,13!"=="cli_version:=" (
+    SET "_SCALA_CLI_VERSION=!line:~13!"
+    GOTO :foundCliVersion
+  )
+)
+
+:foundCliVersion
+endlocal & set "SCALA_CLI_VERSION=%_SCALA_CLI_VERSION%"
+
+set SCALA_CLI_CMD_WIN="%_PROG_HOME%\bin\scala-cli.exe" "--cli-version" "%SCALA_CLI_VERSION%"
\ No newline at end of file
diff --git a/dist/bin/cli-common-platform b/dist/bin/cli-common-platform
new file mode 100644
index 000000000000..a5906e882bb4
--- /dev/null
+++ b/dist/bin/cli-common-platform
@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+SCALA_CLI_CMD_BASH=("\"$JAVACMD\"" "-jar \"$PROG_HOME/bin/scala-cli.jar\"")
diff --git a/dist/bin/cli-common-platform.bat b/dist/bin/cli-common-platform.bat
new file mode 100644
index 000000000000..99103266c1d9
--- /dev/null
+++ b/dist/bin/cli-common-platform.bat
@@ -0,0 +1,5 @@
+@echo off
+
+@rem we need to escape % in the java command path, for some reason this doesnt work in common.bat
+set "_JAVACMD=!_JAVACMD:%%=%%%%!"
+set SCALA_CLI_CMD_WIN="%_JAVACMD%" "-jar" "%_PROG_HOME%\bin\scala-cli.jar"
\ No newline at end of file
diff --git a/dist/bin/common b/dist/bin/common
index e3e4253938fb..4a0152fbc4cb 100755
--- a/dist/bin/common
+++ b/dist/bin/common
@@ -1,132 +1,6 @@
 #!/usr/bin/env bash
 
-#/*--------------------------------------------------------------------------
-# *  Credits: This script is based on the script generated by sbt-pack.
-# *--------------------------------------------------------------------------*/
-
-# save terminal settings
-saved_stty=$(stty -g 2>/dev/null)
-# clear on error so we don't later try to restore them
-if [[ ! $? ]]; then
-  saved_stty=""
-fi
-
-# restore stty settings (echo in particular)
-function restoreSttySettings() {
-  stty $saved_stty
-  saved_stty=""
-}
-
-scala_exit_status=127
-function onExit() {
-  [[ "$saved_stty" != "" ]] && restoreSttySettings
-  exit $scala_exit_status
-}
-
-# to reenable echo if we are interrupted before completing.
-trap onExit INT TERM EXIT
-
-unset cygwin mingw msys darwin conemu
-
-# COLUMNS is used together with command line option '-pageWidth'.
-if command -v tput >/dev/null 2>&1; then
-  export COLUMNS="$(tput -Tdumb cols)"
-fi
-
-case "`uname`" in
-  CYGWIN*) cygwin=true
-          ;;
-  MINGW*) mingw=true
-          ;;
-  MSYS*) msys=true
-          ;;
-  Darwin*) darwin=true
-           if [ -z "$JAVA_VERSION" ] ; then
-             JAVA_VERSION="CurrentJDK"
-           else
-            echo "Using Java version: $JAVA_VERSION" 1>&2
-           fi
-           if [ -z "$JAVA_HOME" ] ; then
-             JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/${JAVA_VERSION}/Home
-           fi
-           JAVACMD="`which java`"
-           ;;
-esac
-
-unset CYGPATHCMD
-if [[ ${cygwin-} || ${mingw-} || ${msys-} ]]; then
-  # ConEmu terminal is incompatible with jna-5.*.jar
-  [[ (${CONEMUANSI-} || ${ConEmuANSI-}) ]] && conemu=true
-  # cygpath is used by various windows shells: cygwin, git-sdk, gitbash, msys, etc.
-  CYGPATHCMD=`which cygpath 2>/dev/null`
-  case "$TERM" in
-    rxvt* | xterm* | cygwin*)
-      stty -icanon min 1 -echo
-      JAVA_OPTS="$JAVA_OPTS -Djline.terminal=unix"
-    ;;
-  esac
-fi
-
-# Resolve JAVA_HOME from javac command path
-if [ -z "$JAVA_HOME" ]; then
-  javaExecutable="`which javac`"
-  if [ -n "$javaExecutable" -a -f "$javaExecutable" -a ! "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
-    # readlink(1) is not available as standard on Solaris 10.
-    readLink=`which readlink`
-    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
-      javaExecutable="`readlink -f \"$javaExecutable\"`"
-      javaHome="`dirname \"$javaExecutable\"`"
-      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
-      JAVA_HOME="$javaHome"
-      export JAVA_HOME
-    fi
-  fi
-fi
-
-if [ -z "${JAVACMD-}" ] ; then
-  if [ -n "${JAVA_HOME-}"  ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-      # IBM's JDK on AIX uses strange locations for the executables
-      JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-      JAVACMD="$JAVA_HOME/bin/java"
-    fi
-  else
-    JAVACMD="`which java`"
-  fi
-fi
-
-if [ ! -x "$JAVACMD" ] ; then
-  echo "Error: JAVA_HOME is not defined correctly."
-  echo "  We cannot execute $JAVACMD"
-  exit 1
-fi
-
-if [ -z "$JAVA_HOME" ] ; then
-  echo "Warning: JAVA_HOME environment variable is not set."
-fi
-
-CLASSPATH_SUFFIX=""
-# Path separator used in EXTRA_CLASSPATH
-PSEP=":"
-
-# translate paths to Windows-mixed format before running java
-if [ -n "${CYGPATHCMD-}" ]; then
-  [ -n "${PROG_HOME-}" ] &&
-    PROG_HOME=`"$CYGPATHCMD" -am "$PROG_HOME"`
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME=`"$CYGPATHCMD" -am "$JAVA_HOME"`
-  CLASSPATH_SUFFIX=";"
-  PSEP=";"
-elif [[ ${mingw-} || ${msys-} ]]; then
-  # For Mingw / Msys, convert paths from UNIX format before anything is touched
-  [ -n "$PROG_HOME" ] &&
-    PROG_HOME="`(cd "$PROG_HOME"; pwd -W | sed 's|/|\\\\|g')`"
-  [ -n "$JAVA_HOME" ] &&
-    JAVA_HOME="`(cd "$JAVA_HOME"; pwd -W | sed 's|/|\\\\|g')`"
-  CLASSPATH_SUFFIX=";"
-  PSEP=";"
-fi
+source "$PROG_HOME/bin/common-shared"
 
 #/*--------------------------------------------------
 # * The code below is for Dotty
@@ -205,16 +79,12 @@ ReplMain=dotty.tools.repl.Main
 ScriptingMain=dotty.tools.scripting.Main
 
 declare -a java_args
-declare -a scala_args
 declare -a residual_args
 declare -a script_args
 
 addJava () {
   java_args+=("'$1'")
 }
-addScala () {
-  scala_args+=("'$1'")
-}
 addResidual () {
   residual_args+=("'$1'")
 }
diff --git a/dist/bin/common-shared b/dist/bin/common-shared
new file mode 100644
index 000000000000..8c85993a5283
--- /dev/null
+++ b/dist/bin/common-shared
@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+
+# Common options for both scala-cli and java based launchers
+
+#/*--------------------------------------------------------------------------
+# *  Credits: This script is based on the script generated by sbt-pack.
+# *--------------------------------------------------------------------------*/
+
+# save terminal settings
+saved_stty=$(stty -g 2>/dev/null)
+# clear on error so we don't later try to restore them
+if [[ ! $? ]]; then
+  saved_stty=""
+fi
+
+# restore stty settings (echo in particular)
+function restoreSttySettings() {
+  stty $saved_stty
+  saved_stty=""
+}
+
+scala_exit_status=127
+function onExit() {
+  [[ "$saved_stty" != "" ]] && restoreSttySettings
+  exit $scala_exit_status
+}
+
+# to reenable echo if we are interrupted before completing.
+trap onExit INT TERM EXIT
+
+unset cygwin mingw msys darwin conemu
+
+# COLUMNS is used together with command line option '-pageWidth'.
+if command -v tput >/dev/null 2>&1; then
+  export COLUMNS="$(tput -Tdumb cols)"
+fi
+
+case "`uname`" in
+  CYGWIN*) cygwin=true
+          ;;
+  MINGW*) mingw=true
+          ;;
+  MSYS*) msys=true
+          ;;
+  Darwin*) darwin=true
+           if [ -z "$JAVA_VERSION" ] ; then
+             JAVA_VERSION="CurrentJDK"
+           else
+            echo "Using Java version: $JAVA_VERSION" 1>&2
+           fi
+           if [ -z "$JAVA_HOME" ] ; then
+             JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/${JAVA_VERSION}/Home
+           fi
+           JAVACMD="`which java`"
+           ;;
+esac
+
+unset CYGPATHCMD
+if [[ ${cygwin-} || ${mingw-} || ${msys-} ]]; then
+  # ConEmu terminal is incompatible with jna-5.*.jar
+  [[ (${CONEMUANSI-} || ${ConEmuANSI-}) ]] && conemu=true
+  # cygpath is used by various windows shells: cygwin, git-sdk, gitbash, msys, etc.
+  CYGPATHCMD=`which cygpath 2>/dev/null`
+  case "$TERM" in
+    rxvt* | xterm* | cygwin*)
+      stty -icanon min 1 -echo
+      JAVA_OPTS="$JAVA_OPTS -Djline.terminal=unix"
+    ;;
+  esac
+fi
+
+# Resolve JAVA_HOME from javac command path
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" -a -f "$javaExecutable" -a ! "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+      javaExecutable="`readlink -f \"$javaExecutable\"`"
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "${JAVACMD-}" ] ; then
+  if [ -n "${JAVA_HOME-}"  ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="`which java`"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly."
+  echo "  We cannot execute $JAVACMD"
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+CLASSPATH_SUFFIX=""
+# Path separator used in EXTRA_CLASSPATH
+PSEP=":"
+PROG_HOME_URI="file://$PROG_HOME"
+
+# translate paths to Windows-mixed format before running java
+if [ -n "${CYGPATHCMD-}" ]; then
+  [ -n "${PROG_HOME-}" ] &&
+    PROG_HOME=`"$CYGPATHCMD" -am "$PROG_HOME"`
+    PROG_HOME_URI="file:///$PROG_HOME" # Add extra root dir prefix
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`"$CYGPATHCMD" -am "$JAVA_HOME"`
+  CLASSPATH_SUFFIX=";"
+  PSEP=";"
+elif [[ ${mingw-} || ${msys-} ]]; then
+  # For Mingw / Msys, convert paths from UNIX format before anything is touched
+  [ -n "$PROG_HOME" ] &&
+    PROG_HOME="`(cd "$PROG_HOME"; pwd -W | sed 's|/|\\\\|g')`"
+    PROG_HOME_URI="file:///$PROG_HOME" # Add extra root dir prefix
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd -W | sed 's|/|\\\\|g')`"
+  CLASSPATH_SUFFIX=";"
+  PSEP=";"
+fi
+
+declare -a scala_args
+addScala () {
+  scala_args+=("'$1'")
+}
diff --git a/dist/bin/scala b/dist/bin/scala
index 3040c5a9a0f3..71747a8e9e20 100755
--- a/dist/bin/scala
+++ b/dist/bin/scala
@@ -26,7 +26,8 @@ if [ -z "${PROG_HOME-}" ] ; then
   cd "$saveddir"
 fi
 
-source "$PROG_HOME/bin/cli-common"
+source "$PROG_HOME/bin/common-shared"
+source "$PROG_HOME/bin/cli-common-platform"
 
 SCALA_VERSION=""
 # iterate through lines in VERSION_SRC
@@ -44,7 +45,7 @@ if [ -z "$SCALA_VERSION" ]; then
   exit 1
 fi
 
-MVN_REPOSITORY="file://$PROG_HOME/maven2"
+MVN_REPOSITORY="$PROG_HOME_URI/maven2"
 
 # escape all script arguments
 while [[ $# -gt 0 ]]; do
@@ -54,8 +55,9 @@ done
 
 # exec here would prevent onExit from being called, leaving terminal in unusable state
 [ -z "${ConEmuPID-}" -o -n "${cygwin-}" ] && export MSYSTEM= PWD= # workaround for #12405
-eval "\"$JAVACMD\"" \
-  "-jar \"$SCALA_CLI_JAR\"" \
+
+# SCALA_CLI_CMD_BASH is an array, set by cli-common-platform
+eval "${SCALA_CLI_CMD_BASH[@]}" \
   "--prog-name scala" \
   "--cli-default-scala-version \"$SCALA_VERSION\"" \
   "-r \"$MVN_REPOSITORY\"" \
diff --git a/dist/bin/scala.bat b/dist/bin/scala.bat
index 78336272055b..d473facbbb1c 100644
--- a/dist/bin/scala.bat
+++ b/dist/bin/scala.bat
@@ -19,10 +19,11 @@ if not %_EXITCODE%==0 goto end
 
 call :setScalaOpts
 
-@rem we need to escape % in the java command path, for some reason this doesnt work in common.bat
-set "_JAVACMD=!_JAVACMD:%%=%%%%!"
+call "%_PROG_HOME%\bin\cli-common-platform.bat"
+
+@rem SCALA_CLI_CMD_WIN is an array, set in cli-common-platform.bat
+call %SCALA_CLI_CMD_WIN% "--prog-name" "scala" "--cli-default-scala-version" "%_SCALA_VERSION%" "-r" "%MVN_REPOSITORY%" %*
 
-call "%_JAVACMD%" "-jar" "%SCALA_CLI_JAR%" "--prog-name" "scala" "--cli-default-scala-version" "%_SCALA_VERSION%" "-r" "%MVN_REPOSITORY%" %*
 if not %ERRORLEVEL%==0 ( set _EXITCODE=1& goto end )
 
 goto end
@@ -42,19 +43,8 @@ if not "%char%"==":" (
   goto :findColon
 )
 
-@REM set _PROG_HOME to the substring from the first colon to the end
-set "_PROG_HOME_SUB=!_PROG_HOME:~%index%!"
-@REM strip initial character
-set "_PROG_HOME_SUB=!_PROG_HOME_SUB:~1!"
-
-@REM set drive to substring from 0 to the first colon
-set "_PROG_HOME_DRIVE=!_PROG_HOME:~0,%index%!"
-
-
-
 set "_SCALA_VERSION="
-set "MVN_REPOSITORY=file://%_PROG_HOME_DRIVE%\%_PROG_HOME_SUB:\=/%/maven2"
-set "SCALA_CLI_JAR=%_PROG_HOME%\etc\scala-cli.jar"
+set "MVN_REPOSITORY=file:///%_PROG_HOME:\=/%/maven2"
 
 @rem read for version:=_SCALA_VERSION in VERSION_FILE
 FOR /F "usebackq delims=" %%G IN ("%_PROG_HOME%\VERSION") DO (
diff --git a/project/Build.scala b/project/Build.scala
index 0876353a6a2f..99871c4c87e8 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -28,7 +28,6 @@ import sbttastymima.TastyMiMaPlugin
 import sbttastymima.TastyMiMaPlugin.autoImport._
 
 import scala.util.Properties.isJavaAtLeast
-import scala.collection.mutable
 
 import org.portablescala.sbtplatformdeps.PlatformDepsPlugin.autoImport._
 import org.scalajs.linker.interface.{ModuleInitializer, StandardConfig}
@@ -119,7 +118,11 @@ object Build {
   val mimaPreviousLTSDottyVersion = "3.3.0"
 
   /** Version of Scala CLI to download */
-  val scalaCliLauncherVersion = "1.3.1"
+  val scalaCliLauncherVersion = "1.3.2"
+  /** Version of Scala CLI to download (on Windows - last known validated version) */
+  val scalaCliLauncherVersionWindows = "1.3.2"
+  /** Version of Coursier to download for initializing the local maven repo of Scala command */
+  val coursierJarVersion = "2.1.10"
 
   object CompatMode {
     final val BinaryCompatible = 0
@@ -2121,22 +2124,72 @@ object Build {
     packMain := Map(),
     publishArtifact := false,
     packGenerateMakefile := false,
-    packArchiveName := "scala3-" + dottyVersion,
     republishRepo := target.value / "republish",
-    republishLaunchers := {
-      val cliV = scalaCliLauncherVersion
-      Seq(
-        ("scala-cli.jar", cliV, url(s"https://github.com/VirtusLab/scala-cli/releases/download/v$cliV/scala-cli.jar"))
-      )
-    },
+    packResourceDir += (republishRepo.value / "bin" -> "bin"),
+    packResourceDir += (republishRepo.value / "maven2" -> "maven2"),
     Compile / pack := (Compile / pack).dependsOn(republish).value,
   )
 
   lazy val dist = project.asDist(Bootstrapped)
     .settings(
-      packResourceDir += (baseDirectory.value / "bin" -> "bin"),
-      packResourceDir += (republishRepo.value / "maven2" -> "maven2"),
-      packResourceDir += (republishRepo.value / "etc" -> "etc"),
+      packArchiveName := "scala3-" + dottyVersion,
+      republishBinDir := baseDirectory.value / "bin",
+      republishCoursier +=
+        ("coursier.jar" -> s"https://github.com/coursier/coursier/releases/download/v$coursierJarVersion/coursier.jar"),
+      republishLaunchers +=
+        ("scala-cli.jar" -> s"https://github.com/VirtusLab/scala-cli/releases/download/v$scalaCliLauncherVersion/scala-cli.jar"),
+    )
+
+  lazy val `dist-mac-x86_64` = project.in(file("dist/mac-x86_64")).asDist(Bootstrapped)
+    .settings(
+      republishBinDir := (dist / republishBinDir).value,
+      packArchiveName := (dist / packArchiveName).value + "-x86_64-apple-darwin",
+      republishBinOverrides += (dist / baseDirectory).value / "bin-native-overrides",
+      republishFetchCoursier := (dist / republishFetchCoursier).value,
+      republishLaunchers +=
+        ("scala-cli" -> s"gz+https://github.com/VirtusLab/scala-cli/releases/download/v$scalaCliLauncherVersion/scala-cli-x86_64-apple-darwin.gz")
+    )
+
+  lazy val `dist-mac-aarch64` = project.in(file("dist/mac-aarch64")).asDist(Bootstrapped)
+    .settings(
+      republishBinDir := (dist / republishBinDir).value,
+      packArchiveName := (dist / packArchiveName).value + "-aarch64-apple-darwin",
+      republishBinOverrides += (dist / baseDirectory).value / "bin-native-overrides",
+      republishFetchCoursier := (dist / republishFetchCoursier).value,
+      republishLaunchers +=
+        ("scala-cli" -> s"gz+https://github.com/VirtusLab/scala-cli/releases/download/v$scalaCliLauncherVersion/scala-cli-aarch64-apple-darwin.gz")
+    )
+
+  lazy val `dist-win-x86_64` = project.in(file("dist/win-x86_64")).asDist(Bootstrapped)
+    .settings(
+      republishBinDir := (dist / republishBinDir).value,
+      packArchiveName := (dist / packArchiveName).value + "-x86_64-pc-win32",
+      republishBinOverrides += (dist / baseDirectory).value / "bin-native-overrides",
+      republishFetchCoursier := (dist / republishFetchCoursier).value,
+      republishExtraProps += ("cli_version" -> scalaCliLauncherVersion),
+      mappings += (republishRepo.value / "etc" / "EXTRA_PROPERTIES" -> "EXTRA_PROPERTIES"),
+      republishLaunchers +=
+        ("scala-cli.exe" -> s"zip+https://github.com/VirtusLab/scala-cli/releases/download/v$scalaCliLauncherVersionWindows/scala-cli-x86_64-pc-win32.zip!/scala-cli.exe")
+    )
+
+  lazy val `dist-linux-x86_64` = project.in(file("dist/linux-x86_64")).asDist(Bootstrapped)
+    .settings(
+      republishBinDir := (dist / republishBinDir).value,
+      packArchiveName := (dist / packArchiveName).value + "-x86_64-pc-linux",
+      republishBinOverrides += (dist / baseDirectory).value / "bin-native-overrides",
+      republishFetchCoursier := (dist / republishFetchCoursier).value,
+      republishLaunchers +=
+        ("scala-cli" -> s"gz+https://github.com/VirtusLab/scala-cli/releases/download/v$scalaCliLauncherVersion/scala-cli-x86_64-pc-linux.gz")
+    )
+
+  lazy val `dist-linux-aarch64` = project.in(file("dist/linux-aarch64")).asDist(Bootstrapped)
+    .settings(
+      republishBinDir := (dist / republishBinDir).value,
+      packArchiveName := (dist / packArchiveName).value + "-aarch64-pc-linux",
+      republishBinOverrides += (dist / baseDirectory).value / "bin-native-overrides",
+      republishFetchCoursier := (dist / republishFetchCoursier).value,
+      republishLaunchers +=
+        ("scala-cli" -> s"gz+https://github.com/VirtusLab/scala-cli/releases/download/v$scalaCliLauncherVersion/scala-cli-aarch64-pc-linux.gz")
     )
 
   private def customMimaReportBinaryIssues(issueFilterLocation: String) = mimaReportBinaryIssues := {
@@ -2265,8 +2318,7 @@ object Build {
       settings(scala3PresentationCompilerBuildInfo)
 
     def asDist(implicit mode: Mode): Project = project.
-      enablePlugins(PackPlugin).
-      enablePlugins(RepublishPlugin).
+      enablePlugins(PackPlugin, RepublishPlugin).
       withCommonSettings.
       settings(commonDistSettings).
       dependsOn(
diff --git a/project/RepublishPlugin.scala b/project/RepublishPlugin.scala
index bd1190dfec88..537c82d62cce 100644
--- a/project/RepublishPlugin.scala
+++ b/project/RepublishPlugin.scala
@@ -12,9 +12,45 @@ import sbt.util.CacheImplicits._
 import scala.collection.mutable
 import java.nio.file.Files
 
+import java.nio.file.attribute.PosixFilePermission
+import java.nio.file.{Files, Path}
+
+import scala.jdk.CollectionConverters._
+
 /** This local plugin provides ways of publishing a project classpath and library dependencies to
  * .a local repository */
 object RepublishPlugin extends AutoPlugin {
+
+  /** copied from github.com/coursier/coursier */
+  private object FileUtil {
+
+    def tryMakeExecutable(path: Path): Boolean =
+      try {
+        val perms = Files.getPosixFilePermissions(path).asScala.toSet
+
+        var newPerms = perms
+        if (perms(PosixFilePermission.OWNER_READ))
+          newPerms += PosixFilePermission.OWNER_EXECUTE
+        if (perms(PosixFilePermission.GROUP_READ))
+          newPerms += PosixFilePermission.GROUP_EXECUTE
+        if (perms(PosixFilePermission.OTHERS_READ))
+          newPerms += PosixFilePermission.OTHERS_EXECUTE
+
+        if (newPerms != perms)
+          Files.setPosixFilePermissions(
+            path,
+            newPerms.asJava
+          )
+
+        true
+      }
+      catch {
+        case _: UnsupportedOperationException =>
+          false
+      }
+
+  }
+
   override def trigger = allRequirements
   override def requires = super.requires && PublishBinPlugin && PackPlugin
 
@@ -24,9 +60,17 @@ object RepublishPlugin extends AutoPlugin {
     val republishAllResolved = taskKey[Seq[ResolvedArtifacts]]("Resolve the dependencies for the distribution")
     val republishClasspath = taskKey[Set[File]]("cache the dependencies for the distribution")
     val republishFetchLaunchers = taskKey[Set[File]]("cache the launcher deps for the distribution")
+    val republishFetchCoursier = taskKey[File]("cache the coursier.jar for resolving the local maven repo.")
+    val republishPrepareBin = taskKey[File]("prepare the bin directory, including launchers and scripts.")
+    val republishWriteExtraProps = taskKey[Option[File]]("write extra properties for the launchers.")
+    val republishBinDir = settingKey[File]("where to find static files for the bin dir.")
+    val republishCoursierDir = settingKey[File]("where to download the coursier launcher jar.")
+    val republishBinOverrides = settingKey[Seq[File]]("files to override those in bin-dir.")
     val republish = taskKey[File]("cache the dependencies and download launchers for the distribution")
     val republishRepo = settingKey[File]("the location to store the republished artifacts.")
-    val republishLaunchers = settingKey[Seq[(String, String, URL)]]("launchers to download. Sequence of (name, version, URL).")
+    val republishLaunchers = settingKey[Seq[(String, String)]]("launchers to download. Sequence of (name, URL).")
+    val republishCoursier = settingKey[Seq[(String, String)]]("coursier launcher to download. Sequence of (name, URL).")
+    val republishExtraProps = settingKey[Seq[(String, String)]]("extra properties for launchers.")
   }
 
   import autoImport._
@@ -34,11 +78,207 @@ object RepublishPlugin extends AutoPlugin {
   case class SimpleModuleId(org: String, name: String, revision: String) {
     override def toString = s"$org:$name:$revision"
   }
-  case class ResolvedArtifacts(id: SimpleModuleId, jar: File, pom: File)
+  case class ResolvedArtifacts(id: SimpleModuleId, jar: Option[File], pom: Option[File])
 
-  val isRelease = sys.env.get("RELEASEBUILD") == Some("yes")
+  private def republishResolvedArtifacts(resolved: Seq[ResolvedArtifacts], mavenRepo: File, logOpt: Option[Logger]): Set[File] = {
+    IO.createDirectory(mavenRepo)
+    resolved.map { ra =>
+      for (log <- logOpt)
+        log.info(s"[republish] publishing ${ra.id} to $mavenRepo...")
+      val jarOpt = ra.jar
+      val pomOpt = ra.pom
+
+      assert(jarOpt.nonEmpty || pomOpt.nonEmpty, s"Neither jar nor pom found for ${ra.id}")
+
+      val pathElems = ra.id.org.split('.').toVector :+ ra.id.name :+ ra.id.revision
+      val artifactDir = pathElems.foldLeft(mavenRepo)(_ / _)
+      IO.createDirectory(artifactDir)
+      for (pom <- pomOpt) IO.copyFile(pom, artifactDir / pom.getName)
+      for (jar <- jarOpt) IO.copyFile(jar, artifactDir / jar.getName)
+      artifactDir
+    }.toSet
+  }
+
+  private def coursierCmd(jar: File, cache: File, args: Seq[String]): Unit = {
+    val jar0 = jar.getAbsolutePath.toString
+    val javaHome = sys.props.get("java.home").getOrElse {
+      throw new MessageOnlyException("java.home property not set")
+    }
+    val javaCmd = {
+      val cmd = if (scala.util.Properties.isWin) "java.exe" else "java"
+      (file(javaHome) / "bin" / cmd).getAbsolutePath
+    }
+    val env = Map("COURSIER_CACHE" -> cache.getAbsolutePath.toString)
+    val cmdLine = Seq(javaCmd, "-jar", jar0) ++ args
+    // invoke cmdLine with env
+    val p = new ProcessBuilder(cmdLine: _*).inheritIO()
+    p.environment().putAll(env.asJava)
+    val proc = p.start()
+    proc.waitFor()
+    if (proc.exitValue() != 0)
+      throw new MessageOnlyException(s"Error running coursier.jar with args ${args.mkString(" ")}")
+  }
+
+  private def coursierFetch(coursierJar: File, log: Logger, cacheDir: File, localRepo: File, libs: Seq[String]): Unit = {
+    val localRepoArg = {
+      val path = localRepo.getAbsolutePath
+      if (scala.util.Properties.isWin) {
+        val path0 = path.replace('\\', '/')
+        s"file:///$path0" // extra root slash for Windows paths
+      }
+      else
+        s"file://$path"
+    }
+
+    IO.createDirectory(cacheDir)
+    for (lib <- libs) {
+      log.info(s"[republish] Fetching $lib with coursier.jar...")
+      coursierCmd(coursierJar, cacheDir,
+        Seq(
+          "fetch",
+          "--repository", localRepoArg,
+          lib
+        )
+      )
+    }
+  }
+
+  /**Resolve the transitive library dependencies of `libs` to `csrCacheDir`.
+   */
+  private def resolveLibraryDeps(
+      coursierJar: File,
+      log: Logger,
+      csrCacheDir: File,
+      localRepo: File,
+      resolvedLocal: Seq[ResolvedArtifacts]): Seq[ResolvedArtifacts] = {
+
+    // publish the local artifacts to the local repo, so coursier can resolve them
+    republishResolvedArtifacts(resolvedLocal, localRepo, logOpt = None)
+
+    coursierFetch(coursierJar, log, csrCacheDir, localRepo, resolvedLocal.map(_.id.toString))
+
+    val maven2Root = java.nio.file.Files.walk(csrCacheDir.toPath)
+      .filter(_.getFileName.toString == "maven2")
+      .findFirst()
+      .orElseThrow(() => new MessageOnlyException(s"Could not find maven2 directory in $csrCacheDir"))
+
+    def pathToArtifact(p: Path): ResolvedArtifacts = {
+      // relative path from maven2Root
+      val lastAsString = p.getFileName.toString
+      val relP = maven2Root.relativize(p)
+      val parts = relP.iterator().asScala.map(_.toString).toVector
+      val (orgParts :+ name :+ rev :+ _) = parts
+      val id = SimpleModuleId(orgParts.mkString("."), name, rev)
+      if (lastAsString.endsWith(".jar")) {
+        ResolvedArtifacts(id, Some(p.toFile), None)
+      } else {
+        ResolvedArtifacts(id, None, Some(p.toFile))
+      }
+    }
+
+    java.nio.file.Files.walk(maven2Root)
+      .filter(p => {
+        val lastAsString = p.getFileName.toString
+        lastAsString.endsWith(".pom") || lastAsString.endsWith(".jar")
+      })
+      .map[ResolvedArtifacts](pathToArtifact(_))
+      .iterator()
+      .asScala
+      .toSeq
+  }
+
+  private def fetchFilesTask(
+      libexecT: Def.Initialize[Task[File]],
+      srcs: SettingKey[Seq[(String, String)]],
+      strict: Boolean) = Def.task[Set[File]] {
+    val s = streams.value
+    val log = s.log
+    val repoDir = republishRepo.value
+    val launcherVersions = srcs.value
+    val libexec = libexecT.value
+
+    val dlCache = s.cacheDirectory / "republish-launchers"
+
+    val store = s.cacheStoreFactory / "versions"
+
+    def work(name: String, dest: File, launcher: String): File = {
+      val (launcherURL, workFile, prefix, subPart) = {
+        if (launcher.startsWith("gz+")) {
+          IO.createDirectory(dlCache)
+          val launcherURL = url(launcher.stripPrefix("gz+"))
+          (launcherURL, dlCache / s"$name.gz", "gz", "")
+        } else if (launcher.startsWith("zip+")) {
+          IO.createDirectory(dlCache)
+          val (urlPart, subPath) = launcher.split("!/") match {
+            case Array(urlPart, subPath) => (urlPart, subPath)
+            case _ =>
+              throw new MessageOnlyException(s"[republish] Invalid zip+ URL, expected ! to mark subpath: $launcher")
+          }
+          val launcherURL = url(urlPart.stripPrefix("zip+"))
+          (launcherURL, dlCache / s"$name.zip", "zip", subPath)
+        } else {
+          IO.createDirectory(libexec)
+          (url(launcher), dest, "", "")
+        }
+      }
+      IO.delete(workFile)
+      Using.urlInputStream(launcherURL) { in =>
+        log.info(s"[republish] Downloading $launcherURL to $workFile...")
+        IO.transfer(in, workFile)
+        log.info(s"[republish] Downloaded $launcherURL to $workFile...")
+      }
+      if (prefix == "gz") {
+        IO.delete(dest)
+        Using.fileInputStream(workFile) { in =>
+          Using.gzipInputStream(in) { gzIn =>
+            IO.transfer(gzIn, dest)
+          }
+        }
+        log.info(s"[republish] uncompressed gz file $workFile to $dest...")
+        IO.delete(workFile)
+      } else if (prefix == "zip") {
+        IO.delete(dest)
+        val files = IO.unzip(workFile, dlCache, new ExactFilter(subPart))
+        val extracted = files.headOption.getOrElse(throw new MessageOnlyException(s"[republish] No files extracted from $workFile matching $subPart"))
+        log.info(s"[republish] unzipped $workFile to $extracted...")
+        IO.move(extracted, dest)
+        log.info(s"[republish] moved $extracted to $dest...")
+        IO.delete(workFile)
+      }
+      FileUtil.tryMakeExecutable(dest.toPath)
+      dest
+    }
+
+    val allLaunchers = {
+      if (strict && launcherVersions.isEmpty)
+        throw new MessageOnlyException(s"[republish] No launchers to fetch, check the build configuration for ${srcs.key.label}.")
+
+      for ((name, launcher) <- launcherVersions) yield {
+        val dest = libexec / name
+
+        val id = name.replaceAll("[^a-zA-Z0-9]", "_")
+
+        val fetchAction = Tracked.inputChanged[String, File](store.make(id)) { (inChanged, launcher) =>
+          if (inChanged || !Files.exists(dest.toPath)) {
+            work(name, dest, launcher)
+          } else {
+            log.info(s"[republish] Using cached $name launcher ($launcher).")
+            dest
+          }
+        }
+
+        fetchAction(launcher)
+      }
+    }
+    allLaunchers.toSet
+  }
 
   override val projectSettings: Seq[Def.Setting[_]] = Def.settings(
+    republishCoursierDir := republishRepo.value / "coursier",
+    republishLaunchers := Seq.empty,
+    republishCoursier := Seq.empty,
+    republishBinOverrides := Seq.empty,
+    republishExtraProps := Seq.empty,
     republishLocalResolved / republishProjectRefs := {
       val proj = thisProjectRef.value
       val deps = buildDependencies.value
@@ -55,7 +295,6 @@ object RepublishPlugin extends AutoPlugin {
 
         ids.zip(published).map({ case (id, as) =>
           val simpleId = {
-            val disabled = CrossVersion.disabled
             val name0 = id.crossVersion match {
               case cv: CrossVersion.Binary =>
                 // projectID does not add binary suffix
@@ -76,122 +315,85 @@ object RepublishPlugin extends AutoPlugin {
           })
           assert(jarOrNull != null, s"Could not find jar for ${id}")
           assert(pomOrNull != null, s"Could not find pom for ${id}")
-          ResolvedArtifacts(simpleId, jarOrNull, pomOrNull)
+          ResolvedArtifacts(simpleId, Some(jarOrNull), Some(pomOrNull))
         })
       }
     }.value,
     republishAllResolved := {
-      val localResolved = republishLocalResolved.value
+      val resolvedLocal = republishLocalResolved.value
+      val coursierJar = republishFetchCoursier.value
       val report = (thisProjectRef / updateFull).value
+      val s = streams.value
+      val lm = (republishAllResolved / dependencyResolution).value
+      val cacheDir = republishRepo.value
 
-      val found = mutable.Map.empty[SimpleModuleId, ResolvedArtifacts]
-      val evicted = mutable.Set.empty[SimpleModuleId]
-
-      localResolved.foreach({ resolved =>
-        val simpleId = resolved.id
-        if(isRelease)
-          evicted += simpleId.copy(revision = simpleId.revision + "-bin-nonbootstrapped")
-        else
-          evicted += simpleId.copy(revision = simpleId.revision + "-nonbootstrapped")
-        found(simpleId) = resolved
-      })
+      val log = s.log
+      val csrCacheDir = s.cacheDirectory / "csr-cache"
+      val localRepo = s.cacheDirectory / "localRepo" / "maven2"
 
-      report.allModuleReports.foreach { mr =>
-        val simpleId = {
-          val id = mr.module
-          SimpleModuleId(id.organization, id.name, id.revision)
-        }
+      // resolve the transitive dependencies of the local artifacts
+      val resolvedLibs = resolveLibraryDeps(coursierJar, log, csrCacheDir, localRepo, resolvedLocal)
 
-        if (!found.contains(simpleId) && !evicted(simpleId)) {
-          var jarOrNull: File = null
-          var pomOrNull: File = null
-          mr.artifacts.foreach({ case (a, f) =>
-            if (a.`type` == "jar" || a.`type` == "bundle") {
-              jarOrNull = f
-            } else if (a.`type` == "pom") {
-              pomOrNull = f
-            }
-          })
-          assert(jarOrNull != null, s"Could not find jar for ${simpleId}")
-          if (pomOrNull == null) {
-            val jarPath = jarOrNull.toPath
-            // we found the jar, so assume we can resolve a sibling pom file
-            val pomPath = jarPath.resolveSibling(jarPath.getFileName.toString.stripSuffix(".jar") + ".pom")
-            assert(Files.exists(pomPath), s"Could not find pom for ${simpleId}")
-            pomOrNull = pomPath.toFile
-          }
-          found(simpleId) = ResolvedArtifacts(simpleId, jarOrNull, pomOrNull)
-        }
+      // the combination of local artifacts and resolved transitive dependencies
+      val merged =
+        (resolvedLocal ++ resolvedLibs).groupBy(_.id).values.map(_.reduce { (ra1, ra2) =>
+          val jar = ra1.jar.orElse(ra2.jar)
+          val pom = ra1.pom.orElse(ra2.pom)
+          ResolvedArtifacts(ra1.id, jar, pom)
+        })
 
-      }
-      found.values.toSeq
+      merged.toSeq
     },
     republishClasspath := {
       val s = streams.value
       val resolved = republishAllResolved.value
       val cacheDir = republishRepo.value
-
-      val log = s.log
-      val mavenRepo = cacheDir / "maven2"
-      IO.createDirectory(mavenRepo)
-      resolved.map { ra =>
-        log.info(s"[republish] publishing ${ra.id} to $mavenRepo...")
-        val jar = ra.jar
-        val pom = ra.pom
-
-        val pathElems = ra.id.org.split('.').toVector :+ ra.id.name :+ ra.id.revision
-        val artifactDir = pathElems.foldLeft(mavenRepo)(_ / _)
-        IO.createDirectory(artifactDir)
-        IO.copyFile(jar, artifactDir / jar.getName)
-        IO.copyFile(pom, artifactDir / pom.getName)
-        artifactDir
-      }.toSet
+      republishResolvedArtifacts(resolved, cacheDir / "maven2", logOpt = Some(s.log))
     },
     republishFetchLaunchers := {
-      val s = streams.value
-      val log = s.log
+      fetchFilesTask(republishPrepareBin, republishLaunchers, strict = true).value
+    },
+    republishFetchCoursier := {
+      fetchFilesTask(republishCoursierDir.toTask, republishCoursier, strict = true).value.head
+    },
+    republishPrepareBin := {
+      val baseDir = baseDirectory.value
+      val srcBin = republishBinDir.value
+      val overrides = republishBinOverrides.value
       val repoDir = republishRepo.value
-      val launcherVersions = republishLaunchers.value
-
-      val etc = repoDir / "etc"
 
-      val store = s.cacheStoreFactory / "versions"
-
-      def work(dest: File, launcher: URL) = {
-        IO.delete(dest)
-        Using.urlInputStream(launcher) { in =>
-          IO.createDirectory(etc)
-          log.info(s"[republish] Downloading $launcher to $dest...")
-          IO.transfer(in, dest)
-          log.info(s"[republish] Downloaded $launcher to $dest...")
-        }
-        dest
+      val targetBin = repoDir / "bin"
+      IO.copyDirectory(srcBin, targetBin)
+      overrides.foreach { dir =>
+        IO.copyDirectory(dir, targetBin, overwrite = true)
       }
-
-      val allLaunchers = {
-        for ((name, version, launcher) <- launcherVersions) yield {
-          val dest = etc / name
-
-          val id = name.replaceAll("[^a-zA-Z0-9]", "_")
-
-          val fetchAction = Tracked.inputChanged[String, File](store.make(id)) { (inChanged, version) =>
-            if (inChanged || !Files.exists(dest.toPath)) {
-              work(dest, launcher)
-            } else {
-              log.info(s"[republish] Using cached $launcher at $dest...")
-              dest
-            }
+      targetBin
+    },
+    republishWriteExtraProps := {
+      val s = streams.value
+      val log = s.log
+      val extraProps = republishExtraProps.value
+      if (extraProps.isEmpty) {
+        log.info("[republish] No extra properties to write.")
+        None
+      }
+      else {
+        val repoDir = republishRepo.value
+        val propsFile = repoDir / "etc" / "EXTRA_PROPERTIES"
+        log.info(s"[republish] Writing extra properties to $propsFile...")
+        Using.fileWriter()(propsFile) { writer =>
+          extraProps.foreach { case (k, v) =>
+            writer.write(s"$k:=$v\n")
           }
-
-          fetchAction(version)
         }
+        Some(propsFile)
       }
-      allLaunchers.toSet
     },
     republish := {
       val cacheDir = republishRepo.value
       val artifacts = republishClasspath.value
       val launchers = republishFetchLaunchers.value
+      val extraProps = republishWriteExtraProps.value
       cacheDir
     }
   )
diff --git a/project/scripts/bootstrappedOnlyCmdTests b/project/scripts/bootstrappedOnlyCmdTests
index f3d730f8f494..11c35a7028cc 100755
--- a/project/scripts/bootstrappedOnlyCmdTests
+++ b/project/scripts/bootstrappedOnlyCmdTests
@@ -15,13 +15,13 @@ echo "testing scala.quoted.Expr.run from sbt scala"
 grep -qe "val a: scala.Int = 3" "$tmp"
 
 # setup for `scalac`/`scala` script tests
-"$SBT" dist/pack
+"$SBT" "$DIST_PROJECT/pack"
 
-echo "capturing scala version from dist/target/pack/VERSION"
-IFS=':=' read -ra versionProps < "$ROOT/dist/target/pack/VERSION" # temporarily set IFS to ':=' to split versionProps
+echo "capturing scala version from $DIST_DIR/target/pack/VERSION"
+IFS=':=' read -ra versionProps < "$ROOT/$DIST_DIR/target/pack/VERSION" # temporarily set IFS to ':=' to split versionProps
 [ ${#versionProps[@]} -eq 3 ] && \
   [ ${versionProps[0]} = "version" ] && \
-  [ -n ${versionProps[2]} ] || die "Expected non-empty 'version' property in $ROOT/dist/target/pack/VERSION"
+  [ -n ${versionProps[2]} ] || die "Expected non-empty 'version' property in $ROOT/$DIST_DIR/target/pack/VERSION"
 scala_version=${versionProps[2]}
 
 # check that `scalac` compiles and `scala` runs it
@@ -77,7 +77,7 @@ echo "testing sbt scalac with suspension"
 clear_out "$OUT"
 "$SBT" "scala3-compiler-bootstrapped/scalac -d $OUT tests/pos-macros/macros-in-same-project-1/Bar.scala tests/pos-macros/macros-in-same-project-1/Foo.scala"  > "$tmp"
 
-# echo ":quit" | ./dist/target/pack/bin/scala  # not supported by CI
+# echo ":quit" | ./$DIST_DIR/target/pack/bin/scala  # not supported by CI
 
 echo "testing ./bin/scaladoc"
 clear_out "$OUT1"
@@ -101,6 +101,13 @@ grep -qe "See 'scala <command> --help' to read about a specific subcommand." "$t
 
 ./bin/scala -d hello.jar tests/run/hello.scala
 ls hello.jar
+clear_cli_dotfiles tests/run
+
+# check that `scala` runs scripts with args
+echo "testing ./bin/scala with arguments"
+./bin/scala run project/scripts/echoArgs.sc -- abc true 123 > "$tmp"
+test "$EXPECTED_OUTPUT_ARGS" = "$(cat "$tmp")"
+clear_cli_dotfiles project/scripts
 
 echo "testing i12973"
 clear_out "$OUT"
diff --git a/project/scripts/buildScalaBinary b/project/scripts/buildScalaBinary
new file mode 100755
index 000000000000..7fc5275e5d8d
--- /dev/null
+++ b/project/scripts/buildScalaBinary
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >& /dev/null && pwd)/../.."
+SBT="$ROOT/project/scripts/sbt" # if run on CI
+
+# set the $DIST_PROJECT and $DIST_DIR variables
+source "$ROOT/bin/common-platform"
+
+# build the scala/scalac/scaladoc binary, where scala is native for the current platform.
+"$SBT" "$DIST_PROJECT/pack"
diff --git a/project/scripts/cmdTestsCommon.inc.sh b/project/scripts/cmdTestsCommon.inc.sh
index a37ab757c057..bccb4aa56ac1 100644
--- a/project/scripts/cmdTestsCommon.inc.sh
+++ b/project/scripts/cmdTestsCommon.inc.sh
@@ -9,11 +9,15 @@ SOURCE="tests/pos/HelloWorld.scala"
 MAIN="HelloWorld"
 TASTY="HelloWorld.tasty"
 EXPECTED_OUTPUT="hello world"
+EXPECTED_OUTPUT_ARGS="[0:abc],[1:true],[2:123]"
 
 OUT=$(mktemp -d)
 OUT1=$(mktemp -d)
 tmp=$(mktemp)
 
+# set the $DIST_PROJECT and $DIST_DIR variables
+source "$ROOT/bin/common-platform"
+
 die () {
     echo >&2 "$@"
     exit 1
@@ -24,3 +28,16 @@ clear_out()
   local out="$1"
   rm -rf "$out"/*
 }
+
+clear_cli_dotfiles()
+{
+  local out="$1"
+  rm -rf "$out"/.bsp
+  rm -rf "$out"/.scala-build
+
+  rm -f "$ROOT"/.bsp/scala.json
+  if [ -z "$(ls -A "$ROOT"/.bsp)" ]; then
+    rm -rf "$ROOT"/.bsp
+  fi
+  rm -rf "$ROOT"/.scala-build
+}
diff --git a/project/scripts/echoArgs.sc b/project/scripts/echoArgs.sc
new file mode 100644
index 000000000000..cb9acbb6ad2e
--- /dev/null
+++ b/project/scripts/echoArgs.sc
@@ -0,0 +1,6 @@
+// This is a Scala CLI script
+
+val formatted =
+  (for (arg, i) <- args.zipWithIndex yield
+    s"[$i:$arg]").mkString(",")
+println(formatted)
diff --git a/project/scripts/native-integration/bashTests b/project/scripts/native-integration/bashTests
new file mode 100755
index 000000000000..5fb77355238c
--- /dev/null
+++ b/project/scripts/native-integration/bashTests
@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+set -eux
+
+#/*---------------*\
+# *  SETUP VARS   *#
+# *---------------*/
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" >& /dev/null && pwd)/../../.."
+
+SBT="$ROOT/project/scripts/sbt" # if run on CI
+# SBT="sbt" # if run locally
+
+# set the $DIST_PROJECT and $DIST_DIR variables
+source "$ROOT/bin/common-platform"
+
+die () {
+    echo >&2 "$@"
+    exit 1
+}
+
+PROG_HOME="$DIST_DIR/target/pack"
+
+SOURCE="$ROOT/tests/pos/HelloWorld.scala"
+SOURCE_VERSION="$ROOT/project/scripts/native-integration/reportScalaVersion.scala"
+
+clear_cli_dotfiles()
+{
+  local out="$1"
+  rm -rf "$out"/.bsp
+  rm -rf "$out"/.scala-build
+
+  rm -f "$ROOT"/.bsp/scala.json
+  if [ -z "$(ls -A "$ROOT"/.bsp)" ]; then
+    rm -rf "$ROOT"/.bsp
+  fi
+  rm -rf "$ROOT"/.scala-build
+}
+
+#/*---------------*\
+# *  INITIALIZE   *#
+# *---------------*/
+
+# build the distribution
+"$SBT" "$DIST_PROJECT/pack"
+
+SCALA_VERSION=""
+# iterate through lines in VERSION_SRC
+while IFS= read -r line; do
+  # if line starts with "version:=" then extract the version
+  if [[ "$line" == version:=* ]]; then
+    SCALA_VERSION="${line#version:=}"
+    break
+  fi
+done < "$PROG_HOME/VERSION"
+
+if [ -z "$SCALA_VERSION" ]; then
+  die "Could not find scala version in $PROG_HOME/VERSION"
+fi
+
+#/*-------------------*\
+# *  TESTING BEGINS   *#
+# *-------------------*/
+
+echo "assert native launcher matches expected version"
+if [ -z "$LAUNCHER_EXPECTED_PROJECT" ]; then
+  die "LAUNCHER_EXPECTED_PROJECT is not set in the environment"
+fi
+test "$LAUNCHER_EXPECTED_PROJECT" = "$DIST_PROJECT"
+
+echo "testing version output (default)"
+std_output=$("$PROG_HOME/bin/scala" version --scala-version)
+test "$SCALA_VERSION" = "$std_output"
+
+echo "testing run command"
+std_output=$("$PROG_HOME/bin/scala" run "$SOURCE" --power --offline --server=false)
+test "hello world" = "$std_output"
+clear_cli_dotfiles "$ROOT/tests/pos"
+
+echo "testing run command (-with-compiler)"
+std_output=$("$PROG_HOME/bin/scala" run "$SOURCE_VERSION" -with-compiler --power --offline --server=false)
+test "$SCALA_VERSION" = "$std_output"
+clear_cli_dotfiles "$ROOT/project/scripts/native-integration"
+
diff --git a/project/scripts/native-integration/reportScalaVersion.scala b/project/scripts/native-integration/reportScalaVersion.scala
new file mode 100644
index 000000000000..dc6e93708a48
--- /dev/null
+++ b/project/scripts/native-integration/reportScalaVersion.scala
@@ -0,0 +1,4 @@
+// To be ran by Scala CLI (requires -with-compiler command line option)
+
+@main def reportScalaVersion: Unit =
+  println(dotty.tools.dotc.config.Properties.versionNumberString)
diff --git a/project/scripts/native-integration/winTests.bat b/project/scripts/native-integration/winTests.bat
new file mode 100755
index 000000000000..a85b2c8c2531
--- /dev/null
+++ b/project/scripts/native-integration/winTests.bat
@@ -0,0 +1,19 @@
+@echo off
+setlocal
+
+@rem paths are relative to the root project directory
+set "_PREFIX=dist\win-x86_64\target\pack"
+set "_SOURCE=tests\pos\HelloWorld.scala"
+set "_OUT_DIR=out"
+
+@rem if-tests mimic the non-existing bash instruction 'set -e'.
+call "%_PREFIX%\bin\scalac.bat" "@project\scripts\options" "%_SOURCE%"
+if not %ERRORLEVEL%==0 endlocal& exit /b 1
+
+call "%_PREFIX%\bin\scalac.bat" -d "%_OUT_DIR%" "%_SOURCE%"
+if not %ERRORLEVEL%==0 endlocal& exit /b 1
+
+call "%_PREFIX%\bin\scala.bat" --power -classpath "%_OUT_DIR%" -M HelloWorld --offline --server=false
+if not %ERRORLEVEL%==0 endlocal& exit /b 1
+
+endlocal
diff --git a/project/scripts/winCmdTests b/project/scripts/winCmdTests
index 2dffff5b196a..fe6a43c7f68f 100644
--- a/project/scripts/winCmdTests
+++ b/project/scripts/winCmdTests
@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 set -e
-PREFIX="dist/target/pack"
+PREFIX="dist/win-x86_64/target/pack"
 SOURCE="tests/pos/HelloWorld.scala"
 $PREFIX/bin/scalac @project/scripts/options "$SOURCE"
 $PREFIX/bin/scalac -d out "$SOURCE"
diff --git a/project/scripts/winCmdTests.bat b/project/scripts/winCmdTests.bat
index d9b594d560ab..903f74d7ab98 100644
--- a/project/scripts/winCmdTests.bat
+++ b/project/scripts/winCmdTests.bat
@@ -2,7 +2,7 @@
 setlocal
 
 @rem paths are relative to the root project directory
-set "_PREFIX=dist\target\pack"
+set "_PREFIX=dist\win-x86_64\target\pack"
 set "_SOURCE=tests\pos\HelloWorld.scala"
 set "_OUT_DIR=out"
 set "_SITE_DIR=_site"
diff --git a/tests/cmdTest-sbt-tests/sourcepath-with-inline/src/main/scala/a/zz.scala b/tests/cmdTest-sbt-tests/sourcepath-with-inline/src/main/scala/a/zz.scala
new file mode 100644
index 000000000000..17a7488ccb1a
--- /dev/null
+++ b/tests/cmdTest-sbt-tests/sourcepath-with-inline/src/main/scala/a/zz.scala
@@ -0,0 +1,6 @@
+package a
+
+object Foo: // note that `Foo` is defined in `zz.scala`
+  class Local
+  inline def foo(using Local): Nothing =
+    ???