diff --git a/src/Pure/System/platform.scala b/src/Pure/System/platform.scala
--- a/src/Pure/System/platform.scala
+++ b/src/Pure/System/platform.scala
@@ -1,125 +1,128 @@
 /*  Title:      Pure/System/platform.scala
     Author:     Makarius
 
 System platform identification.
 */
 
 package isabelle
 
 
 object Platform {
   /* platform family */
 
   val is_windows: Boolean = isabelle.setup.Environment.is_windows()
   val is_linux: Boolean = System.getProperty("os.name", "") == "Linux"
   val is_macos: Boolean = System.getProperty("os.name", "") == "Mac OS X"
   val is_unix: Boolean = is_linux || is_macos
 
   def is_arm: Boolean = cpu_arch.startsWith("arm")
 
   def family: Family =
     if (is_linux && is_arm) Family.linux_arm
     else if (is_linux) Family.linux
     else if (is_macos) Family.macos
     else if (is_windows) Family.windows
     else error("Failed to determine current platform family")
 
   object Family {
     val list: List[Family] = List(Family.linux, Family.linux_arm, Family.windows, Family.macos)
 
     def unapply(name: String): Option[Family] =
       try { Some(Family.valueOf(name)) }
       catch { case _: IllegalArgumentException => None }
 
     def parse(name: String): Family =
       unapply(name) getOrElse error("Bad platform family: " + quote(name))
 
     val standard: Family => String =
       {
         case Family.linux_arm => "arm64-linux"
         case Family.linux => "x86_64-linux"
         case Family.macos => "x86_64-darwin"
         case Family.windows => "x86_64-cygwin"
       }
 
     val native: Family => String =
       {
         case Family.macos => "arm64-darwin"
         case Family.windows => "x86_64-windows"
         case platform => standard(platform)
       }
 
     def from_platform(platform: String): Family =
       list.find(family => platform == standard(family) || platform == native(family))
         .getOrElse(error("Bad platform " + quote(platform)))
   }
 
   enum Family { case linux_arm, linux, macos, windows }
 
 
   /* platform identifiers */
 
   private val X86_64 = """amd64|x86_64""".r
   private val Arm64 = """arm64|aarch64""".r
 
   def cpu_arch: String =
     System.getProperty("os.arch", "") match {
       case X86_64() => "x86_64"
       case Arm64() => "arm64"
       case _ => error("Failed to determine CPU architecture")
     }
 
   def os_name: String =
     family match {
       case Family.linux_arm => "linux"
       case Family.macos => "darwin"
       case _ => family.toString
     }
 
   lazy val jvm_platform: String = cpu_arch + "-" + os_name
 
 
   /* platform info */
 
   object Info {
+    val ALL = "all"
+
     def check(infos: List[Info], spec: String): String = {
-      val specs = Library.distinct(infos.map(_.family_name) ::: infos.map(_.platform))
+      val specs = Library.distinct(ALL :: infos.map(_.family_name) ::: infos.map(_.platform))
       if (specs.contains(spec)) spec
       else {
         error("Bad platform specification " + quote(spec) +
           "\n  expected " + commas_quote(specs))
       }
     }
   }
 
   trait Info {
     def platform: String
     override def toString: String = platform
     def path: Path = Path.explode(platform)
 
     val family: Family = Family.from_platform(platform)
     def family_name: String = family.toString
 
     def is_linux_arm: Boolean = family == Family.linux_arm
     def is_linux: Boolean = family == Family.linux
     def is_macos: Boolean = family == Family.macos
     def is_windows: Boolean = family == Family.windows
 
-    def is(spec: String): Boolean = platform == spec || family_name == spec
+    def is(spec: String): Boolean =
+      Info.ALL == spec || platform == spec || family_name == spec
   }
 
 
   /* JVM version */
 
   private val Version = """1\.(\d+)\.0_(\d+)""".r
   lazy val jvm_version: String =
     System.getProperty("java.version") match {
       case Version(a, b) => a + "u" + b
       case a => a
     }
 
 
   /* JVM name */
 
   val jvm_name: String = System.getProperty("java.vm.name", "")
 }
