diff --git a/d/rules/defs.bzl b/d/rules/defs.bzl
index 1411668c9e..a9729140f8 100644
--- a/d/rules/defs.bzl
+++ b/d/rules/defs.bzl
@@ -106,13 +106,15 @@ def _cover(kwargs):
         "//conditions:default": [],
     }))
 
+_WARNINGS = ("dopts", ["-w"], [])
+
 def d_library(name, srcs, visibility = None, **kwargs):
     """Thin wrapper over the rules_d d_library rule."""
     kwargs = d_kwargs(kwargs)
     kwargs = _cover(kwargs)
     quality_srcs = d_quality_srcs(srcs, kwargs.get("string_srcs"))
     kwargs = _string_srcs(name, kwargs)
-    dx_wrap(name, _d_library, _d_library_forward, srcs, visibility = visibility, quality_srcs = quality_srcs, **kwargs)
+    dx_wrap(name, _d_library, _d_library_forward, srcs, visibility = visibility, quality_srcs = quality_srcs, warnings = _WARNINGS, **kwargs)
 
 def d_binary(name, *, srcs = None, visibility = None, **kwargs):
     """Thin wrapper over the rules_d d_binary rule. srcs is required."""
@@ -122,7 +124,7 @@ def d_binary(name, *, srcs = None, visibility = None, **kwargs):
     quality_srcs = d_quality_srcs(srcs, kwargs.get("string_srcs"))
     kwargs = _string_srcs(name, kwargs)
     upstream = dict(kwargs, tags = dx_upstream_tags(kwargs.get("tags", None)))
-    dx_wrap_binary(name, _d_binary, _d_binary_forward, srcs, visibility = visibility, upstream_kwargs = upstream, quality_srcs = quality_srcs, **kwargs)
+    dx_wrap_binary(name, _d_binary, _d_binary_forward, srcs, visibility = visibility, upstream_kwargs = upstream, quality_srcs = quality_srcs, warnings = _WARNINGS, **kwargs)
 
 D_COVERAGE_COLLECTOR = True
 
@@ -133,7 +135,7 @@ def d_test(name, *, srcs = None, visibility = None, **kwargs):
     kwargs = d_kwargs(kwargs)
     quality_srcs = d_quality_srcs(srcs, kwargs.get("string_srcs"))
     kwargs = _cover(_string_srcs(name, kwargs))
-    dx_wrap_test(name, _d_test, _d_forward_test, srcs, visibility = visibility, quality_srcs = quality_srcs, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, coverage_collector = D_COVERAGE_COLLECTOR, **kwargs)
+    dx_wrap_test(name, _d_test, _d_forward_test, srcs, visibility = visibility, quality_srcs = quality_srcs, warnings = _WARNINGS, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, coverage_collector = D_COVERAGE_COLLECTOR, **kwargs)
 
 def d_fuzz_test(name, *, srcs = None, visibility = None, tags = None, dopts = None, linkopts = None, **kwargs):
     """A libFuzzer binary with AddressSanitizer plus a `<name>_run` runner for `dx fuzz`. srcs define LLVMFuzzerTestOneInput, for example with ldc.libfuzzer."""
diff --git a/erlang/rules/defs.bzl b/erlang/rules/defs.bzl
index 60fc29c570..c9082f4b09 100644
--- a/erlang/rules/defs.bzl
+++ b/erlang/rules/defs.bzl
@@ -16,7 +16,7 @@ load("//erlang/toolchain:cells.bzl", "otp_compatible_with")
 load("//erlang/toolchain:pins.bzl", "OTP_DIALYZER_UNPORTED_CELLS", "OTP_NIF_UNPORTED_CELLS")
 load("//libs/launcher:defs.bzl", "NATIVE_LAUNCHER_ATTRS", "target_is_windows", "write_native_launcher")
 load("//libs/starlark:fuzz_bench.bzl", "merge_tags", "with_default_size")
