diff --git a/src/tint/lang/core/ir/BUILD.bazel b/src/tint/lang/core/ir/BUILD.bazel
index fe29cfa..b12f3ee 100644
--- a/src/tint/lang/core/ir/BUILD.bazel
+++ b/src/tint/lang/core/ir/BUILD.bazel
@@ -77,6 +77,7 @@
     "multi_in_block.cc",
     "next_iteration.cc",
     "operand_instruction.cc",
+    "override.cc",
     "return.cc",
     "store.cc",
     "store_vector_element.cc",
@@ -132,6 +133,7 @@
     "multi_in_block.h",
     "next_iteration.h",
     "operand_instruction.h",
+    "override.h",
     "referenced_functions.h",
     "referenced_module_vars.h",
     "return.h",
@@ -209,6 +211,7 @@
     "multi_in_block_test.cc",
     "next_iteration_test.cc",
     "operand_instruction_test.cc",
+    "override_test.cc",
     "referenced_functions_test.cc",
     "referenced_module_vars_test.cc",
     "return_test.cc",
diff --git a/src/tint/lang/core/ir/BUILD.cmake b/src/tint/lang/core/ir/BUILD.cmake
index 3fec311..c833689 100644
--- a/src/tint/lang/core/ir/BUILD.cmake
+++ b/src/tint/lang/core/ir/BUILD.cmake
@@ -119,6 +119,8 @@
   lang/core/ir/next_iteration.h
   lang/core/ir/operand_instruction.cc
   lang/core/ir/operand_instruction.h
+  lang/core/ir/override.cc
+  lang/core/ir/override.h
   lang/core/ir/referenced_functions.h
   lang/core/ir/referenced_module_vars.h
   lang/core/ir/return.cc
@@ -213,6 +215,7 @@
   lang/core/ir/multi_in_block_test.cc
   lang/core/ir/next_iteration_test.cc
   lang/core/ir/operand_instruction_test.cc
+  lang/core/ir/override_test.cc
   lang/core/ir/referenced_functions_test.cc
   lang/core/ir/referenced_module_vars_test.cc
   lang/core/ir/return_test.cc
diff --git a/src/tint/lang/core/ir/BUILD.gn b/src/tint/lang/core/ir/BUILD.gn
index 6e2695c..c4c2f29 100644
--- a/src/tint/lang/core/ir/BUILD.gn
+++ b/src/tint/lang/core/ir/BUILD.gn
@@ -122,6 +122,8 @@
     "next_iteration.h",
     "operand_instruction.cc",
     "operand_instruction.h",
+    "override.cc",
+    "override.h",
     "referenced_functions.h",
     "referenced_module_vars.h",
     "return.cc",
@@ -210,6 +212,7 @@
       "multi_in_block_test.cc",
       "next_iteration_test.cc",
       "operand_instruction_test.cc",
+      "override_test.cc",
       "referenced_functions_test.cc",
       "referenced_module_vars_test.cc",
       "return_test.cc",
diff --git a/src/tint/lang/core/ir/builder.h b/src/tint/lang/core/ir/builder.h
index a72b4f9..ec9b23a 100644
--- a/src/tint/lang/core/ir/builder.h
+++ b/src/tint/lang/core/ir/builder.h
@@ -59,6 +59,7 @@
 #include "src/tint/lang/core/ir/module.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
 #include "src/tint/lang/core/ir/next_iteration.h"
+#include "src/tint/lang/core/ir/override.h"
 #include "src/tint/lang/core/ir/return.h"
 #include "src/tint/lang/core/ir/store.h"
 #include "src/tint/lang/core/ir/store_vector_element.h"
@@ -1744,6 +1745,32 @@
         });
     }
 
+    /// Creates a new `override` declaration
+    /// @param name the override name
+    /// @param value the override value
+    /// @returns the instruction
+    template <typename VALUE>
+    ir::Override* Override(std::string_view name, VALUE&& value) {
+        auto* val = Value(std::forward<VALUE>(value));
+        if (DAWN_UNLIKELY(!val)) {
+            TINT_ASSERT(val);
+            return nullptr;
+        }
+        auto* override = Append(ir.CreateInstruction<ir::Override>(InstructionResult(val->Type())));
+        override->SetInitializer(val);
+        ir.SetName(override->Result(0), name);
+        return override;
+    }
+
+    /// Creates a new `override` declaration, with an unassigned value
+    /// @param type the override type
+    /// @returns the instruction
+    ir::Override* Override(const type::Type* type) {
+        auto* override = ir.CreateInstruction<ir::Override>(InstructionResult(type));
+        Append(override);
+        return override;
+    }
+
     /// The IR module.
     Module& ir;
 
