diff --git a/python/private/pypi/env_marker_setting.bzl b/python/private/pypi/env_marker_setting.bzl
new file mode 100644
index 0000000000..bbc59ab110
--- /dev/null
+++ b/python/private/pypi/env_marker_setting.bzl
@@ -0,0 +1,186 @@
+"""Implement a flag for matching the dependency specifiers at analysis time."""
+
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
+load("//python/private:toolchain_types.bzl", "TARGET_TOOLCHAIN_TYPE")
+load(
+    ":pep508_env.bzl",
+    "env_aliases",
+    "os_name_select_map",
+    "platform_machine_select_map",
+    "platform_system_select_map",
+    "sys_platform_select_map",
+)
+load(":pep508_evaluate.bzl", "evaluate")
+
+# Use capitals to hint its not an actual boolean type.
+_ENV_MARKER_TRUE = "TRUE"
+_ENV_MARKER_FALSE = "FALSE"
+
+def env_marker_setting(*, name, expression, **kwargs):
+    """Creates an env_marker setting.
+
+    Generated targets:
+
+    * `is_{name}_true`: config_setting that matches when the expression is true.
+    * `{name}`: env marker target that evalutes the expression.
+
+    Args:
+        name: {type}`str` target name
+        expression: {type}`str` the environment marker string to evaluate
+        **kwargs: {type}`dict` additional common kwargs.
+    """
+    native.config_setting(
+        name = "is_{}_true".format(name),
+        flag_values = {
+            ":{}".format(name): _ENV_MARKER_TRUE,
+        },
+        **kwargs
+    )
+    _env_marker_setting(
+        name = name,
+        expression = expression,
+        os_name = select(os_name_select_map),
+        sys_platform = select(sys_platform_select_map),
+        platform_machine = select(platform_machine_select_map),
+        platform_system = select(platform_system_select_map),
+        platform_release = select({
+            "@platforms//os:osx": "USE_OSX_VERSION_FLAG",
+            "//conditions:default": "",
+        }),
+        **kwargs
+    )
+
+def _env_marker_setting_impl(ctx):
+    env = {}
+
+    runtime = ctx.toolchains[TARGET_TOOLCHAIN_TYPE].py3_runtime
+    if runtime.interpreter_version_info:
+        version_info = runtime.interpreter_version_info
+        env["python_version"] = "{major}.{minor}".format(
+            major = version_info.major,
+            minor = version_info.minor,
+        )
+        full_version = _format_full_version(version_info)
+        env["python_full_version"] = full_version
+        env["implementation_version"] = full_version
+    else:
+        env["python_version"] = _get_flag(ctx.attr._python_version_major_minor_flag)
+        full_version = _get_flag(ctx.attr._python_full_version_flag)
+        env["python_full_version"] = full_version
+        env["implementation_version"] = full_version
+
+    # We assume cpython if the toolchain doesn't specify because it's most
+    # likely to be true.
+    env["implementation_name"] = runtime.implementation_name or "cpython"
+    env["os_name"] = ctx.attr.os_name
+    env["sys_platform"] = ctx.attr.sys_platform
+    env["platform_machine"] = ctx.attr.platform_machine
+
+    # The `platform_python_implementation` marker value is supposed to come
+    # from `platform.python_implementation()`, however, PEP 421 introduced
+    # `sys.implementation.name` and the `implementation_name` env marker to
+    # replace it. Per the platform.python_implementation docs, there's now
+    # essentially just two possible "registered" values: CPython or PyPy.
+    # Rather than add a field to the toolchain, we just special case the value
+    # from `sys.implementation.name` to handle the two documented values.
+    platform_python_impl = runtime.implementation_name
+    if platform_python_impl == "cpython":
+        platform_python_impl = "CPython"
+    elif platform_python_impl == "pypy":
+        platform_python_impl = "PyPy"
+    env["platform_python_implementation"] = platform_python_impl
+
+    # NOTE: Platform release for Android will be Android version:
+    # https://peps.python.org/pep-0738/#platform
+    # Similar for iOS:
+    # https://peps.python.org/pep-0730/#platform
+    platform_release = ctx.attr.platform_release
+    if platform_release == "USE_OSX_VERSION_FLAG":
+        platform_release = _get_flag(ctx.attr._pip_whl_osx_version_flag)
+    env["platform_release"] = platform_release
+    env["platform_system"] = ctx.attr.platform_system
+
+    # For lack of a better option, just use an empty string for now.
+    env["platform_version"] = ""
+
+    env.update(env_aliases())
+
+    if evaluate(ctx.attr.expression, env = env):
+        value = _ENV_MARKER_TRUE
+    else:
+        value = _ENV_MARKER_FALSE
+    return [config_common.FeatureFlagInfo(value = value)]
+
+_env_marker_setting = rule(
+    doc = """
+Evaluates an environment marker expression using target configuration info.
+
+See
+https://packaging.python.org/en/latest/specifications/dependency-specifiers
+for the specification of behavior.
+""",
+    implementation = _env_marker_setting_impl,
+    attrs = {
+        "expression": attr.string(
+            mandatory = True,
+            doc = "Environment marker expression to evaluate.",
+        ),
+        "os_name": attr.string(),
+        "platform_machine": attr.string(),
+        "platform_release": attr.string(),
+        "platform_system": attr.string(),
+        "sys_platform": attr.string(),
+        "_pip_whl_osx_version_flag": attr.label(
+            default = "//python/config_settings:pip_whl_osx_version",
+            providers = [[BuildSettingInfo], [config_common.FeatureFlagInfo]],
+        ),
+        "_python_full_version_flag": attr.label(
+            default = "//python/config_settings:python_version",
+            providers = [config_common.FeatureFlagInfo],
+        ),
+        "_python_version_major_minor_flag": attr.label(
+            default = "//python/config_settings:python_version_major_minor",
+            providers = [config_common.FeatureFlagInfo],
+        ),
+    },
+    provides = [config_common.FeatureFlagInfo],
+    toolchains = [
+        TARGET_TOOLCHAIN_TYPE,
+    ],
+)
+
+def _format_full_version(info):
+    """Format the full python interpreter version.
+
+    Adapted from spec code at:
+    https://packaging.python.org/en/latest/specifications/dependency-specifiers/#environment-markers
+
+    Args:
+        info: The provider from the Python runtime.
+
+    Returns:
+        a {type}`str` with the version
+    """
+    kind = info.releaselevel
+    if kind == "final":
+        kind = ""
+        serial = ""
+    else:
+        kind = kind[0] if kind else ""
+        serial = str(info.serial) if info.serial else ""
+
+    return "{major}.{minor}.{micro}{kind}{serial}".format(
+        v = info,
+        major = info.major,
+        minor = info.minor,
+        micro = info.micro,
+        kind = kind,
+        serial = serial,
+    )
+
+def _get_flag(t):
+    if config_common.FeatureFlagInfo in t:
+        return t[config_common.FeatureFlagInfo].value
+    if BuildSettingInfo in t:
+        return t[BuildSettingInfo].value
+    fail("Should not occur: {} does not have necessary providers")
diff --git a/python/private/pypi/pep508_env.bzl b/python/private/pypi/pep508_env.bzl
index 265a8e9b99..3708c46f1d 100644
--- a/python/private/pypi/pep508_env.bzl
+++ b/python/private/pypi/pep508_env.bzl
@@ -18,7 +18,7 @@
 load(":pep508_platform.bzl", "platform_from_str")
 
 # See https://stackoverflow.com/a/45125525
