diff --git a/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 9cd28d80784..91cfa5c6058 100644
--- a/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1253,8 +1253,10 @@ impl<'a> Resolver<'a> {
                 if let Some((hir_expr, object_type)) = self.resolve_trait_generic_path(&path) {
                     let expr_id = self.interner.push_expr(hir_expr);
                     self.interner.push_expr_location(expr_id, expr.span, self.file);
-                    self.interner
-                        .select_impl_for_ident(expr_id, TraitImplKind::Assumed { object_type });
+                    self.interner.select_impl_for_expression(
+                        expr_id,
+                        TraitImplKind::Assumed { object_type },
+                    );
                     return expr_id;
                 } else {
                     // If the Path is being used as an Expression, then it is referring to a global from a separate module
@@ -1313,10 +1315,12 @@ impl<'a> Resolver<'a> {
             ExpressionKind::Infix(infix) => {
                 let lhs = self.resolve_expression(infix.lhs);
                 let rhs = self.resolve_expression(infix.rhs);
+                let trait_id = self.interner.get_operator_trait_method(infix.operator.contents);
 
                 HirExpression::Infix(HirInfixExpression {
                     lhs,
                     operator: HirBinaryOp::new(infix.operator, self.file),
+                    trait_method_id: trait_id,
                     rhs,
                 })
             }
diff --git a/compiler/noirc_frontend/src/hir/resolution/traits.rs b/compiler/noirc_frontend/src/hir/resolution/traits.rs
index 54d2630c722..40041b0fd00 100644
--- a/compiler/noirc_frontend/src/hir/resolution/traits.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/traits.rs
@@ -52,6 +52,13 @@ pub(crate) fn resolve_traits(
         context.def_interner.update_trait(trait_id, |trait_def| {
             trait_def.set_methods(methods);
         });
+
+        // This check needs to be after the trait's methods are set since
+        // the interner may set `interner.ordering_type` based on the result type
+        // of the Cmp trait, if this is it.
+        if crate_id.is_stdlib() {
+            context.def_interner.try_add_operator_trait(trait_id);
+        }
     }
     res
 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index e8f9f23d378..caa77852560 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -136,11 +136,21 @@ impl<'interner> TypeChecker<'interner> {
                 let rhs_span = self.interner.expr_span(&infix_expr.rhs);
                 let span = lhs_span.merge(rhs_span);
 
-                self.infix_operand_type_rules(&lhs_type, &infix_expr.operator, &rhs_type, span)
-                    .unwrap_or_else(|error| {
+                let operator = &infix_expr.operator;
+                match self.infix_operand_type_rules(&lhs_type, operator, &rhs_type, span) {
+                    Ok((typ, use_impl)) => {
+                        if use_impl {
+                            let id = infix_expr.trait_method_id;
+                            self.verify_trait_constraint(&lhs_type, id.trait_id, *expr_id, span);
+                            self.typecheck_operator_method(*expr_id, id, &lhs_type, span);
+                        }
+                        typ
+                    }
+                    Err(error) => {
                         self.errors.push(error);
                         Type::Error
-                    })
+                    }
+                }
             }
             HirExpression::Index(index_expr) => self.check_index_expression(expr_id, index_expr),
             HirExpression::Call(call_expr) => {
@@ -294,7 +304,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 // We must also remember to apply these substitutions to the object_type
                 // referenced by the selected trait impl, if one has yet to be selected.
-                let impl_kind = self.interner.get_selected_impl_for_ident(*expr_id);
+                let impl_kind = self.interner.get_selected_impl_for_expression(*expr_id);
                 if let Some(TraitImplKind::Assumed { object_type }) = impl_kind {
                     let the_trait = self.interner.get_trait(method.trait_id);
                     let object_type = object_type.substitute(&bindings);
@@ -302,8 +312,10 @@ impl<'interner> TypeChecker<'interner> {
                         the_trait.self_type_typevar_id,
                         (the_trait.self_type_typevar.clone(), object_type.clone()),
                     );
-                    self.interner
-                        .select_impl_for_ident(*expr_id, TraitImplKind::Assumed { object_type });
+                    self.interner.select_impl_for_expression(
+                        *expr_id,
+                        TraitImplKind::Assumed { object_type },
+                    );
                 }
 
                 self.interner.store_instantiation_bindings(*expr_id, bindings);
@@ -323,7 +335,7 @@ impl<'interner> TypeChecker<'interner> {
         span: Span,
     ) {
         match self.interner.lookup_trait_implementation(object_type, trait_id) {
-            Ok(impl_kind) => self.interner.select_impl_for_ident(function_ident_id, impl_kind),
+            Ok(impl_kind) => self.interner.select_impl_for_expression(function_ident_id, impl_kind),
             Err(erroring_constraints) => {
                 // Don't show any errors where try_get_trait returns None.
                 // This can happen if a trait is used that was never declared.
@@ -753,19 +765,22 @@ impl<'interner> TypeChecker<'interner> {
         None
     }
 
+    // Given a binary comparison operator and another type. This method will produce the output type
+    // and a boolean indicating whether to use the trait impl corresponding to the operator
+    // or not. A value of false indicates the caller to use a primitive operation for this
+    // operator, while a true value indicates a user-provided trait impl is required.
     fn comparator_operand_type_rules(
         &mut self,
         lhs_type: &Type,
         rhs_type: &Type,
         op: &HirBinaryOp,
         span: Span,
-    ) -> Result<Type, TypeCheckError> {
-        use crate::BinaryOpKind::{Equal, NotEqual};
+    ) -> Result<(Type, bool), TypeCheckError> {
         use Type::*;
 
         match (lhs_type, rhs_type) {
             // Avoid reporting errors multiple times
-            (Error, _) | (_, Error) => Ok(Bool),
+            (Error, _) | (_, Error) => Ok((Bool, false)),
 
             // Matches on TypeVariable must be first to follow any type
             // bindings.
@@ -791,7 +806,7 @@ impl<'interner> TypeChecker<'interner> {
                     || other == &Type::Error
                 {
                     Type::apply_type_bindings(bindings);
-                    Ok(Bool)
+                    Ok((Bool, false))
                 } else {
                     Err(TypeCheckError::TypeMismatchWithSource {
                         expected: lhs_type.clone(),
@@ -816,36 +831,23 @@ impl<'interner> TypeChecker<'interner> {
                         span,
                     });
                 }
-                Ok(Bool)
-            }
-            (Integer(..), FieldElement) | (FieldElement, Integer(..)) => {
-                Err(TypeCheckError::IntegerAndFieldBinaryOperation { span })
-            }
-            (Integer(..), typ) | (typ, Integer(..)) => {
-                Err(TypeCheckError::IntegerTypeMismatch { typ: typ.clone(), span })
+                Ok((Bool, false))
             }
             (FieldElement, FieldElement) => {
                 if op.kind.is_valid_for_field_type() {
-                    Ok(Bool)
+                    Ok((Bool, false))
                 } else {
                     Err(TypeCheckError::FieldComparison { span })
                 }
             }
 
             // <= and friends are technically valid for booleans, just not very useful
-            (Bool, Bool) => Ok(Bool),
+            (Bool, Bool) => Ok((Bool, false)),
 
             // Special-case == and != for arrays
             (Array(x_size, x_type), Array(y_size, y_type))
-                if matches!(op.kind, Equal | NotEqual) =>
+                if matches!(op.kind, BinaryOpKind::Equal | BinaryOpKind::NotEqual) =>
             {
-                self.unify(x_type, y_type, || TypeCheckError::TypeMismatchWithSource {
-                    expected: lhs_type.clone(),
-                    actual: rhs_type.clone(),
-                    source: Source::ArrayElements,
-                    span: op.location.span,
-                });
-
                 self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource {
                     expected: lhs_type.clone(),
                     actual: rhs_type.clone(),
@@ -853,19 +855,9 @@ impl<'interner> TypeChecker<'interner> {
                     span: op.location.span,
                 });
 
-                Ok(Bool)
-            }
-            (lhs @ NamedGeneric(binding_a, _), rhs @ NamedGeneric(binding_b, _)) => {
-                if binding_a == binding_b {
-                    return Ok(Bool);
-                }
-                Err(TypeCheckError::TypeMismatchWithSource {
-                    expected: lhs.clone(),
-                    actual: rhs.clone(),
-                    source: Source::Comparison,
-                    span,
-                })
+                self.comparator_operand_type_rules(x_type, y_type, op, span)
             }
+
             (String(x_size), String(y_size)) => {
                 self.unify(x_size, y_size, || TypeCheckError::TypeMismatchWithSource {
                     expected: *x_size.clone(),
@@ -874,14 +866,17 @@ impl<'interner> TypeChecker<'interner> {
                     source: Source::StringLen,
                 });
 
-                Ok(Bool)
+                Ok((Bool, false))
+            }
+            (lhs, rhs) => {
+                self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource {
+                    expected: lhs.clone(),
+                    actual: rhs.clone(),
+                    span: op.location.span,
+                    source: Source::Binary,
+                });
+                Ok((Bool, true))
             }
-            (lhs, rhs) => Err(TypeCheckError::TypeMismatchWithSource {
-                expected: lhs.clone(),
-                actual: rhs.clone(),
-                source: Source::Comparison,
-                span,
-            }),
         }
     }
 
@@ -1041,13 +1036,16 @@ impl<'interner> TypeChecker<'interner> {
     }
 
     // Given a binary operator and another type. This method will produce the output type
+    // and a boolean indicating whether to use the trait impl corresponding to the operator
+    // or not. A value of false indicates the caller to use a primitive operation for this
+    // operator, while a true value indicates a user-provided trait impl is required.
     fn infix_operand_type_rules(
         &mut self,
         lhs_type: &Type,
         op: &HirBinaryOp,
         rhs_type: &Type,
         span: Span,
-    ) -> Result<Type, TypeCheckError> {
+    ) -> Result<(Type, bool), TypeCheckError> {
         if op.kind.is_comparator() {
             return self.comparator_operand_type_rules(lhs_type, rhs_type, op, span);
         }
@@ -1055,7 +1053,7 @@ impl<'interner> TypeChecker<'interner> {
         use Type::*;
         match (lhs_type, rhs_type) {
             // An error type on either side will always return an error
-            (Error, _) | (_, Error) => Ok(Error),
+            (Error, _) | (_, Error) => Ok((Error, false)),
 
             // Matches on TypeVariable must be first so that we follow any type
             // bindings.
@@ -1096,7 +1094,7 @@ impl<'interner> TypeChecker<'interner> {
                     || other == &Type::Error
                 {
                     Type::apply_type_bindings(bindings);
-                    Ok(other.clone())
+                    Ok((other.clone(), false))
                 } else {
                     Err(TypeCheckError::TypeMismatchWithSource {
                         expected: lhs_type.clone(),
@@ -1121,25 +1119,8 @@ impl<'interner> TypeChecker<'interner> {
                         span,
                     });
                 }
-                Ok(Integer(*sign_x, *bit_width_x))
-            }
-            (Integer(..), FieldElement) | (FieldElement, Integer(..)) => {
-                Err(TypeCheckError::IntegerAndFieldBinaryOperation { span })
+                Ok((Integer(*sign_x, *bit_width_x), false))
             }
-            (Integer(..), typ) | (typ, Integer(..)) => {
-                Err(TypeCheckError::IntegerTypeMismatch { typ: typ.clone(), span })
-            }
-            // These types are not supported in binary operations
-            (Array(..), _) | (_, Array(..)) => {
-                Err(TypeCheckError::InvalidInfixOp { kind: "Arrays", span })
-            }
-            (Struct(..), _) | (_, Struct(..)) => {
-                Err(TypeCheckError::InvalidInfixOp { kind: "Structs", span })
-            }
-            (Tuple(_), _) | (_, Tuple(_)) => {
-                Err(TypeCheckError::InvalidInfixOp { kind: "Tuples", span })
-            }
-
             // The result of two Fields is always a witness
             (FieldElement, FieldElement) => {
                 if op.is_bitwise() {
@@ -1148,17 +1129,20 @@ impl<'interner> TypeChecker<'interner> {
                 if op.is_modulo() {
                     return Err(TypeCheckError::FieldModulo { span });
                 }
-                Ok(FieldElement)
+                Ok((FieldElement, false))
             }
 
-            (Bool, Bool) => Ok(Bool),
+            (Bool, Bool) => Ok((Bool, false)),
 
-            (lhs, rhs) => Err(TypeCheckError::TypeMismatchWithSource {
-                expected: lhs.clone(),
-                actual: rhs.clone(),
-                source: Source::BinOp(op.kind),
-                span,
-            }),
+            (lhs, rhs) => {
+                self.unify(lhs, rhs, || TypeCheckError::TypeMismatchWithSource {
+                    expected: lhs.clone(),
+                    actual: rhs.clone(),
+                    span: op.location.span,
+                    source: Source::Binary,
+                });
+                Ok((lhs.clone(), true))
+            }
         }
     }
 
@@ -1210,6 +1194,57 @@ impl<'interner> TypeChecker<'interner> {
             }
         }
     }
+
+    /// Prerequisite: verify_trait_constraint of the operator's trait constraint.
+    ///
+    /// Although by this point the operator is expected to already have a trait impl,
+    /// we still need to match the operator's type against the method's instantiated type
+    /// to ensure the instantiation bindings are correct and the monomorphizer can
+    /// re-apply the needed bindings.
+    fn typecheck_operator_method(
+        &mut self,
+        expr_id: ExprId,
+        trait_method_id: TraitMethodId,
+        object_type: &Type,
+        span: Span,
+    ) {
+        let the_trait = self.interner.get_trait(trait_method_id.trait_id);
+
+        let method = &the_trait.methods[trait_method_id.method_index];
+        let (method_type, mut bindings) = method.typ.instantiate(self.interner);
+
+        match method_type {
+            Type::Function(args, _, _) => {
+                // We can cheat a bit and match against only the object type here since no operator
+                // overload uses other generic parameters or return types aside from the object type.
+                let expected_object_type = &args[0];
+                self.unify(object_type, expected_object_type, || TypeCheckError::TypeMismatch {
+                    expected_typ: expected_object_type.to_string(),
+                    expr_typ: object_type.to_string(),
+                    expr_span: span,
+                });
+            }
+            other => {
+                unreachable!("Expected operator method to have a function type, but found {other}")
+            }
+        }
+
+        // We must also remember to apply these substitutions to the object_type
+        // referenced by the selected trait impl, if one has yet to be selected.
+        let impl_kind = self.interner.get_selected_impl_for_expression(expr_id);
+        if let Some(TraitImplKind::Assumed { object_type }) = impl_kind {
+            let the_trait = self.interner.get_trait(trait_method_id.trait_id);
+            let object_type = object_type.substitute(&bindings);
+            bindings.insert(
+                the_trait.self_type_typevar_id,
+                (the_trait.self_type_typevar.clone(), object_type.clone()),
+            );
+            self.interner
+                .select_impl_for_expression(expr_id, TraitImplKind::Assumed { object_type });
+        }
+
+        self.interner.store_instantiation_bindings(expr_id, bindings);
+    }
 }
 
 /// Taken from: https://stackoverflow.com/a/47127500
diff --git a/compiler/noirc_frontend/src/hir/type_check/mod.rs b/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 95991047091..092e8631f1b 100644
--- a/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -241,7 +241,7 @@ mod test {
         function::{FuncMeta, HirFunction},
         stmt::HirStatement,
     };
-    use crate::node_interner::{DefinitionKind, FuncId, NodeInterner};
+    use crate::node_interner::{DefinitionKind, FuncId, NodeInterner, TraitId, TraitMethodId};
     use crate::{
         hir::{
             def_map::{CrateDefMap, LocalModuleId, ModuleDefId},
@@ -254,6 +254,7 @@ mod test {
     #[test]
     fn basic_let() {
         let mut interner = NodeInterner::default();
+        interner.populate_dummy_operator_traits();
 
         // Safety: The FileId in a location isn't used for tests
         let file = FileId::default();
@@ -284,7 +285,9 @@ mod test {
 
         // Create Infix
         let operator = HirBinaryOp { location, kind: BinaryOpKind::Add };
-        let expr = HirInfixExpression { lhs: x_expr_id, operator, rhs: y_expr_id };
+        let trait_id = TraitId(ModuleId::dummy_id());
+        let trait_method_id = TraitMethodId { trait_id, method_index: 0 };
+        let expr = HirInfixExpression { lhs: x_expr_id, operator, rhs: y_expr_id, trait_method_id };
         let expr_id = interner.push_expr(HirExpression::Infix(expr));
         interner.push_expr_location(expr_id, Span::single_char(0), file);
 
@@ -469,6 +472,7 @@ mod test {
     ) {
         let (program, errors) = parse_program(src);
         let mut interner = NodeInterner::default();
+        interner.populate_dummy_operator_traits();
 
         assert_eq!(
             errors.len(),
diff --git a/compiler/noirc_frontend/src/hir_def/expr.rs b/compiler/noirc_frontend/src/hir_def/expr.rs
index ef1c3af7ac0..7c04398ca88 100644
--- a/compiler/noirc_frontend/src/hir_def/expr.rs
+++ b/compiler/noirc_frontend/src/hir_def/expr.rs
@@ -101,6 +101,12 @@ pub struct HirInfixExpression {
     pub lhs: ExprId,
     pub operator: HirBinaryOp,
     pub rhs: ExprId,
+
+    /// The trait method id for the operator trait method that corresponds to this operator.
+    /// For derived operators like `!=`, this will lead to the method `Eq::eq`. For these
+    /// cases, it is up to the monomorphization pass to insert the appropriate `not` operation
+    /// after the call to `Eq::eq` to get the result of the `!=` operator.
+    pub trait_method_id: TraitMethodId,
 }
 
 /// This is always a struct field access `my_struct.field`
diff --git a/compiler/noirc_frontend/src/monomorphization/ast.rs b/compiler/noirc_frontend/src/monomorphization/ast.rs
index 5a5f07b0a38..42a618e7d77 100644
--- a/compiler/noirc_frontend/src/monomorphization/ast.rs
+++ b/compiler/noirc_frontend/src/monomorphization/ast.rs
@@ -352,7 +352,7 @@ impl std::fmt::Display for Type {
                 };
                 write!(f, "fn({}) -> {}{}", args.join(", "), ret, closure_env_text)
             }
-            Type::Slice(element) => write!(f, "[{element}"),
+            Type::Slice(element) => write!(f, "[{element}]"),
             Type::MutableReference(element) => write!(f, "&mut {element}"),
         }
     }
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 39b05dcd5ac..5bdd41eafaa 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -26,7 +26,7 @@ use crate::{
     },
     node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId},
     token::FunctionAttribute,
-    ContractFunctionType, FunctionKind, Type, TypeBinding, TypeBindings, TypeVariableKind,
+    ContractFunctionType, FunctionKind, Type, TypeBinding, TypeBindings, TypeVariableKind, UnaryOp,
     Visibility,
 };
 
@@ -238,6 +238,7 @@ impl<'interner> Monomorphizer<'interner> {
         });
 
         let parameters = self.parameters(meta.parameters);
+
         let body = self.expr(body_expr_id);
         let unconstrained = modifiers.is_unconstrained
             || matches!(modifiers.contract_function_type, Some(ContractFunctionType::Open));
@@ -356,11 +357,37 @@ impl<'interner> Monomorphizer<'interner> {
             }
 
             HirExpression::Infix(infix) => {
-                let lhs = Box::new(self.expr(infix.lhs));
-                let rhs = Box::new(self.expr(infix.rhs));
+                let lhs = self.expr(infix.lhs);
+                let rhs = self.expr(infix.rhs);
                 let operator = infix.operator.kind;
                 let location = self.interner.expr_location(&expr);
-                ast::Expression::Binary(ast::Binary { lhs, rhs, operator, location })
+
+                if self.interner.get_selected_impl_for_expression(expr).is_some() {
+                    // If an impl was selected for this infix operator, replace it
+                    // with a method call to the appropriate trait impl method.
+                    let lhs_type = self.interner.id_type(infix.lhs);
+                    let args = vec![lhs_type.clone(), lhs_type];
+
+                    // If this is a comparison operator, the result is a boolean but
+                    // the actual method call returns an Ordering
+                    use crate::BinaryOpKind::*;
+                    let ret = if matches!(operator, Less | LessEqual | Greater | GreaterEqual) {
+                        self.interner.ordering_type()
+                    } else {
+                        self.interner.id_type(expr)
+                    };
+
+                    let env = Box::new(Type::Unit);
+                    let function_type = Type::Function(args, Box::new(ret.clone()), env);
+
+                    let method = infix.trait_method_id;
+                    let func = self.resolve_trait_method_reference(expr, function_type, method);
+                    self.create_operator_impl_call(func, lhs, infix.operator, rhs, ret, location)
+                } else {
+                    let lhs = Box::new(lhs);
+                    let rhs = Box::new(rhs);
+                    ast::Expression::Binary(ast::Binary { lhs, rhs, operator, location })
+                }
             }
 
             HirExpression::Index(index) => self.index(expr, index),
@@ -400,13 +427,8 @@ impl<'interner> Monomorphizer<'interner> {
             HirExpression::Lambda(lambda) => self.lambda(lambda, expr),
 
             HirExpression::TraitMethodReference(method) => {
-                if let Type::Function(_, _, _) = self.interner.id_type(expr) {
-                    self.resolve_trait_method_reference(expr, method)
-                } else {
-                    unreachable!(
-                        "Calling a non-function, this should've been caught in typechecking"
-                    );
-                }
+                let function_type = self.interner.id_type(expr);
+                self.resolve_trait_method_reference(expr, function_type, method)
             }
 
             HirExpression::MethodCall(hir_method_call) => {
@@ -826,13 +848,12 @@ impl<'interner> Monomorphizer<'interner> {
     fn resolve_trait_method_reference(
         &mut self,
         expr_id: node_interner::ExprId,
+        function_type: HirType,
         method: TraitMethodId,
     ) -> ast::Expression {
-        let function_type = self.interner.id_type(expr_id);
-
         let trait_impl = self
             .interner
-            .get_selected_impl_for_ident(expr_id)
+            .get_selected_impl_for_expression(expr_id)
             .expect("ICE: missing trait impl - should be caught during type checking");
 
         let hir_func_id = match trait_impl {
@@ -1087,7 +1108,7 @@ impl<'interner> Monomorphizer<'interner> {
         function_type: HirType,
     ) -> FuncId {
         let new_id = self.next_function_id();
-        self.define_global(id, function_type, new_id);
+        self.define_global(id, function_type.clone(), new_id);
 
         let bindings = self.interner.get_instantiation_bindings(expr_id);
         let bindings = self.follow_bindings(bindings);
@@ -1417,6 +1438,70 @@ impl<'interner> Monomorphizer<'interner> {
             ),
         })
     }
+
+    /// Call an operator overloading method for the given operator.
+    /// This function handles the special cases some operators have which don't map
+    /// 1 to 1 onto their operator function. For example: != requires a negation on
+    /// the result of its `eq` method, and the comparison operators each require a
+    /// conversion from the `Ordering` result to a boolean.
+    fn create_operator_impl_call(
+        &self,
+        func: ast::Expression,
+        lhs: ast::Expression,
+        operator: HirBinaryOp,
+        rhs: ast::Expression,
+        ret: Type,
+        location: Location,
+    ) -> ast::Expression {
+        let arguments = vec![lhs, rhs];
+        let func = Box::new(func);
+        let return_type = self.convert_type(&ret);
+
+        let mut result =
+            ast::Expression::Call(ast::Call { func, arguments, return_type, location });
+
+        use crate::BinaryOpKind::*;
+        match operator.kind {
+            // Negate the result of the == operation
+            NotEqual => {
+                result = ast::Expression::Unary(ast::Unary {
+                    operator: UnaryOp::Not,
+                    rhs: Box::new(result),
+                    result_type: ast::Type::Bool,
+                    location,
+                });
+            }
+            // All the comparison operators require special handling since their `cmp` method
+            // returns an `Ordering` rather than a boolean value.
+            //
+            // (a < b) => a.cmp(b) == Ordering::Less
+            // (a <= b) => a.cmp(b) != Ordering::Greater
+            // (a > b) => a.cmp(b) == Ordering::Greater
+            // (a >= b) => a.cmp(b) != Ordering::Less
+            Less | LessEqual | Greater | GreaterEqual => {
+                // Comparing an Ordering directly to a field value in this way takes advantage
+                // of the fact the Ordering struct contains a single Field type, and our SSA
+                // pass will automatically unpack tuple values.
+                let ordering_value = if matches!(operator.kind, Less | GreaterEqual) {
+                    FieldElement::zero() // Ordering::Less
+                } else {
+                    2u128.into() // Ordering::Greater
+                };
+
+                let operator =
+                    if matches!(operator.kind, Less | Greater) { Equal } else { NotEqual };
+
+                let int_value = ast::Literal::Integer(ordering_value, ast::Type::Field, location);
+                let rhs = Box::new(ast::Expression::Literal(int_value));
+                let lhs = Box::new(ast::Expression::ExtractTupleField(Box::new(result), 0));
+
+                result = ast::Expression::Binary(ast::Binary { lhs, operator, rhs, location });
+            }
+            _ => (),
+        }
+
+        result
+    }
 }
 
 fn unwrap_tuple_type(typ: &HirType) -> Vec<HirType> {
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 34313595271..7c42e279916 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -21,8 +21,8 @@ use crate::hir_def::{
 };
 use crate::token::{Attributes, SecondaryAttribute};
 use crate::{
-    ContractFunctionType, FunctionDefinition, FunctionVisibility, Generics, Shared, TypeAliasType,
-    TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind,
+    BinaryOpKind, ContractFunctionType, FunctionDefinition, FunctionVisibility, Generics, Shared,
+    TypeAliasType, TypeBindings, TypeVariable, TypeVariableId, TypeVariableKind,
 };
 
 /// An arbitrary number to limit the recursion depth when searching for trait impls.
@@ -110,6 +110,12 @@ pub struct NodeInterner {
     /// the context to get the concrete type of the object and select the correct impl itself.
     selected_trait_implementations: HashMap<ExprId, TraitImplKind>,
 
+    /// Holds the trait ids of the traits used for operator overloading
+    operator_traits: HashMap<BinaryOpKind, TraitId>,
+
+    /// The `Ordering` type is a semi-builtin type that is the result of the comparison traits.
+    ordering_type: Option<Type>,
+
     /// Map from ExprId (referring to a Function/Method call) to its corresponding TypeBindings,
     /// filled out during type checking from instantiated variables. Used during monomorphization
     /// to map call site types back onto function parameter types, and undo this binding as needed.
@@ -423,6 +429,8 @@ impl Default for NodeInterner {
             trait_implementations: Vec::new(),
             trait_implementation_map: HashMap::new(),
             selected_trait_implementations: HashMap::new(),
+            operator_traits: HashMap::new(),
+            ordering_type: None,
             instantiation_bindings: HashMap::new(),
             field_indices: HashMap::new(),
             next_type_variable_id: std::cell::Cell::new(0),
@@ -1254,13 +1262,12 @@ impl NodeInterner {
     /// Tags the given identifier with the selected trait_impl so that monomorphization
     /// can later recover which impl was selected, or alternatively see if it needs to
     /// decide which impl to select (because the impl was Assumed).
-    pub fn select_impl_for_ident(&mut self, ident_id: ExprId, trait_impl: TraitImplKind) {
+    pub fn select_impl_for_expression(&mut self, ident_id: ExprId, trait_impl: TraitImplKind) {
         self.selected_trait_implementations.insert(ident_id, trait_impl);
     }
 
-    /// Retrieves the impl selected for a given IdentId during name resolution.
-    /// From type checking and on, the "ident" referred to is changed to a TraitMethodReference node.
-    pub fn get_selected_impl_for_ident(&self, ident_id: ExprId) -> Option<TraitImplKind> {
+    /// Retrieves the impl selected for a given ExprId during name resolution.
+    pub fn get_selected_impl_for_expression(&self, ident_id: ExprId) -> Option<TraitImplKind> {
         self.selected_trait_implementations.get(&ident_id).cloned()
     }
 
@@ -1294,7 +1301,6 @@ impl NodeInterner {
             }
             HirExpression::Constructor(expr) => {
                 let struct_type = &expr.r#type.borrow();
-
                 Some(struct_type.location)
             }
             HirExpression::MemberAccess(expr_member_access) => {
@@ -1332,6 +1338,91 @@ impl NodeInterner {
             Location::new(found_field_name.span(), struct_type.location.file)
         })
     }
+
+    /// Retrieves the trait id for a given binary operator.
+    /// All binary operators correspond to a trait - although multiple may correspond
+    /// to the same trait (such as `==` and `!=`).
+    /// `self.operator_traits` is expected to be filled before name resolution,
+    /// during definition collection.
+    pub fn get_operator_trait_method(&self, operator: BinaryOpKind) -> TraitMethodId {
+        let trait_id = self.operator_traits[&operator];
+
+        // Assume that the operator's method to be overloaded is the first method of the trait.
+        TraitMethodId { trait_id, method_index: 0 }
+    }
+
+    /// Add the given trait as an operator trait if its name matches one of the
+    /// operator trait names (Add, Sub, ...).
+    pub fn try_add_operator_trait(&mut self, trait_id: TraitId) {
+        let the_trait = self.get_trait(trait_id);
+
+        let operator = match the_trait.name.0.contents.as_str() {
+            "Add" => BinaryOpKind::Add,
+            "Sub" => BinaryOpKind::Subtract,
+            "Mul" => BinaryOpKind::Multiply,
+            "Div" => BinaryOpKind::Divide,
+            "Rem" => BinaryOpKind::Modulo,
+            "Eq" => BinaryOpKind::Equal,
+            "Ord" => BinaryOpKind::Less,
+            "BitAnd" => BinaryOpKind::And,
+            "BitOr" => BinaryOpKind::Or,
+            "BitXor" => BinaryOpKind::Xor,
+            "Shl" => BinaryOpKind::ShiftLeft,
+            "Shr" => BinaryOpKind::ShiftRight,
+            _ => return,
+        };
+
+        self.operator_traits.insert(operator, trait_id);
+
+        // Some operators also require we insert a matching entry for related operators
+        match operator {
+            BinaryOpKind::Equal => {
+                self.operator_traits.insert(BinaryOpKind::NotEqual, trait_id);
+            }
+            BinaryOpKind::Less => {
+                self.operator_traits.insert(BinaryOpKind::LessEqual, trait_id);
+                self.operator_traits.insert(BinaryOpKind::Greater, trait_id);
+                self.operator_traits.insert(BinaryOpKind::GreaterEqual, trait_id);
+
+                let the_trait = self.get_trait(trait_id);
+                self.ordering_type = match &the_trait.methods[0].typ {
+                    Type::Forall(_, typ) => match typ.as_ref() {
+                        Type::Function(_, return_type, _) => Some(return_type.as_ref().clone()),
+                        other => unreachable!("Expected function type for `cmp`, found {}", other),
+                    },
+                    other => unreachable!("Expected Forall type for `cmp`, found {}", other),
+                };
+            }
+            _ => (),
+        }
+    }
+
+    /// This function is needed when creating a NodeInterner for testing so that calls
+    /// to `get_operator_trait` do not panic when the stdlib isn't present.
+    #[cfg(test)]
+    pub fn populate_dummy_operator_traits(&mut self) {
+        let dummy_trait = TraitId(ModuleId::dummy_id());
+        self.operator_traits.insert(BinaryOpKind::Add, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Subtract, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Multiply, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Divide, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Modulo, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Equal, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::NotEqual, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Less, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::LessEqual, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Greater, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::GreaterEqual, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::And, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Or, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::Xor, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::ShiftLeft, dummy_trait);
+        self.operator_traits.insert(BinaryOpKind::ShiftRight, dummy_trait);
+    }
+
+    pub(crate) fn ordering_type(&self) -> Type {
+        self.ordering_type.clone().expect("Expected ordering_type to be set in the NodeInterner")
+    }
 }
 
 impl Methods {
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index cd0c34f7e09..063e0215a30 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -53,6 +53,7 @@ mod test {
         let root = std::path::Path::new("/");
         let fm = FileManager::new(root);
         let mut context = Context::new(fm);
+        context.def_interner.populate_dummy_operator_traits();
         let root_file_id = FileId::dummy();
         let root_crate_id = context.crate_graph.add_crate_root(root_file_id);
         let (program, parser_errors) = parse_program(src);
diff --git a/cspell.json b/cspell.json
index 4ba51240c19..94449a68a77 100644
--- a/cspell.json
+++ b/cspell.json
@@ -15,6 +15,8 @@
         "bincode",
         "bindgen",
         "bitand",
+        "bitxor",
+        "bitor",
         "blackbox",
         "bridgekeeper",
         "brillig",
diff --git a/docs/docs/explanations/standard_library/traits.md b/docs/docs/explanations/standard_library/traits.md
deleted file mode 100644
index 63b4f3d6f0b..00000000000
--- a/docs/docs/explanations/standard_library/traits.md
+++ /dev/null
@@ -1,140 +0,0 @@
----
-title: Traits
-description: Noir's stdlib provides a few commonly used traits.
-keywords: [traits, trait, interface, protocol, default, add, eq]
----
-
-## `std::default`
-
-### `std::default::Default`
-
-```rust
-trait Default {
-    fn default() -> Self;
-}
-```
-
-Constructs a default value of a type.
-
-Implementations:
-```rust
-impl Default for Field { .. }
-
-impl Default for i8 { .. }
-impl Default for i16 { .. }
-impl Default for i32 { .. }
-impl Default for i64 { .. }
-
-impl Default for u8 { .. }
-impl Default for u16 { .. }
-impl Default for u32 { .. }
-impl Default for u64 { .. }
-
-impl Default for () { .. }
-impl Default for bool { .. }
-
-impl<T, N> Default for [T; N]
-    where T: Default { .. }
-
-impl<A, B> Default for (A, B)
-    where A: Default, B: Default { .. }
-
-impl<A, B, C> Default for (A, B, C)
-    where A: Default, B: Default, C: Default { .. }
-
-impl<A, B, C, D> Default for (A, B, C, D)
-    where A: Default, B: Default, C: Default, D: Default { .. }
-
-impl<A, B, C, D, E> Default for (A, B, C, D, E)
-    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
-```
-
-For primitive integer types, the return value of `default` is `0`. Container
-types such as arrays are filled with default values of their element type.
-
-## `std::ops`
-
-### `std::ops::Eq`
-
-```rust
-trait Eq {
-    fn eq(self, other: Self) -> bool;
-}
-```
-Returns `true` if `self` is equal to `other`.
-
-Implementations:
-```rust
-impl Eq for Field { .. }
-
-impl Eq for i8 { .. }
-impl Eq for i16 { .. }
-impl Eq for i32 { .. }
-impl Eq for i64 { .. }
-
-impl Eq for u8 { .. }
-impl Eq for u16 { .. }
-impl Eq for u32 { .. }
-impl Eq for u64 { .. }
-
-impl Eq for () { .. }
-impl Eq for bool { .. }
-
-impl<T, N> Eq for [T; N]
-    where T: Eq { .. }
-
-impl<A, B> Eq for (A, B)
-    where A: Eq, B: Eq { .. }
-
-impl<A, B, C> Eq for (A, B, C)
-    where A: Eq, B: Eq, C: Eq { .. }
-
-impl<A, B, C, D> Eq for (A, B, C, D)
-    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
-
-impl<A, B, C, D, E> Eq for (A, B, C, D, E)
-    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
-```
-
-### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
-
-These traits abstract over addition, subtraction, multiplication, and division respectively.
-Although Noir does not currently have operator overloading, in the future 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.
-
-```rust
-trait Add {
-    fn add(self, other: Self) -> Self;
-}
-
-trait Sub {
-    fn sub(self, other: Self) -> Self;
-}
-
-trait Mul {
-    fn mul(self, other: Self) -> Self;
-}
-
-trait Div {
-    fn div(self, other: Self) -> Self;
-}
-```
-
-The implementations block below is given for the `Add` trait, but the same types that implement
-`Add` also implement `Sub`, `Mul`, and `Div`.
-
-Implementations:
-```rust
-impl Add for Field { .. }
-
-impl Add for i8 { .. }
-impl Add for i16 { .. }
-impl Add for i32 { .. }
-impl Add for i64 { .. }
-
-impl Add for u8 { .. }
-impl Add for u16 { .. }
-impl Add for u32 { .. }
-impl Add for u64 { .. }
-```
diff --git a/docs/docs/getting_started/create_a_project.md b/docs/docs/getting_started/create_a_project.md
index f10916c39c5..26ff265c389 100644
--- a/docs/docs/getting_started/create_a_project.md
+++ b/docs/docs/getting_started/create_a_project.md
@@ -69,7 +69,7 @@ x : Field, y : pub Field
 
 Program inputs in Noir are private by default (e.g. `x`), but can be labeled public using the
 keyword `pub` (e.g. `y`). To learn more about private and public values, check the
-[Data Types](../noir/syntax/data_types/index.md) section.
+[Data Types](../noir/concepts/data_types/index.md) section.
 
 The next line of the program specifies its body:
 
@@ -79,7 +79,7 @@ assert(x != y);
 
 The Noir syntax `assert` can be interpreted as something similar to constraints in other zk-contract languages.
 
-For more Noir syntax, check the [Language Concepts](../noir/syntax/comments.md) chapter.
+For more Noir syntax, check the [Language Concepts](../noir/concepts/comments.md) chapter.
 
 ## Build In/Output Files
 
diff --git a/docs/docs/migration_notes.md b/docs/docs/migration_notes.md
index 184ca283539..9f27230a1a0 100644
--- a/docs/docs/migration_notes.md
+++ b/docs/docs/migration_notes.md
@@ -16,7 +16,7 @@ To update, please make sure this field in `Nargo.toml` matches the output of `na
 
 ## ≥0.14
 
-The index of the [for loops](noir/syntax/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
+The index of the [for loops](noir/concepts/control_flow.md#loops) is now of type `u64` instead of `Field`. An example refactor would be:
 
 ```rust
 for i in 0..10 {
diff --git a/docs/docs/noir/concepts/_category_.json b/docs/docs/noir/concepts/_category_.json
index 78dd943647f..7da08f8a8c5 100644
--- a/docs/docs/noir/concepts/_category_.json
+++ b/docs/docs/noir/concepts/_category_.json
@@ -3,4 +3,4 @@
     "position": 0,
     "collapsible": true,
     "collapsed": true
-}
+}
\ No newline at end of file
diff --git a/docs/docs/noir/concepts/data_types/function_types.md b/docs/docs/noir/concepts/data_types/function_types.md
index 61e4076adaf..e224e860d59 100644
--- a/docs/docs/noir/concepts/data_types/function_types.md
+++ b/docs/docs/noir/concepts/data_types/function_types.md
@@ -23,4 +23,4 @@ fn main() {
 ```
 
 A function type also has an optional capture environment - this is necessary to support closures.
-See [Lambdas](@site/docs/noir/syntax/lambdas.md) for more details.
+See [Lambdas](@site/docs/noir/concepts/lambdas.md) for more details.
diff --git a/docs/docs/noir/concepts/data_types/index.md b/docs/docs/noir/concepts/data_types/index.md
index 01cd0431a68..3c9cd4c2437 100644
--- a/docs/docs/noir/concepts/data_types/index.md
+++ b/docs/docs/noir/concepts/data_types/index.md
@@ -79,7 +79,7 @@ fn main() {
 }
 ```
 
-Type aliases can also be used with [generics](@site/docs/noir/syntax/generics.md):
+Type aliases can also be used with [generics](@site/docs/noir/concepts/generics.md):
 
 ```rust
 type Id<Size> = Size;
diff --git a/docs/docs/explanations/noir/traits.md b/docs/docs/noir/concepts/traits.md
similarity index 100%
rename from docs/docs/explanations/noir/traits.md
rename to docs/docs/noir/concepts/traits.md
diff --git a/docs/docs/noir/standard_library/traits.md b/docs/docs/noir/standard_library/traits.md
new file mode 100644
index 00000000000..50b0e6816ab
--- /dev/null
+++ b/docs/docs/noir/standard_library/traits.md
@@ -0,0 +1,284 @@
+---
+title: Traits
+description: Noir's stdlib provides a few commonly used traits.
+keywords: [traits, trait, interface, protocol, default, add, eq]
+---
+
+## `std::default`
+
+### `std::default::Default`
+
+```rust
+trait Default {
+    fn default() -> Self;
+}
+```
+
+Constructs a default value of a type.
+
+Implementations:
+```rust
+impl Default for Field { .. }
+
+impl Default for i8 { .. }
+impl Default for i16 { .. }
+impl Default for i32 { .. }
+impl Default for i64 { .. }
+
+impl Default for u8 { .. }
+impl Default for u16 { .. }
+impl Default for u32 { .. }
+impl Default for u64 { .. }
+
+impl Default for () { .. }
+impl Default for bool { .. }
+
+impl<T, N> Default for [T; N]
+    where T: Default { .. }
+
+impl<A, B> Default for (A, B)
+    where A: Default, B: Default { .. }
+
+impl<A, B, C> Default for (A, B, C)
+    where A: Default, B: Default, C: Default { .. }
+
+impl<A, B, C, D> Default for (A, B, C, D)
+    where A: Default, B: Default, C: Default, D: Default { .. }
+
+impl<A, B, C, D, E> Default for (A, B, C, D, E)
+    where A: Default, B: Default, C: Default, D: Default, E: Default { .. }
+```
+
+For primitive integer types, the return value of `default` is `0`. Container
+types such as arrays are filled with default values of their element type.
+
+## `std::cmp`
+
+### `std::cmp::Eq`
+
+```rust
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+```
+Returns `true` if `self` is equal to `other`. Implementing this trait on a type
+allows the type to be used with `==` and `!=`.
+
+Implementations:
+```rust
+impl Eq for Field { .. }
+
+impl Eq for i8 { .. }
+impl Eq for i16 { .. }
+impl Eq for i32 { .. }
+impl Eq for i64 { .. }
+
+impl Eq for u8 { .. }
+impl Eq for u16 { .. }
+impl Eq for u32 { .. }
+impl Eq for u64 { .. }
+
+impl Eq for () { .. }
+impl Eq for bool { .. }
+
+impl<T, N> Eq for [T; N]
+    where T: Eq { .. }
+
+impl<A, B> Eq for (A, B)
+    where A: Eq, B: Eq { .. }
+
+impl<A, B, C> Eq for (A, B, C)
+    where A: Eq, B: Eq, C: Eq { .. }
+
+impl<A, B, C, D> Eq for (A, B, C, D)
+    where A: Eq, B: Eq, C: Eq, D: Eq { .. }
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E)
+    where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq { .. }
+```
+
+### `std::cmp::Cmp`
+
+```rust
+trait Cmp {
+    fn cmp(self, other: Self) -> Ordering;
+}
+```
+
+`a.cmp(b)` compares two values returning `Ordering::less()` if `a < b`,
+`Ordering::equal()` if `a == b`, or `Ordering::greater()` if `a > b`.
+Implementing this trait on a type allows `<`, `<=`, `>`, and `>=` to be
+used on values of the type.
+
+Implementations:
+
+```rust
+impl Ord for u8 { .. }
+impl Ord for u16 { .. }
+impl Ord for u32 { .. }
+impl Ord for u64 { .. }
+
+impl Ord for i8 { .. }
+impl Ord for i16 { .. }
+impl Ord for i32 { .. }
+
+impl Ord for i64 { .. }
+
+impl Ord for () { .. }
+impl Ord for bool { .. }
+
+impl<T, N> Ord for [T; N]
+    where T: Ord { .. }
+
+impl<A, B> Ord for (A, B)
+    where A: Ord, B: Ord { .. }
+
+impl<A, B, C> Ord for (A, B, C)
+    where A: Ord, B: Ord, C: Ord { .. }
+
+impl<A, B, C, D> Ord for (A, B, C, D)
+    where A: Ord, B: Ord, C: Ord, D: Ord { .. }
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E)
+    where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord { .. }
+```
+
+## `std::ops`
+
+### `std::ops::Add`, `std::ops::Sub`, `std::ops::Mul`, and `std::ops::Div`
+
+These traits abstract over addition, subtraction, multiplication, and division respectively.
+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.
+
+```rust
+trait Add {
+    fn add(self, other: Self) -> Self;
+}
+
+trait Sub {
+    fn sub(self, other: Self) -> Self;
+}
+
+trait Mul {
+    fn mul(self, other: Self) -> Self;
+}
+
+trait Div {
+    fn div(self, other: Self) -> Self;
+}
+```
+
+The implementations block below is given for the `Add` trait, but the same types that implement
+`Add` also implement `Sub`, `Mul`, and `Div`.
+
+Implementations:
+```rust
+impl Add for Field { .. }
+
+impl Add for i8 { .. }
+impl Add for i16 { .. }
+impl Add for i32 { .. }
+impl Add for i64 { .. }
+
+impl Add for u8 { .. }
+impl Add for u16 { .. }
+impl Add for u32 { .. }
+impl Add for u64 { .. }
+```
+
+### `std::ops::Rem`
+
+```rust
+trait Rem {
+    fn rem(self, other: Self) -> Self;
+}
+```
+
+`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
+to be used with the implementation type.
+
+Unlike other numeric traits, `Rem` is not implemented for `Field`.
+
+Implementations:
+```rust
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { 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 } }
+```
+
+### `std::ops::{ BitOr, BitAnd, BitXor }`
+
+```rust
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
+}
+
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
+}
+
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
+}
+```
+
+Traits for the bitwise operations `|`, `&`, and `^`.
+
+Implementing `BitOr`, `BitAnd` or `BitXor` for a type allows the `|`, `&`, or `^` operator respectively
+to be used with the type.
+
+The implementations block below is given for the `BitOr` trait, but the same types that implement
+`BitOr` also implement `BitAnd` and `BitXor`.
+
+Implementations:
+```rust
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { 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 } }
+```
+
+### `std::ops::{ Shl, Shr }`
+
+```rust
+trait Shl {
+    fn shl(self, other: Self) -> Self;
+}
+
+trait Shr {
+    fn shr(self, other: Self) -> Self;
+}
+```
+
+Traits for a bit shift left and bit shift right.
+
+Implementing `Shl` for a type allows the left shift operator (`<<`) to be used with the implementation type.
+Similarly, implementing `Shr` allows the right shift operator (`>>`) to be used with the type.
+
+Note that bit shifting is not currently implemented for signed types.
+
+The implementations block below is given for the `Shl` trait, but the same types that implement
+`Shl` also implement `Shr`.
+
+Implementations:
+```rust
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+```
\ No newline at end of file
diff --git a/noir_stdlib/src/cmp.nr b/noir_stdlib/src/cmp.nr
new file mode 100644
index 00000000000..11127494c18
--- /dev/null
+++ b/noir_stdlib/src/cmp.nr
@@ -0,0 +1,310 @@
+trait Eq {
+    fn eq(self, other: Self) -> bool;
+}
+
+impl Eq for Field { fn eq(self, other: Field) -> bool { self == other } }
+
+impl Eq for u1 { fn eq(self, other: u1) -> bool { self == other } }
+impl Eq for u8 { fn eq(self, other: u8) -> bool { self == other } }
+impl Eq for u16 { fn eq(self, other: u16) -> bool { self == other } }
+impl Eq for u32 { fn eq(self, other: u32) -> bool { self == other } }
+impl Eq for u64 { fn eq(self, other: u64) -> bool { self == other } }
+
+impl Eq for i8 { fn eq(self, other: i8) -> bool { self == other } }
+impl Eq for i16 { fn eq(self, other: i16) -> bool { self == other } }
+impl Eq for i32 { fn eq(self, other: i32) -> bool { self == other } }
+impl Eq for i64 { fn eq(self, other: i64) -> bool { self == other } }
+
+impl Eq for () { fn eq(_self: Self, _other: ()) -> bool { true } }
+impl Eq for bool { fn eq(self, other: bool) -> bool { self == other } }
+
+impl<T, N> Eq for [T; N] where T: Eq {
+    fn eq(self, other: [T; N]) -> bool {
+        let mut result = true;
+        for i in 0 .. self.len() {
+            result &= self[i].eq(other[i]);
+        }
+        result
+    }
+}
+
+impl<N> Eq for str<N> {
+    fn eq(self, other: str<N>) -> bool {
+        let self_bytes = self.as_bytes();
+        let other_bytes = other.as_bytes();
+        self_bytes == other_bytes
+    }
+}
+
+impl<A, B> Eq for (A, B) where A: Eq, B: Eq {
+    fn eq(self, other: (A, B)) -> bool {
+        self.0.eq(other.0) & self.1.eq(other.1)
+    }
+}
+
+impl<A, B, C> Eq for (A, B, C) where A: Eq, B: Eq, C: Eq {
+    fn eq(self, other: (A, B, C)) -> bool {
+        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)
+    }
+}
+
+impl<A, B, C, D> Eq for (A, B, C, D) where A: Eq, B: Eq, C: Eq, D: Eq {
+    fn eq(self, other: (A, B, C, D)) -> bool {
+        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)
+    }
+}
+
+impl<A, B, C, D, E> Eq for (A, B, C, D, E) where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq {
+    fn eq(self, other: (A, B, C, D, E)) -> bool {
+        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3) & self.4.eq(other.4)
+    }
+}
+
+impl Eq for Ordering {
+    fn eq(self, other: Ordering) -> bool {
+        self.result == other.result
+    }
+}
+
+
+// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct
+// that has 3 public functions for constructing the struct.
+struct Ordering {
+    result: Field,
+}
+
+impl Ordering {
+    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built
+    // into the compiler, do not change these without also updating
+    // the compiler itself!
+    pub fn less() -> Ordering {
+        Ordering { result: 0 }
+    }
+
+    pub fn equal() -> Ordering {
+        Ordering { result: 1 }
+    }
+
+    pub fn greater() -> Ordering {
+        Ordering { result: 2 }
+    }
+}
+
+
+trait Ord {
+    fn cmp(self, other: Self) -> Ordering;
+}
+
+// Note: Field deliberately does not implement Ord
+
+impl Ord for u8 {
+    fn cmp(self, other: u8) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for u16 {
+    fn cmp(self, other: u16) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for u32 {
+    fn cmp(self, other: u32) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for u64 {
+    fn cmp(self, other: u64) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for i8 {
+    fn cmp(self, other: i8) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for i16 {
+    fn cmp(self, other: i16) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for i32 {
+    fn cmp(self, other: i32) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for i64 {
+    fn cmp(self, other: i64) -> Ordering {
+        if self < other {
+            Ordering::less()
+        } else if self > other {
+            Ordering::greater()
+        } else {
+            Ordering::equal()
+        }
+    }
+}
+
+impl Ord for () {
+    fn cmp(_self: Self, _other: ()) -> Ordering {
+        Ordering::equal()
+    }
+}
+
+impl Ord for bool {
+    fn cmp(self, other: bool) -> Ordering {
+        if self {
+            if other {
+                Ordering::equal()
+            } else {
+                Ordering::greater()
+            }
+        } else {
+            if other {
+                Ordering::less()
+            } else {
+                Ordering::equal()
+            }
+        }
+    }
+}
+
+impl<T, N> Ord for [T; N] where T: Ord {
+    // The first non-equal element of both arrays determines
+    // the ordering for the whole array.
+    fn cmp(self, other: [T; N]) -> Ordering {
+        let mut result = Ordering::equal();
+        for i in 0 .. self.len() {
+            if result == Ordering::equal() {
+                let result_i = self[i].cmp(other[i]);
+
+                if result_i == Ordering::less() {
+                    result = result_i;
+                } else if result_i == Ordering::greater() {
+                    result = result_i;
+                }
+            }
+        }
+        result
+    }
+}
+
+impl<A, B> Ord for (A, B) where A: Ord, B: Ord {
+    fn cmp(self, other: (A, B)) -> Ordering {
+        let result = self.0.cmp(other.0);
+
+        if result != Ordering::equal() {
+            result
+        } else {
+            self.1.cmp(other.1)
+        }
+    }
+}
+
+impl<A, B, C> Ord for (A, B, C) where A: Ord, B: Ord, C: Ord {
+    fn cmp(self, other: (A, B, C)) -> Ordering {
+        let mut result = self.0.cmp(other.0);
+
+        if result == Ordering::equal() {
+            result = self.1.cmp(other.1);
+        }
+
+        if result == Ordering::equal() {
+            result = self.2.cmp(other.2);
+        }
+
+        result
+    }
+}
+
+impl<A, B, C, D> Ord for (A, B, C, D) where A: Ord, B: Ord, C: Ord, D: Ord {
+    fn cmp(self, other: (A, B, C, D)) -> Ordering {
+        let mut result = self.0.cmp(other.0);
+
+        if result == Ordering::equal() {
+            result = self.1.cmp(other.1);
+        }
+
+        if result == Ordering::equal() {
+            result = self.2.cmp(other.2);
+        }
+
+        if result == Ordering::equal() {
+            result = self.3.cmp(other.3);
+        }
+
+        result
+    }
+}
+
+impl<A, B, C, D, E> Ord for (A, B, C, D, E) where A: Ord, B: Ord, C: Ord, D: Ord, E: Ord {
+    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {
+        let mut result = self.0.cmp(other.0);
+
+        if result == Ordering::equal() {
+            result = self.1.cmp(other.1);
+        }
+
+        if result == Ordering::equal() {
+            result = self.2.cmp(other.2);
+        }
+
+        if result == Ordering::equal() {
+            result = self.3.cmp(other.3);
+        }
+
+        if result == Ordering::equal() {
+            result = self.4.cmp(other.4);
+        }
+
+        result
+    }
+}
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index 70b4681b54d..9b166f6ae94 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -19,6 +19,7 @@ mod compat;
 mod option;
 mod string;
 mod test;
+mod cmp;
 mod ops;
 mod default;
 mod prelude;
diff --git a/noir_stdlib/src/ops.nr b/noir_stdlib/src/ops.nr
index 23acc2f0e5d..3078ac11296 100644
--- a/noir_stdlib/src/ops.nr
+++ b/noir_stdlib/src/ops.nr
@@ -63,55 +63,94 @@ impl Div for i16 { fn div(self, other: i16) -> i16 { 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 } }
 
-trait Eq {
-    fn eq(self, other: Self) -> bool;
+trait Rem {
+    fn rem(self, other: Self) -> Self;
 }
 
-impl Eq for Field { fn eq(self, other: Field) -> bool { self == other } }
-
-impl Eq for u8 { fn eq(self, other: u8) -> bool { self == other } }
-impl Eq for u16 { fn eq(self, other: u16) -> bool { self == other } }
-impl Eq for u32 { fn eq(self, other: u32) -> bool { self == other } }
-impl Eq for u64 { fn eq(self, other: u64) -> bool { self == other } }
-
-impl Eq for i8 { fn eq(self, other: i8) -> bool { self == other } }
-impl Eq for i16 { fn eq(self, other: i16) -> bool { self == other } }
-impl Eq for i32 { fn eq(self, other: i32) -> bool { self == other } }
-impl Eq for i64 { fn eq(self, other: i64) -> bool { self == other } }
-
-impl Eq for () { fn eq(_self: Self, _other: ()) -> bool { true } }
-impl Eq for bool { fn eq(self, other: bool) -> bool { self == other } }
-
-impl<T, N> Eq for [T; N] where T: Eq {
-    fn eq(self, other: [T; N]) -> bool {
-        let mut result = true;
-        for i in 0 .. self.len() {
-            result &= self[i].eq(other[i]);
-        }
-        result
-    }
+impl Rem for u8 { fn rem(self, other: u8) -> u8 { self % other } }
+impl Rem for u16 { fn rem(self, other: u16) -> u16 { self % other } }
+impl Rem for u32 { fn rem(self, other: u32) -> u32 { self % other } }
+impl Rem for u64 { fn rem(self, other: u64) -> u64 { self % other } }
+
+impl Rem for i8 { fn rem(self, other: i8) -> i8 { self % other } }
+impl Rem for i16 { fn rem(self, other: i16) -> i16 { 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 } }
+
+trait BitOr {
+    fn bitor(self, other: Self) -> Self;
 }
 
-impl<A, B> Eq for (A, B) where A: Eq, B: Eq {
-    fn eq(self, other: (A, B)) -> bool {
-        self.0.eq(other.0) & self.1.eq(other.1)
-    }
+impl BitOr for bool { fn bitor(self, other: bool) -> bool { self | other } }
+
+impl BitOr for u8 { fn bitor(self, other: u8) -> u8 { self | other } }
+impl BitOr for u16 { fn bitor(self, other: u16) -> u16 { self | other } }
+impl BitOr for u32 { fn bitor(self, other: u32) -> u32 { self | other } }
+impl BitOr for u64 { fn bitor(self, other: u64) -> u64 { self | other } }
+
+impl BitOr for i8 { fn bitor(self, other: i8) -> i8 { self | other } }
+impl BitOr for i16 { fn bitor(self, other: i16) -> i16 { 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 } }
+
+trait BitAnd {
+    fn bitand(self, other: Self) -> Self;
 }
 
-impl<A, B, C> Eq for (A, B, C) where A: Eq, B: Eq, C: Eq {
-    fn eq(self, other: (A, B, C)) -> bool {
-        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)
-    }
+impl BitAnd for bool { fn bitand(self, other: bool) -> bool { self & other } }
+
+impl BitAnd for u8 { fn bitand(self, other: u8) -> u8 { self & other } }
+impl BitAnd for u16 { fn bitand(self, other: u16) -> u16 { self & other } }
+impl BitAnd for u32 { fn bitand(self, other: u32) -> u32 { self & other } }
+impl BitAnd for u64 { fn bitand(self, other: u64) -> u64 { self & other } }
+
+impl BitAnd for i8 { fn bitand(self, other: i8) -> i8 { self & other } }
+impl BitAnd for i16 { fn bitand(self, other: i16) -> i16 { 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 } }
+
+trait BitXor {
+    fn bitxor(self, other: Self) -> Self;
 }
 
-impl<A, B, C, D> Eq for (A, B, C, D) where A: Eq, B: Eq, C: Eq, D: Eq {
-    fn eq(self, other: (A, B, C, D)) -> bool {
-        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)
-    }
+impl BitXor for bool { fn bitxor(self, other: bool) -> bool { self ^ other } }
+
+impl BitXor for u8 { fn bitxor(self, other: u8) -> u8 { self ^ other } }
+impl BitXor for u16 { fn bitxor(self, other: u16) -> u16 { self ^ other } }
+impl BitXor for u32 { fn bitxor(self, other: u32) -> u32 { self ^ other } }
+impl BitXor for u64 { fn bitxor(self, other: u64) -> u64 { self ^ other } }
+
+impl BitXor for i8 { fn bitxor(self, other: i8) -> i8 { self ^ other } }
+impl BitXor for i16 { fn bitxor(self, other: i16) -> i16 { 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 } }
+
+trait Shl {
+    fn shl(self, other: Self) -> Self;
 }
 
-impl<A, B, C, D, E> Eq for (A, B, C, D, E) where A: Eq, B: Eq, C: Eq, D: Eq, E: Eq {
-    fn eq(self, other: (A, B, C, D, E)) -> bool {
-        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3) & self.4.eq(other.4)
-    }
+impl Shl for u8 { fn shl(self, other: u8) -> u8 { self << other } }
+impl Shl for u16 { fn shl(self, other: u16) -> u16 { self << other } }
+impl Shl for u32 { fn shl(self, other: u32) -> u32 { self << other } }
+impl Shl for u64 { fn shl(self, other: u64) -> u64 { self << other } }
+
+// Bit shifting is not currently supported for signed integer types
+// impl Shl for i8 { fn shl(self, other: i8) -> i8 { self << other } }
+// impl Shl for i16 { fn shl(self, other: i16) -> i16 { self << other } }
+// impl Shl for i32 { fn shl(self, other: i32) -> i32 { self << other } }
+// impl Shl for i64 { fn shl(self, other: i64) -> i64 { self << other } }
+
+trait Shr {
+    fn shr(self, other: Self) -> Self;
 }
+
+impl Shr for u8 { fn shr(self, other: u8) -> u8 { self >> other } }
+impl Shr for u16 { fn shr(self, other: u16) -> u16 { self >> other } }
+impl Shr for u32 { fn shr(self, other: u32) -> u32 { self >> other } }
+impl Shr for u64 { fn shr(self, other: u64) -> u64 { self >> other } }
+
+// Bit shifting is not currently supported for signed integer types
+// impl Shr for i8 { fn shr(self, other: i8) -> i8 { self >> other } }
+// impl Shr for i16 { fn shr(self, other: i16) -> i16 { self >> other } }
+// impl Shr for i32 { fn shr(self, other: i32) -> i32 { self >> other } }
+// impl Shr for i64 { fn shr(self, other: i64) -> i64 { self >> other } }
diff --git a/noir_stdlib/src/prelude.nr b/noir_stdlib/src/prelude.nr
index f33a1f7e7f1..56020509122 100644
--- a/noir_stdlib/src/prelude.nr
+++ b/noir_stdlib/src/prelude.nr
@@ -1,3 +1,5 @@
 use crate::collections::vec::Vec;
 use crate::option::Option;
 use crate::{print, println, assert_constant};
+use crate::cmp::{Eq, Ord};
+use crate::default::Default;
diff --git a/test_programs/compile_success_empty/impl_with_where_clause/src/main.nr b/test_programs/compile_success_empty/impl_with_where_clause/src/main.nr
index de3078be8ba..780512f04dc 100644
--- a/test_programs/compile_success_empty/impl_with_where_clause/src/main.nr
+++ b/test_programs/compile_success_empty/impl_with_where_clause/src/main.nr
@@ -1,27 +1,27 @@
 fn main() {
     let array: [Field; 3] = [1, 2, 3];
-    assert(array.eq(array));
+    assert(array.my_eq(array));
     // Ensure this still works if we have to infer the type of the integer literals
     let array = [1, 2, 3];
-    assert(array.eq(array));
+    assert(array.my_eq(array));
 }
 
-trait Eq {
-    fn eq(self, other: Self) -> bool;
+trait MyEq {
+    fn my_eq(self, other: Self) -> bool;
 }
 
-impl<T> Eq for [T; 3] where T: Eq {
-    fn eq(self, other: Self) -> bool {
+impl<T> MyEq for [T; 3] where T: MyEq {
+    fn my_eq(self, other: Self) -> bool {
         let mut ret = true;
         for i in 0 .. self.len() {
-            ret &= self[i].eq(other[i]);
+            ret &= self[i].my_eq(other[i]);
         }
         ret
     }
 }
 
-impl Eq for Field {
-    fn eq(self, other: Field) -> bool {
+impl MyEq for Field {
+    fn my_eq(self, other: Field) -> bool {
         self == other
     }
 }
diff --git a/test_programs/compile_success_empty/trait_default_implementation/src/main.nr b/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
index e1f29ce3f48..2f5bff8c40c 100644
--- a/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
+++ b/test_programs/compile_success_empty/trait_default_implementation/src/main.nr
@@ -1,12 +1,11 @@
 use dep::std;
 
-trait Default {
-    fn default(x: Field, y: Field) -> Self;
+trait MyDefault {
+    fn my_default(x: Field, y: Field) -> Self;
 
     fn method2(x: Field) -> Field {
-	x
+	    x
     }
-
 }
 
 struct Foo {
@@ -14,8 +13,8 @@ struct Foo {
     array: [Field; 2],
 }
 
-impl Default for Foo {
-    fn default(x: Field,y: Field) -> Self {
+impl MyDefault for Foo {
+    fn my_default(x: Field,y: Field) -> Self {
         Self { bar: x, array: [x,y] }
     }
 }
diff --git a/test_programs/compile_success_empty/trait_override_implementation/src/main.nr b/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
index a385efc63fd..85528291870 100644
--- a/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
+++ b/test_programs/compile_success_empty/trait_override_implementation/src/main.nr
@@ -1,7 +1,7 @@
 use dep::std;
 
-trait Default {
-    fn default(x: Field, y: Field) -> Self;
+trait MyDefault {
+    fn my_default(x: Field, y: Field) -> Self;
 
     fn method2(x: Field) -> Field {
         x
@@ -13,8 +13,8 @@ struct Foo {
     array: [Field; 2],
 }
 
-impl Default for Foo {
-    fn default(x: Field,y: Field) -> Self {
+impl MyDefault for Foo {
+    fn my_default(x: Field,y: Field) -> Self {
         Self { bar: x, array: [x,y] }
     }
 
@@ -25,18 +25,18 @@ impl Default for Foo {
 
 trait F {
     fn f1(self) -> Field;
-    fn f2(self) -> Field { 2 }
-    fn f3(self) -> Field { 3 }
-    fn f4(self) -> Field { 4 }
-    fn f5(self) -> Field { 5 }
+    fn f2(_self: Self) -> Field { 2 }
+    fn f3(_self: Self) -> Field { 3 }
+    fn f4(_self: Self) -> Field { 4 }
+    fn f5(_self: Self) -> Field { 5 }
 }
 
 struct Bar {}
 
 impl F for Bar {
-    fn f5(self) -> Field { 50 }
-    fn f1(self) -> Field { 10 }
-    fn f3(self) -> Field { 30 }
+    fn f5(_self: Self) -> Field { 50 }
+    fn f1(_self: Self) -> Field { 10 }
+    fn f3(_self: Self) -> Field { 30 }
 }
 // Impls on mutable references are temporarily disabled
 // impl F for &mut Bar {
diff --git a/test_programs/compile_success_empty/traits/src/main.nr b/test_programs/compile_success_empty/traits/src/main.nr
index 784ff01a883..ed804559fed 100644
--- a/test_programs/compile_success_empty/traits/src/main.nr
+++ b/test_programs/compile_success_empty/traits/src/main.nr
@@ -1,7 +1,7 @@
 use dep::std;
 
-trait Default {
-    fn default(x: Field, y: Field) -> Self;
+trait MyDefault {
+    fn my_default(x: Field, y: Field) -> Self;
 }
 
 struct Foo {
@@ -9,13 +9,13 @@ struct Foo {
     array: [Field; 2],
 }
 
-impl Default for Foo {
-    fn default(x: Field,y: Field) -> Self {
+impl MyDefault for Foo {
+    fn my_default(x: Field,y: Field) -> Self {
         Self { bar: x, array: [x,y] }
     }
 }
 
 fn main(x: Field, y: Field) {
-    let first = Foo::default(x, y);
+    let first = Foo::my_default(x, y);
     assert(first.bar == x);
 }
diff --git a/test_programs/execution_success/operator_overloading/Nargo.toml b/test_programs/execution_success/operator_overloading/Nargo.toml
new file mode 100644
index 00000000000..7f9f18ff567
--- /dev/null
+++ b/test_programs/execution_success/operator_overloading/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "operator_overloading"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.20.0"
+
+[dependencies]
diff --git a/test_programs/execution_success/operator_overloading/Prover.toml b/test_programs/execution_success/operator_overloading/Prover.toml
new file mode 100644
index 00000000000..516b7b4074c
--- /dev/null
+++ b/test_programs/execution_success/operator_overloading/Prover.toml
@@ -0,0 +1,2 @@
+x = 3
+y = 9
diff --git a/test_programs/execution_success/operator_overloading/src/main.nr b/test_programs/execution_success/operator_overloading/src/main.nr
new file mode 100644
index 00000000000..3867531abca
--- /dev/null
+++ b/test_programs/execution_success/operator_overloading/src/main.nr
@@ -0,0 +1,154 @@
+use dep::std::ops::{ Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr };
+use dep::std::cmp::Ordering;
+
+// x = 3, y = 9
+fn main(x: u32, y: u32) {
+    let wx = Wrapper::new(x);
+    let wy = Wrapper::new(y);
+
+    // expected x and expected y values
+    let ex: u32 = 3;
+    let ey: u32 = 9;
+
+    assert((wx + wy).inner == ex + ey);
+    assert((wy - wx).inner == ey - ex);
+    assert((wx * wy).inner == ex * ey);
+    assert((wx / wy).inner == ex / ey);
+    assert((wx % wy).inner == ex % ey);
+
+    assert((wx & wy).inner == (ex & ey));
+    assert((wx | wy).inner == (ex | ey));
+    assert((wx ^ wy).inner == (ex ^ ey));
+
+    assert((wy << wx).inner == (ey << ex));
+    assert((wy >> wx).inner == (ey >> ex));
+
+    assert((wx == wy) == (ex == ey));
+    assert((wx < wy) == (ex < ey));
+    assert((wx <= wy) == (ex <= ey));
+    assert((wx > wy) == (ex > ey));
+    assert((wx >= wy) == (ex >= ey));
+    assert(wx.cmp(wy) == ex.cmp(ey));
+
+    // Ensure operator overloading still works with more complex types 
+    let pair_ascending = Pair { x: wx, y: wy };
+    let pair_descending = Pair { x: wy, y: wx };
+
+    assert(pair_ascending != pair_descending);
+
+    assert(pair_ascending < pair_descending);
+    assert(pair_ascending <= pair_descending);
+    assert(pair_descending > pair_ascending);
+    assert(pair_descending >= pair_ascending);
+
+    assert(pair_ascending.cmp(pair_descending) == Ordering::less());
+}
+
+struct Wrapper {
+    inner: u32
+}
+
+impl Wrapper {
+    fn new(inner: u32) -> Self {
+        Wrapper { inner }
+    }
+}
+
+impl Add for Wrapper {
+    fn add(self, other: Self) -> Self {
+        Wrapper::new(self.inner + other.inner)
+    }
+}
+
+impl Sub for Wrapper {
+    fn sub(self, other: Self) -> Self {
+        Wrapper::new(self.inner - other.inner)
+    }
+}
+
+impl Mul for Wrapper {
+    fn mul(self, other: Self) -> Self {
+        Wrapper::new(self.inner * other.inner)
+    }
+}
+
+impl Div for Wrapper {
+    fn div(self, other: Self) -> Self {
+        Wrapper::new(self.inner / other.inner)
+    }
+}
+
+impl Rem for Wrapper {
+    fn rem(self, other: Self) -> Self {
+        Wrapper::new(self.inner % other.inner)
+    }
+}
+
+impl BitAnd for Wrapper {
+    fn bitand(self, other: Self) -> Self {
+        Wrapper::new(self.inner & other.inner)
+    }
+}
+
+impl BitOr for Wrapper {
+    fn bitor(self, other: Self) -> Self {
+        Wrapper::new(self.inner | other.inner)
+    }
+}
+
+impl BitXor for Wrapper {
+    fn bitxor(self, other: Self) -> Self {
+        Wrapper::new(self.inner ^ other.inner)
+    }
+}
+
+impl Shl for Wrapper {
+    fn shl(self, other: Self) -> Self {
+        Wrapper::new(self.inner << other.inner)
+    }
+}
+
+impl Shr for Wrapper {
+    fn shr(self, other: Self) -> Self {
+        Wrapper::new(self.inner >> other.inner)
+    }
+}
+
+impl Eq for Wrapper {
+    fn eq(self, other: Self) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl Ord for Wrapper {
+    fn cmp(self, other: Self) -> Ordering {
+        self.inner.cmp(other.inner)
+    }
+}
+
+
+
+
+
+struct Pair {
+    x: Wrapper,
+    y: Wrapper,
+}
+
+impl Eq for Pair {
+    fn eq(self, o: Self) -> bool {
+        (self.x == o.x) & (self.y == o.y)
+    }
+}
+
+impl Ord for Pair {
+    fn cmp(self, o: Self) -> Ordering {
+        let mut result = self.x.cmp(o.x);
+
+        if result == Ordering::equal() {
+            result = self.y.cmp(o.y);
+        }
+
+        result
+    }
+}
diff --git a/tooling/lsp/src/lib.rs b/tooling/lsp/src/lib.rs
index 9887e5b8e96..90e8e563cd3 100644
--- a/tooling/lsp/src/lib.rs
+++ b/tooling/lsp/src/lib.rs
@@ -21,14 +21,12 @@ use fm::codespan_files as files;
 use lsp_types::CodeLens;
 use nargo::workspace::Workspace;
 use nargo_toml::{find_file_manifest, resolve_workspace_from_toml, PackageSelection};
-use noirc_driver::NOIR_ARTIFACT_VERSION_STRING;
+use noirc_driver::{file_manager_with_stdlib, prepare_crate, NOIR_ARTIFACT_VERSION_STRING};
 use noirc_frontend::{
     graph::{CrateId, CrateName},
     hir::{Context, FunctionNameMatch},
 };
 
-use fm::FileManager;
-
 use notifications::{
     on_did_change_configuration, on_did_change_text_document, on_did_close_text_document,
     on_did_open_text_document, on_did_save_text_document, on_exit, on_initialized,
@@ -223,14 +221,14 @@ pub(crate) fn resolve_workspace_for_source_path(file_path: &Path) -> Result<Work
 /// in order to offer code lenses to the user
 fn prepare_source(source: String) -> (Context<'static>, CrateId) {
     let root = Path::new("");
-    let mut file_manager = FileManager::new(root);
-    let root_file_id = file_manager.add_file_with_source(Path::new("main.nr"), source).expect(
+    let file_name = Path::new("main.nr");
+    let mut file_manager = file_manager_with_stdlib(root);
+    file_manager.add_file_with_source(file_name, source).expect(
         "Adding source buffer to file manager should never fail when file manager is empty",
     );
 
     let mut context = Context::new(file_manager);
-
-    let root_crate_id = context.crate_graph.add_crate_root(root_file_id);
+    let root_crate_id = prepare_crate(&mut context, file_name);
 
     (context, root_crate_id)
 }