diff --git a/src/tint/lang/core/ir/disassembler.cc b/src/tint/lang/core/ir/disassembler.cc
index dac70e0..4d9091a 100644
--- a/src/tint/lang/core/ir/disassembler.cc
+++ b/src/tint/lang/core/ir/disassembler.cc
@@ -53,6 +53,7 @@
 #include "src/tint/lang/core/ir/member_builtin_call.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
 #include "src/tint/lang/core/ir/next_iteration.h"
+#include "src/tint/lang/core/ir/override.h"
 #include "src/tint/lang/core/ir/return.h"
 #include "src/tint/lang/core/ir/store.h"
 #include "src/tint/lang/core/ir/store_vector_element.h"
@@ -515,6 +516,16 @@
                 EmitOperandList(c, UserCall::kArgsOperandOffset);
             }
         },
+        [&](const Override* o) {
+            EmitValueWithType(o);
+            out_ << " = ";
+            EmitInstructionName(o);
+            if (o->Initializer()) {
+                out_ << ", ";
+                EmitOperand(o, Var::kInitializerOperandOffset);
+            }
+            out_ << " @id(" << o->OverrideId().value << ")";
+        },
         [&](const Var* v) {
             EmitValueWithType(v);
             out_ << " = ";
diff --git a/src/tint/lang/core/ir/instruction_result.h b/src/tint/lang/core/ir/instruction_result.h
index 2b6b442..dc48935 100644
--- a/src/tint/lang/core/ir/instruction_result.h
+++ b/src/tint/lang/core/ir/instruction_result.h
@@ -29,7 +29,6 @@
 #define SRC_TINT_LANG_CORE_IR_INSTRUCTION_RESULT_H_
 
 #include "src/tint/lang/core/ir/value.h"
-#include "src/tint/utils/text/string_stream.h"
 
 namespace tint::core::ir {
 
@@ -46,9 +45,6 @@
     /// @copydoc Value::Destroy
     void Destroy() override;
 
-    /// @returns the type of the value
-    const core::type::Type* Type() const override { return type_; }
-
     /// @copydoc Value::Clone()
     InstructionResult* Clone(CloneContext& ctx) override;
 
@@ -56,6 +52,9 @@
     /// @param type the new type of the value
     void SetType(const core::type::Type* type) { type_ = type; }
 
+    /// @returns the type of the value
+    const core::type::Type* Type() const override { return type_; }
+
     /// Sets the instruction for this value
     /// @param inst the instruction to set
     void SetInstruction(Instruction* inst) { instruction_ = inst; }
diff --git a/src/tint/lang/core/ir/override.cc b/src/tint/lang/core/ir/override.cc
new file mode 100644
index 0000000..cee6ede
--- /dev/null
+++ b/src/tint/lang/core/ir/override.cc
@@ -0,0 +1,74 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/core/ir/override.h"
+
+#include "src/tint/lang/core/ir/clone_context.h"
+#include "src/tint/lang/core/ir/module.h"
+#include "src/tint/lang/core/ir/store.h"
+#include "src/tint/lang/core/type/pointer.h"
+#include "src/tint/utils/ice/ice.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::core::ir::Override);
+
+namespace tint::core::ir {
+
+Override::Override(Id id) : Base(id) {}
+
+Override::Override(Id id, InstructionResult* result) : Base(id) {
+    // Default to no initializer.
+    AddOperand(Override::kInitializerOperandOffset, nullptr);
+    AddResult(result);
+}
+
+Override::~Override() = default;
+
+void Override::SetInitializer(Value* initializer) {
+    SetOperand(Override::kInitializerOperandOffset, initializer);
+}
+
+Override* Override::Clone(CloneContext& ctx) {
+    auto* new_result = ctx.Clone(Result(0));
+    TINT_ASSERT(new_result);
+
+    auto* new_override = ctx.ir.CreateInstruction<Override>(new_result);
+
+    new_override->id_ = id_;
+
+    if (auto* init = Initializer()) {
+        new_override->SetInitializer(ctx.Clone(init));
+    }
+    new_override->SetOverrideId(override_id_);
+
+    auto name = ctx.ir.NameOf(this);
+    if (name.IsValid()) {
+        ctx.ir.SetName(new_override, name.Name());
+    }
+    return new_override;
+}
+
+}  // namespace tint::core::ir
diff --git a/src/tint/lang/core/ir/override.h b/src/tint/lang/core/ir/override.h
new file mode 100644
index 0000000..f69cc46
--- /dev/null
+++ b/src/tint/lang/core/ir/override.h
@@ -0,0 +1,85 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef SRC_TINT_LANG_CORE_IR_OVERRIDE_H_
+#define SRC_TINT_LANG_CORE_IR_OVERRIDE_H_
+
+#include <string>
+
+#include "src/tint/api/common/override_id.h"
+#include "src/tint/lang/core/ir/operand_instruction.h"
+#include "src/tint/utils/rtti/castable.h"
+
+namespace tint::core::ir {
+
+/// A var instruction in the IR.
+class Override final : public Castable<Override, OperandInstruction<1, 1>> {
+  public:
+    /// The offset in Operands() for the initializer
+    static constexpr size_t kInitializerOperandOffset = 0;
+
+    /// The fixed number of results returned by this instruction
+    static constexpr size_t kNumResults = 1;
+
+    /// Constructor (no results, no operands)
+    /// @param id the instruction id
+    explicit Override(Id id);
+
+    /// Constructor
+    /// @param id the instruction id
+    /// @param result the result value
+    Override(Id id, InstructionResult* result);
+
+    ~Override() override;
+
+    /// @copydoc Instruction::Clone()
+    Override* Clone(CloneContext& ctx) override;
+
+    /// Sets the var initializer
+    /// @param initializer the initializer
+    void SetInitializer(Value* initializer);
+    /// @returns the initializer
+    Value* Initializer() { return Operand(kInitializerOperandOffset); }
+    /// @returns the initializer
+    const Value* Initializer() const { return Operand(kInitializerOperandOffset); }
+
+    /// Sets the override Id attribute
+    /// @param id the override id
+    void SetOverrideId(OverrideId id) { override_id_ = id; }
+    /// @returns the override ID
+    tint::OverrideId OverrideId() const { return override_id_; }
+
+    /// @returns the friendly name for the instruction
+    std::string FriendlyName() const override { return "override"; }
+
+  private:
+    tint::OverrideId override_id_;
+};
+
+}  // namespace tint::core::ir
+
+#endif  // SRC_TINT_LANG_CORE_IR_OVERRIDE_H_
diff --git a/src/tint/lang/core/ir/override_test.cc b/src/tint/lang/core/ir/override_test.cc
new file mode 100644
index 0000000..638a14b
--- /dev/null
+++ b/src/tint/lang/core/ir/override_test.cc
@@ -0,0 +1,100 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/core/ir/var.h"
+
+#include "gmock/gmock.h"
+#include "src/tint/lang/core/ir/builder.h"
+#include "src/tint/lang/core/ir/instruction.h"
+#include "src/tint/lang/core/ir/ir_helper_test.h"
+
+namespace tint::core::ir {
+namespace {
+
+using namespace tint::core::fluent_types;     // NOLINT
+using namespace tint::core::number_suffixes;  // NOLINT
+
+using IR_OverrideTest = IRTestHelper;
+using IR_OverrideDeathTest = IR_OverrideTest;
+
+TEST_F(IR_OverrideDeathTest, Fail_NullType) {
+    EXPECT_DEATH_IF_SUPPORTED(
+        {
+            Module mod;
+            Builder b{mod};
+            b.Override(nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_OverrideTest, Results) {
+    auto* var = b.Override(ty.i32());
+    EXPECT_EQ(var->Results().Length(), 1u);
+    EXPECT_TRUE(var->Result(0)->Is<InstructionResult>());
+    EXPECT_EQ(var->Result(0)->Instruction(), var);
+}
+
+TEST_F(IR_OverrideTest, Initializer_Usage) {
+    Module mod;
+    Builder b{mod};
+    auto* var = b.Override(ty.f32());
+    auto* init = b.Constant(1_f);
+    var->SetInitializer(init);
+
+    EXPECT_THAT(init->UsagesUnsorted(), testing::UnorderedElementsAre(Usage{var, 0u}));
+    var->SetInitializer(nullptr);
+    EXPECT_FALSE(init->IsUsed());
+}
+
+TEST_F(IR_OverrideTest, Clone) {
+    auto* v = b.Override(ty.f32());
+    v->SetInitializer(b.Constant(4_f));
+    v->SetOverrideId(OverrideId{2});
+
+    auto* new_v = clone_ctx.Clone(v);
+
+    EXPECT_NE(v, new_v);
+    ASSERT_NE(nullptr, new_v->Result(0));
+    EXPECT_NE(v->Result(0), new_v->Result(0));
+    EXPECT_EQ(new_v->Result(0)->Type(), mod.Types().f32());
+
+    ASSERT_NE(nullptr, new_v->Initializer());
+    auto new_val = new_v->Initializer()->As<Constant>()->Value();
+    ASSERT_TRUE(new_val->Is<core::constant::Scalar<f32>>());
+    EXPECT_FLOAT_EQ(4_f, new_val->As<core::constant::Scalar<f32>>()->ValueAs<f32>());
+    EXPECT_EQ(OverrideId{2u}, new_v->OverrideId());
+}
+
+TEST_F(IR_OverrideTest, CloneWithName) {
+    auto* v = b.Override("v", b.Constant(1_f));
+    auto* new_v = clone_ctx.Clone(v);
+
+    EXPECT_EQ(std::string("v"), mod.NameOf(new_v).Name());
+}
+
+}  // namespace
+}  // namespace tint::core::ir
diff --git a/src/tint/lang/core/ir/validator.cc b/src/tint/lang/core/ir/validator.cc
index 6cc6af1..5c3b6f5 100644
--- a/src/tint/lang/core/ir/validator.cc
+++ b/src/tint/lang/core/ir/validator.cc
@@ -64,6 +64,7 @@
 #include "src/tint/lang/core/ir/member_builtin_call.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
 #include "src/tint/lang/core/ir/next_iteration.h"
+#include "src/tint/lang/core/ir/override.h"
 #include "src/tint/lang/core/ir/referenced_module_vars.h"
 #include "src/tint/lang/core/ir/return.h"
 #include "src/tint/lang/core/ir/store.h"
@@ -874,6 +875,10 @@
     /// @param blk the block
     void CheckRootBlock(const Block* blk);
 
+    /// Validates the given instruction is only used in the root block.
+    /// @param inst the instruction
+    void CheckOnlyUsedInRootBlock(const Instruction* inst);
+
     /// Validates the given function
     /// @param func the function to validate
     void CheckFunction(const Function* func);
@@ -974,6 +979,10 @@
     /// @param inst the instruction to validate
     void CheckInstruction(const Instruction* inst);
 
+    /// Validates the given override
+    /// @param o the override to validate
+    void CheckOverride(const Override* o);
+
     /// Validates the given var
     /// @param var the var to validate
     void CheckVar(const Var* var);
@@ -1221,6 +1230,7 @@
     Hashmap<const ir::Function*, Hashset<const ir::UserCall*, 4>, 4> user_func_calls_;
     Hashset<const ir::Discard*, 4> discards_;
     core::ir::ReferencedModuleVars<const Module> referenced_module_vars_;
+    Hashset<OverrideId, 8> seen_override_ids_;
 
     Hashset<ValidatedType, 16> validated_types_{};
 };
@@ -1731,6 +1741,13 @@
 
         tint::Switch(
             inst,  //
+            [&](const core::ir::Override* o) {
+                if (capabilities_.Contains(Capability::kAllowOverrides)) {
+                    CheckInstruction(o);
+                } else {
+                    AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name;
+                }
+            },
             [&](const core::ir::Var* var) { CheckInstruction(var); },
             [&](const core::ir::Let* let) {
                 if (capabilities_.Contains(Capability::kAllowModuleScopeLets)) {
@@ -1747,11 +1764,31 @@
                 }
             },
             [&](Default) {
-                AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name;
+                // Note, this validation is looser then it could be. There are only certain
+                // expressions and builtins which can be used in an override. We can tighten this up
+                // later to a constrained set of instructions and builtins if necessary.
+                if (capabilities_.Contains(Capability::kAllowOverrides)) {
+                    // If overrides are allowed we can have regular instructions in the root block,
+                    // with the caveat that those instructions can _only_ be used in the root block.
+                    CheckOnlyUsedInRootBlock(inst);
+                } else {
+                    AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name;
+                }
             });
     }
 }
 
+void Validator::CheckOnlyUsedInRootBlock(const Instruction* inst) {
+    for (auto& usage : inst->Result(0)->UsagesSorted()) {
+        if (usage.instruction->Block() != mod_.root_block) {
+            AddError(inst) << "root block: instruction used outside of root block "
+                           << inst->TypeInfo().name;
+        }
+    }
+
+    CheckInstruction(inst);
+}
+
 void Validator::CheckFunction(const Function* func) {
     // Scope holds the parameters and block
     scope_stack_.Push();
@@ -2083,6 +2120,7 @@
         [&](const Swizzle* s) { CheckSwizzle(s); },                        //
         [&](const Terminator* b) { CheckTerminator(b); },                  //
         [&](const Unary* u) { CheckUnary(u); },                            //
+        [&](const Override* o) { CheckOverride(o); },                      //
         [&](const Var* var) { CheckVar(var); },                            //
         [&](const Default) { AddError(inst) << "missing validation"; });
 
@@ -2091,6 +2129,36 @@
     }
 }
 
