diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml
index 8166fb0f7c2..08c02af519f 100644
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@@ -44,7 +44,7 @@ jobs:
           save-if: ${{ github.event_name != 'merge_group' }}
 
       - name: Run `cargo clippy`
-        run: cargo clippy --workspace --locked --release
+        run: cargo clippy --all-targets --workspace --locked --release
 
       - name: Run `cargo fmt`
         run: cargo fmt --all --check
diff --git a/Cargo.lock b/Cargo.lock
index 859579c077f..a8c63c032aa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -462,7 +462,6 @@ dependencies = [
  "dirs",
  "flate2",
  "reqwest",
- "serde",
  "serde_json",
  "tar",
  "tempfile",
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index ef874d45f88..f18997d5d7f 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -54,8 +54,8 @@ pub const NOIR_ARTIFACT_VERSION_STRING: &str =
 #[derive(Args, Clone, Debug, Default)]
 pub struct CompileOptions {
     /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width)]
-    pub expression_width: Option<ExpressionWidth>,
+    #[arg(long, value_parser = parse_expression_width, default_value = "3")]
+    pub expression_width: ExpressionWidth,
 
     /// Force a full recompilation.
     #[arg(long = "force")]
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index 873ebe51e6f..f660c8e0b7a 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1328,7 +1328,15 @@ impl<'block> BrilligBlock<'block> {
 
         self.brillig_context.binary_instruction(left, right, result_variable, brillig_binary_op);
 
-        self.add_overflow_check(brillig_binary_op, left, right, result_variable, is_signed);
+        self.add_overflow_check(
+            brillig_binary_op,
+            left,
+            right,
+            result_variable,
+            binary,
+            dfg,
+            is_signed,
+        );
     }
 
     /// Splits a two's complement signed integer in the sign bit and the absolute value.