diff --git a/src/Pure/Tools/dotnet_setup.scala b/src/Pure/Tools/dotnet_setup.scala
--- a/src/Pure/Tools/dotnet_setup.scala
+++ b/src/Pure/Tools/dotnet_setup.scala
@@ -1,188 +1,188 @@
 /*  Title:      Pure/Tools/dotnet_setup.scala
     Author:     Makarius
 
 Dynamic setup of Dotnet component.
 */
 
 package isabelle
 
 
 object Dotnet_Setup {
   /* platforms */
 
   sealed case class Platform_Info(
     platform: String,
     os: String = "",
     arch: String = "x64",
     ext: String = "sh",
     exec: String = "bash",
     check: () => Unit = () => ()
   ) extends Platform.Info
 
   val all_platforms: List[Platform_Info] =
     List(
       Platform_Info("arm64-linux", os = "linux", arch = "arm64"),
       Platform_Info("x86_64-linux", os = "linux"),
       Platform_Info("arm64-darwin", os = "osx", arch = "arm64"),
       Platform_Info("x86_64-darwin", os = "osx"),
       Platform_Info("x86_64-windows",
         ext = "ps1",
         exec = "powershell -ExecutionPolicy ByPass",
         check = () => Isabelle_System.require_command("powershell", "-NoProfile -Command Out-Null")))
 
   def check_platform(spec: String): String = Platform.Info.check(all_platforms, spec)
 
 
   /* dotnet download and setup */
 
   def default_platform: String =
     Isabelle_Platform.self.ISABELLE_PLATFORM(windows = true, apple = true)
   def default_target_dir: Path = Components.default_components_base
   def default_install_url: String = "https://dot.net/v1/dotnet-install"
   def default_version: String = Isabelle_System.getenv_strict("ISABELLE_DOTNET_VERSION")
 
   def dotnet_setup(
     platforms: List[String] = List(default_platform),
     target_dir: Path = default_target_dir,
     install_url: String = default_install_url,
     version: String = default_version,
     force: Boolean = false,
     dry_run: Boolean = false,
     progress: Progress = new Progress
   ): Unit = {
     platforms.foreach(check_platform)
 
 
     /* component directory */
 
     val component_dir =
       Components.Directory(
         target_dir + Path.explode(if (version.isEmpty) "dotnet-latest" else "dotnet-" + version))
 
     if (!dry_run) {
       progress.echo("Component directory " + component_dir)
       component_dir.create(permissive = true)
 
       component_dir.write_settings("""
 ISABELLE_DOTNET_ROOT="$COMPONENT"
 
 if [ -n "$ISABELLE_WINDOWS_PLATFORM64" -a -d "$ISABELLE_DOTNET_ROOT/$ISABELLE_WINDOWS_PLATFORM64" ]; then
   ISABELLE_DOTNET="$ISABELLE_DOTNET_ROOT/$ISABELLE_WINDOWS_PLATFORM64/dotnet.exe"
 elif [ -n "$ISABELLE_APPLE_PLATFORM64" -a -d "$ISABELLE_DOTNET_ROOT/$ISABELLE_APPLE_PLATFORM64" ]; then
   ISABELLE_DOTNET="$ISABELLE_DOTNET_ROOT/$ISABELLE_APPLE_PLATFORM64/dotnet"
 elif [ -d "$ISABELLE_DOTNET_ROOT/$ISABELLE_PLATFORM64" ]; then
   ISABELLE_DOTNET="$ISABELLE_DOTNET_ROOT/$ISABELLE_PLATFORM64/dotnet"
 fi
 
 DOTNET_CLI_TELEMETRY_OPTOUT="true"
 DOTNET_CLI_HOME="$(platform_path "$ISABELLE_HOME_USER/dotnet")"
 """)
 
       File.write(component_dir.README,
         """This installation of Dotnet has been produced via "isabelle dotnet_setup".
 
 
       Makarius
       """ + Date.Format.date(Date.now()) + "\n")
 
       for (old <- proper_string(Isabelle_System.getenv("ISABELLE_DOTNET_ROOT"))) {
         Components.update_components(false, Path.explode(old))
       }
 
       Components.update_components(true, component_dir.path)
     }
 
 
     /* platform directories */
 
     for (platform <- all_platforms if platforms.exists(platform.is)) {
       progress.expose_interrupt()
 
       Isabelle_System.with_tmp_file("install", ext = platform.ext) { install =>
         Isabelle_System.download_file(install_url + "." + platform.ext, install)
 
         val platform_dir = component_dir.path + platform.path
         if (platform_dir.is_dir && !force) {
           progress.echo_warning("Platform " + platform + " already installed")
         }
         else {
           progress.echo("Platform " + platform + " ...")
           platform.check()
           if (platform_dir.is_dir && force) Isabelle_System.rm_tree(platform_dir)
           val script =
             platform.exec + " " + File.bash_platform_path(install) +
               if_proper(version, " -Version " + Bash.string(version)) +
               " -Architecture " + Bash.string(platform.arch) +
               if_proper(platform.os, " -OS " + Bash.string(platform.os)) +
               " -InstallDir " + File.bash_path(platform.path) +
               (if (dry_run) " -DryRun" else "") +
               " -NoPath"
           progress.bash(script, echo = progress.verbose,
             cwd = if (dry_run) null else component_dir.path.file).check
           for (exe <- File.find_files(platform_dir.file, pred = _.getName.endsWith(".exe"))) {
             File.set_executable(File.path(exe))
           }
         }
       }
     }
   }
 
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool =
     Isabelle_Tool("dotnet_setup", "dynamic setup of Dotnet component (for Fsharp)",
       Scala_Project.here,
       { args =>
 
         var target_dir = default_target_dir
         var install_url = default_install_url
         var version = default_version
         var force = false
         var dry_run = false
         var platforms = List(default_platform)
         var verbose = false
 
         val getopts = Getopts("""
 Usage: isabelle dotnet_setup [OPTIONS]
 
   Options are:
     -D DIR       target directory (default: """ + default_target_dir.expand + """)
     -I URL       URL for install script without extension
                  (default: """ + quote(default_install_url) + """)
     -V VERSION   version (empty means "latest",
                  default: ISABELLE_DOTNET_VERSION=""" + quote(default_version) + """)
     -f           force fresh installation of specified platforms
     -n           dry run: try download without installation
-    -p PLATFORMS comma-separated list of platform specifications,
+    -p PLATFORMS comma-separated list of platform specifications: "all" or
                  as family or formal name (default: """ + quote(default_platform) + """)
     -v           verbose
 
   Download the Dotnet / Fsharp platform and configure it as Isabelle component.
 
   See also:
     https://fsharp.org
     https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script
     https://learn.microsoft.com/en-us/dotnet/core/tools/telemetry
 """,
           "D:" -> (arg => target_dir = Path.explode(arg)),
           "I:" -> (arg => install_url = arg),
           "V:" -> (arg => version = arg),
           "f" -> (_ => force = true),
           "n" -> (_ => dry_run = true),
           "p:" -> (arg => platforms = space_explode(',', arg).map(check_platform)),
           "v" -> (_ => verbose = true))
 
         val more_args = getopts(args)
         if (more_args.nonEmpty) getopts.usage()
 
         val progress = new Console_Progress(verbose = verbose)
 
         dotnet_setup(platforms = platforms, target_dir = target_dir, install_url = install_url,
           version = version, force = force, dry_run = dry_run, progress = progress)
       })
 }
 
 class Dotnet_Setup extends Setup_Tool("dotnet_setup", "ISABELLE_DOTNET_SETUP") {
   override val test_file: Path = Path.explode("lib/Tools/dotnet")
 }