-load("//libs/starlark:wrapper.bzl", "DX_EXEC_PROVIDES", "dx_binary_forward_kwargs", "dx_binary_upstream_kwargs", "dx_executable_forward_rule", "dx_forward_data_attr", "dx_language_kwargs", "dx_lcov_merger_attr", "dx_library_forward_rule", "dx_native_coverage_attrs", "dx_native_coverage_toolchains", "dx_native_test_coverage", "dx_quality_sources", "dx_setdefaults", "dx_test_forward_kwargs", "dx_test_upstream_kwargs", "dx_upstream_tags", "dx_wrap", "dx_wrap_test")
+load("//libs/starlark:wrapper.bzl", "DX_EXEC_PROVIDES", "dx_binary_forward_kwargs", "dx_binary_upstream_kwargs", "dx_executable_forward_rule", "dx_forward_data_attr", "dx_language_kwargs", "dx_lcov_merger_attr", "dx_library_forward_rule", "dx_native_coverage_attrs", "dx_native_coverage_toolchains", "dx_native_test_coverage", "dx_quality_sources", "dx_setdefaults", "dx_test_forward_kwargs", "dx_test_upstream_kwargs", "dx_upstream_tags", "dx_warnings_as_errors", "dx_wrap", "dx_wrap_test")
 load("//quality:sources.bzl", "QualitySourcesInfo")
 load(":kwargs.bzl", "erlang_app_forward_kwargs", "erlang_kwargs", _ERLANG_CELLS = "ERLANG_CELLS", _ERLANG_COMPATIBLE_WITH = "ERLANG_COMPATIBLE_WITH")
 
@@ -286,8 +286,15 @@ def app_sources(kwargs, glob = None):
     excluded = [entry for entry in _listed(kwargs, ["extra_srcs", "extra_hdrs"]) if not _is_label(entry)]
     return glob(ERLANG_SOURCE_GLOBS, exclude = excluded, allow_empty = True)
 
+_ERLC_OPTS = ["+debug_info", "+warn_export_vars", "+warn_shadow_vars", "+warn_obsolete_guard"] + select({
+    Label("@rules_erlang//:debug_build"): [],
+    "//conditions:default": ["+deterministic"],
+})
+
 def _app(upstream_macro, name, testonly, visibility, kwargs):
-    kwargs = erlang_kwargs(kwargs)
+    kwargs, warning_flags = dx_warnings_as_errors(erlang_kwargs(kwargs), ["-Werror"])
+    if "erlc_opts" not in kwargs and "beam_files" not in kwargs:
+        kwargs["erlc_opts"] = _ERLC_OPTS + warning_flags
     tags = kwargs.pop("tags", None)
     nifs = kwargs.pop("nifs", [])
     if nifs:
diff --git a/families/dotnet/BUILD.bazel b/families/dotnet/BUILD.bazel
index 640928ed0e..bbc89e1a86 100644
--- a/families/dotnet/BUILD.bazel
+++ b/families/dotnet/BUILD.bazel
@@ -1,3 +1,4 @@
+load("@rules_dx//libs/starlark:conformance.bzl", "dx_warnings_parity_test")
 load("@rules_dx//quality:fixtures.bzl", "real_source_target")
 load("@rules_shell//shell:sh_test.bzl", "sh_test")
 
@@ -52,3 +53,12 @@ exports_files(
     visibility = ["//.dx:__pkg__"],
 )
 # dx:end exports
+
+dx_warnings_parity_test(
+    name = "warnings_parity_test",
+    mapped = {
+        "csharp": ["//csharp/rules:kwargs.bzl"],
+        "fsharp": ["//fsharp/rules:kwargs.bzl"],
+    },
+    opted_out = [],
+)
diff --git a/fortran/rules/defs.bzl b/fortran/rules/defs.bzl
index 2182b23dc7..8e13a1b599 100644
--- a/fortran/rules/defs.bzl
+++ b/fortran/rules/defs.bzl
@@ -82,6 +82,8 @@ _fortran_forward_test = dx_executable_forward_rule(
     coverage_providers = _fortran_test_coverage,
 )
 
