feat(dotnet): add support for runtime-only installs

Author: fragon10

docs/lang/dotnet.md

@@ -78,6 +78,42 @@ version.
 | Install location     | `DOTNET_ROOT`          | `installs/dotnet/<version>/` |
 | Multi-targeting      | Works out of the box   | Requires switching versions  |
 
+## Runtime-only Installs
+
+By default, mise installs the full .NET SDK. If you only need to _run_ .NET applications without building them and without the added overhead of the SDK, you can install just the runtime using the `runtime` inline option:
+
+```sh
+mise use dotnet[runtime=dotnet]@8.0.14
+dotnet --list-runtimes
+```
+
+### Valid runtime values
+
+| Value          | Framework                    | Use case                 |
+| -------------- | ---------------------------- | ------------------------ |
+| dotnet         | Microsoft.NETCore.App        | Console apps, libraries  |
+| aspnetcore     | Microsoft.AspNetCore.App     | ASP.NET Core web apps    |
+| windowsdesktop | Microsoft.WindowsDesktop.App | WPF / WinForms (Windows) |
+
+### Example: mix SDK and runtime
+
+You can install a full SDK for development alongside a runtime for a production-like environment:
+
+```toml
+[tools]
+dotnet = ["9", { version = "8.0.14", runtime = "dotnet" }]
+```
+
+::: warning
+
+- **Version numbers are runtime versions**, not SDK versions. For example, `8.0.14` refers to .NET Runtime 8.0.14, not SDK 8.0.14. Check the [.NET release notes](https://github.com/dotnet/core/tree/main/release-notes) for available runtime versions.
+- Runtime-only installs do **not** include the SDK build tools. Commands like `dotnet build` and `dotnet publish` will not be available, and `dotnet --version` will not report an SDK version.
+  :::
+
+::: tip
+Only exact runtime versions are supported (e.g., `dotnet[runtime=dotnet]@8.0.14`). Channel syntax like `@8` is not currently supported for runtime installs, as it resolves against SDK versions rather than runtime versions.
+:::
+
 ## Environment Variables
 
 The plugin sets the following environment variables:

e2e/core/test_dotnet

@@ -16,3 +16,18 @@ cat <<EOF >global.json
 EOF
 
 assert_contains "mise x -- dotnet --version" "8.0.408"
+
+# Prepare and test environment is clean for runtime-only install tests
+mise uninstall "dotnet[runtime=dotnet]@8.0.13" 2>/dev/null || true
+assert_not_contains "mise x dotnet@8.0.408 -- dotnet --list-runtimes" "Microsoft.NETCore.App 8.0.13"
+
+# Test runtime-only install: version NOT bundled by SDK 8.0.408, `--list-runtimes`
+assert_contains "mise x dotnet[runtime=dotnet]@8.0.13 -- dotnet --list-runtimes" "Microsoft.NETCore.App 8.0.13"
+
+# Test runtime uninstall cleans up shared directory
+mise uninstall "dotnet[runtime=dotnet]@8.0.13"
+assert_not_contains "mise x dotnet@8.0.408 -- dotnet --list-runtimes" "Microsoft.NETCore.App 8.0.13"
+
+# Prepare by removing any stale install and test (uncached) invalid runtime option returns a validation error
+mise uninstall "dotnet[runtime=invalid]@8.0.12" 2>/dev/null || mise uninstall "dotnet@8.0.12" 2>/dev/null || true
+assert_fail_contains "mise x dotnet[runtime=invalid]@8.0.12 -- true" "Invalid runtime option"

src/cli/uninstall.rs

@@ -125,20 +125,27 @@ impl Uninstall {
                     .filter(|v| v.starts_with(&query))
                     .collect_vec(),
             };
-            let mut tvs = matches
-                .into_iter()
-                .map(|v| {
-                    let tvr = ToolRequest::new(backend.ba().clone(), v, ToolSource::Unknown)?;
-                    let tv = ToolVersion::new(tvr, v.into());
-                    Ok((backend.clone(), tv))
-                })
-                .collect::<Result<Vec<_>>>()?;
+
+            let mut tvs = Vec::new();
+
             if let Some(tvr) = &ta.tvr {
                 tvs.push((
                     backend.clone(),
                     tvr.resolve(config, &Default::default()).await?,
                 ));
             }
+
+            tvs.extend(
+                matches
+                    .into_iter()
+                    .map(|v| {
+                        let tvr = ToolRequest::new(backend.ba().clone(), v, ToolSource::Unknown)?;
+                        let tv = ToolVersion::new(tvr, v.into());
+                        Ok((backend.clone(), tv))
+                    })
+                    .collect::<Result<Vec<_>>>()?,
+            );
+
             if tvs.is_empty() {
                 warn!(
                     "no versions found for {}",

src/plugins/core/dotnet.rs

@@ -36,6 +36,10 @@ impl DotnetPlugin {
     }
 
     async fn test_dotnet(&self, ctx: &InstallContext, tv: &ToolVersion) -> Result<()> {
+        if tv.request.options().get("runtime").is_some() {
+            // Skip version check for runtime-only installs — `dotnet --version` exits non-zero without an SDK
+            return Ok(());
+        }
         ctx.pr.set_message("dotnet --version".into());
         CmdLineRunner::new(DOTNET_BIN)
             .with_pr(ctx.pr.as_ref())
@@ -120,6 +124,17 @@ impl Backend for DotnetPlugin {
         };
         file::create_dir_all(&install_dir)?;
 
+        // Read and validate runtime options
+        let runtime = tv.request.options().get("runtime").map(|s| s.to_string());
+        if let Some(ref rt) = runtime
+            && runtime_framework_name(rt).is_none()
+        {
+            return Err(eyre::eyre!(
+                "Invalid runtime option '{}'. Valid options: dotnet, aspnetcore, windowsdesktop",
+                rt
+            ));
+        }
+
         // Download install script (always refresh to pick up upstream fixes)
         let script_path = install_script_path();
         file::create_dir_all(script_path.parent().unwrap())?;
@@ -131,9 +146,10 @@ impl Backend for DotnetPlugin {
         file::make_executable(&script_path)?;
 
         // Run install script
+        let install_type = if runtime.is_some() { "Runtime" } else { "SDK" };
         ctx.pr
-            .set_message(format!("Installing .NET SDK {}", tv.version));
-        install_cmd(&script_path, &install_dir, &tv.version)
+            .set_message(format!("Installing .NET {} {}", install_type, tv.version));
+        install_cmd(&script_path, &install_dir, &tv.version, runtime.as_deref())
             .with_pr(ctx.pr.as_ref())
             .envs(self.exec_env(&ctx.config, &ctx.ts, &tv).await?)
             .execute()?;
@@ -158,10 +174,25 @@ impl Backend for DotnetPlugin {
         if Self::is_isolated() {
             // Isolated: mise handles removal of install_path by default
         } else {
-            // Shared: only remove this SDK version from the shared root
-            let sdk_dir = dotnet_root().join("sdk").join(&tv.version);
-            if sdk_dir.exists() {
-                file::remove_all(&sdk_dir)?;
+            let runtime = tv.request.options().get("runtime").map(|s| s.to_string());
+            if let Some(rt) = runtime {
+                // Runtime: remove the shared runtime directory for this version
+                let Some(framework) = runtime_framework_name(&rt) else {
+                    return Ok(());
+                };
+                let runtime_dir = dotnet_root()
+                    .join("shared")
+                    .join(framework)
+                    .join(&tv.version);
+                if runtime_dir.exists() {
+                    file::remove_all(&runtime_dir)?;
+                }
+            } else {
+                // SDK: only remove this SDK version from the shared root
+                let sdk_dir = dotnet_root().join("sdk").join(&tv.version);
+                if sdk_dir.exists() {
+                    file::remove_all(&sdk_dir)?;
+                }
             }
         }
         Ok(())
@@ -207,6 +238,15 @@ impl Backend for DotnetPlugin {
     }
 }
 
+fn runtime_framework_name(runtime: &str) -> Option<&'static str> {
+    match runtime {
+        "dotnet" => Some("Microsoft.NETCore.App"),
+        "aspnetcore" => Some("Microsoft.AspNetCore.App"),
+        "windowsdesktop" => Some("Microsoft.WindowsDesktop.App"),
+        _ => None,
+    }
+}
+
 fn dotnet_root() -> PathBuf {
     Settings::get()
         .dotnet
@@ -243,18 +283,32 @@ fn install_script_url() -> &'static str {
 }
 
 #[cfg(unix)]
-fn install_cmd<'a>(script_path: &Path, install_dir: &Path, version: &str) -> CmdLineRunner<'a> {
-    CmdLineRunner::new(script_path)
+fn install_cmd<'a>(
+    script_path: &Path,
+    install_dir: &Path,
+    version: &str,
+    runtime: Option<&str>,
+) -> CmdLineRunner<'a> {
+    let mut cmd = CmdLineRunner::new(script_path)
         .arg("--install-dir")
         .arg(install_dir)
         .arg("--version")
         .arg(version)
-        .arg("--no-path")
+        .arg("--no-path");
+    if let Some(rt) = runtime {
+        cmd = cmd.arg("--runtime").arg(rt);
+    }
+    cmd
 }
 
 #[cfg(windows)]
-fn install_cmd<'a>(script_path: &Path, install_dir: &Path, version: &str) -> CmdLineRunner<'a> {
-    CmdLineRunner::new("powershell")
+fn install_cmd<'a>(
+    script_path: &Path,
+    install_dir: &Path,
+    version: &str,
+    runtime: Option<&str>,
+) -> CmdLineRunner<'a> {
+    let mut cmd = CmdLineRunner::new("powershell")
         .arg("-ExecutionPolicy")
         .arg("Bypass")
         .arg("-File")
@@ -263,7 +317,11 @@ fn install_cmd<'a>(script_path: &Path, install_dir: &Path, version: &str) -> Cmd
         .arg(install_dir)
         .arg("-Version")
         .arg(version)
-        .arg("-NoPath")
+        .arg("-NoPath");
+    if let Some(rt) = runtime {
+        cmd = cmd.arg("-Runtime").arg(rt);
+    }
+    cmd
 }
 
 // --- Microsoft releases API types ---