diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index 8db4098..8028d02 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -76,14 +76,6 @@
     using DisableIfVectorLike = utils::traits::EnableIf<
         !utils::IsVectorLike<utils::traits::Decay<utils::traits::NthTypeOf<0, TYPES..., void>>>>;
 
-    template <typename T>
-    T* Append(T* val) {
-        if (current_block_) {
-            current_block_->Append(val);
-        }
-        return val;
-    }
-
     /// If set, any created instruction will be auto-appended to the block.
     ir::Block* current_block_ = nullptr;
 
@@ -103,6 +95,18 @@
     /// @returns the builder
     Builder With(Block* b) { return Builder(ir, b); }
 
+    /// Appends and returns the instruction @p val to the current block. If there is no current
+    /// block bound, then @p val is just returned.
+    /// @param val the instruction to append
+    /// @returns the instruction
+    template <typename T>
+    T* Append(T* val) {
+        if (current_block_) {
+            current_block_->Append(val);
+        }
+        return val;
+    }
+
     /// @returns a new block
     ir::Block* Block();
 
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index 7ff5cf5..e23f88e 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -295,7 +295,11 @@
 }
 
 void Disassembler::EmitValueWithType(Instruction* val) {
-    EmitValueWithType(val->Result());
+    if (val->Result()) {
+        EmitValueWithType(val->Result());
+    } else {
+        out_ << "undef";
+    }
 }
 
 void Disassembler::EmitValueWithType(Value* val) {
diff --git a/src/tint/ir/validate.cc b/src/tint/ir/validate.cc
index 34436e3..3f82487 100644
--- a/src/tint/ir/validate.cc
+++ b/src/tint/ir/validate.cc
@@ -158,6 +158,7 @@
                          std::string("root block: invalid instruction: ") + inst->TypeInfo().name);
                 continue;
             }
+            CheckVar(var);
         }
     }
 
@@ -181,6 +182,25 @@
     }
 
     void CheckInstruction(Instruction* inst) {
+        if (!inst->Alive()) {
+            AddError(inst, "destroyed instruction found in instruction list");
+        }
+        if (inst->Result()) {
+            if (inst->Result()->Source() == nullptr) {
+                AddError(inst, "instruction result source is undefined");
+            } else if (inst->Result()->Source() != inst) {
+                AddError(inst, "instruction result source has wrong instruction");
+            }
+        }
+
+        for (auto* op : inst->Operands()) {
+            // Note, a `nullptr` is a valid operand in some cases, like `var` so we can't just check
+            // for `nullptr` here.
+            if (op && !op->Alive()) {
+                AddError(inst, "instruction has undefined operand");
+            }
+        }
+
         tint::Switch(
             inst,                                        //
             [&](Access* a) { CheckAccess(a); },          //
@@ -194,7 +214,7 @@
             [&](Swizzle*) {},                            //
             [&](Terminator* b) { CheckTerminator(b); },  //
             [&](Unary*) {},                              //
-            [&](Var*) {},                                //
+            [&](Var* var) { CheckVar(var); },            //
             [&](Default) {
                 AddError(std::string("missing validation of: ") + inst->TypeInfo().name);
             });
@@ -310,6 +330,18 @@
             AddError(if_, If::kConditionOperandOffset, "if: condition must be a `bool` type");
         }
     }
+
+    void CheckVar(Var* var) {
+        if (var->Result() == nullptr) {
+            AddError(var, "var: result is a nullptr");
+        }
+
+        if (var->Result() && var->Initializer()) {
+            if (var->Initializer()->Type() != var->Result()->Type()->UnwrapPtr()) {
+                AddError(var, "var initializer has incorrect type");
+            }
+        }
+    }
 };  // namespace
 
 }  // namespace
diff --git a/src/tint/ir/validate_test.cc b/src/tint/ir/validate_test.cc
index d49f553..2569415 100644
--- a/src/tint/ir/validate_test.cc
+++ b/src/tint/ir/validate_test.cc
@@ -528,5 +528,189 @@
 )");
 }
 
+TEST_F(IR_ValidateTest, Var_RootBlock_NullResult) {
+    auto* v = mod.instructions.Create<ir::Var>(nullptr);
+    b.RootBlock()->Append(v);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:2:11 error: var: result is a nullptr
+  undef = var
+          ^^^
+
+:1:1 note: In block
+%b1 = block {  # root
+^^^^^^^^^^^
+
+note: # Disassembly
+%b1 = block {  # root
+  undef = var
+}
+
+)");
+}
+
+TEST_F(IR_ValidateTest, Var_Function_NullResult) {
+    auto* v = mod.instructions.Create<ir::Var>(nullptr);
+
+    auto* f = b.Function("my_func", ty.void_());
+    mod.functions.Push(f);
+
+    auto sb = b.With(f->StartTarget());
+    sb.Append(v);
+    sb.Return(f);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:13 error: var: result is a nullptr
+    undef = var
+            ^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    undef = var
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Var_Init_WrongType) {
+    auto* f = b.Function("my_func", ty.void_());
+    mod.functions.Push(f);
+
+    auto sb = b.With(f->StartTarget());
+    auto* v = sb.Var(ty.ptr<function, f32>());
+    sb.Return(f);
+
+    auto* result = sb.InstructionResult(ty.i32());
+    v->SetInitializer(result);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: var initializer has incorrect type
+    %2:ptr<function, f32, read_write> = var, %3
+                                        ^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    %2:ptr<function, f32, read_write> = var, %3
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Instruction_AppendedDead) {
+    auto* f = b.Function("my_func", ty.void_());
+    mod.functions.Push(f);
+
+    auto sb = b.With(f->StartTarget());
+    auto* v = sb.Var(ty.ptr<function, f32>());
+    auto* ret = sb.Return(f);
+
+    v->Destroy();
+    v->InsertBefore(ret);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: destroyed instruction found in instruction list
+    %2:ptr<function, f32, read_write> = var
+                                        ^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+:3:41 error: instruction result source is undefined
+    %2:ptr<function, f32, read_write> = var
+                                        ^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    %2:ptr<function, f32, read_write> = var
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Instruction_NullSource) {
+    auto* f = b.Function("my_func", ty.void_());
+    mod.functions.Push(f);
+
+    auto sb = b.With(f->StartTarget());
+    auto* v = sb.Var(ty.ptr<function, f32>());
+    sb.Return(f);
+
+    v->Result()->SetSource(nullptr);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: instruction result source is undefined
+    %2:ptr<function, f32, read_write> = var
+                                        ^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    %2:ptr<function, f32, read_write> = var
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Instruction_DeadOperand) {
+    auto* f = b.Function("my_func", ty.void_());
+    mod.functions.Push(f);
+
+    auto sb = b.With(f->StartTarget());
+    auto* v = sb.Var(ty.ptr<function, f32>());
+    sb.Return(f);
+
+    auto* result = sb.InstructionResult(ty.f32());
+    result->Destroy();
+    v->SetInitializer(result);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: instruction has undefined operand
+    %2:ptr<function, f32, read_write> = var, %3
+                                        ^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    %2:ptr<function, f32, read_write> = var, %3
+    ret
+  }
+}
+)");
+}
+
 }  // namespace
 }  // namespace tint::ir