diff --git a/rust/platform/cpu/BUILD.bazel b/rust/platform/cpu/BUILD.bazel
index 476f8cf..2618a44 100644
--- a/rust/platform/cpu/BUILD.bazel
+++ b/rust/platform/cpu/BUILD.bazel
@@ -1,5 +1,6 @@
-constraint_value(
+alias(
     name = "wasm32",
-    constraint_setting = "@platforms//cpu",
+    actual = "@platforms//cpu:wasm32",
+    deprecation = "Use @platforms//cpu:wasm32 directly instead.",
     visibility = ["//visibility:public"],
 )
diff --git a/rust/platform/os/BUILD.bazel b/rust/platform/os/BUILD.bazel
index 7692abe..366fb59 100644
--- a/rust/platform/os/BUILD.bazel
+++ b/rust/platform/os/BUILD.bazel
@@ -1,11 +1,5 @@
-constraint_value(
+alias(
     name = "unknown",
-    constraint_setting = "@platforms//os",
-    visibility = ["//visibility:public"],
-)
-
-constraint_value(
-    name = "wasi",
-    constraint_setting = "@platforms//os",
+    actual = "@platforms//os:none",
     visibility = ["//visibility:public"],
 )
diff --git a/rust/platform/platform.bzl b/rust/platform/platform.bzl
index 98e295a..f6517d6 100644
--- a/rust/platform/platform.bzl
+++ b/rust/platform/platform.bzl
@@ -18,6 +18,7 @@
     "s390x",
     "x86_64",
     "riscv32",
+    "riscv64",
 ]
 
 _SUPPORTED_SYSTEMS = [
@@ -67,7 +68,7 @@
     native.platform(
         name = "wasm",
         constraint_values = [
-            str(Label("//rust/platform/cpu:wasm32")),
+            "@platforms//cpu:wasm32",
             str(Label("//rust/platform/os:unknown")),
         ],
     )
@@ -75,8 +76,8 @@
     native.platform(
         name = "wasi",
         constraint_values = [
-            str(Label("//rust/platform/cpu:wasm32")),
-            str(Label("//rust/platform/os:wasi")),
+            "@platforms//cpu:wasm32",
+            "@platforms//os:wasi",
         ],
     )
 
diff --git a/rust/platform/triple.bzl b/rust/platform/triple.bzl
index 2c42704..2c99363 100644
--- a/rust/platform/triple.bzl
+++ b/rust/platform/triple.bzl
@@ -3,7 +3,7 @@
 parsing in starlark code, and a way for a repository_rule to extract the target triple
 of the host platform.
 
-Triples can be described at the following link: 
+Triples can be described at the following link:
 https://clang.llvm.org/docs/CrossCompilation.html#target-triple
 """
 
@@ -29,6 +29,14 @@
             abi = None,
             str = triple,
         )
+    elif triple in ("aarch64-fuchsia", "x86_64-fuchsia"):
+        return struct(
+            arch = triple.split("-")[0],
+            system = "fuchsia",
+            vendor = "fuchsia",
+            abi = None,
+            str = triple,
+        )
 
     component_parts = triple.split("-")
     if len(component_parts) < 3:
@@ -39,6 +47,11 @@
     system = component_parts[2]
     abi = None
 
+    if cpu_arch.startswith(("thumbv8m", "thumbv7m", "thumbv7e", "thumbv6m")):
+        abi = system
+        system = vendor
+        vendor = None
+
     if system == "androideabi":
         system = "android"
         abi = "eabi"
@@ -92,12 +105,18 @@
         # Example output:
         # OSArchitecture
         # 64-bit
+        #
+        # In some cases windows can return the same but with an uppercase b
+        # OSArchitecture
+        # 64-Bit
         lines = result.stdout.split("\n")
-        arch = lines[1].strip()
+        arch = lines[1].strip().lower()
 
         # Translate 64-bit to a compatible rust platform
         # https://doc.rust-lang.org/nightly/rustc/platform-support.html
-        if arch == "64-bit":
+        if arch.startswith("arm 64-bit"):
+            arch = "aarch64"
+        elif arch == "64-bit":
             arch = "x86_64"
     else:
         arch = result.stdout.strip("\n")
@@ -151,7 +170,7 @@
     supported_architectures = {
         "linux": ["aarch64", "x86_64"],
         "macos": ["aarch64", "x86_64"],
-        "windows": ["x86_64"],
+        "windows": ["aarch64", "x86_64"],
     }
 
     if "linux" in repository_ctx.os.name:
diff --git a/rust/platform/triple_mappings.bzl b/rust/platform/triple_mappings.bzl
index 0ff191a..61a71c7 100644
--- a/rust/platform/triple_mappings.bzl
+++ b/rust/platform/triple_mappings.bzl
@@ -4,6 +4,7 @@
 
 # All T1 Platforms should be supported, but aren't, see inline notes.
 SUPPORTED_T1_PLATFORM_TRIPLES = [
+    "aarch64-unknown-linux-gnu",
     "i686-apple-darwin",
     "i686-pc-windows-msvc",
     "i686-unknown-linux-gnu",
@@ -21,23 +22,29 @@
 # See @rules_rust//rust/platform:triple_mappings.bzl for the complete list.
 SUPPORTED_T2_PLATFORM_TRIPLES = [
     "aarch64-apple-darwin",
-    "aarch64-apple-ios",
     "aarch64-apple-ios-sim",
+    "aarch64-apple-ios",
+    "aarch64-fuchsia",
     "aarch64-linux-android",
-    "aarch64-unknown-linux-gnu",
+    "aarch64-pc-windows-msvc",
     "arm-unknown-linux-gnueabi",
-    "armv7-unknown-linux-gnueabi",
     "armv7-linux-androideabi",
+    "armv7-unknown-linux-gnueabi",
     "i686-linux-android",
     "i686-unknown-freebsd",
     "powerpc-unknown-linux-gnu",
+    "riscv32imc-unknown-none-elf",
+    "riscv64gc-unknown-none-elf",
     "s390x-unknown-linux-gnu",
+    "thumbv7em-none-eabi",
+    "thumbv8m.main-none-eabi",
     "wasm32-unknown-unknown",
     "wasm32-wasi",
     "x86_64-apple-ios",
+    "x86_64-fuchsia",
     "x86_64-linux-android",
     "x86_64-unknown-freebsd",
-    "riscv32imc-unknown-none-elf",
+    "x86_64-unknown-none",
 ]
 
 SUPPORTED_PLATFORM_TRIPLES = SUPPORTED_T1_PLATFORM_TRIPLES + SUPPORTED_T2_PLATFORM_TRIPLES
@@ -60,9 +67,14 @@
     "powerpc64le": None,
     "riscv32": "riscv32",
     "riscv32imc": "riscv32",
+    "riscv64": "riscv64",
+    "riscv64gc": "riscv64",
     "s390": None,
     "s390x": "s390x",
-    "thumbv7m": "armv7",
+    "thumbv6m": "armv6-m",
+    "thumbv7em": "armv7e-m",
+    "thumbv7m": "armv7-m",
+    "thumbv8m.main": "armv8-m",
     "wasm32": None,
     "x86_64": "x86_64",
 }
@@ -74,8 +86,10 @@
     "darwin": "osx",
     "dragonfly": None,
     "eabi": "none",
+    "eabihf": "none",
     "emscripten": None,
     "freebsd": "freebsd",
+    "fuchsia": "fuchsia",
     "ios": "ios",
     "linux": "linux",
     "nacl": None,
@@ -92,8 +106,10 @@
     "android": "",
     "darwin": "",
     "eabi": "",
+    "eabihf": "",
     "emscripten": ".js",
     "freebsd": "",
+    "fuchsia": "",
     "ios": "",
     "linux": "",
     "none": "",
@@ -109,8 +125,10 @@
     "android": ".a",
     "darwin": ".a",
     "eabi": ".a",
+    "eabihf": ".a",
     "emscripten": ".js",
     "freebsd": ".a",
+    "fuchsia": ".a",
     "ios": ".a",
     "linux": ".a",
     "none": ".a",
@@ -123,8 +141,10 @@
     "android": ".so",
     "darwin": ".dylib",
     "eabi": ".so",
+    "eabihf": ".so",
     "emscripten": ".js",
     "freebsd": ".so",
+    "fuchsia": ".so",
     "ios": ".dylib",
     "linux": ".so",
     "none": ".so",
@@ -137,7 +157,7 @@
 _SYSTEM_TO_STDLIB_LINKFLAGS = {
     # NOTE: Rust stdlib `build.rs` treats android as a subset of linux, rust rules treat android
     # as its own system.
-    "android": ["-ldl", "-llog", "-lgcc"],
+    "android": ["-ldl", "-llog"],
     "bitrig": [],
     # TODO(gregbowyer): If rust stdlib is compiled for cloudabi with the backtrace feature it
     # includes `-lunwind` but this might not actually be required.
@@ -146,6 +166,7 @@
     "darwin": ["-lSystem", "-lresolv"],
     "dragonfly": ["-lpthread"],
     "eabi": [],
+    "eabihf": [],
     "emscripten": [],
     # TODO(bazelbuild/rules_cc#75):
     #
@@ -176,11 +197,24 @@
     "windows": ["advapi32.lib", "ws2_32.lib", "userenv.lib", "Bcrypt.lib"],
 }
 
-def cpu_arch_to_constraints(cpu_arch):
+def cpu_arch_to_constraints(cpu_arch, *, system = None):
+    """Returns a list of contraint values which represents a triple's CPU.
+
+    Args:
+        cpu_arch (str): The architecture to match constraints for
+        system (str, optional): The system for the associated ABI value.
+
+    Returns:
+        List: A list of labels to constraint values
+    """
+    if cpu_arch not in _CPU_ARCH_TO_BUILTIN_PLAT_SUFFIX:
+        fail("CPU architecture \"{}\" is not supported by rules_rust".format(cpu_arch))
+
     plat_suffix = _CPU_ARCH_TO_BUILTIN_PLAT_SUFFIX[cpu_arch]
 
-    if not plat_suffix:
-        fail("CPU architecture \"{}\" is not supported by rules_rust".format(cpu_arch))
+    # Patch armv7e-m to mf if hardfloat abi is selected
+    if plat_suffix == "armv7e-m" and system == "eabihf":
+        plat_suffix = "armv7e-mf"
 
     return ["@platforms//cpu:{}".format(plat_suffix)]
 
@@ -192,37 +226,37 @@
     return []
 
 def system_to_constraints(system):
-    sys_suffix = _SYSTEM_TO_BUILTIN_SYS_SUFFIX[system]
+    if system not in _SYSTEM_TO_BUILTIN_SYS_SUFFIX:
+        fail("System \"{}\" is not supported by rules_rust".format(system))
 
-    if not sys_suffix:
-        fail("System \"{}\" is not supported by rules_rust".format(sys_suffix))
+    sys_suffix = _SYSTEM_TO_BUILTIN_SYS_SUFFIX[system]
 
     return ["@platforms//os:{}".format(sys_suffix)]
 
-def abi_to_constraints(_abi):
-    # TODO(acmcarther): Implement when C++ toolchain is more mature and we
-    # figure out how they're doing this
-    return []
+def abi_to_constraints(abi, *, arch = None, system = None):
+    """Return a list of constraint values which represents a triple's ABI.
 
-def extra_ios_constraints(triple):
-    """Add constraints specific to iOS targets.
+    Note that some ABI values require additional info to accurately match a set of constraints.
 
     Args:
-        triple: The full triple struct for the target
+        abi (str): The abi value to match constraints for
+        arch (str, optional): The architecture for the associated ABI value.
+        system (str, optional): The system for the associated ABI value.
 
     Returns:
-        A list of constraints to add to the target
+        List: A list of labels to constraint values
     """
 
-    # TODO: Simplify if https://github.com/bazelbuild/bazel/issues/11454 is fixed
-    if triple.system != "ios":
-        return []
-    if triple.abi == "sim":
-        return ["@build_bazel_apple_support//constraints:simulator"]
-    elif triple.arch == "aarch64":  # Only add device for archs that have both
-        return ["@build_bazel_apple_support//constraints:device"]
-    else:
-        return []
+    # add constraints for iOS + watchOS simulator and device triples
+    if system in ["ios", "watchos"]:
+        if arch == "x86_64" or abi == "sim":
+            return ["@build_bazel_apple_support//constraints:simulator"]
+        else:
+            return ["@build_bazel_apple_support//constraints:device"]
+
+    # TODO(bazelbuild/platforms#38): Implement when C++ toolchain is more mature and we
+    # figure out how they're doing this
+    return []
 
 def triple_to_system(target_triple):
     """Returns a system name for a given platform triple
@@ -235,7 +269,9 @@
     Returns:
         str: A system name
     """
-    return triple(target_triple).system
+    if type(target_triple) == "string":
+        target_triple = triple(target_triple)
+    return target_triple.system
 
 def triple_to_arch(target_triple):
     """Returns a system architecture name for a given platform triple
@@ -248,7 +284,9 @@
     Returns:
         str: A cpu architecture
     """
-    return triple(target_triple).arch
+    if type(target_triple) == "string":
+        target_triple = triple(target_triple)
+    return target_triple.arch
 
 def triple_to_abi(target_triple):
     """Returns a system abi name for a given platform triple
@@ -261,7 +299,9 @@
     Returns:
         str: The triple's abi
     """
-    return triple(target_triple).system
+    if type(target_triple) == "string":
+        target_triple = triple(target_triple)
+    return target_triple.system
 
 def system_to_dylib_ext(system):
     return _SYSTEM_TO_DYLIB_EXT[system]
@@ -286,22 +326,28 @@
     """
     if target_triple == "wasm32-wasi":
         return [
-            "@rules_rust//rust/platform/cpu:wasm32",
-            "@rules_rust//rust/platform/os:wasi",
+            "@platforms//cpu:wasm32",
+            "@platforms//os:wasi",
         ]
     if target_triple == "wasm32-unknown-unknown":
         return [
-            "@rules_rust//rust/platform/cpu:wasm32",
+            "@platforms//cpu:wasm32",
             "@rules_rust//rust/platform/os:unknown",
         ]
 
     triple_struct = triple(target_triple)
 
     constraint_set = []
-    constraint_set += cpu_arch_to_constraints(triple_struct.arch)
+    constraint_set += cpu_arch_to_constraints(
+        triple_struct.arch,
+        system = triple_struct.system,
+    )
     constraint_set += vendor_to_constraints(triple_struct.vendor)
     constraint_set += system_to_constraints(triple_struct.system)
-    constraint_set += abi_to_constraints(triple_struct.abi)
-    constraint_set += extra_ios_constraints(triple_struct)
+    constraint_set += abi_to_constraints(
+        triple_struct.abi,
+        arch = triple_struct.arch,
+        system = triple_struct.system,
+    )
 
     return constraint_set