-_platform_machine_aliases = {
+platform_machine_aliases = {
     # These pairs mean the same hardware, but different values may be used
     # on different host platforms.
     "amd64": "x86_64",
@@ -27,6 +27,41 @@ _platform_machine_aliases = {
     "i686": "x86_32",
 }
 
+# NOTE: There are many cpus, and unfortunately, the value isn't directly
+# accessible to Starlark. Using CcToolchain.cpu might work, though.
+platform_machine_select_map = {
+    "@platforms//cpu:aarch32": "aarch32",
+    "@platforms//cpu:aarch64": "aarch64",
+    "@platforms//cpu:arm": "arm",
+    "@platforms//cpu:arm64": "arm64",
+    "@platforms//cpu:arm64_32": "arm64_32",
+    "@platforms//cpu:arm64e": "arm64e",
+    "@platforms//cpu:armv6-m": "armv6-m",
+    "@platforms//cpu:armv7": "armv7",
+    "@platforms//cpu:armv7-m": "armv7-m",
+    "@platforms//cpu:armv7e-m": "armv7e-m",
+    "@platforms//cpu:armv7e-mf": "armv7e-mf",
+    "@platforms//cpu:armv7k": "armv7k",
+    "@platforms//cpu:armv8-m": "armv8-m",
+    "@platforms//cpu:cortex-r52": "cortex-r52",
+    "@platforms//cpu:cortex-r82": "cortex-r82",
+    "@platforms//cpu:i386": "i386",
+    "@platforms//cpu:mips64": "mips64",
+    "@platforms//cpu:ppc": "ppc",
+    "@platforms//cpu:ppc32": "ppc32",
+    "@platforms//cpu:ppc64le": "ppc64le",
+    "@platforms//cpu:riscv32": "riscv32",
+    "@platforms//cpu:riscv64": "riscv64",
+    "@platforms//cpu:s390x": "s390x",
+    "@platforms//cpu:wasm32": "wasm32",
+    "@platforms//cpu:wasm64": "wasm64",
+    "@platforms//cpu:x86_32": "x86_32",
+    "@platforms//cpu:x86_64": "x86_64",
+    # The value is empty string if it cannot be determined:
+    # https://docs.python.org/3/library/platform.html#platform.machine
+    "//conditions:default": "",
+}
+
 # Platform system returns results from the `uname` call.
 _platform_system_values = {
     "linux": "Linux",
@@ -34,6 +69,23 @@ _platform_system_values = {
     "windows": "Windows",
 }
 
+platform_system_select_map = {
+    # See https://peps.python.org/pep-0738/#platform
+    "@platforms//os:android": "Android",
+    "@platforms//os:freebsd": "FreeBSD",
+    # See https://peps.python.org/pep-0730/#platform
+    # NOTE: Per Pep 730, "iPadOS" is also an acceptable value
+    "@platforms//os:ios": "iOS",
+    "@platforms//os:linux": "Linux",
+    "@platforms//os:netbsd": "NetBSD",
+    "@platforms//os:openbsd": "OpenBSD",
+    "@platforms//os:osx": "Darwin",
+    "@platforms//os:windows": "Windows",
+    # The value is empty string if it cannot be determined:
+    # https://docs.python.org/3/library/platform.html#platform.machine
+    "//conditions:default": "",
+}
+
 # The copy of SO [answer](https://stackoverflow.com/a/13874620) containing
 # all of the platforms:
 # ┍━━━━━━━━━━━━━━━━━━━━━┯━━━━━━━━━━━━━━━━━━━━━┑
@@ -64,12 +116,45 @@ _sys_platform_values = {
     "osx": "darwin",
     "windows": "win32",
 }
+
+# Taken from
+# https://docs.python.org/3/library/sys.html#sys.platform
+sys_platform_select_map = {
+    # These values are decided by the sys.platform docs.
+    "@platforms//os:android": "android",
+    "@platforms//os:emscripten": "emscripten",
+    # NOTE: The below values are approximations. The sys.platform() docs
+    # don't have documented values for these OSes. Per docs, the
+    # sys.platform() value reflects the OS at the time Python was *built*
+    # instead of the runtime (target) OS value.
+    "@platforms//os:freebsd": "freebsd",
+    "@platforms//os:ios": "ios",
+    "@platforms//os:linux": "linux",
+    "@platforms//os:openbsd": "openbsd",
+    "@platforms//os:osx": "darwin",
+    "@platforms//os:wasi": "wasi",
+    "@platforms//os:windows": "win32",
+    # For lack of a better option, use empty string. No standard doc/spec
+    # about sys_platform value.
+    "//conditions:default": "",
+}
+
 _os_name_values = {
     "linux": "posix",
     "osx": "posix",
     "windows": "nt",
 }
 
+os_name_select_map = {
+    # The "java" value is documented, but with Jython defunct,
+    # shouldn't occur in practice.
+    # The os.name value is technically a property of the runtime, not the
+    # targetted runtime OS, but the distinction shouldn't matter if
+    # things are properly configured.
+    "@platforms//os:windows": "nt",
+    "//conditions:default": "posix",
+}
+
 def env(target_platform, *, extra = None):
     """Return an env target platform
 
@@ -113,8 +198,11 @@ def env(target_platform, *, extra = None):
         }
 
     # This is split by topic
-    return env | {
+    return env | env_aliases()
+
+def env_aliases():
+    return {
         "_aliases": {
-            "platform_machine": _platform_machine_aliases,
+            "platform_machine": platform_machine_aliases,
         },
     }
diff --git a/tests/pypi/env_marker_setting/BUILD.bazel b/tests/pypi/env_marker_setting/BUILD.bazel
new file mode 100644
index 0000000000..9605e650ce
--- /dev/null
+++ b/tests/pypi/env_marker_setting/BUILD.bazel
@@ -0,0 +1,5 @@
+load(":env_marker_setting_tests.bzl", "env_marker_setting_test_suite")
+
+env_marker_setting_test_suite(
+    name = "env_marker_setting_tests",
+)
diff --git a/tests/pypi/env_marker_setting/env_marker_setting_tests.bzl b/tests/pypi/env_marker_setting/env_marker_setting_tests.bzl
new file mode 100644
index 0000000000..549c15c20b
--- /dev/null
+++ b/tests/pypi/env_marker_setting/env_marker_setting_tests.bzl
@@ -0,0 +1,69 @@
+"""env_marker_setting tests."""
+
+load("@rules_testing//lib:analysis_test.bzl", "analysis_test")
+load("@rules_testing//lib:test_suite.bzl", "test_suite")
+load("@rules_testing//lib:util.bzl", "TestingAspectInfo")
+load("//python/private/pypi:env_marker_setting.bzl", "env_marker_setting")  # buildifier: disable=bzl-visibility
+load("//tests/support:support.bzl", "PYTHON_VERSION")
+
+_tests = []
+
+def _test_expr(name):
+    def impl(env, target):
+        env.expect.where(
+            expression = target[TestingAspectInfo].attrs.expression,
+        ).that_str(
+            target[config_common.FeatureFlagInfo].value,
+        ).equals(
+            env.ctx.attr.expected,
+        )
+
+    cases = {
+        "python_full_version_lt_negative": {
+            "config_settings": {
+                PYTHON_VERSION: "3.12.0",
+            },
+            "expected": "FALSE",
+            "expression": "python_full_version < '3.8'",
+        },
+        "python_version_gte": {
+            "config_settings": {
+                PYTHON_VERSION: "3.12.0",
+            },
+            "expected": "TRUE",
+            "expression": "python_version >= '3.12.0'",
+        },
+    }
+
+    tests = []
+    for case_name, case in cases.items():
+        test_name = name + "_" + case_name
+        tests.append(test_name)
+        env_marker_setting(
+            name = test_name + "_subject",
+            expression = case["expression"],
+        )
+        analysis_test(
+            name = test_name,
+            impl = impl,
+            target = test_name + "_subject",
+            config_settings = case["config_settings"],
+            attr_values = {
+                "expected": case["expected"],
+            },
+            attrs = {
+                "expected": attr.string(),
+            },
+        )
+    native.test_suite(
+        name = name,
+        tests = tests,
+    )
+
+_tests.append(_test_expr)
+
+def env_marker_setting_test_suite(name):
+    test_suite(
+        name = name,
+        tests = _tests,
+    )