+void Validator::CheckOverride(const Override* o) {
+    // Intentionally not checking operands, since Override may have a null operand
+    if (!CheckResults(o, Override::kNumResults)) {
+        return;
+    }
+
+    if (!seen_override_ids_.Add(o->OverrideId())) {
+        AddError(o) << "duplicate override id encountered: " << o->OverrideId().value;
+        return;
+    }
+
+    if (!o->Result(0)->Type()->IsScalar()) {
+        AddError(o) << "override type " << style::Type(o->Result(0)->Type()->FriendlyName())
+                    << " is not a scalar";
+        return;
+    }
+
+    if (o->Initializer()) {
+        if (!CheckOperand(o, ir::Var::kInitializerOperandOffset)) {
+            return;
+        }
+        if (o->Initializer()->Type() != o->Result(0)->Type()) {
+            AddError(o) << "override type " << style::Type(o->Result(0)->Type()->FriendlyName())
+                        << " does not match initializer type "
+                        << style::Type(o->Initializer()->Type()->FriendlyName());
+            return;
+        }
+    }
+}
+
 void Validator::CheckVar(const Var* var) {
     // Intentionally not checking operands, since Var may have a null operand
     if (!CheckResults(var, Var::kNumResults)) {
diff --git a/src/tint/lang/core/ir/validator.h b/src/tint/lang/core/ir/validator.h
index 4681e03..cf4809a 100644
--- a/src/tint/lang/core/ir/validator.h
+++ b/src/tint/lang/core/ir/validator.h
@@ -44,18 +44,20 @@
 enum class Capability : uint8_t {
     /// Allows 8-bit integer types.
     kAllow8BitIntegers,
-    /// Allows access instructions to create pointers to vector elements.
-    kAllowVectorElementPointer,
-    /// Allows ref types
-    kAllowRefTypes,
-    /// Allows module scoped lets
-    kAllowModuleScopeLets,
-    /// Allows pointers inside structures.
-    kAllowPointersInStructures,
-    /// Allows handle vars to not have binding points
-    kAllowHandleVarsWithoutBindings,
     /// Allows ClipDistances on f32 parameters
     kAllowClipDistancesOnF32,
+    /// Allows handle vars to not have binding points
+    kAllowHandleVarsWithoutBindings,
+    /// Allows module scoped lets
+    kAllowModuleScopeLets,
+    /// Allow overrides
+    kAllowOverrides,
+    /// Allows pointers inside structures.
+    kAllowPointersInStructures,
+    /// Allows ref types
+    kAllowRefTypes,
+    /// Allows access instructions to create pointers to vector elements.
+    kAllowVectorElementPointer,
 };
 
 /// Capabilities is a set of Capability
diff --git a/src/tint/lang/core/ir/validator_test.cc b/src/tint/lang/core/ir/validator_test.cc
index e944db2..3060f7c 100644
--- a/src/tint/lang/core/ir/validator_test.cc
+++ b/src/tint/lang/core/ir/validator_test.cc
@@ -9660,5 +9660,189 @@
 )");
 }
 
