diff --git a/crates/bench/benches/uv.rs b/crates/bench/benches/uv.rs
index a6f554442f6..e53d8a8e103 100644
--- a/crates/bench/benches/uv.rs
+++ b/crates/bench/benches/uv.rs
@@ -136,7 +136,7 @@ mod resolver {
         let index_locations = IndexLocations::default();
         let installed_packages = EmptyInstalledPackages;
         let interpreter = venv.interpreter();
-        let python_requirement = PythonRequirement::from_marker_environment(interpreter, &MARKERS);
+        let python_requirement = PythonRequirement::from_interpreter(interpreter);
 
         let build_context = BuildDispatch::new(
             client,
diff --git a/crates/uv-dispatch/src/lib.rs b/crates/uv-dispatch/src/lib.rs
index 456c5e44a3b..62ef5368037 100644
--- a/crates/uv-dispatch/src/lib.rs
+++ b/crates/uv-dispatch/src/lib.rs
@@ -150,9 +150,8 @@ impl<'a> BuildContext for BuildDispatch<'a> {
     }
 
     async fn resolve<'data>(&'data self, requirements: &'data [Requirement]) -> Result<Resolution> {
+        let python_requirement = PythonRequirement::from_interpreter(self.interpreter);
         let markers = self.interpreter.markers();
-        let python_requirement =
-            PythonRequirement::from_marker_environment(self.interpreter, markers);
         let tags = self.interpreter.tags()?;
         let resolver = Resolver::new(
             Manifest::simple(requirements.to_vec()),
diff --git a/crates/uv-resolver/src/pubgrub/report.rs b/crates/uv-resolver/src/pubgrub/report.rs
index e3897e11718..aaa742158e2 100644
--- a/crates/uv-resolver/src/pubgrub/report.rs
+++ b/crates/uv-resolver/src/pubgrub/report.rs
@@ -49,11 +49,17 @@ impl ReportFormatter<PubGrubPackage, Range<Version>, UnavailableReason>
                         &**package,
                         PubGrubPackageInner::Python(PubGrubPython::Target)
                     ) {
-                        return format!(
-                            "the requested {package} version ({}) does not satisfy {}",
-                            python.target(),
-                            PackageRange::compatibility(package, set)
-                        );
+                        return if let Some(target) = python.target() {
+                            format!(
+                                "the requested {package} version ({target}) does not satisfy {}",
+                                PackageRange::compatibility(package, set)
+                            )
+                        } else {
+                            format!(
+                                "the requested {package} version does not satisfy {}",
+                                PackageRange::compatibility(package, set)
+                            )
+                        };
                     }
                     if matches!(
                         &**package,
diff --git a/crates/uv-resolver/src/python_requirement.rs b/crates/uv-resolver/src/python_requirement.rs
index 84a6dd5568d..55f43ebb9fa 100644
--- a/crates/uv-resolver/src/python_requirement.rs
+++ b/crates/uv-resolver/src/python_requirement.rs
@@ -1,5 +1,5 @@
-use pep508_rs::{MarkerEnvironment, StringVersion};
-use uv_interpreter::Interpreter;
+use pep508_rs::StringVersion;
+use uv_interpreter::{Interpreter, PythonVersion};
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct PythonRequirement {
@@ -8,21 +8,29 @@ pub struct PythonRequirement {
     /// The target version of Python; that is, the version of Python for which we are resolving
     /// dependencies. This is typically the same as the installed version, but may be different
     /// when specifying an alternate Python version for the resolution.
-    target: StringVersion,
+    ///
+    /// If `None`, the target version is the same as the installed version.
+    target: Option<StringVersion>,
 }
 
 impl PythonRequirement {
-    pub fn from_marker_environment(interpreter: &Interpreter, env: &MarkerEnvironment) -> Self {
+    /// Create a [`PythonRequirement`] to resolve against both an [`Interpreter`] and a
+    /// [`PythonVersion`].
+    pub fn from_python_version(interpreter: &Interpreter, python_version: &PythonVersion) -> Self {
         Self {
             installed: interpreter.python_full_version().clone(),
-            target: env.python_full_version().clone(),
+            target: Some(StringVersion {
+                string: python_version.to_string(),
+                version: python_version.python_full_version(),
+            }),
         }
     }
 
+    /// Create a [`PythonRequirement`] to resolve against an [`Interpreter`].
     pub fn from_interpreter(interpreter: &Interpreter) -> Self {
         Self {
             installed: interpreter.python_full_version().clone(),
-            target: interpreter.python_full_version().clone(),
+            target: None,
         }
     }
 
@@ -32,7 +40,7 @@ impl PythonRequirement {
     }
 
     /// Return the target version of Python.
-    pub fn target(&self) -> &StringVersion {
-        &self.target
+    pub fn target(&self) -> Option<&StringVersion> {
+        self.target.as_ref()
     }
 }
diff --git a/crates/uv-resolver/src/resolver/mod.rs b/crates/uv-resolver/src/resolver/mod.rs
index ed972d8abab..de01e8f2010 100644
--- a/crates/uv-resolver/src/resolver/mod.rs
+++ b/crates/uv-resolver/src/resolver/mod.rs
@@ -308,7 +308,9 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
 
         debug!(
             "Solving with target Python version {}",
-            self.python_requirement.target()
+            self.python_requirement
+                .target()
+                .unwrap_or(self.python_requirement.installed())
         );
 
         'FORK: while let Some(mut state) = forked_states.pop() {
@@ -715,9 +717,7 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
 
                 // The version is incompatible due to its Python requirement.
                 if let Some(requires_python) = metadata.requires_python.as_ref() {
-                    let installed = self.python_requirement.installed();
-                    let target = self.python_requirement.target();
-                    if target != installed {
+                    if let Some(target) = self.python_requirement.target() {
                         if !requires_python.contains(target) {
                             return Ok(Some(ResolverVersion::Unavailable(
                                 version.clone(),
@@ -730,6 +730,8 @@ impl<InstalledPackages: InstalledPackagesProvider> ResolverState<InstalledPackag
                             )));
                         }
                     }
+
+                    let installed = self.python_requirement.installed();
                     if !requires_python.contains(installed) {
                         return Ok(Some(ResolverVersion::Unavailable(
                             version.clone(),
diff --git a/crates/uv-resolver/src/version_map.rs b/crates/uv-resolver/src/version_map.rs
index 13bd5173cf2..50886fe5e17 100644
--- a/crates/uv-resolver/src/version_map.rs
+++ b/crates/uv-resolver/src/version_map.rs
@@ -466,8 +466,8 @@ impl VersionMapLazy {
         // Source distributions must meet both the _target_ Python version and the
         // _installed_ Python version (to build successfully)
         if let Some(requires_python) = requires_python {
-            if self.python_requirement.target() != self.python_requirement.installed() {
-                if !requires_python.contains(self.python_requirement.target()) {
+            if let Some(target) = self.python_requirement.target() {
+                if !requires_python.contains(target) {
                     return SourceDistCompatibility::Incompatible(
                         IncompatibleSource::RequiresPython(
                             requires_python,
@@ -533,11 +533,20 @@ impl VersionMapLazy {
 
         // Check for a Python version incompatibility`
         if let Some(requires_python) = requires_python {
-            if !requires_python.contains(self.python_requirement.target()) {
-                return WheelCompatibility::Incompatible(IncompatibleWheel::RequiresPython(
-                    requires_python,
-                    PythonRequirementKind::Target,
-                ));
+            if let Some(target) = self.python_requirement.target() {
+                if !requires_python.contains(target) {
+                    return WheelCompatibility::Incompatible(IncompatibleWheel::RequiresPython(
+                        requires_python,
+                        PythonRequirementKind::Target,
+                    ));
+                }
+            } else {
+                if !requires_python.contains(self.python_requirement.installed()) {
+                    return WheelCompatibility::Incompatible(IncompatibleWheel::RequiresPython(
+                        requires_python,
+                        PythonRequirementKind::Installed,
+                    ));
+                }
             }
         }
 
diff --git a/crates/uv-resolver/tests/resolver.rs b/crates/uv-resolver/tests/resolver.rs
index 7079deea0e0..f12a7f8a519 100644
--- a/crates/uv-resolver/tests/resolver.rs
+++ b/crates/uv-resolver/tests/resolver.rs
@@ -146,7 +146,7 @@ async fn resolve(
         .expect("Python should be installed")
         .into_interpreter();
     let interpreter = Interpreter::artificial(real_interpreter.platform().clone(), markers.clone());
-    let python_requirement = PythonRequirement::from_marker_environment(&interpreter, markers);
+    let python_requirement = PythonRequirement::from_interpreter(&interpreter);
     let cache = Cache::temp().unwrap().init().unwrap();
     let build_context = DummyContext::new(cache, interpreter.clone());
     let hashes = HashStrategy::None;
diff --git a/crates/uv/src/commands/pip/compile.rs b/crates/uv/src/commands/pip/compile.rs
index d1474ce04b2..81ebe54f10b 100644
--- a/crates/uv/src/commands/pip/compile.rs
+++ b/crates/uv/src/commands/pip/compile.rs
@@ -215,6 +215,13 @@ pub(crate) async fn pip_compile(
         InMemoryIndexRef::Borrowed(&source_index)
     };
 
+    // Determine the Python requirement, based on the interpreter and the requested version.
+    let python_requirement = if let Some(python_version) = python_version.as_ref() {
+        PythonRequirement::from_python_version(&interpreter, python_version)
+    } else {
+        PythonRequirement::from_interpreter(&interpreter)
+    };
+
     // Determine the tags, markers, and interpreter to use for resolution.
     let tags = match (python_platform, python_version.as_ref()) {
         (Some(python_platform), Some(python_version)) => Cow::Owned(Tags::from_env(
@@ -251,8 +258,6 @@ pub(crate) async fn pip_compile(
         (None, None) => Cow::Borrowed(interpreter.markers()),
     };
 
-    let python_requirement = PythonRequirement::from_marker_environment(&interpreter, &markers);
-
     // Generate, but don't enforce hashes for the requirements.
     let hasher = if generate_hashes {
         HashStrategy::Generate
diff --git a/crates/uv/src/commands/pip/operations.rs b/crates/uv/src/commands/pip/operations.rs
index cbab850c765..7c805c5982d 100644
--- a/crates/uv/src/commands/pip/operations.rs
+++ b/crates/uv/src/commands/pip/operations.rs
@@ -182,11 +182,6 @@ pub(crate) async fn resolve<InstalledPackages: InstalledPackagesProvider>(
     // Collect constraints and overrides.
     let constraints = Constraints::from_requirements(constraints);
     let overrides = Overrides::from_requirements(overrides);
-    let python_requirement = if let Some(markers) = markers {
-        PythonRequirement::from_marker_environment(interpreter, markers)
-    } else {
-        PythonRequirement::from_interpreter(interpreter)
-    };
 
     // Determine any lookahead requirements.
     let lookaheads = match options.dependency_mode {
@@ -206,6 +201,8 @@ pub(crate) async fn resolve<InstalledPackages: InstalledPackagesProvider>(
         DependencyMode::Direct => Vec::new(),
     };
 
+    let python_requirement = PythonRequirement::from_interpreter(interpreter);
+
     // TODO(zanieb): Consider consuming these instead of cloning
     let exclusions = Exclusions::new(reinstall.clone(), upgrade.clone());