@@ -1481,15 +1489,20 @@ impl<'block> BrilligBlock<'block> {
         self.brillig_context.deallocate_single_addr(bias);
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn add_overflow_check(
         &mut self,
         binary_operation: BrilligBinaryOp,
         left: SingleAddrVariable,
         right: SingleAddrVariable,
         result: SingleAddrVariable,
+        binary: &Binary,
+        dfg: &DataFlowGraph,
         is_signed: bool,
     ) {
         let bit_size = left.bit_size;
+        let max_lhs_bits = dfg.get_value_max_num_bits(binary.lhs);
+        let max_rhs_bits = dfg.get_value_max_num_bits(binary.rhs);
 
         if bit_size == FieldElement::max_num_bits() {
             return;
@@ -1497,6 +1510,11 @@ impl<'block> BrilligBlock<'block> {
 
         match (binary_operation, is_signed) {
             (BrilligBinaryOp::Add, false) => {
+                if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
+                    // `left` and `right` have both been casted up from smaller types and so cannot overflow.
+                    return;
+                }
+
                 let condition =
                     SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that lhs <= result
@@ -1511,6 +1529,12 @@ impl<'block> BrilligBlock<'block> {
                 self.brillig_context.deallocate_single_addr(condition);
             }
             (BrilligBinaryOp::Sub, false) => {
+                if dfg.is_constant(binary.lhs) && max_lhs_bits > max_rhs_bits {
+                    // `left` is a fixed constant and `right` is restricted such that `left - right > 0`
+                    // Note strict inequality as `right > left` while `max_lhs_bits == max_rhs_bits` is possible.
+                    return;
+                }
+
                 let condition =
                     SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
                 // Check that rhs <= lhs
@@ -1527,39 +1551,36 @@ impl<'block> BrilligBlock<'block> {
                 self.brillig_context.deallocate_single_addr(condition);
             }
             (BrilligBinaryOp::Mul, false) => {
-                // Multiplication overflow is only possible for bit sizes > 1
-                if bit_size > 1 {
-                    let is_right_zero =
-                        SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
-                    let zero =
-                        self.brillig_context.make_constant_instruction(0_usize.into(), bit_size);
-                    self.brillig_context.binary_instruction(
-                        zero,
-                        right,
-                        is_right_zero,
-                        BrilligBinaryOp::Equals,
-                    );
-                    self.brillig_context.codegen_if_not(is_right_zero.address, |ctx| {
-                        let condition = SingleAddrVariable::new(ctx.allocate_register(), 1);
-                        let division = SingleAddrVariable::new(ctx.allocate_register(), bit_size);
-                        // Check that result / rhs == lhs
-                        ctx.binary_instruction(
-                            result,
-                            right,
-                            division,
-                            BrilligBinaryOp::UnsignedDiv,
-                        );
-                        ctx.binary_instruction(division, left, condition, BrilligBinaryOp::Equals);
-                        ctx.codegen_constrain(
-                            condition,
-                            Some("attempt to multiply with overflow".to_string()),
-                        );
-                        ctx.deallocate_single_addr(condition);
-                        ctx.deallocate_single_addr(division);
-                    });
-                    self.brillig_context.deallocate_single_addr(is_right_zero);
-                    self.brillig_context.deallocate_single_addr(zero);
+                if bit_size == 1 || max_lhs_bits + max_rhs_bits <= bit_size {
+                    // Either performing boolean multiplication (which cannot overflow),
+                    // or `left` and `right` have both been casted up from smaller types and so cannot overflow.
+                    return;
                 }
+
+                let is_right_zero =
+                    SingleAddrVariable::new(self.brillig_context.allocate_register(), 1);
+                let zero = self.brillig_context.make_constant_instruction(0_usize.into(), bit_size);
+                self.brillig_context.binary_instruction(
+                    zero,
+                    right,
+                    is_right_zero,
+                    BrilligBinaryOp::Equals,
+                );
+                self.brillig_context.codegen_if_not(is_right_zero.address, |ctx| {
+                    let condition = SingleAddrVariable::new(ctx.allocate_register(), 1);
+                    let division = SingleAddrVariable::new(ctx.allocate_register(), bit_size);
+                    // Check that result / rhs == lhs
+                    ctx.binary_instruction(result, right, division, BrilligBinaryOp::UnsignedDiv);
+                    ctx.binary_instruction(division, left, condition, BrilligBinaryOp::Equals);
+                    ctx.codegen_constrain(
+                        condition,
+                        Some("attempt to multiply with overflow".to_string()),
+                    );
+                    ctx.deallocate_single_addr(condition);
+                    ctx.deallocate_single_addr(division);
+                });
+                self.brillig_context.deallocate_single_addr(is_right_zero);
+                self.brillig_context.deallocate_single_addr(zero);
             }
             _ => {}
         }
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 2e2f03a0012..dea7e2fa13b 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -1837,15 +1837,15 @@ impl<'a> Context<'a> {
 
         let binary_type = AcirType::from(binary_type);
         let bit_count = binary_type.bit_size();
-
-        match binary.operator {
+        let num_type = binary_type.to_numeric_type();
+        let result = match binary.operator {
             BinaryOp::Add => self.acir_context.add_var(lhs, rhs),
             BinaryOp::Sub => self.acir_context.sub_var(lhs, rhs),
             BinaryOp::Mul => self.acir_context.mul_var(lhs, rhs),
             BinaryOp::Div => self.acir_context.div_var(
                 lhs,
                 rhs,
-                binary_type,
+                binary_type.clone(),
                 self.current_side_effects_enabled_var,
             ),
             // Note: that this produces unnecessary constraints when
@@ -1869,7 +1869,71 @@ impl<'a> Context<'a> {
             BinaryOp::Shl | BinaryOp::Shr => unreachable!(
                 "ICE - bit shift operators do not exist in ACIR and should have been replaced"
             ),
+        }?;
+
+        if let NumericType::Unsigned { bit_size } = &num_type {
+            // Check for integer overflow
+            self.check_unsigned_overflow(
+                result,
+                *bit_size,
+                binary.lhs,
+                binary.rhs,
+                dfg,
+                binary.operator,
+            )?;
         }
+
+        Ok(result)
+    }
+
+    /// Adds a range check against the bit size of the result of addition, subtraction or multiplication
+    fn check_unsigned_overflow(
+        &mut self,
+        result: AcirVar,
+        bit_size: u32,
+        lhs: ValueId,
+        rhs: ValueId,
+        dfg: &DataFlowGraph,
+        op: BinaryOp,
+    ) -> Result<(), RuntimeError> {
+        // We try to optimize away operations that are guaranteed not to overflow
+        let max_lhs_bits = dfg.get_value_max_num_bits(lhs);
+        let max_rhs_bits = dfg.get_value_max_num_bits(rhs);
+
+        let msg = match op {
+            BinaryOp::Add => {
+                if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
+                    // `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
+                    return Ok(());
+                }
+                "attempt to add with overflow".to_string()
+            }
+            BinaryOp::Sub => {
+                if dfg.is_constant(lhs) && max_lhs_bits > max_rhs_bits {
+                    // `lhs` is a fixed constant and `rhs` is restricted such that `lhs - rhs > 0`
+                    // Note strict inequality as `rhs > lhs` while `max_lhs_bits == max_rhs_bits` is possible.
+                    return Ok(());
+                }
+                "attempt to subtract with overflow".to_string()
+            }
+            BinaryOp::Mul => {
+                if bit_size == 1 || max_lhs_bits + max_rhs_bits <= bit_size {
+                    // Either performing boolean multiplication (which cannot overflow),
+                    // or `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
+                    return Ok(());
+                }
+                "attempt to multiply with overflow".to_string()
+            }
+            _ => return Ok(()),
+        };
+
+        let with_pred = self.acir_context.mul_var(result, self.current_side_effects_enabled_var)?;
+        self.acir_context.range_constrain_var(
+            with_pred,
+            &NumericType::Unsigned { bit_size },
+            Some(msg),
+        )?;
+        Ok(())
     }
 
     /// Operands in a binary operation are checked to have the same type.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index 42727054503..65a77552c79 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -109,7 +109,7 @@ impl Context<'_> {
                     return InsertInstructionResult::SimplifiedTo(zero).first();
                 }
             }
-            let pow = self.numeric_constant(FieldElement::from(rhs_bit_size_pow_2), typ);
+            let pow = self.numeric_constant(FieldElement::from(rhs_bit_size_pow_2), typ.clone());
 
             let max_lhs_bits = self.function.dfg.get_value_max_num_bits(lhs);
 
@@ -123,15 +123,18 @@ impl Context<'_> {
             // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
             let rhs_unsigned = self.insert_cast(rhs, Type::unsigned(bit_size));
             let pow = self.pow(base, rhs_unsigned);
-            let pow = self.insert_cast(pow, typ);
+            let pow = self.insert_cast(pow, typ.clone());
             (FieldElement::max_num_bits(), self.insert_binary(predicate, BinaryOp::Mul, pow))
         };
 
         if max_bit <= bit_size {
             self.insert_binary(lhs, BinaryOp::Mul, pow)
         } else {
-            let result = self.insert_binary(lhs, BinaryOp::Mul, pow);
-            self.insert_truncate(result, bit_size, max_bit)
+            let lhs_field = self.insert_cast(lhs, Type::field());
+            let pow_field = self.insert_cast(pow, Type::field());
+            let result = self.insert_binary(lhs_field, BinaryOp::Mul, pow_field);
+            let result = self.insert_truncate(result, bit_size, max_bit);
+            self.insert_cast(result, typ)
         }
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 02b9202b209..ea37d857e58 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -108,17 +108,19 @@ impl Context {
     fn responds_to_side_effects_var(dfg: &DataFlowGraph, instruction: &Instruction) -> bool {
         use Instruction::*;
         match instruction {
-            Binary(binary) => {
-                if matches!(binary.operator, BinaryOp::Div | BinaryOp::Mod) {
+            Binary(binary) => match binary.operator {
+                BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul => {
+                    dfg.type_of_value(binary.lhs).is_unsigned()
+                }
+                BinaryOp::Div | BinaryOp::Mod => {
                     if let Some(rhs) = dfg.get_numeric_constant(binary.rhs) {
                         rhs == FieldElement::zero()
                     } else {
                         true
                     }
-                } else {
-                    false
                 }
-            }
+                _ => false,
+            },
 
             Cast(_, _)
             | Not(_)
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index f7ecdc8870d..ebcbfbabe73 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -304,7 +304,7 @@ impl<'a> FunctionContext<'a> {
 
     /// Insert constraints ensuring that the operation does not overflow the bit size of the result
     ///
-    /// If the result is unsigned, we simply range check against the bit size
+    /// If the result is unsigned, overflow will be checked during acir-gen (cf. issue #4456), except for bit-shifts, because we will convert them to field multiplication
     ///
     /// If the result is signed, we just prepare it for check_signed_overflow() by casting it to
     /// an unsigned value representing the signed integer.
@@ -351,51 +351,12 @@ impl<'a> FunctionContext<'a> {
             }
             Type::Numeric(NumericType::Unsigned { bit_size }) => {
                 let dfg = &self.builder.current_function.dfg;
-
-                let max_lhs_bits = self.builder.current_function.dfg.get_value_max_num_bits(lhs);
-                let max_rhs_bits = self.builder.current_function.dfg.get_value_max_num_bits(rhs);
+                let max_lhs_bits = dfg.get_value_max_num_bits(lhs);
 
                 match operator {
-                    BinaryOpKind::Add => {
-                        if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
-                            // `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
-                            return result;
-                        }
-
-                        let message = "attempt to add with overflow".to_string();
-                        self.builder.set_location(location).insert_range_check(
-                            result,
-                            bit_size,
-                            Some(message),
-                        );
-                    }
-                    BinaryOpKind::Subtract => {
-                        if dfg.is_constant(lhs) && max_lhs_bits > max_rhs_bits {
-                            // `lhs` is a fixed constant and `rhs` is restricted such that `lhs - rhs > 0`
-                            // Note strict inequality as `rhs > lhs` while `max_lhs_bits == max_rhs_bits` is possible.
-                            return result;
-                        }
-
-                        let message = "attempt to subtract with overflow".to_string();
-                        self.builder.set_location(location).insert_range_check(
-                            result,
-                            bit_size,
-                            Some(message),
-                        );
-                    }
-                    BinaryOpKind::Multiply => {
-                        if bit_size == 1 || max_lhs_bits + max_rhs_bits <= bit_size {
-                            // Either performing boolean multiplication (which cannot overflow),
-                            // or `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
-                            return result;
-                        }
-
-                        let message = "attempt to multiply with overflow".to_string();
-                        self.builder.set_location(location).insert_range_check(
-                            result,
-                            bit_size,
-                            Some(message),
-                        );
+                    BinaryOpKind::Add | BinaryOpKind::Subtract | BinaryOpKind::Multiply => {
+                        // Overflow check is deferred to acir-gen
+                        return result;
                     }
                     BinaryOpKind::ShiftLeft => {
                         if let Some(rhs_const) = dfg.get_numeric_constant(rhs) {
diff --git a/compiler/noirc_frontend/src/ast/mod.rs b/compiler/noirc_frontend/src/ast/mod.rs
index 254ec4a7590..1c5a5c610aa 100644
--- a/compiler/noirc_frontend/src/ast/mod.rs
+++ b/compiler/noirc_frontend/src/ast/mod.rs
@@ -32,6 +32,7 @@ use iter_extended::vecmap;
 pub enum IntegerBitSize {
     One,
     Eight,
+    Sixteen,
     ThirtyTwo,
     SixtyFour,
 }
@@ -48,6 +49,7 @@ impl From<IntegerBitSize> for u32 {
         match size {
             One => 1,
             Eight => 8,
+            Sixteen => 16,
             ThirtyTwo => 32,
             SixtyFour => 64,
         }
@@ -64,6 +66,7 @@ impl TryFrom<u32> for IntegerBitSize {
         match value {
             1 => Ok(One),
             8 => Ok(Eight),
+            16 => Ok(Sixteen),
             32 => Ok(ThirtyTwo),
             64 => Ok(SixtyFour),
             _ => Err(InvalidIntegerBitSizeError(value)),
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 26b7c212a30..84df3a0a244 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -401,6 +401,14 @@ impl<'a> Interpreter<'a> {
                     let value = if is_negative { 0u8.wrapping_sub(value) } else { value };
                     Ok(Value::U8(value))
                 }
+                (Signedness::Unsigned, IntegerBitSize::Sixteen) => {
+                    let value: u16 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { 0u16.wrapping_sub(value) } else { value };
+                    Ok(Value::U16(value))
+                }
                 (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
                     let value: u32 =
                         value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
@@ -430,6 +438,14 @@ impl<'a> Interpreter<'a> {
                     let value = if is_negative { -value } else { value };
                     Ok(Value::I8(value))
                 }
+                (Signedness::Signed, IntegerBitSize::Sixteen) => {
+                    let value: i16 =
+                        value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
+                            InterpreterError::IntegerOutOfRangeForType { value, typ, location },
+                        )?;
+                    let value = if is_negative { -value } else { value };
+                    Ok(Value::I16(value))
+                }
                 (Signedness::Signed, IntegerBitSize::ThirtyTwo) => {
                     let value: i32 =
                         value.try_to_u64().and_then(|value| value.try_into().ok()).ok_or(
@@ -509,9 +525,11 @@ impl<'a> Interpreter<'a> {
             crate::ast::UnaryOp::Minus => match rhs {
                 Value::Field(value) => Ok(Value::Field(FieldElement::zero() - value)),
                 Value::I8(value) => Ok(Value::I8(-value)),
+                Value::I16(value) => Ok(Value::I16(-value)),
                 Value::I32(value) => Ok(Value::I32(-value)),
                 Value::I64(value) => Ok(Value::I64(-value)),
                 Value::U8(value) => Ok(Value::U8(0 - value)),
+                Value::U16(value) => Ok(Value::U16(0 - value)),
                 Value::U32(value) => Ok(Value::U32(0 - value)),
                 Value::U64(value) => Ok(Value::U64(0 - value)),
                 value => {
@@ -523,9 +541,11 @@ impl<'a> Interpreter<'a> {
             crate::ast::UnaryOp::Not => match rhs {
                 Value::Bool(value) => Ok(Value::Bool(!value)),
                 Value::I8(value) => Ok(Value::I8(!value)),
+                Value::I16(value) => Ok(Value::I16(!value)),
                 Value::I32(value) => Ok(Value::I32(!value)),
                 Value::I64(value) => Ok(Value::I64(!value)),
                 Value::U8(value) => Ok(Value::U8(!value)),
+                Value::U16(value) => Ok(Value::U16(!value)),
                 Value::U32(value) => Ok(Value::U32(!value)),
                 Value::U64(value) => Ok(Value::U64(!value)),
                 value => {
@@ -559,9 +579,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Add => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs + rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs + rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs + rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs + rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs + rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs + rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs + rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs + rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs + rhs)),
                 (lhs, rhs) => {
@@ -572,9 +594,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Subtract => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs - rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs - rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs - rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs - rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs - rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs - rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs - rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs - rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs - rhs)),
                 (lhs, rhs) => {
@@ -585,9 +609,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Multiply => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs * rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs * rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs * rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs * rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs * rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs * rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs * rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs * rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs * rhs)),
                 (lhs, rhs) => {
@@ -598,9 +624,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Divide => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Field(lhs / rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs / rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs / rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs / rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs / rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs / rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs / rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs / rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs / rhs)),
                 (lhs, rhs) => {
@@ -611,9 +639,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Equal => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs == rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs == rhs)),
                 (lhs, rhs) => {
@@ -624,9 +654,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::NotEqual => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs != rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs != rhs)),
                 (lhs, rhs) => {
@@ -637,9 +669,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Less => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs < rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs < rhs)),
                 (lhs, rhs) => {
@@ -650,9 +684,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::LessEqual => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs <= rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs <= rhs)),
                 (lhs, rhs) => {
@@ -663,9 +699,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Greater => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs > rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs > rhs)),
                 (lhs, rhs) => {
@@ -676,9 +714,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::GreaterEqual => match (lhs, rhs) {
                 (Value::Field(lhs), Value::Field(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::Bool(lhs >= rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::Bool(lhs >= rhs)),
                 (lhs, rhs) => {
@@ -689,9 +729,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::And => match (lhs, rhs) {
                 (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs & rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs & rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs & rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs & rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs & rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs & rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs & rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs & rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs & rhs)),
                 (lhs, rhs) => {
@@ -702,9 +744,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Or => match (lhs, rhs) {
                 (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs | rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs | rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs | rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs | rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs | rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs | rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs | rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs | rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs | rhs)),
                 (lhs, rhs) => {
@@ -715,9 +759,11 @@ impl<'a> Interpreter<'a> {
             BinaryOpKind::Xor => match (lhs, rhs) {
                 (Value::Bool(lhs), Value::Bool(rhs)) => Ok(Value::Bool(lhs ^ rhs)),
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs ^ rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs ^ rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs ^ rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs ^ rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs ^ rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs ^ rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs ^ rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs ^ rhs)),
                 (lhs, rhs) => {
@@ -727,9 +773,11 @@ impl<'a> Interpreter<'a> {
             },
             BinaryOpKind::ShiftRight => match (lhs, rhs) {
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs >> rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs >> rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs >> rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs >> rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs >> rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs >> rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs >> rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs >> rhs)),
                 (lhs, rhs) => {
@@ -739,9 +787,11 @@ impl<'a> Interpreter<'a> {
             },
             BinaryOpKind::ShiftLeft => match (lhs, rhs) {
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs << rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs << rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs << rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs << rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs << rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs << rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs << rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs << rhs)),
                 (lhs, rhs) => {
@@ -751,9 +801,11 @@ impl<'a> Interpreter<'a> {
             },
             BinaryOpKind::Modulo => match (lhs, rhs) {
                 (Value::I8(lhs), Value::I8(rhs)) => Ok(Value::I8(lhs % rhs)),
+                (Value::I16(lhs), Value::I16(rhs)) => Ok(Value::I16(lhs % rhs)),
                 (Value::I32(lhs), Value::I32(rhs)) => Ok(Value::I32(lhs % rhs)),
                 (Value::I64(lhs), Value::I64(rhs)) => Ok(Value::I64(lhs % rhs)),
                 (Value::U8(lhs), Value::U8(rhs)) => Ok(Value::U8(lhs % rhs)),
+                (Value::U16(lhs), Value::U16(rhs)) => Ok(Value::U16(lhs % rhs)),
                 (Value::U32(lhs), Value::U32(rhs)) => Ok(Value::U32(lhs % rhs)),
                 (Value::U64(lhs), Value::U64(rhs)) => Ok(Value::U64(lhs % rhs)),
                 (lhs, rhs) => {
@@ -795,9 +847,11 @@ impl<'a> Interpreter<'a> {
                 value.try_to_u64().expect("index could not fit into u64") as usize
             }
             Value::I8(value) => value as usize,
+            Value::I16(value) => value as usize,
             Value::I32(value) => value as usize,
             Value::I64(value) => value as usize,
             Value::U8(value) => value as usize,
+            Value::U16(value) => value as usize,
             Value::U32(value) => value as usize,
             Value::U64(value) => value as usize,
             value => {
@@ -908,9 +962,11 @@ impl<'a> Interpreter<'a> {
         let (mut lhs, lhs_is_negative) = match self.evaluate(cast.lhs)? {
             Value::Field(value) => (value, false),
             Value::U8(value) => ((value as u128).into(), false),
+            Value::U16(value) => ((value as u128).into(), false),
             Value::U32(value) => ((value as u128).into(), false),
             Value::U64(value) => ((value as u128).into(), false),
             Value::I8(value) => signed_int_to_field!(value),
+            Value::I16(value) => signed_int_to_field!(value),
             Value::I32(value) => signed_int_to_field!(value),
             Value::I64(value) => signed_int_to_field!(value),
             Value::Bool(value) => {
@@ -946,6 +1002,9 @@ impl<'a> Interpreter<'a> {
                     Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
                 }
                 (Signedness::Unsigned, IntegerBitSize::Eight) => cast_to_int!(lhs, to_u128, u8, U8),
+                (Signedness::Unsigned, IntegerBitSize::Sixteen) => {
+                    cast_to_int!(lhs, to_u128, u16, U16)
+                }
                 (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => {
                     cast_to_int!(lhs, to_u128, u32, U32)
                 }
@@ -957,6 +1016,9 @@ impl<'a> Interpreter<'a> {
                     Err(InterpreterError::TypeUnsupported { typ: cast.r#type, location })
                 }
                 (Signedness::Signed, IntegerBitSize::Eight) => cast_to_int!(lhs, to_i128, i8, I8),
+                (Signedness::Signed, IntegerBitSize::Sixteen) => {
+                    cast_to_int!(lhs, to_i128, i16, I16)
+                }
                 (Signedness::Signed, IntegerBitSize::ThirtyTwo) => {
                     cast_to_int!(lhs, to_i128, i32, I32)
                 }
@@ -1149,9 +1211,11 @@ impl<'a> Interpreter<'a> {
         let get_index = |this: &mut Self, expr| -> IResult<(_, fn(_) -> _)> {
             match this.evaluate(expr)? {
                 Value::I8(value) => Ok((value as i128, |i| Value::I8(i as i8))),
+                Value::I16(value) => Ok((value as i128, |i| Value::I16(i as i16))),
                 Value::I32(value) => Ok((value as i128, |i| Value::I32(i as i32))),
                 Value::I64(value) => Ok((value as i128, |i| Value::I64(i as i64))),
                 Value::U8(value) => Ok((value as i128, |i| Value::U8(i as u8))),
+                Value::U16(value) => Ok((value as i128, |i| Value::U16(i as u16))),
                 Value::U32(value) => Ok((value as i128, |i| Value::U32(i as u32))),
                 Value::U64(value) => Ok((value as i128, |i| Value::U64(i as u64))),
                 value => {
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 5a12eb7292c..41475d3ccf4 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -103,6 +103,19 @@ fn for_loop() {
     assert_eq!(result, Value::U8(15));
 }
 
+#[test]
+fn for_loop_u16() {
+    let program = "fn main() -> pub u16 {
+        let mut x = 0;
+        for i in 0 .. 6 {
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U16(15));
+}
+
 #[test]
 fn for_loop_with_break() {
     let program = "unconstrained fn main() -> pub u32 {
diff --git a/compiler/noirc_frontend/src/hir/comptime/value.rs b/compiler/noirc_frontend/src/hir/comptime/value.rs
index 6845c6ac5a9..4e4a260871a 100644
--- a/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -22,9 +22,11 @@ pub enum Value {
     Bool(bool),
     Field(FieldElement),
     I8(i8),
+    I16(i16),
     I32(i32),
     I64(i64),
     U8(u8),
+    U16(u16),
     U32(u32),
     U64(u64),
     String(Rc<String>),
@@ -45,9 +47,11 @@ impl Value {
             Value::Bool(_) => Type::Bool,
             Value::Field(_) => Type::FieldElement,
             Value::I8(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Eight),
+            Value::I16(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Sixteen),
             Value::I32(_) => Type::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo),
             Value::I64(_) => Type::Integer(Signedness::Signed, IntegerBitSize::SixtyFour),
             Value::U8(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+            Value::U16(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Sixteen),
             Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
             Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
             Value::String(value) => {
@@ -87,6 +91,12 @@ impl Value {
                 let value = (value as u128).into();
                 HirExpression::Literal(HirLiteral::Integer(value, negative))
             }
+            Value::I16(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                HirExpression::Literal(HirLiteral::Integer(value, negative))
+            }
             Value::I32(value) => {
                 let negative = value < 0;
                 let value = value.abs();
@@ -102,6 +112,9 @@ impl Value {
             Value::U8(value) => {
                 HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
             }
+            Value::U16(value) => {
+                HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
+            }
             Value::U32(value) => {
                 HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
             }
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index b627714d2a6..b527284d1a9 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -1374,7 +1374,7 @@ mod test {
                 fresh_statement(),
                 true,
             ),
-            vec!["x as u8", "0 as Field", "(x + 3) as [Field; 8]"],
+            vec!["x as u8", "x as u16", "0 as Field", "(x + 3) as [Field; 8]"],
         );
         parse_all_failing(
             atom_or_right_unary(
@@ -1546,7 +1546,10 @@ mod test {
         // Let statements are not type checked here, so the parser will accept as
         // long as it is a type. Other statements such as Public are type checked
         // Because for now, they can only have one type
-        parse_all(declaration(expression()), vec!["let _ = 42", "let x = y", "let x : u8 = y"]);
+        parse_all(
+            declaration(expression()),
+            vec!["let _ = 42", "let x = y", "let x : u8 = y", "let x: u16 = y"],
+        );
     }
 
     #[test]
diff --git a/docs/docs/noir/concepts/data_types/integers.md b/docs/docs/noir/concepts/data_types/integers.md
index 1c6b375db49..6b2d3773912 100644
--- a/docs/docs/noir/concepts/data_types/integers.md
+++ b/docs/docs/noir/concepts/data_types/integers.md
@@ -5,7 +5,9 @@ keywords: [noir, integer types, methods, examples, arithmetic]
 sidebar_position: 1
 ---
 
-An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
 
 :::info
 
diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
index b32a2969563..08370dde9e4 100644
--- a/docs/docs/noir/standard_library/traits.md
+++ b/docs/docs/noir/standard_library/traits.md
@@ -186,10 +186,10 @@ These traits abstract over addition, subtraction, multiplication, and division r
 Implementing these traits for a given type will also allow that type to be used with the corresponding operator
 for that trait (`+` for Add, etc) in addition to the normal method names.
 
-#include_code add-trait noir_stdlib/src/ops.nr rust
-#include_code sub-trait noir_stdlib/src/ops.nr rust
-#include_code mul-trait noir_stdlib/src/ops.nr rust
-#include_code div-trait noir_stdlib/src/ops.nr rust
+#include_code add-trait noir_stdlib/src/ops/arith.nr rust
+#include_code sub-trait noir_stdlib/src/ops/arith.nr rust
+#include_code mul-trait noir_stdlib/src/ops/arith.nr rust
+#include_code div-trait noir_stdlib/src/ops/arith.nr rust
 
 The implementations block below is given for the `Add` trait, but the same types that implement
 `Add` also implement `Sub`, `Mul`, and `Div`.
@@ -211,7 +211,7 @@ impl Add for u64 { .. }
 
 ### `std::ops::Rem`
 
-#include_code rem-trait noir_stdlib/src/ops.nr rust
+#include_code rem-trait noir_stdlib/src/ops/arith.nr rust
 
 `Rem::rem(a, b)` is the remainder function returning the result of what is
 left after dividing `a` and `b`. Implementing `Rem` allows the `%` operator
@@ -234,18 +234,18 @@ impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
 
 ### `std::ops::Neg`
 
-#include_code neg-trait noir_stdlib/src/ops.nr rust
+#include_code neg-trait noir_stdlib/src/ops/arith.nr rust
 
 `Neg::neg` is equivalent to the unary negation operator `-`.
 
 Implementations:
-#include_code neg-trait-impls noir_stdlib/src/ops.nr rust
+#include_code neg-trait-impls noir_stdlib/src/ops/arith.nr rust
 
 ### `std::ops::{ BitOr, BitAnd, BitXor }`
 
-#include_code bitor-trait noir_stdlib/src/ops.nr rust
-#include_code bitand-trait noir_stdlib/src/ops.nr rust
-#include_code bitxor-trait noir_stdlib/src/ops.nr rust
+#include_code bitor-trait noir_stdlib/src/ops/bit.nr rust
+#include_code bitand-trait noir_stdlib/src/ops/bit.nr rust
+#include_code bitxor-trait noir_stdlib/src/ops/bit.nr rust
 
 Traits for the bitwise operations `|`, `&`, and `^`.
 
@@ -272,8 +272,8 @@ impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
 
 ### `std::ops::{ Shl, Shr }`
 
-#include_code shl-trait noir_stdlib/src/ops.nr rust
-#include_code shr-trait noir_stdlib/src/ops.nr rust
+#include_code shl-trait noir_stdlib/src/ops/bit.nr rust
+#include_code shr-trait noir_stdlib/src/ops/bit.nr rust
 
 Traits for a bit shift left and bit shift right.
 
diff --git a/noir_stdlib/src/embedded_curve_ops.nr b/noir_stdlib/src/embedded_curve_ops.nr
index 6a1f17dae98..21d658db615 100644
--- a/noir_stdlib/src/embedded_curve_ops.nr
+++ b/noir_stdlib/src/embedded_curve_ops.nr
@@ -1,4 +1,4 @@
-use crate::ops::{Add, Sub, Neg};
+use crate::ops::arith::{Add, Sub, Neg};
 
 // TODO(https://github.com/noir-lang/noir/issues/4931)
 struct EmbeddedCurvePoint {
@@ -76,7 +76,4 @@ fn embedded_curve_add(
 }
 
 #[foreign(embedded_curve_add)]
-fn embedded_curve_add_array_return(
-    _point1: EmbeddedCurvePoint,
-    _point2: EmbeddedCurvePoint
-) -> [Field; 2] {}
+fn embedded_curve_add_array_return(_point1: EmbeddedCurvePoint, _point2: EmbeddedCurvePoint) -> [Field; 2] {}
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index e0814267aea..d7ea1dfd484 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -1,170 +1,5 @@
-// docs:start:add-trait
-trait Add {
-    fn add(self, other: Self) -> Self;
-}
-// docs:end:add-trait
-
-impl Add for Field { fn add(self, other: Field) -> Field { self + other } }
-
-impl Add for u64 { fn add(self, other: u64) -> u64 { self + other } }
-impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
-impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
-
-impl Add for i8 { fn add(self, other: i8) -> i8 { self + other } }
-impl Add for i32 { fn add(self, other: i32) -> i32 { self + other } }
-impl Add for i64 { fn add(self, other: i64) -> i64 { self + other } }
-
-// docs:start:sub-trait
-trait Sub {
-    fn sub(self, other: Self) -> Self;
-}
-// docs:end:sub-trait
-
-impl Sub for Field { fn sub(self, other: Field) -> Field { self - other } }
-
-impl Sub for u64 { fn sub(self, other: u64) -> u64 { self - other } }
-impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
-impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
-
-impl Sub for i8 { fn sub(self, other: i8) -> i8 { self - other } }
-impl Sub for i32 { fn sub(self, other: i32) -> i32 { self - other } }
-impl Sub for i64 { fn sub(self, other: i64) -> i64 { self - other } }
-
-// docs:start:mul-trait
-trait Mul {
-    fn mul(self, other: Self) -> Self;
-}
-// docs:end:mul-trait
-
-impl Mul for Field { fn mul(self, other: Field) -> Field { self * other } }
-
-impl Mul for u64 { fn mul(self, other: u64) -> u64 { self * other } }
-impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
-impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
-
-impl Mul for i8 { fn mul(self, other: i8) -> i8 { self * other } }
-impl Mul for i32 { fn mul(self, other: i32) -> i32 { self * other } }
-impl Mul for i64 { fn mul(self, other: i64) -> i64 { self * other } }
-
-// docs:start:div-trait
-trait Div {
-    fn div(self, other: Self) -> Self;
-}
-// docs:end:div-trait
-
-impl Div for Field { fn div(self, other: Field) -> Field { self / other } }
-
-impl Div for u64 { fn div(self, other: u64) -> u64 { self / other } }
-impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
-impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
-
-impl Div for i8 { fn div(self, other: i8) -> i8 { self / other } }
-impl Div for i32 { fn div(self, other: i32) -> i32 { self / other } }
-impl Div for i64 { fn div(self, other: i64) -> i64 { self / other } }
-
-// docs:start:rem-trait
-trait Rem{
-    fn rem(self, other: Self) -> Self;
-}
-// docs:end:rem-trait
-
-impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
-impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
-impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
-
-impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
-impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
-impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
-
-// docs:start:neg-trait
-trait Neg {
-    fn neg(self) -> Self;
-}
-// docs:end:neg-trait
-
-// docs:start:neg-trait-impls
-impl Neg for Field { fn neg(self) -> Field { -self } }
-
-impl Neg for i8 { fn neg(self) -> i8 { -self } }
-impl Neg for i32 { fn neg(self) -> i32 { -self } }
-impl Neg for i64 { fn neg(self) -> i64 { -self } }
-// docs:end:neg-trait-impls
-
-// docs:start:bitor-trait
-trait BitOr {
-    fn bitor(self, other: Self) -> Self;
-}
-// docs:end:bitor-trait
-
-impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
-
-impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
-impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
-impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
-
-impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
-impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
-impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
-
-// docs:start:bitand-trait
-trait BitAnd {
-    fn bitand(self, other: Self) -> Self;
-}
-// docs:end:bitand-trait
-
-impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
-
-impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
-impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
-impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
-
-impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
-impl BitAnd for i32 { fn bitand(self, other: i32) -> i32 { self & other } }
-impl BitAnd for i64 { fn bitand(self, other: i64) -> i64 { self & other } }
-
-// docs:start:bitxor-trait
-trait BitXor {
-    fn bitxor(self, other: Self) -> Self;
-}
-// docs:end:bitxor-trait
-
-impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
-
-impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
-impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
-impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
-
-impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
-impl BitXor for i32 { fn bitxor(self, other: i32) -> i32 { self ^ other } }
-impl BitXor for i64 { fn bitxor(self, other: i64) -> i64 { self ^ other } }
-
-// docs:start:shl-trait
-trait Shl {
-    fn shl(self, other: u8) -> Self;
-}
-// docs:end:shl-trait
-
-impl Shl for u32 { fn shl(self, other: u8) -> u32 { self << other } }
-impl Shl for u64 { fn shl(self, other: u8) -> u64 { self << other } }
-impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
-impl Shl for u1 { fn shl(self, other: u8) -> u1 { self << other } }
-
-impl Shl for i8 { fn shl(self, other: u8) -> i8 { self << other } }
-impl Shl for i32 { fn shl(self, other: u8) -> i32 { self << other } }
-impl Shl for i64 { fn shl(self, other: u8) -> i64 { self << other } }
-
-// docs:start:shr-trait
-trait Shr {
-    fn shr(self, other: u8) -> Self;
-}
-// docs:end:shr-trait
-
-impl Shr for u64 { fn shr(self, other: u8) -> u64 { self >> other } }
-impl Shr for u32 { fn shr(self, other: u8) -> u32 { self >> other } }
-impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
-impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
-
-impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
-impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
-impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
+mod arith;
+mod bit;
 
+use arith::{Add, Sub, Mul, Div, Rem, Neg};
+use bit::{BitOr, BitAnd, BitXor, Shl, Shr};
diff --git a/noir_stdlib/src/ops/arith.nr b/noir_stdlib/src/ops/arith.nr
new file mode 100644
index 00000000000..ea7d633a456
--- /dev/null
+++ b/noir_stdlib/src/ops/arith.nr
@@ -0,0 +1,92 @@
+// docs:start:add-trait
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+// docs:end:add-trait
+
+impl Add for Field { fn add(self, other: Field) -> Field { self + other } }
+
+impl Add for u64 { fn add(self, other: u64) -> u64 { self + other } }
+impl Add for u32 { fn add(self, other: u32) -> u32 { self + other } }
+impl Add for u8 { fn add(self, other: u8) -> u8 { self + other } }
+
+impl Add for i8 { fn add(self, other: i8) -> i8 { self + other } }
+impl Add for i32 { fn add(self, other: i32) -> i32 { self + other } }
+impl Add for i64 { fn add(self, other: i64) -> i64 { self + other } }
+
+// docs:start:sub-trait
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+// docs:end:sub-trait
+
+impl Sub for Field { fn sub(self, other: Field) -> Field { self - other } }
+
+impl Sub for u64 { fn sub(self, other: u64) -> u64 { self - other } }
+impl Sub for u32 { fn sub(self, other: u32) -> u32 { self - other } }
+impl Sub for u8 { fn sub(self, other: u8) -> u8 { self - other } }
+
+impl Sub for i8 { fn sub(self, other: i8) -> i8 { self - other } }
+impl Sub for i32 { fn sub(self, other: i32) -> i32 { self - other } }
+impl Sub for i64 { fn sub(self, other: i64) -> i64 { self - other } }
+
+// docs:start:mul-trait
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+// docs:end:mul-trait
+
+impl Mul for Field { fn mul(self, other: Field) -> Field { self * other } }
+
+impl Mul for u64 { fn mul(self, other: u64) -> u64 { self * other } }
+impl Mul for u32 { fn mul(self, other: u32) -> u32 { self * other } }
+impl Mul for u8 { fn mul(self, other: u8) -> u8 { self * other } }
+
+impl Mul for i8 { fn mul(self, other: i8) -> i8 { self * other } }
+impl Mul for i32 { fn mul(self, other: i32) -> i32 { self * other } }
+impl Mul for i64 { fn mul(self, other: i64) -> i64 { self * other } }
+
+// docs:start:div-trait
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+// docs:end:div-trait
+
+impl Div for Field { fn div(self, other: Field) -> Field { self / other } }
+
+impl Div for u64 { fn div(self, other: u64) -> u64 { self / other } }
+impl Div for u32 { fn div(self, other: u32) -> u32 { self / other } }
+impl Div for u8 { fn div(self, other: u8) -> u8 { self / other } }
+
+impl Div for i8 { fn div(self, other: i8) -> i8 { self / other } }
+impl Div for i32 { fn div(self, other: i32) -> i32 { self / other } }
+impl Div for i64 { fn div(self, other: i64) -> i64 { self / other } }
+
+// docs:start:rem-trait
+trait Rem{
+    fn rem(self, other: Self) -> Self;
+}
+// docs:end:rem-trait
+
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i32 { fn rem(self, other: i32) -> i32 { self % other } }
+impl Rem for i64 { fn rem(self, other: i64) -> i64 { self % other } }
+
+// docs:start:neg-trait
+trait Neg {
+    fn neg(self) -> Self;
+}
+// docs:end:neg-trait
+
+// docs:start:neg-trait-impls
+impl Neg for Field { fn neg(self) -> Field { -self } }
+
+impl Neg for i8 { fn neg(self) -> i8 { -self } }
+impl Neg for i32 { fn neg(self) -> i32 { -self } }
+impl Neg for i64 { fn neg(self) -> i64 { -self } }
+// docs:end:neg-trait-impls
+
diff --git a/noir_stdlib/src/ops/bit.nr b/noir_stdlib/src/ops/bit.nr
new file mode 100644
index 00000000000..8a3d20b1909
--- /dev/null
+++ b/noir_stdlib/src/ops/bit.nr
@@ -0,0 +1,78 @@
+// docs:start:bitor-trait
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+// docs:end:bitor-trait
+
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i32 { fn bitor(self, other: i32) -> i32 { self | other } }
+impl BitOr for i64 { fn bitor(self, other: i64) -> i64 { self | other } }
+
+// docs:start:bitand-trait
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+// docs:end:bitand-trait
+
+impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
+
+impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
+impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
+impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
+
+impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
+impl BitAnd for i32 { fn bitand(self, other: i32) -> i32 { self & other } }
+impl BitAnd for i64 { fn bitand(self, other: i64) -> i64 { self & other } }
+
+// docs:start:bitxor-trait
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+// docs:end:bitxor-trait
+
+impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
+
+impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
+impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
+impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
+
+impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
+impl BitXor for i32 { fn bitxor(self, other: i32) -> i32 { self ^ other } }
+impl BitXor for i64 { fn bitxor(self, other: i64) -> i64 { self ^ other } }
+
+// docs:start:shl-trait
+trait Shl {
+    fn shl(self, other: u8) -> Self;
+}
+// docs:end:shl-trait
+
+impl Shl for u32 { fn shl(self, other: u8) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u8) -> u64 { self << other } }
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u1 { fn shl(self, other: u8) -> u1 { self << other } }
+
+impl Shl for i8 { fn shl(self, other: u8) -> i8 { self << other } }
+impl Shl for i32 { fn shl(self, other: u8) -> i32 { self << other } }
+impl Shl for i64 { fn shl(self, other: u8) -> i64 { self << other } }
+
+// docs:start:shr-trait
+trait Shr {
+    fn shr(self, other: u8) -> Self;
+}
+// docs:end:shr-trait
+
+impl Shr for u64 { fn shr(self, other: u8) -> u64 { self >> other } }
+impl Shr for u32 { fn shr(self, other: u8) -> u32 { self >> other } }
+impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
+impl Shr for u1 { fn shr(self, other: u8) -> u1 { self >> other } }
+
+impl Shr for i8 { fn shr(self, other: u8) -> i8 { self >> other } }
+impl Shr for i32 { fn shr(self, other: u8) -> i32 { self >> other } }
+impl Shr for i64 { fn shr(self, other: u8) -> i64 { self >> other } }
+
diff --git a/test_programs/execution_success/u16_support/Nargo.toml b/test_programs/execution_success/u16_support/Nargo.toml
new file mode 100644
index 00000000000..1c6b58e01e8
--- /dev/null
+++ b/test_programs/execution_success/u16_support/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "u16_support"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/u16_support/Prover.toml b/test_programs/execution_success/u16_support/Prover.toml
new file mode 100644
index 00000000000..a56a84e61a4
--- /dev/null
+++ b/test_programs/execution_success/u16_support/Prover.toml
@@ -0,0 +1 @@
+x = "2"
diff --git a/test_programs/execution_success/u16_support/src/main.nr b/test_programs/execution_success/u16_support/src/main.nr
new file mode 100644
index 00000000000..e8b418f16da
--- /dev/null
+++ b/test_programs/execution_success/u16_support/src/main.nr
@@ -0,0 +1,24 @@
+fn main(x: u16) {
+    test_u16(x);
+    test_u16_unconstrained(x);
+}
+
+unconstrained fn test_u16_unconstrained(x: u16) {
+    test_u16(x)
+}
+
+fn test_u16(x: u16) {
+    let t1: u16 = 1234;
+    let t2: u16 = 4321;
+    let t = t1 + t2;
+
+    let t4 = t - t2;
+    assert(t4 == t1);
+
+    let mut small_int = x as u16;
+    let shift = small_int << (x as u8);
+    assert(shift == 8);
+    assert(shift >> (x as u8) == small_int);
+    assert(shift >> 15 == 0);
+    assert(shift << 15 == 0);
+}
diff --git a/tooling/backend_interface/Cargo.toml b/tooling/backend_interface/Cargo.toml
index b731c138c7d..f6b5d5d0132 100644
--- a/tooling/backend_interface/Cargo.toml
+++ b/tooling/backend_interface/Cargo.toml
@@ -13,7 +13,6 @@ license.workspace = true
 acvm.workspace = true
 dirs.workspace = true
 thiserror.workspace = true
-serde.workspace = true
 serde_json.workspace = true
 bb_abstraction_leaks.workspace = true
 tracing.workspace = true
diff --git a/tooling/backend_interface/src/cli/info.rs b/tooling/backend_interface/src/cli/info.rs
deleted file mode 100644
index 6e6603ce53e..00000000000
--- a/tooling/backend_interface/src/cli/info.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use acvm::acir::circuit::ExpressionWidth;
-
-use serde::Deserialize;
-use std::path::{Path, PathBuf};
-
-use crate::BackendError;
-
-use super::string_from_stderr;
-
-pub(crate) struct InfoCommand {
-    pub(crate) crs_path: PathBuf,
-}
-
-#[derive(Deserialize)]
-struct InfoResponse {
-    language: LanguageResponse,
-}
-
-#[derive(Deserialize)]
-struct LanguageResponse {
-    name: String,
-    width: Option<usize>,
-}
-
-impl InfoCommand {
-    pub(crate) fn run(self, binary_path: &Path) -> Result<ExpressionWidth, BackendError> {
-        let mut command = std::process::Command::new(binary_path);
-
-        command.arg("info").arg("-c").arg(self.crs_path).arg("-o").arg("-");
-
-        let output = command.output()?;
-
-        if !output.status.success() {
-            return Err(BackendError::CommandFailed(string_from_stderr(&output.stderr)));
-        }
-
-        let backend_info: InfoResponse =
-            serde_json::from_slice(&output.stdout).expect("Backend should return valid json");
-        let expression_width: ExpressionWidth = match backend_info.language.name.as_str() {
-            "PLONK-CSAT" => {
-                let width = backend_info.language.width.unwrap();
-                ExpressionWidth::Bounded { width }
-            }
-            "R1CS" => ExpressionWidth::Unbounded,
-            _ => panic!("Unknown Expression width configuration"),
-        };
-
-        Ok(expression_width)
-    }
-}
-
-#[test]
-fn info_command() -> Result<(), BackendError> {
-    let backend = crate::get_mock_backend()?;
-    let crs_path = backend.backend_directory();
-
-    let expression_width = InfoCommand { crs_path }.run(backend.binary_path())?;
-
-    assert!(matches!(expression_width, ExpressionWidth::Bounded { width: 4 }));
-
-    Ok(())
-}
diff --git a/tooling/backend_interface/src/cli/mod.rs b/tooling/backend_interface/src/cli/mod.rs
index b4dec859839..df43bd5cc2f 100644
--- a/tooling/backend_interface/src/cli/mod.rs
+++ b/tooling/backend_interface/src/cli/mod.rs
@@ -2,7 +2,6 @@
 
 mod contract;
 mod gates;
-mod info;
 mod proof_as_fields;
 mod prove;
 mod verify;
@@ -12,7 +11,6 @@ mod write_vk;
 
 pub(crate) use contract::ContractCommand;
 pub(crate) use gates::GatesCommand;
-pub(crate) use info::InfoCommand;
 pub(crate) use proof_as_fields::ProofAsFieldsCommand;
 pub(crate) use prove::ProveCommand;
 pub(crate) use verify::VerifyCommand;
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index fa1f82a5722..20a6dcf70f1 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -3,7 +3,7 @@ use std::io::Write;
 use std::path::Path;
 
 use acvm::acir::{
-    circuit::{ExpressionWidth, Program},
+    circuit::Program,
     native_types::{WitnessMap, WitnessStack},
 };
 use acvm::FieldElement;
@@ -11,8 +11,8 @@ use tempfile::tempdir;
 use tracing::warn;
 
 use crate::cli::{
-    GatesCommand, InfoCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand,
-    VkAsFieldsCommand, WriteVkCommand,
+    GatesCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand, VkAsFieldsCommand,
+    WriteVkCommand,
 };
 use crate::{Backend, BackendError};
 
@@ -33,25 +33,6 @@ impl Backend {
             .run(binary_path)
     }
 
-    pub fn get_backend_info(&self) -> Result<ExpressionWidth, BackendError> {
-        let binary_path = self.assert_binary_exists()?;
-        self.assert_correct_version()?;
-        InfoCommand { crs_path: self.crs_directory() }.run(binary_path)
-    }
-
-    /// If we cannot get a valid backend, returns `ExpressionWidth::Bound { width: 4 }``
-    /// The function also prints a message saying we could not find a backend
-    pub fn get_backend_info_or_default(&self) -> ExpressionWidth {
-        if let Ok(expression_width) = self.get_backend_info() {
-            expression_width
-        } else {
-            warn!(
-                "No valid backend found, ExpressionWidth defaulting to Bounded with a width of 4"
-            );
-            ExpressionWidth::Bounded { width: 4 }
-        }
-    }
-
     #[tracing::instrument(level = "trace", skip_all)]
     pub fn prove(
         &self,
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs b/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
deleted file mode 100644
index cdaebb95fc9..00000000000
--- a/tooling/backend_interface/test-binaries/mock_backend/src/info_cmd.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use clap::Args;
-use std::io::Write;
-use std::path::PathBuf;
-
-const INFO_RESPONSE: &str = r#"{
-    "language": {
-        "name": "PLONK-CSAT",
-        "width": 4
-    },
-    "opcodes_supported": ["arithmetic", "directive", "brillig", "memory_init", "memory_op"],
-    "black_box_functions_supported": [
-        "and",
-        "xor",
-        "range",
-        "sha256",
-        "blake2s",
-        "blake3",
-        "keccak256",
-        "schnorr_verify",
-        "pedersen",
-        "pedersen_hash",
-        "ecdsa_secp256k1",
-        "ecdsa_secp256r1",
-        "multi_scalar_mul",
-        "recursive_aggregation"
-    ]
-}"#;
-
-#[derive(Debug, Clone, Args)]
-pub(crate) struct InfoCommand {
-    #[clap(short = 'c')]
-    pub(crate) crs_path: Option<PathBuf>,
-
-    #[clap(short = 'o')]
-    pub(crate) info_path: Option<PathBuf>,
-}
-
-pub(crate) fn run(_args: InfoCommand) {
-    std::io::stdout().write_all(INFO_RESPONSE.as_bytes()).unwrap();
-}
diff --git a/tooling/backend_interface/test-binaries/mock_backend/src/main.rs b/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
index ef8819af94b..74ea82d28f8 100644
--- a/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
+++ b/tooling/backend_interface/test-binaries/mock_backend/src/main.rs
@@ -7,7 +7,6 @@ use clap::{Parser, Subcommand};
 
 mod contract_cmd;
 mod gates_cmd;
-mod info_cmd;
 mod prove_cmd;
 mod verify_cmd;
 mod write_vk_cmd;
@@ -21,7 +20,6 @@ struct BackendCli {
 
 #[derive(Subcommand, Clone, Debug)]
 enum BackendCommand {
-    Info(info_cmd::InfoCommand),
     Contract(contract_cmd::ContractCommand),
     Gates(gates_cmd::GatesCommand),
     Prove(prove_cmd::ProveCommand),
@@ -34,7 +32,6 @@ fn main() {
     let BackendCli { command } = BackendCli::parse();
 
     match command {
-        BackendCommand::Info(args) => info_cmd::run(args),
         BackendCommand::Contract(args) => contract_cmd::run(args),
         BackendCommand::Gates(args) => gates_cmd::run(args),
         BackendCommand::Prove(args) => prove_cmd::run(args),
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 2b729e44b8a..208379b098d 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -1,4 +1,3 @@
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use clap::Args;
@@ -42,11 +41,7 @@ pub(crate) struct CheckCommand {
     compile_options: CompileOptions,
 }
 
-pub(crate) fn run(
-    _backend: &Backend,
-    args: CheckCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: CheckCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
diff --git a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
index 259e209b65a..8c64d9cd935 100644
--- a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
+++ b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
@@ -44,7 +44,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = backend.get_backend_info()?;
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -62,7 +61,7 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let program = nargo::ops::transform_program(program, expression_width);
+        let program = nargo::ops::transform_program(program, args.compile_options.expression_width);
 
         // TODO(https://github.com/noir-lang/noir/issues/4428):
         // We do not expect to have a smart contract verifier for a foldable program with multiple circuits.
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 54e8535f094..2f878406939 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -20,7 +20,6 @@ use noirc_frontend::hir::ParsedFiles;
 use notify::{EventKind, RecursiveMode, Watcher};
 use notify_debouncer_full::new_debouncer;
 
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use super::fs::program::only_acir;
@@ -47,11 +46,7 @@ pub(crate) struct CompileCommand {
     watch: bool,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    mut args: CompileCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: CompileCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
@@ -63,10 +58,6 @@ pub(crate) fn run(
         Some(NOIR_ARTIFACT_VERSION_STRING.to_owned()),
     )?;
 
-    if args.compile_options.expression_width.is_none() {
-        args.compile_options.expression_width = Some(backend.get_backend_info_or_default());
-    };
-
     if args.watch {
         watch_workspace(&workspace, &args.compile_options)
             .map_err(|err| CliError::Generic(err.to_string()))?;
@@ -128,8 +119,6 @@ fn compile_workspace_full(
     insert_all_files_for_workspace_into_file_manager(workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width =
-        compile_options.expression_width.expect("expression width should have been set");
     let compiled_workspace =
         compile_workspace(&workspace_file_manager, &parsed_files, workspace, compile_options);
 
@@ -149,12 +138,12 @@ fn compile_workspace_full(
     // Save build artifacts to disk.
     let only_acir = compile_options.only_acir;
     for (package, program) in binary_packages.into_iter().zip(compiled_programs) {
-        let program = nargo::ops::transform_program(program, expression_width);
+        let program = nargo::ops::transform_program(program, compile_options.expression_width);
         save_program(program.clone(), &package, &workspace.target_directory_path(), only_acir);
     }
     let circuit_dir = workspace.target_directory_path();
     for (package, contract) in contract_packages.into_iter().zip(compiled_contracts) {
-        let contract = nargo::ops::transform_contract(contract, expression_width);
+        let contract = nargo::ops::transform_contract(contract, compile_options.expression_width);
         save_contract(contract, &package, &circuit_dir);
     }
 
diff --git a/tooling/nargo_cli/src/cli/dap_cmd.rs b/tooling/nargo_cli/src/cli/dap_cmd.rs
index ba4f91609ef..d06d39f3b6a 100644
--- a/tooling/nargo_cli/src/cli/dap_cmd.rs
+++ b/tooling/nargo_cli/src/cli/dap_cmd.rs
@@ -1,6 +1,5 @@
 use acvm::acir::circuit::ExpressionWidth;
 use acvm::acir::native_types::WitnessMap;
-use backend_interface::Backend;
 use clap::Args;
 use nargo::constants::PROVER_INPUT_FILE;
 use nargo::workspace::Workspace;
@@ -29,8 +28,8 @@ use noir_debugger::errors::{DapError, LoadError};
 #[derive(Debug, Clone, Args)]
 pub(crate) struct DapCommand {
     /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width)]
-    expression_width: Option<ExpressionWidth>,
+    #[arg(long, value_parser = parse_expression_width, default_value = "3")]
+    expression_width: ExpressionWidth,
 
     #[clap(long)]
     preflight_check: bool,
@@ -249,14 +248,7 @@ fn run_preflight_check(
     Ok(())
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: DapCommand,
-    _config: NargoConfig,
-) -> Result<(), CliError> {
-    let expression_width =
-        args.expression_width.unwrap_or_else(|| backend.get_backend_info_or_default());
-
+pub(crate) fn run(args: DapCommand, _config: NargoConfig) -> Result<(), CliError> {
     // When the --preflight-check flag is present, we run Noir's DAP server in "pre-flight mode", which test runs
     // the DAP initialization code without actually starting the DAP server.
     //
@@ -270,12 +262,12 @@ pub(crate) fn run(
     // the DAP loop is established, which otherwise are considered "out of band" by the maintainers of the DAP spec.
     // More details here: https://github.com/microsoft/vscode/issues/108138
     if args.preflight_check {
-        return run_preflight_check(expression_width, args).map_err(CliError::DapError);
+        return run_preflight_check(args.expression_width, args).map_err(CliError::DapError);
     }
 
     let output = BufWriter::new(std::io::stdout());
     let input = BufReader::new(std::io::stdin());
     let server = Server::new(input, output);
 
-    loop_uninitialized_dap(server, expression_width).map_err(CliError::DapError)
+    loop_uninitialized_dap(server, args.expression_width).map_err(CliError::DapError)
 }
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 7cb5cd7846b..f950cd0405c 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -24,7 +24,6 @@ use noirc_frontend::hir::ParsedFiles;
 
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 /// Executes a circuit in debug mode
@@ -53,11 +52,7 @@ pub(crate) struct DebugCommand {
     skip_instrumentation: Option<bool>,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: DebugCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: DebugCommand, config: NargoConfig) -> Result<(), CliError> {
     let acir_mode = args.acir_mode;
     let skip_instrumentation = args.skip_instrumentation.unwrap_or(acir_mode);
 
@@ -69,10 +64,6 @@ pub(crate) fn run(
         Some(NOIR_ARTIFACT_VERSION_STRING.to_string()),
     )?;
     let target_dir = &workspace.target_directory_path();
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
 
     let Some(package) = workspace.into_iter().find(|p| p.is_binary()) else {
         println!(
@@ -89,7 +80,8 @@ pub(crate) fn run(
         args.compile_options.clone(),
     )?;
 
-    let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+    let compiled_program =
+        nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
     run_async(package, compiled_program, &args.prover_name, &args.witness_name, target_dir)
 }
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 854ad559012..68f902dfe33 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -18,7 +18,6 @@ use noirc_frontend::graph::CrateName;
 
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 /// Executes a circuit to calculate its return value
@@ -48,11 +47,7 @@ pub(crate) struct ExecuteCommand {
     oracle_resolver: Option<String>,
 }
 
-pub(crate) fn run(
-    backend: &Backend,
-    args: ExecuteCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: ExecuteCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
@@ -68,10 +63,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -89,7 +80,8 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+        let compiled_program =
+            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
         let (return_value, witness_stack) = execute_program_and_decode(
             compiled_program,
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index 044c2cb4ebb..a61f3ccfc02 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -20,7 +20,6 @@ use noirc_frontend::graph::CrateName;
 
 use clap::Args;
 
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use super::check_cmd::check_crate_and_report_errors;
@@ -43,11 +42,7 @@ pub(crate) struct ExportCommand {
     compile_options: CompileOptions,
 }
 
-pub(crate) fn run(
-    _backend: &Backend,
-    args: ExportCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: ExportCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 3695fb57d31..cac3c36f904 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -70,10 +70,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let compiled_workspace = compile_workspace(
         &workspace_file_manager,
         &parsed_files,
@@ -89,10 +85,10 @@ pub(crate) fn run(
     )?;
 
     let compiled_programs = vecmap(compiled_programs, |program| {
-        nargo::ops::transform_program(program, expression_width)
+        nargo::ops::transform_program(program, args.compile_options.expression_width)
     });
     let compiled_contracts = vecmap(compiled_contracts, |contract| {
-        nargo::ops::transform_contract(contract, expression_width)
+        nargo::ops::transform_contract(contract, args.compile_options.expression_width)
     });
 
     if args.profile_info {
@@ -122,13 +118,24 @@ pub(crate) fn run(
     let program_info = binary_packages
         .par_bridge()
         .map(|(package, program)| {
-            count_opcodes_and_gates_in_program(backend, program, package, expression_width)
+            count_opcodes_and_gates_in_program(
+                backend,
+                program,
+                package,
+                args.compile_options.expression_width,
+            )
         })
         .collect::<Result<_, _>>()?;
 
     let contract_info = compiled_contracts
         .into_par_iter()
-        .map(|contract| count_opcodes_and_gates_in_contract(backend, contract, expression_width))
+        .map(|contract| {
+            count_opcodes_and_gates_in_contract(
+                backend,
+                contract,
+                args.compile_options.expression_width,
+            )
+        })
         .collect::<Result<_, _>>()?;
 
     let info_report = InfoReport { programs: program_info, contracts: contract_info };
diff --git a/tooling/nargo_cli/src/cli/lsp_cmd.rs b/tooling/nargo_cli/src/cli/lsp_cmd.rs
index 1428b8070c8..45ac02ea552 100644
--- a/tooling/nargo_cli/src/cli/lsp_cmd.rs
+++ b/tooling/nargo_cli/src/cli/lsp_cmd.rs
@@ -8,7 +8,6 @@ use noir_lsp::NargoLspService;
 use tower::ServiceBuilder;
 
 use super::NargoConfig;
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 /// Starts the Noir LSP server
@@ -19,12 +18,7 @@ use crate::errors::CliError;
 #[derive(Debug, Clone, Args)]
 pub(crate) struct LspCommand;
 
-pub(crate) fn run(
-    // Backend is currently unused, but we might want to use it to inform the lsp in the future
-    _backend: &Backend,
-    _args: LspCommand,
-    _config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(_args: LspCommand, _config: NargoConfig) -> Result<(), CliError> {
     use tokio::runtime::Builder;
 
     let runtime = Builder::new_current_thread().enable_all().build().unwrap();
diff --git a/tooling/nargo_cli/src/cli/mod.rs b/tooling/nargo_cli/src/cli/mod.rs
index e8e17893815..ad778549ac0 100644
--- a/tooling/nargo_cli/src/cli/mod.rs
+++ b/tooling/nargo_cli/src/cli/mod.rs
@@ -107,21 +107,21 @@ pub(crate) fn start_cli() -> eyre::Result<()> {
     let backend = crate::backends::Backend::new(active_backend);
 
     match command {
-        NargoCommand::New(args) => new_cmd::run(&backend, args, config),
+        NargoCommand::New(args) => new_cmd::run(args, config),
         NargoCommand::Init(args) => init_cmd::run(args, config),
-        NargoCommand::Check(args) => check_cmd::run(&backend, args, config),
-        NargoCommand::Compile(args) => compile_cmd::run(&backend, args, config),
-        NargoCommand::Debug(args) => debug_cmd::run(&backend, args, config),
-        NargoCommand::Execute(args) => execute_cmd::run(&backend, args, config),
-        NargoCommand::Export(args) => export_cmd::run(&backend, args, config),
+        NargoCommand::Check(args) => check_cmd::run(args, config),
+        NargoCommand::Compile(args) => compile_cmd::run(args, config),
+        NargoCommand::Debug(args) => debug_cmd::run(args, config),
+        NargoCommand::Execute(args) => execute_cmd::run(args, config),
+        NargoCommand::Export(args) => export_cmd::run(args, config),
         NargoCommand::Prove(args) => prove_cmd::run(&backend, args, config),
         NargoCommand::Verify(args) => verify_cmd::run(&backend, args, config),
-        NargoCommand::Test(args) => test_cmd::run(&backend, args, config),
+        NargoCommand::Test(args) => test_cmd::run(args, config),
         NargoCommand::Info(args) => info_cmd::run(&backend, args, config),
         NargoCommand::CodegenVerifier(args) => codegen_verifier_cmd::run(&backend, args, config),
         NargoCommand::Backend(args) => backend_cmd::run(args),
-        NargoCommand::Lsp(args) => lsp_cmd::run(&backend, args, config),
-        NargoCommand::Dap(args) => dap_cmd::run(&backend, args, config),
+        NargoCommand::Lsp(args) => lsp_cmd::run(args, config),
+        NargoCommand::Dap(args) => dap_cmd::run(args, config),
         NargoCommand::Fmt(args) => fmt_cmd::run(args, config),
     }?;
 
diff --git a/tooling/nargo_cli/src/cli/new_cmd.rs b/tooling/nargo_cli/src/cli/new_cmd.rs
index b4c823d0c1e..21951f27260 100644
--- a/tooling/nargo_cli/src/cli/new_cmd.rs
+++ b/tooling/nargo_cli/src/cli/new_cmd.rs
@@ -1,4 +1,3 @@
-use crate::backends::Backend;
 use crate::errors::CliError;
 
 use super::{init_cmd::initialize_project, NargoConfig};
@@ -30,12 +29,7 @@ pub(crate) struct NewCommand {
     pub(crate) contract: bool,
 }
 
-pub(crate) fn run(
-    // Backend is currently unused, but we might want to use it to inform the "new" template in the future
-    _backend: &Backend,
-    args: NewCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: NewCommand, config: NargoConfig) -> Result<(), CliError> {
     let package_dir = config.program_dir.join(&args.path);
 
     if package_dir.exists() {
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index b9e4bca9e69..47c71527fd8 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -69,10 +69,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -90,7 +86,8 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+        let compiled_program =
+            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
         prove_package(
             backend,
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index 88a804d5cf4..967d4c87e6d 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -19,7 +19,7 @@ use noirc_frontend::{
 use rayon::prelude::{IntoParallelIterator, ParallelBridge, ParallelIterator};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
-use crate::{backends::Backend, cli::check_cmd::check_crate_and_report_errors, errors::CliError};
+use crate::{cli::check_cmd::check_crate_and_report_errors, errors::CliError};
 
 use super::NargoConfig;
 
@@ -54,11 +54,7 @@ pub(crate) struct TestCommand {
     oracle_resolver: Option<String>,
 }
 
-pub(crate) fn run(
-    _backend: &Backend,
-    args: TestCommand,
-    config: NargoConfig,
-) -> Result<(), CliError> {
+pub(crate) fn run(args: TestCommand, config: NargoConfig) -> Result<(), CliError> {
     let toml_path = get_package_manifest(&config.program_dir)?;
     let default_selection =
         if args.workspace { PackageSelection::All } else { PackageSelection::DefaultOrAll };
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
index 7202a179aae..a6078f6c1d3 100644
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ b/tooling/nargo_cli/src/cli/verify_cmd.rs
@@ -54,10 +54,6 @@ pub(crate) fn run(
     insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
     let parsed_files = parse_all(&workspace_file_manager);
 
-    let expression_width = args
-        .compile_options
-        .expression_width
-        .unwrap_or_else(|| backend.get_backend_info_or_default());
     let binary_packages = workspace.into_iter().filter(|package| package.is_binary());
     for package in binary_packages {
         let compilation_result = compile_program(
@@ -75,7 +71,8 @@ pub(crate) fn run(
             args.compile_options.silence_warnings,
         )?;
 
-        let compiled_program = nargo::ops::transform_program(compiled_program, expression_width);
+        let compiled_program =
+            nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
 
         verify_package(backend, &workspace, package, compiled_program, &args.verifier_name)?;
     }
diff --git a/tooling/noir_js/test/node/execute.test.ts b/tooling/noir_js/test/node/execute.test.ts
index b2e76e54efc..d047e35035f 100644
--- a/tooling/noir_js/test/node/execute.test.ts
+++ b/tooling/noir_js/test/node/execute.test.ts
@@ -117,3 +117,15 @@ it('successfully executes a program with multiple acir circuits', async () => {
     expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
   }
 });
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
+  }
+});