+_WARNINGS = ("copts", ["-Werror"], [])
+
 def library_name(name):
     """Returns the name of the private Fortran library behind one executable."""
     return name + "_fortran"
@@ -100,12 +102,12 @@ _fortran_cc_test = _linked(_cc_test)
 
 def fortran_library(name, srcs = None, visibility = None, **kwargs):
     """Thin wrapper over the rules_fortran fortran_library rule."""
-    dx_wrap(name, _fortran_library, _library_forward, srcs or [], visibility = visibility, **fortran_with_defaults(kwargs))
+    dx_wrap(name, _fortran_library, _library_forward, srcs or [], visibility = visibility, warnings = _WARNINGS, **fortran_with_defaults(kwargs))
 
 def fortran_binary(name, srcs = None, visibility = None, **kwargs):
     """Compiles Fortran sources with rules_fortran and links them with cc_binary."""
-    dx_wrap_binary(name, _fortran_cc_binary, _binary_forward, srcs or [], visibility = visibility, **fortran_with_defaults(kwargs))
+    dx_wrap_binary(name, _fortran_cc_binary, _binary_forward, srcs or [], visibility = visibility, warnings = _WARNINGS, **fortran_with_defaults(kwargs))
 
 def fortran_test(name, srcs = None, visibility = None, **kwargs):
     """Compiles Fortran sources with rules_fortran and links them with cc_test."""
-    dx_wrap_test(name, _fortran_cc_test, _fortran_forward_test, srcs or [], visibility = visibility, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, **fortran_with_defaults(kwargs))
+    dx_wrap_test(name, _fortran_cc_test, _fortran_forward_test, srcs or [], visibility = visibility, extra_forward_kwargs = {"deps": kwargs.get("deps", [])}, warnings = _WARNINGS, **fortran_with_defaults(kwargs))
diff --git a/go/rules/defs.bzl b/go/rules/defs.bzl
index 4f5b21052a..1cf24ae741 100644
--- a/go/rules/defs.bzl
+++ b/go/rules/defs.bzl
@@ -74,20 +74,25 @@ _go_forward_test = dx_executable_forward_rule(
     optional_providers = [_GoArchive],
 )
 
+_WARNINGS = ("copts", ["-Werror"], [])
+
+def _cgo_warnings(kwargs):
+    return _WARNINGS if kwargs.get("cgo") == True else None
+
 def _cgo_kwargs(kwargs):
     return {"cgo": kwargs.get("cgo", False)}
 
 def go_library(name, srcs, importpath, visibility = None, **kwargs):
     """Minimal wrapper over go_library."""
-    dx_wrap(name, _go_library, _go_library_forward, srcs, visibility = visibility, importpath = importpath, extra_forward_kwargs = _cgo_kwargs(kwargs), **kwargs)
+    dx_wrap(name, _go_library, _go_library_forward, srcs, visibility = visibility, importpath = importpath, extra_forward_kwargs = _cgo_kwargs(kwargs), warnings = _cgo_warnings(kwargs), **kwargs)
 
 def go_binary(name, *, srcs = None, visibility = None, **kwargs):
     """Minimal wrapper over go_binary. cgo is off unless set."""
-    dx_wrap_binary(name, _go_binary, _go_binary_forward, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), **kwargs)
+    dx_wrap_binary(name, _go_binary, _go_binary_forward, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), warnings = _cgo_warnings(kwargs), **kwargs)
 
 def go_test(name, *, srcs = None, visibility = None, **kwargs):
     """Minimal wrapper over go_test. cgo is off unless set."""
-    dx_wrap_test(name, _go_test, _go_forward_test, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), **kwargs)
+    dx_wrap_test(name, _go_test, _go_forward_test, srcs, visibility = visibility, extra_forward_kwargs = _cgo_kwargs(kwargs), warnings = _cgo_warnings(kwargs), **kwargs)
 
 def go_fuzz_test(name, *, fuzz, srcs = None, visibility = None, tags = None, **kwargs):
     """A go_test plus a `<name>_run` runner that fuzzes the function `fuzz` for `dx fuzz`."""
