diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index c0dbf31..3f2d289 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -226,6 +226,11 @@
       Instruction{spv::Op::OpCapability, {Operand::Int(cap)}});
 }
 
+void Builder::GenerateLabel(uint32_t id) {
+  push_function_inst(spv::Op::OpLabel, {Operand::Int(id)});
+  current_label_id_ = id;
+}
+
 uint32_t Builder::GenerateU32Literal(uint32_t val) {
   ast::type::U32Type u32;
   ast::SintLiteral lit(&u32, val);
@@ -1083,7 +1088,72 @@
   return result_id;
 }
 
+uint32_t Builder::GenerateShortCircuitBinaryExpression(
+    ast::BinaryExpression* expr) {
+  auto lhs_id = GenerateExpression(expr->lhs());
+  if (lhs_id == 0) {
+    return false;
+  }
+  lhs_id = GenerateLoadIfNeeded(expr->lhs()->result_type(), lhs_id);
+
+  auto original_label_id = current_label_id_;
+
+  auto type_id = GenerateTypeIfNeeded(expr->result_type());
+  if (type_id == 0) {
+    return 0;
+  }
+
+  auto merge_block = result_op();
+  auto merge_block_id = merge_block.to_i();
+
+  auto block = result_op();
+  auto block_id = block.to_i();
+
+  auto true_block_id = block_id;
+  auto false_block_id = merge_block_id;
+
+  // For a logical or we want to only check the RHS if the LHS is failed.
+  if (expr->IsLogicalOr()) {
+    std::swap(true_block_id, false_block_id);
+  }
+
+  push_function_inst(spv::Op::OpSelectionMerge,
+                     {Operand::Int(merge_block_id),
+                      Operand::Int(SpvSelectionControlMaskNone)});
+  push_function_inst(spv::Op::OpBranchConditional,
+                     {Operand::Int(lhs_id), Operand::Int(true_block_id),
+                      Operand::Int(false_block_id)});
+
+  // Output block to check the RHS
+  GenerateLabel(block_id);
+  auto rhs_id = GenerateExpression(expr->rhs());
+  if (rhs_id == 0) {
+    return 0;
+  }
+  rhs_id = GenerateLoadIfNeeded(expr->rhs()->result_type(), rhs_id);
+
+  push_function_inst(spv::Op::OpBranch, {Operand::Int(merge_block_id)});
+
+  // Output the merge block
+  GenerateLabel(merge_block_id);
+
+  auto result = result_op();
+  auto result_id = result.to_i();
+
+  push_function_inst(spv::Op::OpPhi,
+                     {Operand::Int(type_id), result, Operand::Int(lhs_id),
+                      Operand::Int(original_label_id), Operand::Int(rhs_id),
+                      Operand::Int(block_id)});
+
+  return result_id;
+}
+
 uint32_t Builder::GenerateBinaryExpression(ast::BinaryExpression* expr) {
+  // There is special logic for short circuiting operators.
+  if (expr->IsLogicalAnd() || expr->IsLogicalOr()) {
+    return GenerateShortCircuitBinaryExpression(expr);
+  }
+
   auto lhs_id = GenerateExpression(expr->lhs());
   if (lhs_id == 0) {
     return 0;
@@ -1466,7 +1536,7 @@
                       Operand::Int(false_block_id)});
 
   // Output true block
-  push_function_inst(spv::Op::OpLabel, {true_block});
+  GenerateLabel(true_block_id);
   if (!GenerateStatementList(true_body)) {
     return false;
   }
@@ -1477,7 +1547,7 @@
 
   // Start the false block if needed
   if (false_block_id != merge_block_id) {
-    push_function_inst(spv::Op::OpLabel, {Operand::Int(false_block_id)});
+    GenerateLabel(false_block_id);
 
     auto* else_stmt = else_stmts[cur_else_idx].get();
     // Handle the else case by just outputting the statements.
@@ -1497,7 +1567,7 @@
   }
 
   // Output the merge block
-  push_function_inst(spv::Op::OpLabel, {merge_block});
+  GenerateLabel(merge_block_id);
 
   return true;
 }
@@ -1568,7 +1638,7 @@
       generated_default = true;
     }
 
-    push_function_inst(spv::Op::OpLabel, {Operand::Int(case_ids[i])});
+    GenerateLabel(case_ids[i]);
     if (!GenerateStatementList(item->body())) {
       return false;
     }
@@ -1585,13 +1655,13 @@
   }
 
   if (!generated_default) {
-    push_function_inst(spv::Op::OpLabel, {Operand::Int(default_block_id)});
+    GenerateLabel(default_block_id);
     push_function_inst(spv::Op::OpBranch, {Operand::Int(merge_block_id)});
   }
 
   merge_stack_.pop_back();
 
-  push_function_inst(spv::Op::OpLabel, {Operand::Int(merge_block_id)});
+  GenerateLabel(merge_block_id);
   return true;
 }
 
@@ -1613,7 +1683,7 @@
   auto loop_header = result_op();
   auto loop_header_id = loop_header.to_i();
   push_function_inst(spv::Op::OpBranch, {Operand::Int(loop_header_id)});