+TEST_F(IR_ValidatorTest, OverrideWithoutCapability) {
+    b.Append(mod.root_block, [&] { b.Override("a", 1_u); });
+
+    auto res = ir::Validate(mod);
+    ASSERT_NE(res, Success);
+    EXPECT_EQ(res.Failure().reason.Str(),
+              R"(:2:12 error: override: root block: invalid instruction: tint::core::ir::Override
+  %a:u32 = override, 1u @id(0)
+           ^^^^^^^^
+
+:1:1 note: in block
+$B1: {  # root
+^^^
+
+note: # Disassembly
+$B1: {  # root
+  %a:u32 = override, 1u @id(0)
+}
+
+)");
+}
+
+TEST_F(IR_ValidatorTest, InstructionInRootBlockWithoutOverrideCap) {
+    b.Append(mod.root_block, [&] { b.Add(ty.u32(), 3_u, 2_u); });
+
+    auto res = ir::Validate(mod);
+    ASSERT_NE(res, Success);
+    EXPECT_EQ(res.Failure().reason.Str(),
+              R"(:2:3 error: binary: root block: invalid instruction: tint::core::ir::CoreBinary
+  %1:u32 = add 3u, 2u
+  ^^^^^^^^^^^^^^^^^^^
+
+:1:1 note: in block
+$B1: {  # root
+^^^
+
+note: # Disassembly
+$B1: {  # root
+  %1:u32 = add 3u, 2u
+}
+
+)");
+}
+
+TEST_F(IR_ValidatorTest, OverrideWithCapability) {
+    b.Append(mod.root_block, [&] { b.Override(ty.u32()); });
+
+    auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    ASSERT_EQ(res, Success);
+}
+
+TEST_F(IR_ValidatorTest, OverrideWithValue) {
+    b.Append(mod.root_block, [&] {
+        auto* z = b.Override(ty.u32());
+        z->SetOverrideId(OverrideId{2});
+        auto* init = b.Add(ty.u32(), z, 2_u);
+
+        b.Override("a", init);
+    });
+
+    auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    ASSERT_EQ(res, Success);
+}
+
+TEST_F(IR_ValidatorTest, OverrideWithInvalidType) {
+    b.Append(mod.root_block, [&] { b.Override(ty.vec3<u32>()); });
+
+    auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    ASSERT_NE(res, Success);
+    EXPECT_EQ(res.Failure().reason.Str(),
+              R"(:2:18 error: override: override type 'vec3<u32>' is not a scalar
+  %1:vec3<u32> = override @id(0)
+                 ^^^^^^^^
+
+:1:1 note: in block
+$B1: {  # root
+^^^
+
+note: # Disassembly
+$B1: {  # root
+  %1:vec3<u32> = override @id(0)
+}
+
+)");
+}
+
+TEST_F(IR_ValidatorTest, OverrideWithMismatchedInitializerType) {
+    b.Append(mod.root_block, [&] {
+        auto* init = b.Constant(1_i);
+        auto* o = b.Override(ty.u32());
+        o->SetInitializer(init);
+    });
+
+    auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    ASSERT_NE(res, Success);
+    EXPECT_EQ(res.Failure().reason.Str(),
+              R"(:2:12 error: override: override type 'u32' does not match initializer type 'i32'
+  %1:u32 = override, 1i @id(0)
+           ^^^^^^^^
+
+:1:1 note: in block
+$B1: {  # root
+^^^
+
+note: # Disassembly
+$B1: {  # root
+  %1:u32 = override, 1i @id(0)
+}
+
+)");
+}
+
+TEST_F(IR_ValidatorTest, OverrideDuplicateId) {
+    b.Append(mod.root_block, [&] {
+        auto* o = b.Override(ty.u32());
+        o->SetOverrideId(OverrideId{2});
+
+        auto* o2 = b.Override(ty.i32());
+        o2->SetOverrideId(OverrideId{2});
+    });
+
+    auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    ASSERT_NE(res, Success);
+    EXPECT_EQ(res.Failure().reason.Str(),
+              R"(:3:12 error: override: duplicate override id encountered: 2
+  %2:i32 = override @id(2)
+           ^^^^^^^^
+
+:1:1 note: in block
+$B1: {  # root
+^^^
+
+note: # Disassembly
+$B1: {  # root
+  %1:u32 = override @id(2)
+  %2:i32 = override @id(2)
+}
+
+)");
+}
+
+TEST_F(IR_ValidatorTest, InstructionInRootBlockOnlyUsedInRootBlock) {
+    core::ir::Value* init = nullptr;
+    b.Append(mod.root_block, [&] {
+        auto* z = b.Override(ty.u32());
+        z->SetOverrideId(OverrideId{2});
+        init = b.Add(ty.u32(), z, 2_u)->Result(0);
+        b.Override("a", init);
+    });
+
+    auto* f = b.Function("my_func", ty.void_());
+    b.Append(f->Block(), [&] {
+        b.Add(ty.u32(), init, 2_u);
+        b.Return(f);
+    });
+
+    auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    ASSERT_NE(res, Success);
+    EXPECT_EQ(
+        res.Failure().reason.Str(),
+        R"(:3:3 error: binary: root block: instruction used outside of root block tint::core::ir::CoreBinary
+  %2:u32 = add %1, 2u
+  ^^^^^^^^^^^^^^^^^^^
+
+:1:1 note: in block
+$B1: {  # root
+^^^
+
+note: # Disassembly
+$B1: {  # root
+  %1:u32 = override @id(2)
+  %2:u32 = add %1, 2u
+  %a:u32 = override, %2 @id(0)
+}
+
+%my_func = func():void {
+  $B2: {
+    %5:u32 = add %2, 2u
+    ret
+  }
+}
+)");
+}
+
 }  // namespace
 }  // namespace tint::core::ir
diff --git a/src/tint/lang/core/type/type.cc b/src/tint/lang/core/type/type.cc
index 29069bd..cf77682 100644
--- a/src/tint/lang/core/type/type.cc
+++ b/src/tint/lang/core/type/type.cc
@@ -88,6 +88,10 @@
     return 0;
 }
 
+bool Type::IsScalar() const {
+    return IsFloatScalar() || IsIntegerScalar() || IsAnyOf<AbstractInt, Bool>();
+}
+
 bool Type::IsFloatScalar() const {
     return IsAnyOf<F16, F32, AbstractFloat>();
 }
diff --git a/src/tint/lang/core/type/type.h b/src/tint/lang/core/type/type.h
index d263428..d4b7647 100644
--- a/src/tint/lang/core/type/type.h
+++ b/src/tint/lang/core/type/type.h
@@ -129,6 +129,8 @@
     /// @see https://www.w3.org/TR/WGSL/#fixed-footprint-types
     inline bool HasFixedFootprint() const { return flags_.Contains(Flag::kFixedFootprint); }
 
+    /// @returns true if the type is a scalar
+    bool IsScalar() const;
     /// @returns true if this type is a float scalar
     bool IsFloatScalar() const;
     /// @returns true if this type is a float matrix
diff --git a/src/tint/lang/wgsl/reader/lower/lower.cc b/src/tint/lang/wgsl/reader/lower/lower.cc
index 02ba26e..2fe327e 100644
--- a/src/tint/lang/wgsl/reader/lower/lower.cc
+++ b/src/tint/lang/wgsl/reader/lower/lower.cc
@@ -35,6 +35,7 @@
 #include "src/tint/lang/core/ir/validator.h"
 #include "src/tint/lang/wgsl/builtin_fn.h"
 #include "src/tint/lang/wgsl/ir/builtin_call.h"
+#include "src/tint/utils/diagnostic/diagnostic.h"
 #include "src/tint/utils/ice/ice.h"
 
 namespace tint::wgsl::reader {
@@ -204,7 +205,9 @@
 }  // namespace
 
 Result<SuccessType> Lower(core::ir::Module& mod) {
-    if (auto res = core::ir::ValidateAndDumpIfNeeded(mod, "wgsl.Lower"); res != Success) {
+    auto res = core::ir::ValidateAndDumpIfNeeded(
+        mod, "wgsl.Lower", core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+    if (res != Success) {
         return res.Failure();
     }
 
diff --git a/src/tint/lang/wgsl/reader/lower/lower.h b/src/tint/lang/wgsl/reader/lower/lower.h
index 91a647e..b11a139 100644
--- a/src/tint/lang/wgsl/reader/lower/lower.h
+++ b/src/tint/lang/wgsl/reader/lower/lower.h
@@ -29,7 +29,6 @@
 #define SRC_TINT_LANG_WGSL_READER_LOWER_LOWER_H_
 
 #include "src/tint/lang/core/ir/module.h"
-#include "src/tint/utils/diagnostic/diagnostic.h"
 #include "src/tint/utils/result/result.h"
 
 namespace tint::wgsl::reader {
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/ir_program_test.h b/src/tint/lang/wgsl/reader/program_to_ir/ir_program_test.h
index 7bdf81a..2ce447c 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/ir_program_test.h
+++ b/src/tint/lang/wgsl/reader/program_to_ir/ir_program_test.h
@@ -66,7 +66,9 @@
             return lower.Failure();
         }
 
-        if (auto validate = core::ir::Validate(result.Get()); validate != Success) {
+        auto validate = core::ir::Validate(
+            result.Get(), core::ir::Capabilities{core::ir::Capability::kAllowOverrides});
+        if (validate != Success) {
             return validate.Failure();
         }
         return result;
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
index 0baa2a4..673889e 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir.cc
@@ -1218,19 +1218,34 @@
                 // Store the results of the initialization
                 scopes_.Set(l->name->symbol, let->Result(0));
             },
-            [&](const ast::Override*) {
-                AddError(var->source) << "found an `Override` variable. The SubstituteOverrides "
-                                         "transform must be run before converting to IR";
+            [&](const ast::Override* o) {
+                auto* o_sem = program_.Sem().Get(o);
+                auto* ty = sem->Type()->Clone(clone_ctx_.type_ctx);
+
+                auto* override = builder_.Override(ty);
+                if (o->initializer) {
+                    auto init = EmitValueExpression(o->initializer);
+                    if (!init) {
+                        return;
+                    }
+                    override->SetInitializer(init);
+                }
+                current_block_->Append(override);
+
+                TINT_ASSERT(o_sem->Attributes().override_id.has_value());
+                override->SetOverrideId(o_sem->Attributes().override_id.value());
+
+                // Store the declaration so we can get the instruction to store too
+                scopes_.Set(o->name->symbol, override->Result(0));
+
+                // Record the original name of the var
+                builder_.ir.SetName(override, o->name->symbol.Name());
             },
             [&](const ast::Const*) {
                 // Skip. This should be handled by const-eval already, so the const will be a
                 // `core::constant::` value at the usage sites. Can just ignore the `const` variable
                 // as it should never be used.
-                //
-                // TODO(dsinclair): Probably want to store the const variable somewhere and then
-                // in identifier expression log an error if we ever see a const identifier. Add
-                // this when identifiers and variables are supported.
-            },  //
+            },
             TINT_ICE_ON_NO_MATCH);
     }
 
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc
index 1b12473..57457f5 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc
@@ -32,6 +32,7 @@
 #include "src/tint/lang/core/ir/if.h"
 #include "src/tint/lang/core/ir/loop.h"
 #include "src/tint/lang/core/ir/multi_in_block.h"
+#include "src/tint/lang/core/ir/override.h"
 #include "src/tint/lang/core/ir/switch.h"
 #include "src/tint/lang/wgsl/reader/program_to_ir/ir_program_test.h"
 
@@ -1160,9 +1161,6 @@
 )");
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Bugs
-////////////////////////////////////////////////////////////////////////////////
 TEST_F(IR_FromProgramTest, BugChromium324466107) {
     Func("f", Empty, ty.void_(),
          Vector{
@@ -1182,5 +1180,87 @@
 )");
 }
 
+TEST_F(IR_FromProgramTest, OverrideNoInitializer) {
+    Override("a", ty.i32());
+
+    auto res = Build();
+    ASSERT_EQ(res, Success);
+
+    auto m = res.Move();
+    auto* overide = FindSingleInstruction<core::ir::Override>(m);
+
+    ASSERT_NE(overide, nullptr);
+    ASSERT_EQ(overide->Initializer(), nullptr);
+
+    EXPECT_EQ(core::ir::Disassembler(m).Plain(), R"($B1: {  # root
+  %a:i32 = override @id(0)
+}
+
+)");
+}
+
+TEST_F(IR_FromProgramTest, OverrideWithConstantInitializer) {
+    Override("a", Expr(1_f));
+
+    auto res = Build();
+    ASSERT_EQ(res, Success);
+
+    auto m = res.Move();
+    auto* override = FindSingleInstruction<core::ir::Override>(m);
+
+    ASSERT_NE(override, nullptr);
+    ASSERT_NE(override->Initializer(), nullptr);
+
+    auto* init = override->Initializer()->As<core::ir::Constant>();
+    ASSERT_NE(init, nullptr);
+    EXPECT_FLOAT_EQ(1.0f, init->Value()->ValueAs<float>());
+
+    EXPECT_EQ(core::ir::Disassembler(m).Plain(), R"($B1: {  # root
+  %a:f32 = override, 1.0f @id(0)
+}
+
+)");
+}
+
+TEST_F(IR_FromProgramTest, OverrideWithAddInitializer) {
+    Override("a", Add(1_u, 2_u));
+
+    auto res = Build();
+    ASSERT_EQ(res, Success);
+
+    auto m = res.Move();
+    auto* override = FindSingleInstruction<core::ir::Override>(m);
+
+    ASSERT_NE(override, nullptr);
+    ASSERT_NE(override->Initializer(), nullptr);
+
+    auto* init = override->Initializer()->As<core::ir::Constant>();
+    ASSERT_NE(init, nullptr);
+    EXPECT_EQ(3u, init->Value()->ValueAs<uint32_t>());
+
+    EXPECT_EQ(core::ir::Disassembler(m).Plain(), R"($B1: {  # root
+  %a:u32 = override, 3u @id(0)
+}
+
+)");
+}
+
+TEST_F(IR_FromProgramTest, OverrideWithOverrideAddInitializer) {
+    auto* z = Override("z", ty.u32());
+    Override("a", Add(z, 2_u));
+
+    auto res = Build();
+    ASSERT_EQ(res, Success);
+
+    auto m = res.Move();
+    EXPECT_EQ(core::ir::Disassembler(m).Plain(), R"($B1: {  # root
+  %z:u32 = override @id(0)
+  %2:u32 = add %z, 2u
+  %a:u32 = override, %2 @id(1)
+}
+
+)");
+}
+
 }  // namespace
 }  // namespace tint::wgsl::reader