diff --git a/libs/starlark/BUILD.bazel b/libs/starlark/BUILD.bazel
index 5f2e9b8d93..c94b3c4855 100644
--- a/libs/starlark/BUILD.bazel
+++ b/libs/starlark/BUILD.bazel
@@ -33,6 +33,7 @@ exports_files([
     "seven_zip.bzl",
     "tag_probe.bzl",
     "wrapper.bzl",
+    "warnings_parity.sh",
     "wrapper_signatures.sh",
 ])
 
diff --git a/libs/starlark/conformance.bzl b/libs/starlark/conformance.bzl
index 1895534351..58880984a1 100644
--- a/libs/starlark/conformance.bzl
+++ b/libs/starlark/conformance.bzl
@@ -269,3 +269,28 @@ def dx_wrapper_signature_test(name, defs = "defs.bzl"):
             "//conditions:default": [],
         }),
     )
+
+def dx_warnings_parity_test(name, mapped, opted_out):
+    """Fails when a compiled language neither maps warnings_as_errors nor opts out.
+
+    Args:
+      name: test name.
+      mapped: dict of language to the .bzl files that map the flag.
+      opted_out: list of languages whose compiler reports no warnings.
+    """
+    args = []
+    data = []
+    for lang in sorted(mapped.keys()):
+        args.append(lang + "=" + ",".join(["$(rootpath {})".format(f) for f in mapped[lang]]))
+        data.extend(mapped[lang])
+    args.extend([lang + "=-" for lang in sorted(opted_out)])
+    sh_test(
+        name = name,
+        srcs = [Label("//libs/starlark:warnings_parity.sh")],
+        args = args,
+        data = data,
+        target_compatible_with = select({
+            "@platforms//os:windows": ["@platforms//:incompatible"],
+            "//conditions:default": [],
+        }),
+    )
diff --git a/libs/starlark/tests/BUILD.bazel b/libs/starlark/tests/BUILD.bazel
index 5206d67cdf..6750247d0e 100644
--- a/libs/starlark/tests/BUILD.bazel
+++ b/libs/starlark/tests/BUILD.bazel
@@ -1,5 +1,6 @@
 load("@bazel_skylib//rules:write_file.bzl", "write_file")
 load("//cc/rules:defs.bzl", "cc_test")
+load("//libs/starlark:conformance.bzl", "dx_warnings_parity_test")
 load("//libs/starlark:defs.bzl", "starlark_test")
 load("//libs/starlark:failure_test.bzl", "failure_test")
 load("//libs/starlark/tests/fixtures/starlark_futures:aspect_subjects.bzl", "aspect_group", "aspect_leaf")
@@ -270,3 +271,27 @@ starlark_test(
     mode = "analysis",
     subjects = [":exec_group_forwarder"],
 )