diff --git a/src/Pure/Tools/go_setup.scala b/src/Pure/Tools/go_setup.scala
--- a/src/Pure/Tools/go_setup.scala
+++ b/src/Pure/Tools/go_setup.scala
@@ -1,175 +1,175 @@
 /*  Title:      Pure/Tools/go_setup.scala
     Author:     Makarius
 
 Dynamic setup of Go component.
 */
 
 package isabelle
 
 
 object Go_Setup {
   /* platform information */
 
   sealed case class Platform_Info(platform: String, go_platform: String)
   extends Platform.Info {
     def paths: List[String] = List(platform, "pkg/tool/" + go_platform)
 
     def download(base_url: String, version: String): String = {
       val ext = if (is_windows) ".zip" else ".tar.gz"
       Url.append_path(base_url, "go" + version + "." + go_platform.replace("_", "-") + ext)
     }
   }
 
   val all_platforms: List[Platform_Info] =
     List(
       Platform_Info("arm64-darwin", "darwin_arm64"),
       Platform_Info("arm64-linux", "linux_arm64"),
       Platform_Info("x86_64-darwin", "darwin_amd64"),
       Platform_Info("x86_64-linux", "linux_amd64"),
       Platform_Info("x86_64-windows", "windows_amd64"))
 
   def check_platform(spec: String): String = Platform.Info.check(all_platforms, spec)
 
 
   /* Go download and setup */
 
   def default_platform: String =
     Isabelle_Platform.self.ISABELLE_PLATFORM(windows = true, apple = true)
   def default_target_dir: Path = Components.default_components_base
   val default_url = "https://go.dev/dl"
   def default_version: String = Isabelle_System.getenv_strict("ISABELLE_GO_VERSION")
 
   def go_setup(
     platforms: List[String] = List(default_platform),
     base_url: String = default_url,
     version: String = default_version,
     target_dir: Path = default_target_dir,
     progress: Progress = new Progress,
     force: Boolean = false
   ): Unit = {
     platforms.foreach(check_platform)
 
 
     /* component directory */
 
     val component_dir =
       Components.Directory(target_dir + Path.basic("go-" + version)).create(permissive = true)
 
     progress.echo("Component directory " + component_dir)
 
     component_dir.write_settings("""
 ISABELLE_GOROOT="$COMPONENT"
 
 if [ -n "$ISABELLE_WINDOWS_PLATFORM64" -a -d "$ISABELLE_GOROOT/$ISABELLE_WINDOWS_PLATFORM64" ]; then
   ISABELLE_GOEXE="$ISABELLE_GOROOT/$ISABELLE_WINDOWS_PLATFORM64"
 elif [ -n "$ISABELLE_APPLE_PLATFORM64" -a -d "$ISABELLE_GOROOT/$ISABELLE_APPLE_PLATFORM64" ]; then
   ISABELLE_GOEXE="$ISABELLE_GOROOT/$ISABELLE_APPLE_PLATFORM64"
 elif [ -d "$ISABELLE_GOROOT/$ISABELLE_PLATFORM64" ]; then
   ISABELLE_GOEXE="$ISABELLE_GOROOT/$ISABELLE_PLATFORM64"
 fi
 """)
 
     File.write(component_dir.platform_props,
       (for ((a, b) <- all_platforms.groupBy(_.family_name).iterator)
         yield a + " = " + b.flatMap(_.paths).mkString(" ")
       ).mkString("", "\n", "\n"))
 
     for (old <- proper_string(Isabelle_System.getenv("ISABELLE_GOROOT"))) {
       Components.update_components(false, Path.explode(old))
     }
 
     Components.update_components(true, component_dir.path)
 
 
     /* download and setup */
 
     Isabelle_System.with_tmp_dir("download") { download_dir =>
       for (platform <- all_platforms if platforms.exists(platform.is)) {
         val platform_dir = component_dir.path + platform.path
         if (platform_dir.is_dir && !force) {
           progress.echo_warning("Platform " + platform + " already installed")
         }
         else {
           progress.echo("Platform " + platform + " ...")
           progress.expose_interrupt()
 
           if (force) {
             for (name <- platform.paths) {
               val dir = component_dir.path + Path.explode(name)
               if (dir.is_dir) Isabelle_System.rm_tree(dir)
             }
           }
 
           val download = platform.download(base_url, version)
 
           val archive_name =
             Url.get_base_name(download) getOrElse
               error("Malformed download URL " + quote(download))
           val archive_path = download_dir + Path.basic(archive_name)
 
           Isabelle_System.download_file(download, archive_path)
           Isabelle_System.extract(archive_path, component_dir.path, strip = true)
           Isabelle_System.move_file(component_dir.bin, platform_dir)
         }
       }
     }
 
     File.find_files(component_dir.path.file, pred = file => File.is_exe(file.getName)).
       foreach(file => File.set_executable(File.path(file)))
 
 
     /* README */
 
     File.write(component_dir.README,
       """This installation of Go has been produced via "isabelle go_setup".
 
 
         Makarius
         """ + Date.Format.date(Date.now()) + "\n")
   }
 
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool =
     Isabelle_Tool("go_setup", "dynamic setup of Go component", Scala_Project.here,
       { args =>
         var target_dir = default_target_dir
         var base_url = default_url
         var version = default_version
         var force = false
         var platforms = List(default_platform)
 
         val getopts = Getopts("""
 Usage: isabelle go_setup [OPTIONS]
 
   Options are:
     -D DIR       target directory (default ".")
     -U URL       download URL (default: """" + default_url + """")
     -V VERSION   version (default: """" + default_version + """")
     -f           force fresh installation of specified platforms
-    -p PLATFORMS comma-separated list of platform specifications,
+    -p PLATFORMS comma-separated list of platform specifications: "all" or
                  as family or formal name (default: """ + quote(default_platform) + """)
 
   Download the Go development environment and configure it as Isabelle
   component. See also https://go.dev
 """,
           "D:" -> (arg => target_dir = Path.explode(arg)),
           "U:" -> (arg => base_url = arg),
           "V:" -> (arg => version = arg),
           "f" -> (_ => force = true),
           "p:" -> (arg => platforms = space_explode(',', arg).map(check_platform)))
 
         val more_args = getopts(args)
         if (more_args.nonEmpty) getopts.usage()
 
         val progress = new Console_Progress()
 
         go_setup(platforms = platforms, base_url = base_url, version = version,
           target_dir = target_dir, progress = progress, force = force)
       })
 }
 
 class Go_Setup extends Setup_Tool("go_setup", "ISABELLE_GO_SETUP") {
   override val test_file: Path = Path.explode("lib/Tools/go")
 }