Support common Unix resource limits in uv run

crates/uv-cli/Cargo.toml

@@ -45,6 +45,9 @@ rustc-hash = { workspace = true }
 serde = { workspace = true }
 url = { workspace = true }
 
+[target.'cfg(unix)'.dependencies]
+uv-unix = { workspace = true }
+
 [dev-dependencies]
 insta = { workspace = true }
 

crates/uv-cli/src/settings.rs

@@ -710,7 +710,7 @@ pub struct RunSettings {
     pub max_recursion_depth: u32,
     pub malware_settings: MalwareCheckSettings,
     #[cfg(unix)]
-    pub run_rlimit_nofile: Option<u32>,
+    pub run_resource_limits: Vec<uv_unix::ResourceLimit>,
 }
 
 impl RunSettings {
@@ -879,7 +879,7 @@ impl RunSettings {
             max_recursion_depth: max_recursion_depth.unwrap_or(Self::DEFAULT_MAX_RECURSION_DEPTH),
             malware_settings,
             #[cfg(unix)]
-            run_rlimit_nofile: environment.run_rlimit_nofile,
+            run_resource_limits: environment.run_resource_limits,
         })
     }
 }

crates/uv-project-commands/src/run.rs

@@ -118,7 +118,7 @@ pub async fn run(
     preview: Preview,
     max_recursion_depth: u32,
     malware_settings: MalwareCheckSettings,
-    #[cfg(unix)] run_rlimit_nofile: Option<u32>,
+    #[cfg(unix)] run_resource_limits: Vec<uv_unix::ResourceLimit>,
 ) -> anyhow::Result<ExitStatus> {
     // Check if max recursion depth was exceeded. This most commonly happens
     // for scripts with a shebang line like `#!/usr/bin/env -S uv run`, so try
@@ -1262,13 +1262,30 @@ pub async fn run(
     }
 
     #[cfg(unix)]
-    if let Some(limit) = run_rlimit_nofile {
-        uv_unix::set_open_file_limit(limit).with_context(|| {
-            format!(
-                "Failed to apply `{}` value `{limit}`",
-                EnvVars::UV_RUN_RLIMIT_NOFILE
-            )
-        })?;
+    if !run_resource_limits.is_empty() {
+        let resource_limits = run_resource_limits
+            .into_iter()
+            .map(|limit| {
+                limit.prepare().with_context(|| {
+                    format!(
+                        "Failed to apply `{}` value `{}`",
+                        limit.environment_variable(),
+                        limit.value()
+                    )
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        // SAFETY: Validation and allocation happen before the fork. The callback only
+        // invokes resource-limit system calls and constructs errors from OS error codes.
+        #[expect(unsafe_code)]
+        unsafe {
+            process.pre_exec(move || {
+                for limit in &resource_limits {
+                    limit.apply()?;
+                }
+                Ok(())
+            });
+        }
     }
 
     // Spawn and wait for completion

crates/uv-settings/Cargo.toml

@@ -51,6 +51,9 @@ toml = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
 
+[target.'cfg(unix)'.dependencies]
+uv-unix = { workspace = true }
+
 [package.metadata.cargo-shear]
 ignored = ["clap"]
 

crates/uv-settings/src/lib.rs

@@ -803,7 +803,7 @@ pub struct EnvironmentOptions {
     pub malware_check: EnvFlag,
     pub malware_check_url: Option<DisplaySafeUrl>,
     #[cfg(unix)]
-    pub run_rlimit_nofile: Option<u32>,
+    pub run_resource_limits: Vec<uv_unix::ResourceLimit>,
 }
 
 impl EnvironmentOptions {
@@ -836,6 +836,20 @@ impl EnvironmentOptions {
             EnvFlag::new(EnvVars::UV_NATIVE_TLS)?
         };
 
+        #[cfg(unix)]
+        let run_resource_limits = uv_unix::SUPPORTED_RESOURCE_LIMITS
+            .iter()
+            .filter_map(|&(environment_variable, resource)| {
+                parse_integer_environment_variable(environment_variable, None)
+                    .map(|value| {
+                        value.map(|value| {
+                            uv_unix::ResourceLimit::new(environment_variable, resource, value)
+                        })
+                    })
+                    .transpose()
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
         Ok(Self {
             ruff_path: parse_path_environment_variable(EnvVars::RUFF),
             ty_path: parse_path_environment_variable(EnvVars::TY),
@@ -961,10 +975,7 @@ impl EnvironmentOptions {
                 })
                 .transpose()?,
             #[cfg(unix)]
-            run_rlimit_nofile: parse_integer_environment_variable(
-                EnvVars::UV_RUN_RLIMIT_NOFILE,
-                None,
-            )?,
+            run_resource_limits,
         })
     }
 }

crates/uv-static/src/env_vars.rs

@@ -1403,14 +1403,38 @@ impl EnvVars {
     #[attr_added_in("0.5.19")]
     pub const UV_GIT_LFS: &'static str = "UV_GIT_LFS";
 
+    /// Sets the soft virtual-address-space limit, in bytes, for commands executed by `uv run`.
+    ///
+    /// Only supported on Unix platforms that provide `RLIMIT_AS`.
+    #[attr_added_in("next release")]
+    pub const UV_RUN_RLIMIT_AS: &'static str = "UV_RUN_RLIMIT_AS";
+
+    /// Sets the soft core-file size limit, in bytes, for commands executed by `uv run`.
+    #[attr_added_in("next release")]
+    pub const UV_RUN_RLIMIT_CORE: &'static str = "UV_RUN_RLIMIT_CORE";
+
+    /// Sets the soft CPU-time limit, in seconds, for commands executed by `uv run`.
+    #[attr_added_in("next release")]
+    pub const UV_RUN_RLIMIT_CPU: &'static str = "UV_RUN_RLIMIT_CPU";
+
+    /// Sets the soft file-size limit, in bytes, for commands executed by `uv run`.
+    #[attr_added_in("next release")]
+    pub const UV_RUN_RLIMIT_FSIZE: &'static str = "UV_RUN_RLIMIT_FSIZE";
+
     /// Sets the soft open-file descriptor limit for commands executed by `uv run`.
     ///
-    /// The limit is applied after uv prepares the environment and immediately before the command
-    /// is spawned. The hard open-file descriptor limit remains unchanged. If the limit cannot be
+    /// The limit is applied in the child process after uv prepares the environment, before the
+    /// command is executed. The hard open-file descriptor limit remains unchanged. If the limit cannot be
     /// applied, uv exits with an error without running the command. Only supported on Unix.
     #[attr_added_in("0.12.3")]
     pub const UV_RUN_RLIMIT_NOFILE: &'static str = "UV_RUN_RLIMIT_NOFILE";
 
+    /// Sets the soft process-count limit for commands executed by `uv run`.
+    ///
+    /// Only supported on Unix platforms that provide `RLIMIT_NPROC`.
+    #[attr_added_in("next release")]
+    pub const UV_RUN_RLIMIT_NPROC: &'static str = "UV_RUN_RLIMIT_NPROC";
+
     /// Number of times that `uv run` has been recursively invoked. Used to guard against infinite
     /// recursion, e.g., when `uv run` is used in a script shebang.
     #[attr_hidden]

crates/uv-unix/Cargo.toml

@@ -17,5 +17,10 @@ test = false
 workspace = true
 
 [target.'cfg(unix)'.dependencies]
+uv-static = { workspace = true }
+
 nix = { workspace = true }
 thiserror = { workspace = true }
+
+[target.'cfg(target_vendor = "apple")'.dependencies]
+rustix = { workspace = true, features = ["process"] }

crates/uv-unix/src/lib.rs

@@ -6,4 +6,7 @@
 
 mod resource_limits;
 
-pub use resource_limits::{OpenFileLimitError, adjust_open_file_limit, set_open_file_limit};
+pub use resource_limits::{
+    OpenFileLimitError, PreparedResourceLimit, ResourceLimit, ResourceLimitError, RunResource,
+    SUPPORTED_RESOURCE_LIMITS, adjust_open_file_limit,
+};