+
+dx_warnings_parity_test(
+    name = "warnings_parity_test",
+    mapped = {
+        "cc": ["//cc/rules:defs.bzl"],
+        "d": ["//d/rules:defs.bzl"],
+        "elixir": ["//elixir/rules:kwargs.bzl"],
+        "erlang": ["//erlang/rules:defs.bzl"],
+        "fortran": ["//fortran/rules:defs.bzl"],
+        "go": ["//go/rules:defs.bzl"],
+        "haskell": ["//haskell/rules:kwargs.bzl"],
+        "java": ["//java/rules:kwargs.bzl"],
+        "kotlin": ["//kotlin/rules:defs.bzl"],
+        "ocaml": ["//ocaml/rules:defs.bzl"],
+        "rust": ["//rust/rules:defs.bzl"],
+        "scala": ["//scala/rules:validate.bzl"],
+        "swift": ["//swift/rules:defs.bzl"],
+    },
+    opted_out = [
+        "dart",
+        "typescript",
+        "zig",
+    ],
+)
diff --git a/libs/starlark/warnings_parity.sh b/libs/starlark/warnings_parity.sh
new file mode 100755
index 0000000000..c374faf5b9
--- /dev/null
+++ b/libs/starlark/warnings_parity.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# Fails when a compiled language neither maps warnings_as_errors nor opts out.
+# Args: language=file[,file...] for a mapped language, language=- for an opt-out.
+set -euo pipefail
+
+status=0
+for entry in "$@"; do
+    lang="${entry%%=*}"
+    files="${entry#*=}"
+    if [[ "$files" == "-" ]]; then
+        continue
+    fi
+    if ! grep -qE 'dx_warnings_as_errors\(|warnings = _[a-z_]*WARNINGS|warnings = _cgo_warnings' ${files//,/ }; then
+        echo "$lang: no warnings_as_errors mapping in $files" >&2
+        status=1
+    fi
+done
+exit "$status"
diff --git a/libs/starlark/wrapper.bzl b/libs/starlark/wrapper.bzl
index b352b4dca3..35da4da380 100644
--- a/libs/starlark/wrapper.bzl
+++ b/libs/starlark/wrapper.bzl
@@ -640,6 +640,7 @@ def dx_test_upstream_kwargs(kwargs, srcs = None, upstream_visibility = None):
     out.setdefault("size", "small")
     out.pop("env", None)
     out.pop("env_inherit", None)
+    out.pop("warnings_as_errors", None)
     if srcs != None:
         out["srcs"] = srcs
     return out
@@ -655,11 +656,12 @@ def dx_binary_upstream_kwargs(kwargs, srcs, upstream_visibility = None):
     out["visibility"] = upstream_visibility if upstream_visibility != None else ["//visibility:private"]
     out.pop("env", None)
     out.pop("env_inherit", None)
+    out.pop("warnings_as_errors", None)
     return out
 
 def dx_wrap_upstream_kwargs(kwargs, srcs = None, upstream_visibility = None):
     """Returns the private upstream kwargs for one library shape."""
-    out = {key: value for key, value in kwargs.items() if key not in ("tags", "srcs")}
+    out = {key: value for key, value in kwargs.items() if key not in ("tags", "srcs", "warnings_as_errors")}
     if srcs != None:
         out["srcs"] = srcs
     out["tags"] = dx_upstream_tags(kwargs.get("tags", None))
@@ -679,9 +681,17 @@ def dx_test_forward_kwargs(kwargs):
         out["target_compatible_with"] = kwargs["target_compatible_with"]
     return out
 
-def dx_wrap_binary(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, **kwargs):
+def dx_warnings_upstream(upstream, kwargs, warnings):
+    """Returns upstream with the warnings_as_errors flags appended to the attribute warnings names."""
+    if warnings == None:
+        return upstream
+    key, on, off = warnings
+    _, flag = dx_warnings_as_errors(kwargs, on, off)
+    return dx_append_flags(upstream, key, flag)
+
+def dx_wrap_binary(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, warnings = None, **kwargs):
     """Instantiates one private upstream binary plus its public forwarder."""
-    effective = dx_binary_upstream_kwargs(upstream_kwargs if upstream_kwargs != None else kwargs, srcs, upstream_visibility)
+    effective = dx_binary_upstream_kwargs(dx_warnings_upstream(upstream_kwargs if upstream_kwargs != None else kwargs, kwargs, warnings), srcs, upstream_visibility)
     upstream_rule(
         name = name + "_upstream",
         **effective
@@ -710,9 +720,9 @@ def dx_with_tag(tags, tag):
         out.append(tag)
     return out
 
-def dx_wrap_test(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, coverage_collector = True, upstream_visibility = None, **kwargs):
+def dx_wrap_test(name, upstream_rule, forward_rule, srcs, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, coverage_collector = True, upstream_visibility = None, warnings = None, **kwargs):
     """Instantiates one private upstream test plus its public forwarder."""
-    base = dict(upstream_kwargs) if upstream_kwargs != None else dict(kwargs)
+    base = dx_warnings_upstream(dict(upstream_kwargs) if upstream_kwargs != None else dict(kwargs), kwargs, warnings)
     effective = dx_test_upstream_kwargs(base, srcs = srcs, upstream_visibility = upstream_visibility)
     forward_srcs = quality_srcs if quality_srcs != None else (srcs if srcs != None else [])
     forward_kwargs = dx_test_forward_kwargs(kwargs)
@@ -733,11 +743,11 @@ def dx_wrap_test(name, upstream_rule, forward_rule, srcs, visibility = None, ups
         **forward_kwargs
     )
 
-def dx_wrap(name, upstream_rule, forward_rule, srcs = None, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, **kwargs):
+def dx_wrap(name, upstream_rule, forward_rule, srcs = None, visibility = None, upstream_kwargs = None, extra_forward_kwargs = None, quality_srcs = None, upstream_visibility = None, warnings = None, **kwargs):
     """Instantiates one private upstream library target plus its public forwarder."""
     upstream_rule(
         name = name + "_upstream",
-        **dx_wrap_upstream_kwargs(upstream_kwargs if upstream_kwargs != None else kwargs, srcs, upstream_visibility)
+        **dx_wrap_upstream_kwargs(dx_warnings_upstream(upstream_kwargs if upstream_kwargs != None else kwargs, kwargs, warnings), srcs, upstream_visibility)
     )
     forward_kwargs = dx_wrap_forward_kwargs(kwargs)
     if extra_forward_kwargs:
diff --git a/rust/rules/defs.bzl b/rust/rules/defs.bzl
index e9f12064c5..68778e409e 100644
--- a/rust/rules/defs.bzl
+++ b/rust/rules/defs.bzl
@@ -9,7 +9,7 @@ load("//libs/starlark:fuzz.bzl", "dx_fuzz_binary", "dx_fuzz_runner")
 load("//libs/starlark:fuzz_bench.bzl", "dx_bench_test", "merge_tags", "split_runner_kwargs")
 load("//libs/starlark:msvc_crt.bzl", "MSVC_CRT_FROM_RUST", "dx_msvc_crt_aspect", "dx_msvc_crt_validate", "msvc_crt_static_settings")
 load("//libs/starlark:resources.bzl", "dx_test_resource_tags")
-load("//libs/starlark:wrapper.bzl", "dx_data_coverage_aspect", "dx_executable_forward_rule", "dx_forwarded_test_kwargs", "dx_lcov_merger_attr", "dx_library_forward_rule", "dx_native_coverage_attrs", "dx_native_coverage_toolchains", "dx_native_test_coverage", "dx_quality_sources", "dx_run_env_attrs", "dx_run_environment", "dx_symlink_default_info", "dx_symlink_executable", "dx_upstream", "dx_wrap", "dx_wrap_binary", "dx_wrap_forward_kwargs", "dx_wrap_test", "dx_wrap_upstream_kwargs")
+load("//libs/starlark:wrapper.bzl", "dx_data_coverage_aspect", "dx_executable_forward_rule", "dx_forwarded_test_kwargs", "dx_lcov_merger_attr", "dx_library_forward_rule", "dx_native_coverage_attrs", "dx_native_coverage_toolchains", "dx_native_test_coverage", "dx_quality_sources", "dx_run_env_attrs", "dx_run_environment", "dx_symlink_default_info", "dx_symlink_executable", "dx_upstream", "dx_warnings_upstream", "dx_wrap", "dx_wrap_binary", "dx_wrap_forward_kwargs", "dx_wrap_test", "dx_wrap_upstream_kwargs")
 load("//quality:pipeline.bzl", "upstream_tags")
 load("//quality:sources.bzl", "QualitySourcesInfo", "RUST")
 load(":edition.bzl", "RUST_EDITION")
@@ -90,6 +90,8 @@ _LIBSTDCXX_ATTRS = {
     "crt_static": attr.bool(doc = "Whether the target's own rustc_flags set +crt-static."),
 }
 
+_WARNINGS = ("rustc_flags", ["-Dwarnings"], [])
+
 def _libstdcxx_forward(rustc_flags = None):
     """Returns the forwarder kwargs that mark libstdc++ platforms and static CRT targets."""
     crt_static = type(rustc_flags) == "list" and any(["+crt-static" in flag for flag in rustc_flags])
@@ -232,6 +234,7 @@ def rust_library(
         visibility = visibility,
         upstream_kwargs = _libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = False),
         extra_forward_kwargs = _libstdcxx_forward(kwargs.get("rustc_flags")),
+        warnings = _WARNINGS,
         **kwargs
     )
 
@@ -260,6 +263,7 @@ def rust_binary(
         visibility = visibility,
         upstream_kwargs = _libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = True),
         extra_forward_kwargs = _libstdcxx_forward(kwargs.get("rustc_flags")) | {"wasm": wasm or ""},
+        warnings = _WARNINGS,
         **kwargs
     )
 