-  push_function_inst(spv::Op::OpLabel, {loop_header});
+  GenerateLabel(loop_header_id);
 
   auto merge_block = result_op();
   auto merge_block_id = merge_block.to_i();
@@ -1632,7 +1702,7 @@
   merge_stack_.push_back(merge_block_id);
 
   push_function_inst(spv::Op::OpBranch, {Operand::Int(body_block_id)});
-  push_function_inst(spv::Op::OpLabel, {body_block});
+  GenerateLabel(body_block_id);
   if (!GenerateStatementList(stmt->body())) {
     return false;
   }
@@ -1642,7 +1712,7 @@
     push_function_inst(spv::Op::OpBranch, {Operand::Int(continue_block_id)});
   }
 
-  push_function_inst(spv::Op::OpLabel, {continue_block});
+  GenerateLabel(continue_block_id);
   if (!GenerateStatementList(stmt->continuing())) {
     return false;
   }
@@ -1651,7 +1721,7 @@
   merge_stack_.pop_back();
   continue_stack_.pop_back();
 
-  push_function_inst(spv::Op::OpLabel, {merge_block});
+  GenerateLabel(merge_block_id);
 
   return true;
 }
diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h
index 094add4..a111094 100644
--- a/src/writer/spirv/builder.h
+++ b/src/writer/spirv/builder.h
@@ -159,7 +159,10 @@
 
   /// Adds a function to the builder
   /// @param func the function to add
-  void push_function(const Function& func) { functions_.push_back(func); }
+  void push_function(const Function& func) {
+    functions_.push_back(func);
+    current_label_id_ = func.label_id();
+  }
   /// @returns the functions
   const std::vector<Function>& functions() const { return functions_; }
   /// Pushes an instruction to the current function
@@ -183,6 +186,9 @@
   /// @returns the SPIR-V builtin or SpvBuiltInMax on error.
   SpvBuiltIn ConvertBuiltin(ast::Builtin builtin) const;
 
+  /// Generates a label for the given id
+  /// @param id the id to use for the label
+  void GenerateLabel(uint32_t id);
   /// Generates a uint32_t literal.
   /// @param val the value to generate
   /// @returns the ID of the generated literal
@@ -291,6 +297,10 @@
   /// @param expr the expression to generate
   /// @returns the expression ID on success or 0 otherwise
   uint32_t GenerateBinaryExpression(ast::BinaryExpression* expr);
+  /// Generates a short circuting binary expression
+  /// @param expr the expression to generate
+  /// @returns teh expression ID on success or 0 otherwise
+  uint32_t GenerateShortCircuitBinaryExpression(ast::BinaryExpression* expr);
   /// Generates a call expression
   /// @param expr the expression to generate
   /// @returns the expression ID on success or 0 otherwise
@@ -395,6 +405,7 @@
   ast::Module* mod_;
   std::string error_;
   uint32_t next_id_ = 1;
+  uint32_t current_label_id_ = 0;
   std::vector<Instruction> capabilities_;
   std::vector<Instruction> preamble_;
   std::vector<Instruction> debug_;
diff --git a/src/writer/spirv/builder_binary_expression_test.cc b/src/writer/spirv/builder_binary_expression_test.cc
index 3d4899f..62986ec 100644
--- a/src/writer/spirv/builder_binary_expression_test.cc
+++ b/src/writer/spirv/builder_binary_expression_test.cc
@@ -16,10 +16,12 @@
 
 #include "gtest/gtest.h"
 #include "src/ast/binary_expression.h"
+#include "src/ast/bool_literal.h"
 #include "src/ast/float_literal.h"
 #include "src/ast/identifier_expression.h"
 #include "src/ast/scalar_constructor_expression.h"
 #include "src/ast/sint_literal.h"
+#include "src/ast/type/bool_type.h"
 #include "src/ast/type/f32_type.h"
 #include "src/ast/type/i32_type.h"
 #include "src/ast/type/matrix_type.h"
@@ -866,6 +868,216 @@
 )");
 }
 