diff --git a/src/tint/lang/wgsl/reader/reader.cc b/src/tint/lang/wgsl/reader/reader.cc
index ac8d967..4cbaaf6 100644
--- a/src/tint/lang/wgsl/reader/reader.cc
+++ b/src/tint/lang/wgsl/reader/reader.cc
@@ -51,29 +51,20 @@
 
 Result<core::ir::Module> WgslToIR(const Source::File* file, const Options& options) {
     Program program = Parse(file, options);
-    auto module = ProgramToIR(program);
-    if (module != Success) {
-        return module.Failure();
-    }
-    // WGSL-dialect -> core-dialect
-    if (auto res = Lower(module.Get()); res != Success) {
-        return res.Failure();
-    }
-    return module;
+    return ProgramToLoweredIR(program);
 }
 
 tint::Result<core::ir::Module> ProgramToLoweredIR(const Program& program) {
-    auto ir = tint::wgsl::reader::ProgramToIR(program);
+    auto ir = ProgramToIR(program);
     if (ir != Success) {
         return ir.Failure();
     }
 
     // Lower from WGSL-dialect to core-dialect
-    auto res = tint::wgsl::reader::Lower(ir.Get());
+    auto res = Lower(ir.Get());
     if (res != Success) {
         return res.Failure();
     }
-
     return ir;
 }