@@ -270,7 +274,7 @@ def _rust_browser_binary(name, srcs, crate_name, edition, visibility, **kwargs):
     bindgen = name + "_bindgen"
     _rust_binary(
         name = upstream,
-        **dx_wrap_upstream_kwargs(_libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = True), srcs)
+        **dx_wrap_upstream_kwargs(dx_warnings_upstream(_libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = True), kwargs, _WARNINGS), srcs)
     )
     private = {
         "tags": ["manual"],
@@ -343,7 +347,7 @@ def rust_test(
         forward_kwargs["crate"] = crate
     if coverage_lib != None:
         forward_kwargs["coverage_lib"] = coverage_lib
-    dx_wrap_test(name, _rust_test, _rust_forward_test, srcs, visibility = visibility, upstream_kwargs = upstream_kwargs, extra_forward_kwargs = forward_kwargs, **kwargs)
+    dx_wrap_test(name, _rust_test, _rust_forward_test, srcs, visibility = visibility, upstream_kwargs = upstream_kwargs, extra_forward_kwargs = forward_kwargs, warnings = _WARNINGS, **kwargs)
 
 def rust_bench(
         name,
@@ -382,7 +386,7 @@ def _rust_wasi_test(name, srcs, crate, edition, visibility, preopens, runtime, *
     }
     if runtime != None:
         forward_kwargs["runtime"] = runtime
-    dx_wrap_test(name, _rust_test, _rust_wasi_run_test, srcs, visibility = visibility, upstream_kwargs = upstream_kwargs, extra_forward_kwargs = forward_kwargs, coverage_collector = False, **{key: value for key, value in kwargs.items() if key != "env"})
+    dx_wrap_test(name, _rust_test, _rust_wasi_run_test, srcs, visibility = visibility, upstream_kwargs = upstream_kwargs, extra_forward_kwargs = forward_kwargs, coverage_collector = False, warnings = _WARNINGS, **{key: value for key, value in kwargs.items() if key != "env"})
 
 def rust_proc_macro(
         name,
@@ -400,6 +404,7 @@ def rust_proc_macro(
         visibility = visibility,
         upstream_kwargs = _libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = False),
         extra_forward_kwargs = _libstdcxx_forward(kwargs.get("rustc_flags")),
+        warnings = _WARNINGS,
         **kwargs
     )
 
@@ -419,6 +424,7 @@ def rust_shared_library(
         visibility = visibility,
         upstream_kwargs = _libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = True),
         extra_forward_kwargs = _libstdcxx_forward(kwargs.get("rustc_flags")),
+        warnings = _WARNINGS,
         **kwargs
     )
 
@@ -438,6 +444,7 @@ def rust_static_library(
         visibility = visibility,
         upstream_kwargs = _libstdcxx_upstream(dict(kwargs, crate_name = _crate_name(name, crate_name), edition = edition), link = False),
         extra_forward_kwargs = _libstdcxx_forward(kwargs.get("rustc_flags")),
+        warnings = _WARNINGS,
         **kwargs
     )
 
@@ -571,7 +578,7 @@ def _rust_browser_test(name, wasm, **kwargs):
     """Runs the bundle under a managed, platform-qualified browser."""
     forward = dx_forwarded_test_kwargs(kwargs)
     forward.setdefault("size", "large")
-    upstream = {k: v for k, v in kwargs.items() if k not in _FORWARDER_ONLY_KWARGS}
+    upstream = {k: v for k, v in kwargs.items() if k not in _FORWARDER_ONLY_KWARGS and k != "warnings_as_errors"}
     user_tags = forward.pop("tags", [])
     _rust_wasm_bindgen_test(
         name = name + "_upstream",
diff --git a/swift/rules/defs.bzl b/swift/rules/defs.bzl
index 1b099f7829..c0020a7075 100644
--- a/swift/rules/defs.bzl
+++ b/swift/rules/defs.bzl
@@ -86,13 +86,15 @@ _swift_forward_test = dx_executable_forward_rule(
     toolchains = dx_native_coverage_toolchains(),
 )
 
+_WARNINGS = ("copts", ["-warnings-as-errors"], [])
+
 def swift_library(name, srcs = None, visibility = None, platforms = None, **kwargs):
     """Wraps swift_library and builds it for Linux, or with Xcode on macOS."""
-    dx_wrap(name, _swift_library, _swift_library_forward, srcs, visibility = visibility, upstream_kwargs = dx_append_flags(kwargs, "features", _STATIC + _INDEX), quality_srcs = srcs or [], extra_forward_kwargs = {"platforms": platforms if platforms != None else swift_linux_platforms()}, **kwargs)
+    dx_wrap(name, _swift_library, _swift_library_forward, srcs, visibility = visibility, upstream_kwargs = dx_append_flags(kwargs, "features", _STATIC + _INDEX), quality_srcs = srcs or [], warnings = _WARNINGS, extra_forward_kwargs = {"platforms": platforms if platforms != None else swift_linux_platforms()}, **kwargs)
 
 def swift_binary(name, srcs = None, visibility = None, platforms = None, **kwargs):
     """Wraps swift_binary and builds it for Linux, or with Xcode on macOS."""
-    dx_wrap_binary(name, _swift_binary, _swift_binary_forward, srcs, visibility = visibility, upstream_kwargs = dx_append_flags(kwargs, "features", _STATIC + _INDEX), quality_srcs = srcs or [], extra_forward_kwargs = {"platforms": platforms if platforms != None else swift_linux_platforms()}, **kwargs)
+    dx_wrap_binary(name, _swift_binary, _swift_binary_forward, srcs, visibility = visibility, upstream_kwargs = dx_append_flags(kwargs, "features", _STATIC + _INDEX), quality_srcs = srcs or [], warnings = _WARNINGS, extra_forward_kwargs = {"platforms": platforms if platforms != None else swift_linux_platforms()}, **kwargs)
 
 def _swift_runtime_kwargs(kwargs, platforms):
     """Returns the forwarder kwargs that ship the sysroot's shared libraries with a swift_test and point the loader at them, so no host library is needed."""
@@ -124,7 +126,7 @@ def _swift_coverage_kwargs(kwargs):
 
 def swift_test(name, srcs = None, visibility = None, platforms = None, **kwargs):
     """Wraps swift_test and builds it for Linux, or with Xcode on macOS."""
-    dx_wrap_test(name, _swift_test, _swift_forward_test, srcs, visibility = visibility, upstream_kwargs = _swift_coverage_kwargs(kwargs), quality_srcs = srcs or [], extra_forward_kwargs = _swift_runtime_kwargs(kwargs, platforms), **kwargs)
+    dx_wrap_test(name, _swift_test, _swift_forward_test, srcs, visibility = visibility, upstream_kwargs = _swift_coverage_kwargs(kwargs), quality_srcs = srcs or [], warnings = _WARNINGS, extra_forward_kwargs = _swift_runtime_kwargs(kwargs, platforms), **kwargs)
 
 def swift_fuzz_test(name, srcs = None, visibility = None, tags = None, copts = None, linkopts = None, **kwargs):
     """A libFuzzer binary with AddressSanitizer plus a `<name>_run` runner for `dx fuzz`. Linux only."""