+TEST_F(BuilderTest, Binary_LogicalAnd) {
+  ast::type::I32Type i32;
+
+  auto lhs = std::make_unique<ast::BinaryExpression>(
+      ast::BinaryOp::kEqual,
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 1)),
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 2)));
+
+  auto rhs = std::make_unique<ast::BinaryExpression>(
+      ast::BinaryOp::kEqual,
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 3)),
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 4)));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, std::move(lhs),
+                             std::move(rhs));
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  b.GenerateLabel(b.next_id());
+
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
+%3 = OpConstant %2 1
+%4 = OpConstant %2 2
+%6 = OpTypeBool
+%9 = OpConstant %2 3
+%10 = OpConstant %2 4
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%1 = OpLabel
+%5 = OpIEqual %6 %3 %4
+OpSelectionMerge %7 None
+OpBranchConditional %5 %8 %7
+%8 = OpLabel
+%11 = OpIEqual %6 %9 %10
+OpBranch %7
+%7 = OpLabel
+%12 = OpPhi %6 %5 %1 %11 %8
+)");
+}
+
+TEST_F(BuilderTest, Binary_LogicalAnd_WithLoads) {
+  ast::type::BoolType bool_type;
+
+  auto a_var = std::make_unique<ast::Variable>(
+      "a", ast::StorageClass::kFunction, &bool_type);
+  a_var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, true)));
+  auto b_var = std::make_unique<ast::Variable>(
+      "b", ast::StorageClass::kFunction, &bool_type);
+  b_var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, false)));
+
+  auto lhs = std::make_unique<ast::IdentifierExpression>("a");
+  auto rhs = std::make_unique<ast::IdentifierExpression>("b");
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(a_var.get());
+  td.RegisterVariableForTesting(b_var.get());
+
+  ast::BinaryExpression expr(ast::BinaryOp::kLogicalAnd, std::move(lhs),
+                             std::move(rhs));
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  b.GenerateLabel(b.next_id());
+
+  ASSERT_TRUE(b.GenerateGlobalVariable(a_var.get())) << b.error();
+  ASSERT_TRUE(b.GenerateGlobalVariable(b_var.get())) << b.error();
+
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
+%3 = OpConstantTrue %2
+%5 = OpTypePointer Function %2
+%4 = OpVariable %5 Function %3
+%6 = OpConstantFalse %2
+%7 = OpVariable %5 Function %6
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%1 = OpLabel
+%8 = OpLoad %2 %4
+OpSelectionMerge %9 None
+OpBranchConditional %8 %10 %9
+%10 = OpLabel
+%11 = OpLoad %2 %7
+OpBranch %9
+%9 = OpLabel
+%12 = OpPhi %2 %8 %1 %11 %10
+)");
+}
+
+TEST_F(BuilderTest, Binary_LogicalOr) {
+  ast::type::I32Type i32;
+
+  auto lhs = std::make_unique<ast::BinaryExpression>(
+      ast::BinaryOp::kEqual,
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 1)),
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 2)));
+
+  auto rhs = std::make_unique<ast::BinaryExpression>(
+      ast::BinaryOp::kEqual,
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 3)),
+      std::make_unique<ast::ScalarConstructorExpression>(
+          std::make_unique<ast::SintLiteral>(&i32, 4)));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, std::move(lhs),
+                             std::move(rhs));
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  b.GenerateLabel(b.next_id());
+
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
+%3 = OpConstant %2 1
+%4 = OpConstant %2 2
+%6 = OpTypeBool
+%9 = OpConstant %2 3
+%10 = OpConstant %2 4
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%1 = OpLabel
+%5 = OpIEqual %6 %3 %4
+OpSelectionMerge %7 None
+OpBranchConditional %5 %7 %8
+%8 = OpLabel
+%11 = OpIEqual %6 %9 %10
+OpBranch %7
+%7 = OpLabel
+%12 = OpPhi %6 %5 %1 %11 %8
+)");
+}
+
+TEST_F(BuilderTest, Binary_LogicalOr_WithLoads) {
+  ast::type::BoolType bool_type;
+
+  auto a_var = std::make_unique<ast::Variable>(
+      "a", ast::StorageClass::kFunction, &bool_type);
+  a_var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, true)));
+  auto b_var = std::make_unique<ast::Variable>(
+      "b", ast::StorageClass::kFunction, &bool_type);
+  b_var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, false)));
+
+  auto lhs = std::make_unique<ast::IdentifierExpression>("a");
+  auto rhs = std::make_unique<ast::IdentifierExpression>("b");
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(a_var.get());
+  td.RegisterVariableForTesting(b_var.get());
+
+  ast::BinaryExpression expr(ast::BinaryOp::kLogicalOr, std::move(lhs),
+                             std::move(rhs));
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  b.GenerateLabel(b.next_id());
+
+  ASSERT_TRUE(b.GenerateGlobalVariable(a_var.get())) << b.error();
+  ASSERT_TRUE(b.GenerateGlobalVariable(b_var.get())) << b.error();
+
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 12u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool
+%3 = OpConstantTrue %2
+%5 = OpTypePointer Function %2
+%4 = OpVariable %5 Function %3
+%6 = OpConstantFalse %2
+%7 = OpVariable %5 Function %6
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%1 = OpLabel
+%8 = OpLoad %2 %4
+OpSelectionMerge %9 None
+OpBranchConditional %8 %9 %10
+%10 = OpLabel
+%11 = OpLoad %2 %7
+OpBranch %9
+%9 = OpLabel
+%12 = OpPhi %2 %8 %1 %11 %10
+)");
+}
+
 }  // namespace
 }  // namespace spirv
 }  // namespace writer
diff --git a/src/writer/spirv/function.h b/src/writer/spirv/function.h
index 26ddfa7..ddc2d0d 100644
--- a/src/writer/spirv/function.h
+++ b/src/writer/spirv/function.h
@@ -52,6 +52,9 @@
   /// @returns the declaration
   const Instruction& declaration() const { return declaration_; }
 
+  /// @returns the function label id
+  uint32_t label_id() const { return label_op_.to_i(); }
+
   /// Adds an instruction to the instruction list
   /// @param op the op to set
   /// @param operands the operands for the instruction