diff --git a/compiler/gen_wasm/src/backend.rs b/compiler/gen_wasm/src/backend.rs
index e4f3e200b2..d90abe2859 100644
--- a/compiler/gen_wasm/src/backend.rs
+++ b/compiler/gen_wasm/src/backend.rs
@@ -4,7 +4,7 @@ use code_builder::Align;
 use roc_collections::all::MutMap;
 use roc_module::symbol::Symbol;
 use roc_mono::ir::{CallType, Expr, JoinPointId, Literal, Proc, Stmt};
-use roc_mono::layout::{Layout, LayoutIds};
+use roc_mono::layout::{Builtin, Layout, LayoutIds};
 
 use crate::layout::WasmLayout;
 use crate::low_level::{build_call_low_level, LowlevelBuildResult};
@@ -326,6 +326,7 @@ impl<'a> WasmBackend<'a> {
                     self.start_block(BlockType::NoResult)
                 }
 
+                let is_bool = matches!(cond_layout, Layout::Builtin(Builtin::Int1));
                 let cond_type = WasmLayout::new(cond_layout).value_type();
 
                 // then, we jump whenever the value under scrutiny is equal to the value of a branch
@@ -334,22 +335,29 @@ impl<'a> WasmBackend<'a> {
                     self.storage
                         .load_symbols(&mut self.code_builder, &[*cond_symbol]);
 
-                    match cond_type {
-                        ValueType::I32 => {
-                            self.code_builder.i32_const(*value as i32);
-                            self.code_builder.i32_eq();
+                    if is_bool {
+                        // We already have a bool, don't need to compare against a const to get one
+                        if *value == 0 {
+                            self.code_builder.i32_eqz();
                         }
-                        ValueType::I64 => {
-                            self.code_builder.i64_const(*value as i64);
-                            self.code_builder.i64_eq();
-                        }
-                        ValueType::F32 => {
-                            self.code_builder.f32_const(f32::from_bits(*value as u32));
-                            self.code_builder.f32_eq();
-                        }
-                        ValueType::F64 => {
-                            self.code_builder.f64_const(f64::from_bits(*value as u64));
-                            self.code_builder.f64_eq();
+                    } else {
+                        match cond_type {
+                            ValueType::I32 => {
+                                self.code_builder.i32_const(*value as i32);
+                                self.code_builder.i32_eq();
+                            }
+                            ValueType::I64 => {
+                                self.code_builder.i64_const(*value as i64);
+                                self.code_builder.i64_eq();
+                            }
+                            ValueType::F32 => {
+                                self.code_builder.f32_const(f32::from_bits(*value as u32));
+                                self.code_builder.f32_eq();
+                            }
+                            ValueType::F64 => {
+                                self.code_builder.f64_const(f64::from_bits(*value as u64));
+                                self.code_builder.f64_eq();
+                            }
                         }
                     }