diff --git a/src/applications/actionlint.rs b/src/applications/actionlint.rs
index 0d3821be..4259a74a 100644
--- a/src/applications/actionlint.rs
+++ b/src/applications/actionlint.rs
@@ -1,10 +1,10 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::{self, Executable};
 use crate::{regexp, Log};
 use const_format::formatcp;
 
@@ -26,7 +26,7 @@ impl AppDefinition for ActionLint {
     github_releases::latest(ORG, REPO, log)
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let cpu = match platform.cpu {
       Cpu::Arm64 => "arm64",
       Cpu::Intel64 => "amd64",
@@ -40,7 +40,7 @@ impl AppDefinition for ActionLint {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/actionlint_{version}_{os}_{cpu}.{ext}"),
@@ -86,9 +86,9 @@ mod tests {
     use crate::applications::actionlint::ActionLint;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -100,7 +100,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/rhysd/actionlint/releases/download/v1.6.26/actionlint_1.6.26_linux_arm64.tar.gz"),
@@ -123,7 +123,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/rhysd/actionlint/releases/download/v1.6.26/actionlint_1.6.26_windows_amd64.zip"),
diff --git a/src/applications/alphavet.rs b/src/applications/alphavet.rs
index 932749d4..d76cfa85 100644
--- a/src/applications/alphavet.rs
+++ b/src/applications/alphavet.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::Method;
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct Alphavet {}
@@ -22,8 +22,8 @@ impl AppDefinition for Alphavet {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, _platform: Platform) -> run::Method {
-    run::Method::ThisApp {
+  fn run_method(&self, version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: format!("github.com/{ORG}/{REPO}/cmd/alphavet@v{version}"),
       }],
@@ -54,7 +54,7 @@ impl AppDefinition for Alphavet {
 
 #[cfg(test)]
 mod tests {
-  use crate::run;
+  use crate::executables::RunMethod;
 
   #[test]
   fn install_methods() {
@@ -72,7 +72,7 @@ mod tests {
         cpu: Cpu::Arm64,
       },
     );
-    let want = run::Method::ThisApp {
+    let want = RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: S("github.com/skx/alphavet/cmd/alphavet@v0.1.0"),
       }],
diff --git a/src/applications/deadcode.rs b/src/applications/deadcode.rs
index 52a579f1..0b6d00fb 100644
--- a/src/applications/deadcode.rs
+++ b/src/applications/deadcode.rs
@@ -1,10 +1,10 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::installation::Method;
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 
 pub(crate) struct Deadcode {}
 
@@ -17,8 +17,8 @@ impl AppDefinition for Deadcode {
     "https://pkg.go.dev/golang.org/x/tools/cmd/deadcode"
   }
 
-  fn run_method(&self, version: &Version, _platform: Platform) -> run::Method {
-    run::Method::ThisApp {
+  fn run_method(&self, version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: format!("golang.org/x/tools/cmd/deadcode@v{version}"),
       }],
@@ -51,7 +51,7 @@ impl AppDefinition for Deadcode {
 #[cfg(test)]
 mod tests {
   use crate::applications::deadcode::Deadcode;
-  use crate::run;
+  use crate::executables::RunMethod;
 
   #[test]
   fn install_methods() {
@@ -68,7 +68,7 @@ mod tests {
         cpu: Cpu::Arm64,
       },
     );
-    let want = run::Method::ThisApp {
+    let want = RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: S("golang.org/x/tools/cmd/deadcode@v0.16.1"),
       }],
diff --git a/src/applications/depth.rs b/src/applications/depth.rs
index 11fe3f1b..5fd0a565 100644
--- a/src/applications/depth.rs
+++ b/src/applications/depth.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::Method;
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct Depth {}
@@ -22,7 +22,7 @@ impl AppDefinition for Depth {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let cpu = match platform.cpu {
       Cpu::Arm64 => "aarch64", // the "arm" binaries don't run on Apple Silicon
       Cpu::Intel64 => "amd64",
@@ -36,7 +36,7 @@ impl AppDefinition for Depth {
       Os::Windows => ".exe",
       Os::Linux | Os::MacOS => "",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadExecutable {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/depth_{version}_{os}_{cpu}{ext}"),
@@ -77,9 +77,9 @@ mod tests {
     use super::super::Depth;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::Method;
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -91,7 +91,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/KyleBanks/depth/releases/download/v1.2.1/depth_1.2.1_linux_aarch64"),
@@ -113,7 +113,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/KyleBanks/depth/releases/download/v1.2.1/depth_1.2.1_windows_amd64.exe"),
diff --git a/src/applications/dprint.rs b/src/applications/dprint.rs
index bfbeda18..398966fc 100644
--- a/src/applications/dprint.rs
+++ b/src/applications/dprint.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use big_s::S;
 
 pub(crate) struct Dprint {}
@@ -22,7 +22,7 @@ impl AppDefinition for Dprint {
     "https://dprint.dev"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let cpu = match platform.cpu {
       Cpu::Arm64 => "aarch64",
       Cpu::Intel64 => "x86_64",
@@ -32,7 +32,7 @@ impl AppDefinition for Dprint {
       Os::MacOS => "apple-darwin",
       Os::Windows => "pc-windows-msvc",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/{version}/dprint-{cpu}-{os}.zip"),
@@ -81,9 +81,9 @@ mod tests {
     use super::super::Dprint;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -95,7 +95,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/dprint/dprint/releases/download/0.48.0/dprint-aarch64-apple-darwin.zip"),
@@ -119,7 +119,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/dprint/dprint/releases/download/0.48.0/dprint-aarch64-unknown-linux-gnu.zip"),
diff --git a/src/applications/exhaustruct.rs b/src/applications/exhaustruct.rs
index a96aa6a7..09dcf576 100644
--- a/src/applications/exhaustruct.rs
+++ b/src/applications/exhaustruct.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::Method;
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct Exhaustruct {}
@@ -26,8 +26,8 @@ impl AppDefinition for Exhaustruct {
     github_releases::latest(ORG, REPO, log)
   }
 
-  fn run_method(&self, version: &Version, _platform: Platform) -> run::Method {
-    run::Method::ThisApp {
+  fn run_method(&self, version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: format!("github.com/{ORG}/{REPO}/v3/cmd/exhaustruct@v{version}"),
       }],
@@ -54,7 +54,7 @@ impl AppDefinition for Exhaustruct {
 #[cfg(test)]
 mod tests {
   use crate::applications::exhaustruct::Exhaustruct;
-  use crate::run;
+  use crate::executables::RunMethod;
 
   #[test]
   fn install_methods() {
@@ -71,7 +71,7 @@ mod tests {
         cpu: Cpu::Arm64,
       },
     );
-    let want = run::Method::ThisApp {
+    let want = RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: S("github.com/GaijinEntertainment/go-exhaustruct/v3/cmd/exhaustruct@v3.3.0"),
       }],
diff --git a/src/applications/gh.rs b/src/applications/gh.rs
index f6bec226..2ea8f88e 100644
--- a/src/applications/gh.rs
+++ b/src/applications/gh.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use big_s::S;
 use std::path;
 
@@ -23,7 +23,7 @@ impl AppDefinition for Gh {
     "https://cli.github.com"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "macOS",
@@ -38,7 +38,7 @@ impl AppDefinition for Gh {
       Os::Windows | Os::MacOS => "zip",
     };
     let sep = path::MAIN_SEPARATOR;
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/gh_{version}_{os}_{cpu}.{ext}"),
         bin_folder: BinFolder::Subfolders {
@@ -84,9 +84,9 @@ mod tests {
     use crate::applications::gh::Gh;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -99,7 +99,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/cli/cli/releases/download/v2.39.1/gh_2.39.1_linux_arm64.tar.gz"),
           bin_folder: BinFolder::Subfolders {
@@ -120,7 +120,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/cli/cli/releases/download/v2.39.1/gh_2.39.1_windows_amd64.zip"),
           bin_folder: BinFolder::Subfolders {
diff --git a/src/applications/ghokin.rs b/src/applications/ghokin.rs
index 95bc5d2b..3e332355 100644
--- a/src/applications/ghokin.rs
+++ b/src/applications/ghokin.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct Ghokin {}
@@ -22,7 +22,7 @@ impl AppDefinition for Ghokin {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let cpu = match platform.cpu {
       Cpu::Arm64 => "arm64",
       Cpu::Intel64 => "amd64",
@@ -32,7 +32,7 @@ impl AppDefinition for Ghokin {
       Os::MacOS => "darwin",
       Os::Windows => "windows",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/ghokin_{version}_{os}_{cpu}.tar.gz"),
@@ -73,9 +73,9 @@ mod tests {
     use crate::applications::ghokin::Ghokin;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -87,7 +87,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/antham/ghokin/releases/download/v3.4.1/ghokin_3.4.1_darwin_amd64.tar.gz"),
@@ -110,7 +110,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/antham/ghokin/releases/download/v3.7.0/ghokin_3.7.0_windows_amd64.tar.gz"),
diff --git a/src/applications/go.rs b/src/applications/go.rs
index cc26c73b..acd69a8c 100644
--- a/src/applications/go.rs
+++ b/src/applications/go.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_tags;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{filesystem, regexp, run, Log};
+use crate::{filesystem, regexp, Log};
 use big_s::S;
 use std::path;
 
@@ -23,7 +23,7 @@ impl AppDefinition for Go {
     "https://go.dev"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -39,7 +39,7 @@ impl AppDefinition for Go {
     };
     let sep = path::MAIN_SEPARATOR;
     let version_str = version.as_str().trim_start_matches("go");
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://go.dev/dl/go{version_str}.{os}-{cpu}.{ext}"),
         bin_folder: BinFolder::Subfolder { path: format!("go{sep}bin") },
@@ -116,9 +116,9 @@ mod tests {
     use crate::applications::go::Go;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -131,7 +131,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://go.dev/dl/go1.21.5.darwin-arm64.tar.gz"),
           bin_folder: BinFolder::Subfolder { path: S("go/bin") },
@@ -150,7 +150,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://go.dev/dl/go1.21.5.windows-amd64.zip"),
           bin_folder: BinFolder::Subfolder { path: S("go\\bin") },
diff --git a/src/applications/goda.rs b/src/applications/goda.rs
index c3a1ee96..1d4c1efa 100644
--- a/src/applications/goda.rs
+++ b/src/applications/goda.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::Method;
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct Goda {}
@@ -22,8 +22,8 @@ impl AppDefinition for Goda {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, _platform: Platform) -> run::Method {
-    run::Method::ThisApp {
+  fn run_method(&self, version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: format!("github.com/{ORG}/{REPO}@v{version}"),
       }],
@@ -54,7 +54,7 @@ impl AppDefinition for Goda {
 
 #[cfg(test)]
 mod tests {
-  use crate::run;
+  use crate::executables::RunMethod;
 
   #[test]
   fn install_methods() {
@@ -72,7 +72,7 @@ mod tests {
         cpu: Cpu::Intel64,
       },
     );
-    let want = run::Method::ThisApp {
+    let want = RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: S("github.com/loov/goda@v0.5.9"),
       }],
diff --git a/src/applications/gofmt.rs b/src/applications/gofmt.rs
index 3aa3cb3b..8889a7bf 100644
--- a/src/applications/gofmt.rs
+++ b/src/applications/gofmt.rs
@@ -1,10 +1,10 @@
 use super::go::Go;
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, ExecutableNameUnix, RunMethod};
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::{Executable, ExecutableNameUnix};
-use crate::{run, Log};
+use crate::Log;
 
 pub(crate) struct Gofmt {}
 
@@ -17,8 +17,8 @@ impl AppDefinition for Gofmt {
     "https://go.dev"
   }
 
-  fn run_method(&self, _version: &Version, _platform: Platform) -> run::Method {
-    run::Method::OtherAppOtherExecutable {
+  fn run_method(&self, _version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::OtherAppOtherExecutable {
       app_definition: Box::new(app_to_install()),
       executable_name: ExecutableNameUnix::from("gofmt"),
     }
@@ -60,8 +60,8 @@ mod tests {
     use crate::applications::gofmt::Gofmt;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::{ExecutableNameUnix, RunMethod};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run::{self, ExecutableNameUnix};
 
     #[test]
     fn macos() {
@@ -72,7 +72,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::OtherAppOtherExecutable {
+      let want = RunMethod::OtherAppOtherExecutable {
         app_definition: Box::new(Go {}),
         executable_name: ExecutableNameUnix::from("gofmt"),
       };
@@ -88,7 +88,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::OtherAppOtherExecutable {
+      let want = RunMethod::OtherAppOtherExecutable {
         app_definition: Box::new(Go {}),
         executable_name: ExecutableNameUnix::from("gofmt"),
       };
diff --git a/src/applications/gofumpt.rs b/src/applications/gofumpt.rs
index 094f90fd..ef96cef2 100644
--- a/src/applications/gofumpt.rs
+++ b/src/applications/gofumpt.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::Method;
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use const_format::formatcp;
 
 pub(crate) struct Gofumpt {}
@@ -22,7 +22,7 @@ impl AppDefinition for Gofumpt {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -36,7 +36,7 @@ impl AppDefinition for Gofumpt {
       Os::Windows => ".exe",
       Os::Linux | Os::MacOS => "",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadExecutable {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/gofumpt_v{version}_{os}_{cpu}{ext}"),
@@ -84,9 +84,9 @@ mod tests {
     use crate::applications::gofumpt::Gofumpt;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::Method;
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -98,7 +98,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/mvdan/gofumpt/releases/download/v0.5.0/gofumpt_v0.5.0_darwin_arm64"),
@@ -120,7 +120,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/mvdan/gofumpt/releases/download/v0.5.0/gofumpt_v0.5.0_windows_amd64.exe"),
diff --git a/src/applications/golangci_lint.rs b/src/applications/golangci_lint.rs
index 0fe57a0b..cd08fd11 100644
--- a/src/applications/golangci_lint.rs
+++ b/src/applications/golangci_lint.rs
@@ -1,10 +1,10 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::{self, Executable};
 use crate::{regexp, Log};
 use const_format::formatcp;
 
@@ -22,7 +22,7 @@ impl AppDefinition for GolangCiLint {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -36,7 +36,7 @@ impl AppDefinition for GolangCiLint {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp { install_methods:
+    RunMethod::ThisApp { install_methods:
     // install from source not recommended, see https://golangci-lint.run/usage/install/#install-from-source
     vec![Method::DownloadArchive {
         url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/golangci-lint-{version}-{os}-{cpu}.{ext}"),
@@ -76,9 +76,9 @@ mod tests {
     use crate::applications::golangci_lint::GolangCiLint;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -90,7 +90,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/golangci/golangci-lint/releases/download/v1.55.2/golangci-lint-1.55.2-darwin-arm64.tar.gz"),
           bin_folder: BinFolder::Subfolder {
@@ -110,7 +110,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/golangci/golangci-lint/releases/download/v1.55.2/golangci-lint-1.55.2-windows-amd64.zip"),
           bin_folder: BinFolder::Subfolder {
diff --git a/src/applications/goreleaser.rs b/src/applications/goreleaser.rs
index 1fb649ea..7e0ffbdb 100644
--- a/src/applications/goreleaser.rs
+++ b/src/applications/goreleaser.rs
@@ -1,10 +1,10 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::{self, Executable};
 use crate::{regexp, Log};
 
 pub(crate) struct Goreleaser {}
@@ -21,7 +21,7 @@ impl AppDefinition for Goreleaser {
     "https://goreleaser.com"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "Linux",
       Os::MacOS => "Darwin",
@@ -35,7 +35,7 @@ impl AppDefinition for Goreleaser {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/goreleaser_{os}_{cpu}.{ext}"),
         bin_folder: BinFolder::Root,
@@ -78,9 +78,9 @@ mod tests {
     use crate::applications::goreleaser::Goreleaser;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -92,7 +92,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/goreleaser/goreleaser/releases/download/v1.22.1/goreleaser_Darwin_arm64.tar.gz"),
           bin_folder: BinFolder::Root,
@@ -110,7 +110,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/goreleaser/goreleaser/releases/download/v1.22.1/goreleaser_Windows_x86_64.zip"),
           bin_folder: BinFolder::Root,
diff --git a/src/applications/govulnchec.rs b/src/applications/govulnchec.rs
index 4c3ceaf0..79e571bc 100644
--- a/src/applications/govulnchec.rs
+++ b/src/applications/govulnchec.rs
@@ -1,9 +1,9 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::installation::Method;
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::{self, Executable};
 use crate::Log;
 
 pub(crate) struct Govulncheck {}
@@ -17,8 +17,8 @@ impl AppDefinition for Govulncheck {
     "https://pkg.go.dev/golang.org/x/vuln/cmd/govulncheck"
   }
 
-  fn run_method(&self, version: &Version, _platform: Platform) -> run::Method {
-    run::Method::ThisApp {
+  fn run_method(&self, version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: format!("golang.org/x/vuln/cmd/govulncheck@v{version}"),
       }],
@@ -50,7 +50,7 @@ impl AppDefinition for Govulncheck {
 
 #[cfg(test)]
 mod tests {
-  use crate::run;
+  use crate::executables::RunMethod;
 
   #[test]
   fn install_methods() {
@@ -68,7 +68,7 @@ mod tests {
         cpu: Cpu::Arm64,
       },
     );
-    let want = run::Method::ThisApp {
+    let want = RunMethod::ThisApp {
       install_methods: vec![Method::CompileGoSource {
         import_path: S("golang.org/x/vuln/cmd/govulncheck@v1.1.4"),
       }],
diff --git a/src/applications/ireturn.rs b/src/applications/ireturn.rs
index eb89cae5..8817bc4d 100644
--- a/src/applications/ireturn.rs
+++ b/src/applications/ireturn.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct Ireturn {}
@@ -22,7 +22,7 @@ impl AppDefinition for Ireturn {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -36,7 +36,7 @@ impl AppDefinition for Ireturn {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/ireturn_{os}_{cpu}.{ext}"),
@@ -77,9 +77,9 @@ mod tests {
     use crate::applications::ireturn::Ireturn;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -91,7 +91,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/butuzov/ireturn/releases/download/v0.3.0/ireturn_linux_x86_64.tar.gz"),
@@ -114,7 +114,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/butuzov/ireturn/releases/download/v0.3.0/ireturn_windows_x86_64.zip"),
diff --git a/src/applications/mdbook.rs b/src/applications/mdbook.rs
index 04bb8472..49b3b1e3 100644
--- a/src/applications/mdbook.rs
+++ b/src/applications/mdbook.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use big_s::S;
 use const_format::formatcp;
 
@@ -23,7 +23,7 @@ impl AppDefinition for MdBook {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "unknown-linux-gnu",
       Os::MacOS => "apple-darwin",
@@ -37,7 +37,7 @@ impl AppDefinition for MdBook {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/mdbook-v{version}-{cpu}-{os}.{ext}"),
@@ -87,9 +87,9 @@ mod tests {
     use crate::applications::mdbook::MdBook;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -101,7 +101,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/rust-lang/mdBook/releases/download/v0.4.37/mdbook-v0.4.37-x86_64-unknown-linux-gnu.tar.gz"),
@@ -125,7 +125,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/rust-lang/mdBook/releases/download/v0.4.37/mdbook-v0.4.37-x86_64-pc-windows-msvc.zip"),
diff --git a/src/applications/mdbook_linkcheck.rs b/src/applications/mdbook_linkcheck.rs
index f2bdccfd..0d9c1595 100644
--- a/src/applications/mdbook_linkcheck.rs
+++ b/src/applications/mdbook_linkcheck.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use big_s::S;
 use const_format::formatcp;
 
@@ -23,7 +23,7 @@ impl AppDefinition for MdBookLinkCheck {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "unknown-linux-gnu",
       Os::MacOS => "apple-darwin",
@@ -33,7 +33,7 @@ impl AppDefinition for MdBookLinkCheck {
       Cpu::Arm64 => "aarch64",
       Cpu::Intel64 => "x86_64",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/mdbook-linkcheck.{cpu}-{os}.zip"),
@@ -83,9 +83,9 @@ mod tests {
     use crate::applications::mdbook_linkcheck::MdBookLinkCheck;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -97,7 +97,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/Michael-F-Bryan/mdbook-linkcheck/releases/download/v0.7.8/mdbook-linkcheck.x86_64-apple-darwin.zip"),
@@ -121,7 +121,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/Michael-F-Bryan/mdbook-linkcheck/releases/download/v0.7.8/mdbook-linkcheck.x86_64-pc-windows-msvc.zip"),
diff --git a/src/applications/mod.rs b/src/applications/mod.rs
index f43b5367..36399067 100644
--- a/src/applications/mod.rs
+++ b/src/applications/mod.rs
@@ -30,9 +30,9 @@ mod staticcheck;
 mod tikibase;
 
 use crate::configuration::Version;
+use crate::executables::{Executable, ExecutableArgs, ExecutableNameUnix, RunMethod};
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::{self, Executable, ExecutableArgs, ExecutableNameUnix};
 use crate::Log;
 use std::fmt::{Debug, Display};
 use std::path::Path;
@@ -87,7 +87,7 @@ pub(crate) trait AppDefinition {
   }
 
   /// define how to run this application
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method;
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod;
 
   /// link to the (human-readable) homepage of the app
   fn homepage(&self) -> &'static str;
@@ -130,12 +130,12 @@ pub(crate) trait AppDefinition {
   /// and arguments to call that executable with.
   fn carrier(&self, version: &Version, platform: Platform) -> (Box<dyn AppDefinition>, ExecutableNameUnix, ExecutableArgs) {
     match self.run_method(version, platform) {
-      run::Method::ThisApp { install_methods: _ } => (self.clone(), self.executable_filename(), ExecutableArgs::None),
-      run::Method::OtherAppOtherExecutable {
+      RunMethod::ThisApp { install_methods: _ } => (self.clone(), self.executable_filename(), ExecutableArgs::None),
+      RunMethod::OtherAppOtherExecutable {
         app_definition,
         executable_name,
       } => (app_definition.clone(), executable_name, ExecutableArgs::None),
-      run::Method::OtherAppDefaultExecutable { app_definition, args } => (app_definition.clone(), app_definition.executable_filename(), args),
+      RunMethod::OtherAppDefaultExecutable { app_definition, args } => (app_definition.clone(), app_definition.executable_filename(), args),
     }
   }
 }
diff --git a/src/applications/node_prune.rs b/src/applications/node_prune.rs
index 8f96fd00..de9bd55c 100644
--- a/src/applications/node_prune.rs
+++ b/src/applications/node_prune.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_tags;
 use crate::installation::Method;
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use const_format::formatcp;
 
 pub(crate) struct NodePrune {}
@@ -30,7 +30,7 @@ impl AppDefinition for NodePrune {
     Ok(Version::from(tag))
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -40,7 +40,7 @@ impl AppDefinition for NodePrune {
       Cpu::Arm64 => "arm64",
       Cpu::Intel64 => "amd64",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadExecutable {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/node-prune_{version}_{os}_{cpu}.tar.gz"),
@@ -77,9 +77,9 @@ mod tests {
     use crate::applications::node_prune::NodePrune;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::Method;
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -91,7 +91,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/tj/node-prune/releases/download/v1.0.1/node-prune_1.0.1_linux_amd64.tar.gz"),
@@ -113,7 +113,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/tj/node-prune/releases/download/v1.0.1/node-prune_1.0.1_windows_amd64.tar.gz"),
diff --git a/src/applications/nodejs.rs b/src/applications/nodejs.rs
index 823bd376..42df56b5 100644
--- a/src/applications/nodejs.rs
+++ b/src/applications/nodejs.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use std::path;
 
 pub(crate) struct NodeJS {}
@@ -22,12 +22,12 @@ impl AppDefinition for NodeJS {
     "https://nodejs.org"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = os_text(platform.os);
     let cpu = cpu_text(platform.cpu);
     let ext = ext_text(platform.os);
     let sep = path::MAIN_SEPARATOR;
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://nodejs.org/dist/v{version}/node-v{version}-{os}-{cpu}.{ext}",),
         bin_folder: BinFolder::RootOrSubfolders {
@@ -96,9 +96,9 @@ mod tests {
     use crate::applications::nodejs::NodeJS;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -111,7 +111,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://nodejs.org/dist/v20.10.0/node-v20.10.0-darwin-arm64.tar.gz"),
           bin_folder: BinFolder::RootOrSubfolders {
@@ -132,7 +132,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://nodejs.org/dist/v20.10.0/node-v20.10.0-win-x64.zip"),
           bin_folder: BinFolder::RootOrSubfolders {
diff --git a/src/applications/npm.rs b/src/applications/npm.rs
index 077785ad..f5781761 100644
--- a/src/applications/npm.rs
+++ b/src/applications/npm.rs
@@ -1,10 +1,10 @@
 use super::nodejs::NodeJS;
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, ExecutableArgs, RunMethod};
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::{Executable, ExecutableArgs};
-use crate::{run, Log};
+use crate::Log;
 
 pub(crate) struct Npm {}
 
@@ -17,8 +17,8 @@ impl AppDefinition for Npm {
     "https://www.npmjs.com"
   }
 
-  fn run_method(&self, _version: &Version, _platform: Platform) -> run::Method {
-    run::Method::OtherAppDefaultExecutable {
+  fn run_method(&self, _version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::OtherAppDefaultExecutable {
       app_definition: Box::new(NodeJS {}),
       args: ExecutableArgs::OneOfTheseInAppFolder {
         options: vec!["node_modules/npm/bin/npm-cli.js", "lib/node_modules/npm/bin/npm-cli.js"],
@@ -60,9 +60,8 @@ mod tests {
     use crate::applications::npm::Npm;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::{ExecutableArgs, RunMethod};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
-    use crate::run::ExecutableArgs;
 
     #[test]
     #[cfg(unix)]
@@ -74,7 +73,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::OtherAppDefaultExecutable {
+      let want = RunMethod::OtherAppDefaultExecutable {
         app_definition: Box::new(NodeJS {}),
         args: ExecutableArgs::OneOfTheseInAppFolder {
           options: vec!["node_modules/npm/bin/npm-cli.js", "lib/node_modules/npm/bin/npm-cli.js"],
@@ -93,7 +92,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::OtherAppDefaultExecutable {
+      let want = RunMethod::OtherAppDefaultExecutable {
         app_definition: Box::new(NodeJS {}),
         args: ExecutableArgs::OneOfTheseInAppFolder {
           options: vec!["node_modules/npm/bin/npm-cli.js", "lib/node_modules/npm/bin/npm-cli.js"],
diff --git a/src/applications/npx.rs b/src/applications/npx.rs
index cbfbbd71..3c9d0883 100644
--- a/src/applications/npx.rs
+++ b/src/applications/npx.rs
@@ -1,10 +1,10 @@
 use super::nodejs::NodeJS;
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, ExecutableArgs, RunMethod};
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::{Executable, ExecutableArgs};
-use crate::{run, Log};
+use crate::Log;
 
 pub(crate) struct Npx {}
 
@@ -17,8 +17,8 @@ impl AppDefinition for Npx {
     "https://www.npmjs.com"
   }
 
-  fn run_method(&self, _version: &Version, _platform: Platform) -> run::Method {
-    run::Method::OtherAppDefaultExecutable {
+  fn run_method(&self, _version: &Version, _platform: Platform) -> RunMethod {
+    RunMethod::OtherAppDefaultExecutable {
       app_definition: Box::new(app_to_install()),
       args: ExecutableArgs::OneOfTheseInAppFolder {
         options: vec!["node_modules/npm/bin/npx-cli.js", "lib/node_modules/npm/bin/npx-cli.js"],
@@ -60,8 +60,8 @@ mod tests {
     use crate::applications::npx::Npx;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::{ExecutableArgs, RunMethod};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run::{self, ExecutableArgs};
 
     #[test]
     #[cfg(unix)]
@@ -73,7 +73,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::OtherAppDefaultExecutable {
+      let want = RunMethod::OtherAppDefaultExecutable {
         app_definition: Box::new(NodeJS {}),
         args: ExecutableArgs::OneOfTheseInAppFolder {
           options: vec!["node_modules/npm/bin/npx-cli.js", "lib/node_modules/npm/bin/npx-cli.js"],
@@ -92,7 +92,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::OtherAppDefaultExecutable {
+      let want = RunMethod::OtherAppDefaultExecutable {
         app_definition: Box::new(NodeJS {}),
         args: ExecutableArgs::OneOfTheseInAppFolder {
           options: vec!["node_modules/npm/bin/npx-cli.js", "lib/node_modules/npm/bin/npx-cli.js"],
diff --git a/src/applications/ripgrep.rs b/src/applications/ripgrep.rs
index 00b6f5a4..dd8f225f 100644
--- a/src/applications/ripgrep.rs
+++ b/src/applications/ripgrep.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{executables, regexp, Log};
 use const_format::formatcp;
 
 pub(crate) struct RipGrep {}
@@ -22,11 +22,11 @@ impl AppDefinition for RipGrep {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn executable_filename(&self) -> run::ExecutableNameUnix {
-    run::ExecutableNameUnix::from("rg")
+  fn executable_filename(&self) -> executables::ExecutableNameUnix {
+    executables::ExecutableNameUnix::from("rg")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let cpu = match platform.cpu {
       Cpu::Arm64 => "aarch64",
       Cpu::Intel64 => "x86_64",
@@ -41,7 +41,7 @@ impl AppDefinition for RipGrep {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://github.com/{ORG}/{REPO}/releases/download/{version}/ripgrep-{version}-{cpu}-{os}.{ext}"),
         bin_folder: BinFolder::Subfolder {
@@ -87,9 +87,9 @@ mod tests {
     use crate::applications::ripgrep::RipGrep;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -101,7 +101,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-aarch64-apple-darwin.tar.gz"),
           bin_folder: BinFolder::Subfolder {
@@ -121,7 +121,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-aarch64-unknown-linux-gnu.tar.gz"),
           bin_folder: BinFolder::Subfolder {
@@ -141,7 +141,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-unknown-linux-musl.tar.gz"),
           bin_folder: BinFolder::Subfolder {
@@ -161,7 +161,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-x86_64-pc-windows-msvc.zip"),
           bin_folder: BinFolder::Subfolder {
diff --git a/src/applications/scc.rs b/src/applications/scc.rs
index c7678bdb..20f1d41c 100644
--- a/src/applications/scc.rs
+++ b/src/applications/scc.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use const_format::formatcp;
 
 pub(crate) struct Scc {}
@@ -22,7 +22,7 @@ impl AppDefinition for Scc {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "Linux",
       Os::MacOS => "Darwin",
@@ -32,7 +32,7 @@ impl AppDefinition for Scc {
       Cpu::Arm64 => "arm64",
       Cpu::Intel64 => "x86_64",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/scc_{os}_{cpu}.tar.gz"),
@@ -81,9 +81,9 @@ mod tests {
     use crate::applications::scc::Scc;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -95,7 +95,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/boyter/scc/releases/download/v3.2.0/scc_Darwin_arm64.tar.gz"),
@@ -118,7 +118,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/boyter/scc/releases/download/v3.2.0/scc_Windows_x86_64.tar.gz"),
diff --git a/src/applications/shellcheck.rs b/src/applications/shellcheck.rs
index 308abe18..375b4349 100644
--- a/src/applications/shellcheck.rs
+++ b/src/applications/shellcheck.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 
 pub(crate) struct ShellCheck {}
 
@@ -21,7 +21,7 @@ impl AppDefinition for ShellCheck {
     "https://www.shellcheck.net"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -35,7 +35,7 @@ impl AppDefinition for ShellCheck {
       Os::Linux | Os::MacOS => "tar.xz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/shellcheck-v{version}.{os}.{cpu}.{ext}"),
         bin_folder: BinFolder::Subfolder {
@@ -80,9 +80,9 @@ mod tests {
     use crate::applications::shellcheck::ShellCheck;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -94,7 +94,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/koalaman/shellcheck/releases/download/v0.9.0/shellcheck-v0.9.0.linux.x86_64.tar.xz"),
           bin_folder: BinFolder::Subfolder { path: S("shellcheck-v0.9.0") },
@@ -112,7 +112,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/koalaman/shellcheck/releases/download/v0.10.0/shellcheck-v0.10.0.darwin.aarch64.tar.xz"),
           bin_folder: BinFolder::Subfolder { path: S("shellcheck-v0.10.0") },
diff --git a/src/applications/shfmt.rs b/src/applications/shfmt.rs
index 2d7a683f..4a0a6bfd 100644
--- a/src/applications/shfmt.rs
+++ b/src/applications/shfmt.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::Method;
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use const_format::formatcp;
 
 pub(crate) struct Shfmt {}
@@ -22,7 +22,7 @@ impl AppDefinition for Shfmt {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -36,7 +36,7 @@ impl AppDefinition for Shfmt {
       Os::Linux | Os::MacOS => "",
       Os::Windows => ".exe",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadExecutable {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/shfmt_v{version}_{os}_{cpu}{ext}"),
@@ -84,9 +84,9 @@ mod tests {
     use crate::applications::shfmt::Shfmt;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::Method;
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -98,7 +98,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/mvdan/sh/releases/download/v3.7.0/shfmt_v3.7.0_darwin_arm64"),
@@ -120,7 +120,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadExecutable {
             url: S("https://github.com/mvdan/sh/releases/download/v3.7.0/shfmt_v3.7.0_windows_amd64.exe"),
diff --git a/src/applications/staticcheck.rs b/src/applications/staticcheck.rs
index 3122b9c0..fdcc0dd2 100644
--- a/src/applications/staticcheck.rs
+++ b/src/applications/staticcheck.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{run, Log};
+use crate::Log;
 use big_s::S;
 
 const ORG: &str = "dominikh";
@@ -22,7 +22,7 @@ impl AppDefinition for StaticCheck {
     "https://staticcheck.dev"
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let os = match platform.os {
       Os::Linux => "linux",
       Os::MacOS => "darwin",
@@ -32,7 +32,7 @@ impl AppDefinition for StaticCheck {
       Cpu::Arm64 => "arm64",
       Cpu::Intel64 => "amd64",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![
         Method::DownloadArchive {
           url: format!("https://github.com/{ORG}/{REPO}/releases/download/{version}/staticcheck_{os}_{cpu}.tar.gz"),
@@ -73,9 +73,9 @@ mod tests {
     use crate::applications::staticcheck::StaticCheck;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -87,7 +87,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/dominikh/go-tools/releases/download/3.7.0/staticcheck_darwin_arm64.tar.gz"),
@@ -110,7 +110,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![
           Method::DownloadArchive {
             url: S("https://github.com/dominikh/go-tools/releases/download/3.7.0/staticcheck_windows_amd64.tar.gz"),
diff --git a/src/applications/tikibase.rs b/src/applications/tikibase.rs
index ed01ad9a..31b5fc08 100644
--- a/src/applications/tikibase.rs
+++ b/src/applications/tikibase.rs
@@ -1,11 +1,11 @@
 use super::{AnalyzeResult, AppDefinition};
 use crate::configuration::Version;
+use crate::executables::{Executable, RunMethod};
 use crate::hosting::github_releases;
 use crate::installation::{BinFolder, Method};
 use crate::platform::{Cpu, Os, Platform};
 use crate::prelude::*;
-use crate::run::Executable;
-use crate::{regexp, run, Log};
+use crate::{regexp, Log};
 use const_format::formatcp;
 
 pub(crate) struct Tikibase {}
@@ -22,7 +22,7 @@ impl AppDefinition for Tikibase {
     formatcp!("https://github.com/{ORG}/{REPO}")
   }
 
-  fn run_method(&self, version: &Version, platform: Platform) -> run::Method {
+  fn run_method(&self, version: &Version, platform: Platform) -> RunMethod {
     let cpu = match platform.cpu {
       Cpu::Arm64 => "arm64",
       Cpu::Intel64 => "intel64",
@@ -36,7 +36,7 @@ impl AppDefinition for Tikibase {
       Os::Linux | Os::MacOS => "tar.gz",
       Os::Windows => "zip",
     };
-    run::Method::ThisApp {
+    RunMethod::ThisApp {
       install_methods: vec![Method::DownloadArchive {
         url: format!("https://github.com/{ORG}/{REPO}/releases/download/v{version}/tikibase_{os}_{cpu}.{ext}"),
         bin_folder: BinFolder::Root,
@@ -80,9 +80,9 @@ mod tests {
     use crate::applications::tikibase::Tikibase;
     use crate::applications::AppDefinition;
     use crate::configuration::Version;
+    use crate::executables::RunMethod;
     use crate::installation::{BinFolder, Method};
     use crate::platform::{Cpu, Os, Platform};
-    use crate::run;
     use big_s::S;
 
     #[test]
@@ -94,7 +94,7 @@ mod tests {
           cpu: Cpu::Arm64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/kevgo/tikibase/releases/download/v0.6.2/tikibase_macos_arm64.tar.gz"),
           bin_folder: BinFolder::Root,
@@ -112,7 +112,7 @@ mod tests {
           cpu: Cpu::Intel64,
         },
       );
-      let want = run::Method::ThisApp {
+      let want = RunMethod::ThisApp {
         install_methods: vec![Method::DownloadArchive {
           url: S("https://github.com/kevgo/tikibase/releases/download/v0.6.2/tikibase_windows_intel64.zip"),
           bin_folder: BinFolder::Root,
diff --git a/src/commands/run.rs b/src/commands/run.rs
index 96a2ef6b..8bd81df2 100644
--- a/src/commands/run.rs
+++ b/src/commands/run.rs
@@ -1,11 +1,11 @@
 use crate::applications::{AnalyzeResult, AppDefinition, ApplicationName, Apps};
 use crate::configuration::{self, AppVersions, RequestedVersion, RequestedVersions, Version};
+use crate::executables::{ExecutableCall, ExecutableCallDefinition};
 use crate::filesystem::find_global_install;
 use crate::installation::Outcome;
 use crate::logging::{self, Event, Log};
 use crate::platform::{self, Platform};
 use crate::prelude::*;
-use crate::run::{ExecutableCall, ExecutableCallDefinition};
 use crate::yard::Yard;
 use crate::{applications, installation, subshell, yard};
 use std::process::ExitCode;
diff --git a/src/commands/test.rs b/src/commands/test.rs
index 07b079ee..7dcfc63d 100644
--- a/src/commands/test.rs
+++ b/src/commands/test.rs
@@ -1,7 +1,7 @@
 use crate::applications::{AnalyzeResult, ApplicationName, Apps};
+use crate::executables::Executable;
 use crate::logging::Event;
 use crate::prelude::*;
-use crate::run::Executable;
 use crate::yard::Yard;
 use crate::{applications, configuration, installation, logging, platform};
 use colored::Colorize;
diff --git a/src/configuration/requested_version.rs b/src/configuration/requested_version.rs
index e1bcab38..76e7c96b 100644
--- a/src/configuration/requested_version.rs
+++ b/src/configuration/requested_version.rs
@@ -71,10 +71,10 @@ mod tests {
   mod parse {
     use crate::applications::{AnalyzeResult, AppDefinition};
     use crate::configuration::Version;
+    use crate::executables::{Executable, ExecutableNameUnix, RunMethod};
     use crate::logging::Log;
     use crate::platform::Platform;
     use crate::prelude::*;
-    use crate::run::{self, Executable, ExecutableNameUnix};
 
     /// an App instance that allows to mock the system version restrictions
     struct TestApp {
@@ -103,7 +103,7 @@ mod tests {
       fn analyze_executable(&self, _path: &Executable, _log: Log) -> Result<AnalyzeResult> {
         unimplemented!()
       }
-      fn run_method(&self, _version: &Version, _platform: Platform) -> run::Method {
+      fn run_method(&self, _version: &Version, _platform: Platform) -> RunMethod {
         unimplemented!()
       }
       fn clone(&self) -> Box<dyn AppDefinition> {
diff --git a/src/run/executable.rs b/src/executables/executable.rs
similarity index 100%
rename from src/run/executable.rs
rename to src/executables/executable.rs
diff --git a/src/run/executable_call.rs b/src/executables/executable_call.rs
similarity index 98%
rename from src/run/executable_call.rs
rename to src/executables/executable_call.rs
index 483b8a64..19085bdd 100644
--- a/src/run/executable_call.rs
+++ b/src/executables/executable_call.rs
@@ -117,12 +117,12 @@ impl Display for ExecutableCall {
 #[cfg(test)]
 mod tests {
   use super::ExecutableCall;
-  use crate::run::Executable;
+  use crate::executables::Executable;
   use big_s::S;
   use std::path::Path;
 
   mod stream_output {
-    use crate::run::Executable;
+    use crate::executables::Executable;
     use crate::subshell;
     use big_s::S;
     use std::fs;
diff --git a/src/run/executable_name.rs b/src/executables/executable_name.rs
similarity index 100%
rename from src/run/executable_name.rs
rename to src/executables/executable_name.rs
diff --git a/src/run/mod.rs b/src/executables/mod.rs
similarity index 63%
rename from src/run/mod.rs
rename to src/executables/mod.rs
index f6b2d639..cffd0aef 100644
--- a/src/run/mod.rs
+++ b/src/executables/mod.rs
@@ -1,11 +1,11 @@
-//! This module implements high-level logic around running applications.
+//! This module implements logic to run the various forms of executables that applications can have.
 
 mod executable;
 mod executable_call;
 mod executable_name;
-mod method;
+mod run_method;
 
 pub(crate) use executable::Executable;
 pub(crate) use executable_call::{ExecutableArgs, ExecutableCall, ExecutableCallDefinition};
 pub(crate) use executable_name::{ExecutableNamePlatform, ExecutableNameUnix};
-pub(crate) use method::Method;
+pub(crate) use run_method::RunMethod;
diff --git a/src/run/method.rs b/src/executables/run_method.rs
similarity index 83%
rename from src/run/method.rs
rename to src/executables/run_method.rs
index e8ad947d..efd590d1 100644
--- a/src/run/method.rs
+++ b/src/executables/run_method.rs
@@ -5,7 +5,7 @@ use crate::installation;
 
 /// the different ways to execute an application
 #[derive(Debug, PartialEq)]
-pub(crate) enum Method {
+pub(crate) enum RunMethod {
   /// execute this app's default executable
   ThisApp {
     /// defines the ways in which this app can be installed
@@ -27,15 +27,15 @@ pub(crate) enum Method {
   },
 }
 
-impl Method {
+impl RunMethod {
   pub(crate) fn install_methods(self) -> Vec<installation::Method> {
     match self {
-      Method::ThisApp { install_methods } => install_methods,
-      Method::OtherAppOtherExecutable {
+      RunMethod::ThisApp { install_methods } => install_methods,
+      RunMethod::OtherAppOtherExecutable {
         app_definition: _,
         executable_name: _,
       }
-      | Method::OtherAppDefaultExecutable { app_definition: _, args: _ } => vec![],
+      | RunMethod::OtherAppDefaultExecutable { app_definition: _, args: _ } => vec![],
     }
   }
 }
diff --git a/src/filesystem/find_global_install.rs b/src/filesystem/find_global_install.rs
index 3b400f8e..52c74232 100644
--- a/src/filesystem/find_global_install.rs
+++ b/src/filesystem/find_global_install.rs
@@ -1,5 +1,5 @@
+use crate::executables::{Executable, ExecutableNamePlatform};
 use crate::logging::{Event, Log};
-use crate::run::{Executable, ExecutableNamePlatform};
 use which::which_global;
 
 pub(crate) fn find_global_install(binary_name: &ExecutableNamePlatform, log: Log) -> Option<Executable> {
diff --git a/src/filesystem/save_buffer.rs b/src/filesystem/save_buffer.rs
index 616c0163..4b0c0ad8 100644
--- a/src/filesystem/save_buffer.rs
+++ b/src/filesystem/save_buffer.rs
@@ -1,6 +1,6 @@
+use crate::executables::Executable;
 use crate::logging::{Event, Log};
 use crate::prelude::*;
-use crate::run::Executable;
 use std::fs;
 use std::path::Path;
 
diff --git a/src/installation/mod.rs b/src/installation/mod.rs
index c30c7e75..24947242 100644
--- a/src/installation/mod.rs
+++ b/src/installation/mod.rs
@@ -7,10 +7,10 @@ mod download_executable;
 
 use crate::applications::AppDefinition;
 use crate::configuration::{self, Version};
+use crate::executables::ExecutableNamePlatform;
 use crate::logging::Log;
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::ExecutableNamePlatform;
 use crate::yard::Yard;
 use std::fmt::{Debug, Display};
 use std::path::{Path, PathBuf};
diff --git a/src/logging/event.rs b/src/logging/event.rs
index 2808b565..efb4730b 100644
--- a/src/logging/event.rs
+++ b/src/logging/event.rs
@@ -1,7 +1,7 @@
 use crate::applications::ApplicationName;
 use crate::configuration::Version;
+use crate::executables::ExecutableNamePlatform;
 use crate::installation::Method;
-use crate::run::ExecutableNamePlatform;
 use std::borrow::Cow;
 use std::path::Path;
 
diff --git a/src/main.rs b/src/main.rs
index dbeb02d0..3eefa8b3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,6 +5,7 @@ mod commands;
 mod configuration;
 mod download;
 mod error;
+mod executables;
 mod filesystem;
 mod hosting;
 mod installation;
@@ -12,7 +13,6 @@ mod logging;
 mod platform;
 mod prelude;
 mod regexp;
-mod run;
 mod subshell;
 mod yard;
 
diff --git a/src/subshell/capture_output.rs b/src/subshell/capture_output.rs
index a3656ab2..6f597e39 100644
--- a/src/subshell/capture_output.rs
+++ b/src/subshell/capture_output.rs
@@ -1,6 +1,6 @@
 use super::add_paths;
+use crate::executables::Executable;
 use crate::prelude::*;
-use crate::run::Executable;
 use std::process::Command;
 
 /// executes the given executable with the given args, returns the captured output (STDOUT and STDERR)
diff --git a/src/subshell/detect_output.rs b/src/subshell/detect_output.rs
index 8e0c0916..c1df7b03 100644
--- a/src/subshell/detect_output.rs
+++ b/src/subshell/detect_output.rs
@@ -1,7 +1,7 @@
 use super::{add_paths, exit_status_to_code, render_call};
 use crate::cli;
+use crate::executables::{Executable, ExecutableCall};
 use crate::prelude::*;
-use crate::run::{Executable, ExecutableCall};
 use std::io::{self, BufRead, BufReader, Read};
 use std::process::{self, Child, Command, ExitCode, Stdio};
 use std::sync::mpsc;
diff --git a/src/subshell/mod.rs b/src/subshell/mod.rs
index d18e1340..fee21bcb 100644
--- a/src/subshell/mod.rs
+++ b/src/subshell/mod.rs
@@ -9,7 +9,7 @@ mod capture_output;
 mod detect_output;
 mod stream_output;
 
-use crate::run::Executable;
+use crate::executables::Executable;
 pub(crate) use capture_output::capture_output;
 pub(crate) use detect_output::detect_output;
 pub(crate) use stream_output::stream_output;
@@ -65,7 +65,7 @@ pub(crate) fn render_call(executable: &Executable, args: &[String]) -> String {
 
 #[cfg(test)]
 mod tests {
-  use crate::run::Executable;
+  use crate::executables::Executable;
   use crate::subshell::render_call;
   use big_s::S;
   use std::path::Path;
diff --git a/src/subshell/stream_output.rs b/src/subshell/stream_output.rs
index 71dae9ee..3ba1cddf 100644
--- a/src/subshell/stream_output.rs
+++ b/src/subshell/stream_output.rs
@@ -1,6 +1,6 @@
 use super::{add_paths, exit_status_to_code, render_call};
+use crate::executables::{Executable, ExecutableCall};
 use crate::prelude::*;
-use crate::run::{Executable, ExecutableCall};
 use std::process::{Command, ExitCode};
 
 /// Runs the given executable with the given arguments.
diff --git a/src/yard/yard.rs b/src/yard/yard.rs
index ebfde787..13e4b04a 100644
--- a/src/yard/yard.rs
+++ b/src/yard/yard.rs
@@ -1,11 +1,11 @@
 use super::root_path;
 use crate::applications::{AppDefinition, ApplicationName};
 use crate::configuration::Version;
+use crate::executables::{Executable, ExecutableNameUnix};
 use crate::installation::BinFolder;
 use crate::logging::{Event, Log};
 use crate::platform::Platform;
 use crate::prelude::*;
-use crate::run::{Executable, ExecutableNameUnix};
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};