diff --git a/.github/workflows/formatting.yml b/.github/workflows/formatting.yml
index 43fd6daa91d..279e90f5f6f 100644
--- a/.github/workflows/formatting.yml
+++ b/.github/workflows/formatting.yml
@@ -63,3 +63,68 @@ jobs:
 
       - name: Run `yarn lint`
         run: yarn lint
+
+  build-nargo:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout Noir repo
+        uses: actions/checkout@v4
+
+      - name: Setup toolchain
+        uses: dtolnay/rust-toolchain@1.73.0
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: x86_64-unknown-linux-gnu
+          cache-on-failure: true
+          save-if: ${{ github.event_name != 'merge_group' }}
+
+      - name: Build Nargo
+        run: cargo build --package nargo_cli --release
+
+      - name: Package artifacts
+        run: |
+          mkdir dist
+          cp ./target/release/nargo ./dist/nargo
+          7z a -ttar -so -an ./dist/* | 7z a -si ./nargo-x86_64-unknown-linux-gnu.tar.gz
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: nargo
+          path: ./dist/*
+          retention-days: 3
+
+  nargo_fmt:
+    needs: [build-nargo]
+    name: Nargo fmt
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+            
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+
+      - name: Format stdlib
+        working-directory: ./noir_stdlib
+        run: nargo fmt --check
+
+      - name: Format test suite
+        working-directory: ./test_programs
+        run: ./format.sh check
diff --git a/noir_stdlib/src/array.nr b/noir_stdlib/src/array.nr
index 7871b1a6f9a..3da4b649174 100644
--- a/noir_stdlib/src/array.nr
+++ b/noir_stdlib/src/array.nr
@@ -17,14 +17,14 @@ impl<T, N> [T; N] {
         for i in 0..N {
             let pos = find_index(sorted_index, i);
             assert(sorted_index[pos] == i);
-         }
+        }
         // Sort the array using the indexes
-         for i in 0..N {
+        for i in 0..N {
             result[i] = self[sorted_index[i]];
-         }
+        }
         // Ensure the array is sorted
-        for i in 0..N-1 {
-            assert(ordering(result[i], result[i+1]));
+        for i in 0..N - 1 {
+            assert(ordering(result[i], result[i + 1]));
         }
 
         result
@@ -32,12 +32,12 @@ impl<T, N> [T; N] {
 
     /// Returns the index of the elements in the array that would sort it, using the provided custom sorting function.
     unconstrained fn get_sorting_index<Env>(self, ordering: fn[Env](T, T) -> bool) -> [u64; N] {
-        let mut result = [0;N];
+        let mut result = [0; N];
         let mut a = self;
         for i in 0..N {
             result[i] = i;
         }
-        for i in 1 .. N {
+        for i in 1..N {
             for j in 0..i {
                 if ordering(a[i], a[j]) {
                     let old_a_j = a[j];
@@ -45,14 +45,13 @@ impl<T, N> [T; N] {
                     a[i] = old_a_j;
                     let old_j = result[j];
                     result[j] = result[i];
-                    result[i] = old_j; 
+                    result[i] = old_j;
                 }
             }
         }
         result
     }
 
-
     // Converts an array into a slice.
     pub fn as_slice(self) -> [T] {
         let mut slice = [];
@@ -68,7 +67,7 @@ impl<T, N> [T; N] {
         let first_elem = f(self[0]);
         let mut ret = [first_elem; N];
 
-        for i in 1 .. self.len() {
+        for i in 1..self.len() {
             ret[i] = f(self[i]);
         }
 
@@ -90,7 +89,7 @@ impl<T, N> [T; N] {
     // element of the given array as its starting accumulator value.
     pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {
         let mut accumulator = self[0];
-        for i in 1 .. self.len() {
+        for i in 1..self.len() {
             accumulator = f(accumulator, self[i]);
         }
         accumulator
@@ -122,7 +121,7 @@ unconstrained fn find_index<N>(a: [u64; N], find: u64) -> u64 {
     for i in 0..a.len() {
         if a[i] == find {
             result = i;
-        }     
+        }
     }
     result
 }
diff --git a/noir_stdlib/src/bigint.nr b/noir_stdlib/src/bigint.nr
index 11026651207..66e81f05812 100644
--- a/noir_stdlib/src/bigint.nr
+++ b/noir_stdlib/src/bigint.nr
@@ -1,5 +1,4 @@
-use crate::ops::{Add, Sub, Mul, Div, Rem,};
-
+use crate::ops::{Add, Sub, Mul, Div, Rem};
 
 global bn254_fq = [0x47, 0xFD, 0x7C, 0xD8, 0x16, 0x8C, 0x20, 0x3C, 0x8d, 0xca, 0x71, 0x68, 0x91, 0x6a, 0x81, 0x97,
                    0x5d, 0x58, 0x81, 0x81, 0xb6, 0x45, 0x50, 0xb8, 0x29, 0xa0, 0x31, 0xe1, 0x72, 0x4e, 0x64, 0x30];
@@ -13,7 +12,6 @@ global secpr1_fq = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF];
 global secpr1_fr = [0x51, 0x25, 0x63, 0xFC, 0xC2, 0xCA, 0xB9, 0xF3, 0x84, 0x9E, 0x17, 0xA7, 0xAD, 0xFA, 0xE6, 0xBC,
                     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,0xFF, 0xFF, 0xFF, 0xFF];
- 
 
 struct BigInt {
     pointer: u32,
@@ -22,17 +20,13 @@ struct BigInt {
 
 impl BigInt {
     #[builtin(bigint_add)]
-    fn bigint_add(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_add(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_sub)]
-    fn bigint_sub(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_sub(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_mul)]
-    fn bigint_mul(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_mul(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_div)]
-    fn bigint_div(self, other: BigInt) -> BigInt {
-    }
+    fn bigint_div(self, other: BigInt) -> BigInt {}
     #[builtin(bigint_from_le_bytes)]
     fn from_le_bytes(bytes: [u8], modulus: [u8]) -> BigInt {}
     #[builtin(bigint_to_le_bytes)]
diff --git a/noir_stdlib/src/collections/bounded_vec.nr b/noir_stdlib/src/collections/bounded_vec.nr
index a4aa4823f38..f78d86de77d 100644
--- a/noir_stdlib/src/collections/bounded_vec.nr
+++ b/noir_stdlib/src/collections/bounded_vec.nr
@@ -29,7 +29,7 @@ impl<T, MaxLen> BoundedVec<T, MaxLen> {
         self.len
     }
 
-    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64{
+    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
         MaxLen
     }
 
diff --git a/noir_stdlib/src/collections/vec.nr b/noir_stdlib/src/collections/vec.nr
index 2e7945be827..deec98185ff 100644
--- a/noir_stdlib/src/collections/vec.nr
+++ b/noir_stdlib/src/collections/vec.nr
@@ -19,12 +19,12 @@ impl<T> Vec<T> {
     /// points beyond the end of the vector.
     pub fn get(self, index: u64) -> T {
         self.slice[index]
-     }
+    }
 
     /// Push a new element to the end of the vector, returning a
     /// new vector with a length one greater than the
     /// original unmodified vector.
-    pub fn push(&mut self, elem: T) { 
+    pub fn push(&mut self, elem: T) {
         self.slice = self.slice.push_back(elem);
     }
 
@@ -32,7 +32,7 @@ impl<T> Vec<T> {
     /// a new vector with a length of one less than the given vector,
     /// as well as the popped element.
     /// Panics if the given vector's length is zero.
-    pub fn pop(&mut self) -> T { 
+    pub fn pop(&mut self) -> T {
         let (popped_slice, last_elem) = self.slice.pop_back();
         self.slice = popped_slice;
         last_elem
@@ -42,7 +42,7 @@ impl<T> Vec<T> {
     /// after it to the right
     pub fn insert(&mut self, index: u64, elem: T) {
         self.slice = self.slice.insert(index, elem);
-    } 
+    }
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the removed element
diff --git a/noir_stdlib/src/ec/montcurve.nr b/noir_stdlib/src/ec/montcurve.nr
index 83a17bae322..7dc756781c0 100644
--- a/noir_stdlib/src/ec/montcurve.nr
+++ b/noir_stdlib/src/ec/montcurve.nr
@@ -31,7 +31,7 @@ mod affine {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field) -> Self {
-            Self {x, y, infty: false}
+            Self { x, y, infty: false }
         }
 
         // Check if zero
@@ -45,30 +45,30 @@ mod affine {
                 curvegroup::Point::zero()
             } else {
                 let (x,y) = (self.x, self.y);
-                curvegroup::Point::new(x,y,1)
+                curvegroup::Point::new(x, y, 1)
             }
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 0, infty: true}
+            Self { x: 0, y: 0, infty: true }
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, infty} = self;
 
-            Self {x, y: 0-y, infty}
+            Self { x, y: 0 - y, infty }
         }
 
         // Map into equivalent Twisted Edwards curve
         fn into_tecurve(self) -> TEPoint {
             let Self {x, y, infty} = self;
-            
-            if infty | (y*(x+1) == 0) {
+
+            if infty | (y * (x + 1) == 0) {
                 TEPoint::zero()
             } else {
-                TEPoint::new(x/y, (x-1)/(x+1))
+                TEPoint::new(x / y, (x - 1) / (x + 1))
             }
         }
     }
@@ -84,9 +84,9 @@ mod affine {
         pub fn new(j: Field, k: Field, gen: Point) -> Self {
             // Check curve coefficients
             assert(k != 0);
-            assert(j*j != 4);
+            assert(j * j != 4);
 
-            let curve = Self {j, k, gen};
+            let curve = Self { j, k, gen };
 
             // gen should be on the curve
             assert(curve.contains(curve.gen));
@@ -103,8 +103,8 @@ mod affine {
         pub fn contains(self, p: Point) -> bool {
             let Self {j, k, gen: _gen} = self;
             let Point {x, y, infty: infty} = p;
-            
-            infty | (k*y*y == x*(x*x + j*x + 1))
+
+            infty | (k * y * y == x * (x * x + j * x + 1))
         }
 
         // Point addition
@@ -122,7 +122,7 @@ mod affine {
         fn mul(self, n: Field, p: Point) -> Point {
             self.into_tecurve().mul(n, p.into_tecurve()).into_montcurve()
         }
-        
+
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
         fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
@@ -142,15 +142,15 @@ mod affine {
         // Conversion to equivalent Twisted Edwards curve
         fn into_tecurve(self) -> TECurve {
             let Self {j, k, gen} = self;
-            TECurve::new((j+2)/k, (j-2)/k, gen.into_tecurve())
+            TECurve::new((j + 2) / k, (j - 2) / k, gen.into_tecurve())
         }
 
         // Conversion to equivalent Short Weierstraß curve
         pub fn into_swcurve(self) -> SWCurve {
             let j = self.j;
             let k = self.k;
-            let a0 = (3-j*j)/(3*k*k);
-            let b0 = (2*j*j*j - 9*j)/(27*k*k*k);
+            let a0 = (3 - j * j) / (3 * k * k);
+            let b0 = (2 * j * j * j - 9 * j) / (27 * k * k * k);
 
             SWCurve::new(a0, b0, self.map_into_swcurve(self.gen))
         }
@@ -160,8 +160,7 @@ mod affine {
             if p.is_zero() {
                 SWPoint::zero()
             } else {
-                SWPoint::new((3*p.x + self.j)/(3*self.k),
-                             p.y/self.k)
+                SWPoint::new((3 * p.x + self.j) / (3 * self.k), p.y / self.k)
             }
         }
 
@@ -170,8 +169,8 @@ mod affine {
             let SWPoint {x, y, infty} = p;
             let j = self.j;
             let k = self.k;
-            
-            Point {x: (3*k*x - j)/3, y: y*k, infty}
+
+            Point { x: (3 * k * x - j) / 3, y: y * k, infty }
         }
 
         // Elligator 2 map-to-curve method; see <https://datatracker.ietf.org/doc/id/draft-irtf-cfrg-hash-to-curve-06.html#name-elligator-2-method>.
@@ -179,18 +178,18 @@ mod affine {
             let j = self.j;
             let k = self.k;
             let z = ZETA; // Non-square Field element required for map
-            
+
             // Check whether curve is admissible
             assert(j != 0);
-            let l = (j*j - 4)/(k*k);
+            let l = (j * j - 4) / (k * k);
             assert(l != 0);
             assert(is_square(l) == false);
 
-            let x1 = safe_inverse(1+z*u*u)*(0 - (j/k));
-            
-            let gx1 = x1*x1*x1 + (j/k)*x1*x1 + x1/(k*k);
-            let x2 = 0 - x1 - (j/k);
-            let gx2 = x2*x2*x2 + (j/k)*x2*x2 + x2/(k*k);
+            let x1 = safe_inverse(1 + z * u * u) * (0 - (j / k));
+
+            let gx1 = x1 * x1 * x1 + (j / k) * x1 * x1 + x1 / (k * k);
+            let x2 = 0 - x1 - (j / k);
+            let gx2 = x2 * x2 * x2 + (j / k) * x2 * x2 + x2 / (k * k);
 
             let x = if is_square(gx1) { x1 } else { x2 };
 
@@ -202,13 +201,12 @@ mod affine {
                 if y0.sgn0() == 0 { y0 } else { 0 - y0 }
             };
 
-            Point::new(x*k, y*k)
-                
+            Point::new(x * k, y * k)
         }
 
         // SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.map_from_swcurve(self.into_swcurve().swu_map(z,u))
+            self.map_from_swcurve(self.into_swcurve().swu_map(z, u))
         }
     }
 }
@@ -240,7 +238,7 @@ mod curvegroup {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field, z: Field) -> Self {
-            Self {x, y, z}
+            Self { x, y, z }
         }
 
         // Check if zero
@@ -254,20 +252,20 @@ mod curvegroup {
                 affine::Point::zero()
             } else {
                 let (x,y,z) = (self.x, self.y, self.z);
-                affine::Point::new(x/z, y/z)
+                affine::Point::new(x / z, y / z)
             }
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 1,z: 0}
+            Self { x: 0, y: 1, z: 0 }
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, z} = self;
 
-            Point::new(x, 0-y, z)
+            Point::new(x, 0 - y, z)
         }
 
         // Map into equivalent Twisted Edwards curve
@@ -287,9 +285,9 @@ mod curvegroup {
         pub fn new(j: Field, k: Field, gen: Point) -> Self {
             // Check curve coefficients
             assert(k != 0);
-            assert(j*j != 4);
+            assert(j * j != 4);
 
-            let curve = Self {j, k, gen};
+            let curve = Self { j, k, gen };
 
             // gen should be on the curve
             assert(curve.contains(curve.gen));
@@ -306,8 +304,8 @@ mod curvegroup {
         pub fn contains(self, p: Point) -> bool {
             let Self {j, k, gen: _gen} = self;
             let Point {x, y, z} = p;
-            
-            k*y*y*z == x*(x*x + j*x*z + z*z)
+
+            k * y * y * z == x * (x * x + j * x * z + z * z)
         }
 
         // Point addition
@@ -320,12 +318,12 @@ mod curvegroup {
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             self.into_tecurve().bit_mul(bits, p.into_tecurve()).into_montcurve()
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         pub fn mul(self, n: Field, p: Point) -> Point {
             self.into_tecurve().mul(n, p.into_tecurve()).into_montcurve()
         }
-        
+
         // Multi-scalar multiplication (n[0]*p[0] + ... + n[N]*p[N], where * denotes scalar multiplication)
         fn msm<N>(self, n: [Field; N], p: [Point; N]) -> Point {
             let mut out = Point::zero();
@@ -345,18 +343,17 @@ mod curvegroup {
         // Conversion to equivalent Twisted Edwards curve
         fn into_tecurve(self) -> TECurve {
             let Self {j, k, gen} = self;
-            TECurve::new((j+2)/k, (j-2)/k, gen.into_tecurve())
+            TECurve::new((j + 2) / k, (j - 2) / k, gen.into_tecurve())
         }
 
         // Conversion to equivalent Short Weierstraß curve
         fn into_swcurve(self) -> SWCurve {
             let j = self.j;
             let k = self.k;
-            let a0 = (3-j*j)/(3*k*k);
-            let b0 = (2*j*j*j - 9*j)/(27*k*k*k);
+            let a0 = (3 - j * j) / (3 * k * k);
+            let b0 = (2 * j * j * j - 9 * j) / (27 * k * k * k);
 
-            SWCurve::new(a0, b0,
-                         self.map_into_swcurve(self.gen))
+            SWCurve::new(a0, b0, self.map_into_swcurve(self.gen))
         }
 
         // Point mapping into equivalent Short Weierstraß curve
@@ -373,10 +370,10 @@ mod curvegroup {
         fn elligator2_map(self, u: Field) -> Point {
             self.into_affine().elligator2_map(u).into_group()
         }
-        
+
         // SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_affine().swu_map(z,u).into_group()
+            self.into_affine().swu_map(z, u).into_group()
         }
     }
 }
diff --git a/noir_stdlib/src/ec/swcurve.nr b/noir_stdlib/src/ec/swcurve.nr
index e64f5a7be02..9dd324f3085 100644
--- a/noir_stdlib/src/ec/swcurve.nr
+++ b/noir_stdlib/src/ec/swcurve.nr
@@ -27,14 +27,14 @@ mod affine {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field) -> Self {
-            Self {x, y, infty: false}
+            Self { x, y, infty: false }
         }
 
         // Check if zero
         pub fn is_zero(self) -> bool {
             self.eq(Point::zero())
         }
-        
+
         // Conversion to CurveGroup coordinates
         fn into_group(self) -> curvegroup::Point {
             let Self {x, y, infty} = self;
@@ -45,16 +45,16 @@ mod affine {
                 curvegroup::Point::new(x, y, 1)
             }
         }
-        
+
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 0, infty: true}
+            Self { x: 0, y: 0, infty: true }
         }
-        
+
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, infty} = self;
-            Self {x, y: 0-y, infty}
+            Self { x, y: 0 - y, infty }
         }
     }
 
@@ -72,8 +72,8 @@ mod affine {
         // Curve constructor
         pub fn new(a: Field, b: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(4*a*a*a + 27*b*b != 0);
-            
+            assert(4 * a * a * a + 27 * b * b != 0);
+
             let curve = Curve { a, b, gen };
 
             // gen should be on the curve
@@ -85,16 +85,16 @@ mod affine {
         // Conversion to CurveGroup coordinates
         fn into_group(self) -> curvegroup::Curve {
             let Curve{a, b, gen} = self;
-            
-            curvegroup::Curve {a, b, gen: gen.into_group()}
+
+            curvegroup::Curve { a, b, gen: gen.into_group() }
         }
 
         // Membership check
         pub fn contains(self, p: Point) -> bool {
             let Point {x, y, infty} = p;
-            infty | (y*y == x*x*x + self.a*x + self.b)
+            infty | (y * y == x * x * x + self.a * x + self.b)
         }
-        
+
         // Point addition, implemented in terms of mixed addition for reasons of efficiency
         pub fn add(self, p1: Point, p2: Point) -> Point {
             self.mixed_add(p1, p2.into_group()).into_affine()
@@ -109,9 +109,9 @@ mod affine {
             } else {
                 let Point {x: x1, y: y1, infty: _inf} = p1;
                 let curvegroup::Point {x: x2, y: y2, z: z2} = p2;
-                let you1 = x1*z2*z2;
+                let you1 = x1 * z2 * z2;
                 let you2 = x2;
-                let s1 = y1*z2*z2*z2;
+                let s1 = y1 * z2 * z2 * z2;
                 let s2 = y2;
 
                 if you1 == you2 {
@@ -120,15 +120,14 @@ mod affine {
                     } else {
                         self.into_group().double(p2)
                     }
-                } else
-                {
+                } else {
                     let h = you2 - you1;
                     let r = s2 - s1;
-                    let x3 = r*r - h*h*h - 2*you1*h*h;
-                    let y3 = r*(you1*h*h - x3) - s1*h*h*h;
-                    let z3 = h*z2;
+                    let x3 = r * r - h * h * h - 2 * you1 * h * h;
+                    let y3 = r * (you1 * h * h - x3) - s1 * h * h * h;
+                    let z3 = h * z2;
 
-                    curvegroup::Point::new(x3,y3,z3)
+                    curvegroup::Point::new(x3, y3, z3)
                 }
             }
         }
@@ -138,7 +137,7 @@ mod affine {
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             self.into_group().bit_mul(bits, p.into_group()).into_affine()
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         pub fn mul(self, n: Field, p: Point) -> Point {
             self.into_group().mul(n, p.into_group()).into_affine()
@@ -165,17 +164,25 @@ mod affine {
         // where g(x) = x^3 + a*x + b. swu_map(c,z,.) then maps a Field element to a point on curve c.
         fn swu_map(self, z: Field, u: Field) -> Point {
             // Check whether curve is admissible
-            assert(self.a*self.b != 0);
-            
+            assert(self.a * self.b != 0);
+
             let Curve {a, b, gen: _gen} = self;
-            
-            let tv1 = safe_inverse(z*z*u*u*u*u + u*u*z);
-            let x1 = if tv1 == 0 {b/(z*a)} else {(0-b/a)*(1 + tv1)};
-            let gx1 = x1*x1*x1 + a*x1 + b;
-            let x2 = z*u*u*x1;
-            let gx2 = x2*x2*x2 + a*x2 + b;
-            let (x,y) = if is_square(gx1) {(x1, sqrt(gx1))} else {(x2, sqrt(gx2))};
-            Point::new(x, if u.sgn0() != y.sgn0() {0-y} else {y})
+
+            let tv1 = safe_inverse(z * z * u * u * u * u + u * u * z);
+            let x1 = if tv1 == 0 {
+                b / (z * a)
+            } else {
+                (0 - b / a) * (1 + tv1)
+            };
+            let gx1 = x1 * x1 * x1 + a * x1 + b;
+            let x2 = z * u * u * x1;
+            let gx2 = x2 * x2 * x2 + a * x2 + b;
+            let (x,y) = if is_square(gx1) {
+                (x1, sqrt(gx1))
+            } else {
+                (x2, sqrt(gx2))
+            };
+            Point::new(x, if u.sgn0() != y.sgn0() { 0 - y } else { y })
         }
     }
 }
@@ -205,14 +212,14 @@ mod curvegroup {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field, z: Field) -> Self {
-            Self {x, y, z}
+            Self { x, y, z }
         }
 
         // Check if zero
         pub fn is_zero(self) -> bool {
             self.eq(Point::zero())
         }
-        
+
         // Conversion to affine coordinates
         pub fn into_affine(self) -> affine::Point {
             let Self {x, y, z} = self;
@@ -220,20 +227,19 @@ mod curvegroup {
             if z == 0 {
                 affine::Point::zero()
             } else {
-                affine::Point::new(x/(z*z), y/(z*z*z))
+                affine::Point::new(x / (z * z), y / (z * z * z))
             }
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Self {x: 0, y: 0, z: 0}
+            Self { x: 0, y: 0, z: 0 }
         }
-        
-        
+
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, z} = self;
-            Self {x, y: 0-y, z}
+            Self { x, y: 0 - y, z }
         }
     }
 
@@ -250,8 +256,8 @@ mod curvegroup {
         // Curve constructor
         pub fn new(a: Field, b: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(4*a*a*a + 27*b*b != 0);
-            
+            assert(4 * a * a * a + 27 * b * b != 0);
+
             let curve = Curve { a, b, gen };
 
             // gen should be on the curve
@@ -264,7 +270,7 @@ mod curvegroup {
         pub fn into_affine(self) -> affine::Curve {
             let Curve{a, b, gen} = self;
 
-            affine::Curve {a, b, gen: gen.into_affine()}
+            affine::Curve { a, b, gen: gen.into_affine() }
         }
 
         // Membership check
@@ -273,13 +279,12 @@ mod curvegroup {
             if z == 0 {
                 true
             } else {
-                y*y == x*x*x + self.a*x*z*z*z*z +  self.b*z*z*z*z*z*z
+                y * y == x * x * x + self.a * x * z * z * z * z + self.b * z * z * z * z * z * z
             }
         }
-        
+
         // Addition
         pub fn add(self, p1: Point, p2: Point) -> Point {
-
             if p1.is_zero() {
                 p2
             } else if p2.is_zero() {
@@ -287,10 +292,10 @@ mod curvegroup {
             } else {
                 let Point {x: x1, y: y1, z: z1} = p1;
                 let Point {x: x2, y: y2, z: z2} = p2;
-                let you1 = x1*z2*z2;
-                let you2 = x2*z1*z1;
-                let s1 = y1*z2*z2*z2;
-                let s2 = y2*z1*z1*z1;
+                let you1 = x1 * z2 * z2;
+                let you2 = x2 * z1 * z1;
+                let s1 = y1 * z2 * z2 * z2;
+                let s2 = y2 * z1 * z1 * z1;
 
                 if you1 == you2 {
                     if s1 != s2 {
@@ -301,11 +306,11 @@ mod curvegroup {
                 } else {
                     let h = you2 - you1;
                     let r = s2 - s1;
-                    let x3 = r*r - h*h*h - 2*you1*h*h;
-                    let y3 = r*(you1*h*h - x3) - s1*h*h*h;
-                    let z3 = h*z1*z2;
+                    let x3 = r * r - h * h * h - 2 * you1 * h * h;
+                    let y3 = r * (you1 * h * h - x3) - s1 * h * h * h;
+                    let z3 = h * z1 * z2;
 
-                    Point::new(x3,y3,z3)
+                    Point::new(x3, y3, z3)
                 }
             }
         }
@@ -313,19 +318,19 @@ mod curvegroup {
         // Point doubling
         pub fn double(self, p: Point) -> Point {
             let Point {x, y, z} = p;
-            
+
             if p.is_zero() {
                 p
             } else if y == 0 {
                 Point::zero()
             } else {
-                let s = 4*x*y*y;
-                let m = 3*x*x + self.a*z*z*z*z;
-                let x0 = m*m - 2*s;
-                let y0 = m*(s-x0) - 8*y*y*y*y;
-                let z0 = 2*y*z;
+                let s = 4 * x * y * y;
+                let m = 3 * x * x + self.a * z * z * z * z;
+                let x0 = m * m - 2 * s;
+                let y0 = m * (s - x0) - 8 * y * y * y * y;
+                let z0 = 2 * y * z;
 
-                Point::new(x0,y0,z0)
+                Point::new(x0, y0, z0)
             }
         }
 
@@ -351,7 +356,7 @@ mod curvegroup {
             let mut n_as_bits: [u1; 254] = [0; 254];
             let tmp = n.to_le_bits(N_BITS as u32);
             for i in 0..254 {
-               n_as_bits[i] = tmp[i]; 
+                n_as_bits[i] = tmp[i];
             }
 
             self.bit_mul(n_as_bits, p)
@@ -375,7 +380,7 @@ mod curvegroup {
 
         // Simplified SWU map-to-curve method
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_affine().swu_map(z,u).into_group()
+            self.into_affine().swu_map(z, u).into_group()
         }
     }
 }
diff --git a/noir_stdlib/src/ec/tecurve.nr b/noir_stdlib/src/ec/tecurve.nr
index 5333ece4c4a..506fe89313a 100644
--- a/noir_stdlib/src/ec/tecurve.nr
+++ b/noir_stdlib/src/ec/tecurve.nr
@@ -40,18 +40,18 @@ mod affine {
         fn into_group(self) -> curvegroup::Point {
             let Self {x, y} = self;
 
-            curvegroup::Point::new(x, y, x*y, 1)
+            curvegroup::Point::new(x, y, x * y, 1)
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Point::new(0,1)
+            Point::new(0, 1)
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y} = self;
-            Point::new(0-x, y)
+            Point::new(0 - x, y)
         }
 
         // Map into prime-order subgroup of equivalent Montgomery curve
@@ -60,10 +60,10 @@ mod affine {
                 MPoint::zero()
             } else {
                 let Self {x, y} = self;
-                let x0 = (1+y)/(1-y);
-                let y0 = (1+y)/(x*(1-y));
+                let x0 = (1 + y) / (1 - y);
+                let y0 = (1 + y) / (x * (1 - y));
 
-                MPoint::new(x0,y0)
+                MPoint::new(x0, y0)
             }
         }
     }
@@ -81,9 +81,9 @@ mod affine {
         // Curve constructor
         pub fn new(a: Field, d: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(a*d*(a-d) != 0);
-            
-            let curve = Curve {a, d, gen};
+            assert(a * d * (a - d) != 0);
+
+            let curve = Curve { a, d, gen };
 
             // gen should be on the curve
             assert(curve.contains(curve.gen));
@@ -95,15 +95,15 @@ mod affine {
         fn into_group(self) -> curvegroup::Curve {
             let Curve{a, d, gen} = self;
 
-            curvegroup::Curve {a, d, gen: gen.into_group()}
+            curvegroup::Curve { a, d, gen: gen.into_group() }
         }
-        
+
         // Membership check
         pub fn contains(self, p: Point) -> bool {
             let Point {x, y} = p;
-            self.a*x*x + y*y == 1 + self.d*x*x*y*y
+            self.a * x * x + y * y == 1 + self.d * x * x * y * y
         }
-        
+
         // Point addition, implemented in terms of mixed addition for reasons of efficiency
         pub fn add(self, p1: Point, p2: Point) -> Point {
             self.mixed_add(p1, p2.into_group()).into_affine()
@@ -114,20 +114,20 @@ mod affine {
             let Point{x: x1, y: y1} = p1;
             let curvegroup::Point{x: x2, y: y2, t: t2, z: z2} = p2;
 
-            let a = x1*x2;
-            let b = y1*y2;
-            let c = self.d*x1*y1*t2;
-            let e = (x1 + y1)*(x2 + y2) - a - b;
+            let a = x1 * x2;
+            let b = y1 * y2;
+            let c = self.d * x1 * y1 * t2;
+            let e = (x1 + y1) * (x2 + y2) - a - b;
             let f = z2 - c;
             let g = z2 + c;
-            let h = b - self.a*a;
+            let h = b - self.a * a;
 
-            let x = e*f;
-            let y = g*h;
-            let t = e*h;
-            let z = f*g;
+            let x = e * f;
+            let y = g * h;
+            let t = e * h;
+            let z = f * g;
 
-            curvegroup::Point::new(x,y,t,z)
+            curvegroup::Point::new(x, y, t, z)
         }
 
         // Scalar multiplication with scalar represented by a bit array (little-endian convention).
@@ -135,7 +135,7 @@ mod affine {
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             self.into_group().bit_mul(bits, p.into_group()).into_affine()
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         fn mul(self, n: Field, p: Point) -> Point {
             self.into_group().mul(n, p.into_group()).into_affine()
@@ -159,10 +159,10 @@ mod affine {
 
         // Conversion to equivalent Montgomery curve
         pub fn into_montcurve(self) -> MCurve {
-            let j = 2*(self.a + self.d)/(self.a - self.d);
-            let k = 4/(self.a - self.d);
+            let j = 2 * (self.a + self.d) / (self.a - self.d);
+            let k = 4 / (self.a - self.d);
             let gen_montcurve = self.gen.into_montcurve();
-            
+
             MCurve::new(j, k, gen_montcurve)
         }
 
@@ -188,7 +188,7 @@ mod affine {
 
         // Simplified SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_montcurve().swu_map(z,u).into_tecurve()
+            self.into_montcurve().swu_map(z, u).into_tecurve()
         }
     }
 }
@@ -222,7 +222,7 @@ mod curvegroup {
     impl Point {
         // Point constructor
         pub fn new(x: Field, y: Field, t: Field, z: Field) -> Self {
-            Self {x, y, t, z}
+            Self { x, y, t, z }
         }
 
         // Check if zero
@@ -235,19 +235,19 @@ mod curvegroup {
         pub fn into_affine(self) -> affine::Point {
             let Self {x, y, t: _t, z} = self;
 
-            affine::Point::new(x/z, y/z)
+            affine::Point::new(x / z, y / z)
         }
 
         // Additive identity
         pub fn zero() -> Self {
-            Point::new(0,1,0,1)
+            Point::new(0, 1, 0, 1)
         }
 
         // Negation
         fn negate(self) -> Self {
             let Self {x, y, t, z} = self;
 
-            Point::new(0-x, y, 0-t, z)
+            Point::new(0 - x, y, 0 - t, z)
         }
 
         // Map into prime-order subgroup of equivalent Montgomery curve
@@ -269,8 +269,8 @@ mod curvegroup {
         // Curve constructor
         pub fn new(a: Field, d: Field, gen: Point) -> Curve {
             // Check curve coefficients
-            assert(a*d*(a-d) != 0);
-            
+            assert(a * d * (a - d) != 0);
+
             let curve = Curve { a, d, gen };
 
             // gen should be on the curve
@@ -283,14 +283,16 @@ mod curvegroup {
         pub fn into_affine(self) -> affine::Curve {
             let Curve{a, d, gen} = self;
 
-            affine::Curve {a, d, gen: gen.into_affine()}
+            affine::Curve { a, d, gen: gen.into_affine() }
         }
 
         // Membership check
         pub fn contains(self, p: Point) -> bool {
             let Point {x, y, t, z} = p;
 
-            (z != 0) & (z*t == x*y) & (z*z*(self.a*x*x + y*y) == z*z*z*z + self.d*x*x*y*y)
+            (z != 0)
+                & (z * t == x * y)
+                & (z * z * (self.a * x * x + y * y) == z * z * z * z + self.d * x * x * y * y)
         }
 
         // Point addition
@@ -298,40 +300,40 @@ mod curvegroup {
             let Point{x: x1, y: y1, t: t1, z: z1} = p1;
             let Point{x: x2, y: y2, t: t2, z: z2} = p2;
 
-            let a = x1*x2;
-            let b = y1*y2;
-            let c = self.d*t1*t2;
-            let d = z1*z2;
-            let e = (x1 + y1)*(x2 + y2) - a - b;
+            let a = x1 * x2;
+            let b = y1 * y2;
+            let c = self.d * t1 * t2;
+            let d = z1 * z2;
+            let e = (x1 + y1) * (x2 + y2) - a - b;
             let f = d - c;
             let g = d + c;
-            let h = b - self.a*a;
+            let h = b - self.a * a;
 
-            let x = e*f;
-            let y = g*h;
-            let t = e*h;
-            let z = f*g;
+            let x = e * f;
+            let y = g * h;
+            let t = e * h;
+            let z = f * g;
 
-            Point::new(x,y,t,z)
+            Point::new(x, y, t, z)
         }
 
         // Point doubling, cf. §3.3
         pub fn double(self, p: Point) -> Point {
             let Point{x, y, t: _t, z} = p;
 
-            let a = x*x;
-            let b = y*y;
-            let c = 2*z*z;
-            let d = self.a*a;
-            let e = (x + y)*(x + y) - a - b;
+            let a = x * x;
+            let b = y * y;
+            let c = 2 * z * z;
+            let d = self.a * a;
+            let e = (x + y) * (x + y) - a - b;
             let g = d + b;
             let f = g - c;
             let h = d - b;
 
-            let x0 = e*f;
-            let y0 = g*h;
-            let t0 = e*h;
-            let z0 = f*g;
+            let x0 = e * f;
+            let y0 = g * h;
+            let t0 = e * h;
+            let z0 = f * g;
 
             Point::new(x0, y0, t0, z0)
         }
@@ -340,7 +342,7 @@ mod curvegroup {
         // If k is the natural number represented by `bits`, then this computes p + ... + p k times.
         fn bit_mul<N>(self, bits: [u1; N], p: Point) -> Point {
             let mut out = Point::zero();
-            
+
             for i in 0..N {
                 out = self.add(
                     self.add(out, out),
@@ -349,7 +351,7 @@ mod curvegroup {
 
             out
         }
-        
+
         // Scalar multiplication (p + ... + p n times)
         pub fn mul(self, n: Field, p: Point) -> Point {
             let N_BITS = crate::field::modulus_num_bits();
@@ -358,7 +360,7 @@ mod curvegroup {
             let mut n_as_bits: [u1; 254] = [0; 254];
             let tmp = n.to_le_bits(N_BITS as u32);
             for i in 0..254 {
-               n_as_bits[i] = tmp[i]; 
+                n_as_bits[i] = tmp[i];
             }
 
             self.bit_mul(n_as_bits, p)
@@ -407,7 +409,7 @@ mod curvegroup {
 
         // Simplified SWU map-to-curve method (via rational map)
         fn swu_map(self, z: Field, u: Field) -> Point {
-            self.into_montcurve().swu_map(z,u).into_tecurve()
+            self.into_montcurve().swu_map(z, u).into_tecurve()
         }
     }
 }
diff --git a/noir_stdlib/src/ecdsa_secp256k1.nr b/noir_stdlib/src/ecdsa_secp256k1.nr
index e8d9af2230f..b72a1acd041 100644
--- a/noir_stdlib/src/ecdsa_secp256k1.nr
+++ b/noir_stdlib/src/ecdsa_secp256k1.nr
@@ -7,4 +7,4 @@ pub fn verify_signature<N>(
     message_hash: [u8; N]
 ) -> bool
 // docs:end:ecdsa_secp256k1
-{}
\ No newline at end of file
+{}
diff --git a/noir_stdlib/src/ecdsa_secp256r1.nr b/noir_stdlib/src/ecdsa_secp256r1.nr
index 9fe932a2f3d..ef92bf24ae4 100644
--- a/noir_stdlib/src/ecdsa_secp256r1.nr
+++ b/noir_stdlib/src/ecdsa_secp256r1.nr
@@ -7,4 +7,4 @@ pub fn verify_signature<N>(
     message_hash: [u8; N]
 ) -> bool
 // docs:end:ecdsa_secp256r1
-{}
\ No newline at end of file
+{}
diff --git a/noir_stdlib/src/field.nr b/noir_stdlib/src/field.nr
index a7278d85999..0f4c2caffdf 100644
--- a/noir_stdlib/src/field.nr
+++ b/noir_stdlib/src/field.nr
@@ -6,7 +6,7 @@ impl Field {
         crate::assert_constant(bit_size);
         self.__to_le_bits(bit_size)
     }
-    
+
     pub fn to_be_bits(self: Self, bit_size: u32) -> [u1] {
         crate::assert_constant(bit_size);
         self.__to_be_bits(bit_size)
@@ -14,7 +14,7 @@ impl Field {
 
     #[builtin(to_le_bits)]
     fn __to_le_bits(self, _bit_size: u32) -> [u1] {}
-    
+
     #[builtin(to_be_bits)]
     fn __to_be_bits(self, bit_size: u32) -> [u1] {}
 
@@ -35,7 +35,6 @@ impl Field {
         self.to_be_radix(256, byte_size)
     }
 
-
     pub fn to_le_radix(self: Self, radix: u32, result_len: u32) -> [u8] {
         crate::assert_constant(radix);
         crate::assert_constant(result_len);
@@ -48,17 +47,14 @@ impl Field {
         self.__to_be_radix(radix, result_len)
     }
 
-
-
     // decompose `_self` into a `_result_len` vector over the `_radix` basis
     // `_radix` must be less than 256
     #[builtin(to_le_radix)]
     fn __to_le_radix(self, radix: u32, result_len: u32) -> [u8] {}
-    
+
     #[builtin(to_be_radix)]
     fn __to_be_radix(self, radix: u32, result_len: u32) -> [u8] {}
 
-
     // Returns self to the power of the given exponent value.
     // Caution: we assume the exponent fits into 32 bits
     // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits
@@ -85,7 +81,6 @@ impl Field {
             lt_fallback(self, another)
         }
     }
-
 }
 
 #[builtin(modulus_num_bits)]
diff --git a/noir_stdlib/src/option.nr b/noir_stdlib/src/option.nr
index cab95731d05..1c32f758af7 100644
--- a/noir_stdlib/src/option.nr
+++ b/noir_stdlib/src/option.nr
@@ -39,11 +39,7 @@ impl<T> Option<T> {
 
     /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.
     pub fn unwrap_or(self, default: T) -> T {
-        if self._is_some {
-            self._value
-        } else {
-            default
-        }
+        if self._is_some { self._value } else { default }
     }
 
     /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return
@@ -112,31 +108,19 @@ impl<T> Option<T> {
 
     /// If self is Some, return self. Otherwise, return `other`.
     pub fn or(self, other: Self) -> Self {
-        if self._is_some {
-            self
-        } else {
-            other
-        }
+        if self._is_some { self } else { other }
     }
 
     /// If self is Some, return self. Otherwise, return `default()`.
     pub fn or_else<U, Env>(self, default: fn[Env]() -> Self) -> Self {
-        if self._is_some {
-            self
-        } else {
-            default()
-        }
+        if self._is_some { self } else { default() }
     }
 
     // If only one of the two Options is Some, return that option.
     // Otherwise, if both options are Some or both are None, None is returned.
     pub fn xor(self, other: Self) -> Self {
         if self._is_some {
-            if other._is_some {
-                Option::none()
-            } else {
-                self
-            }
+            if other._is_some { Option::none() } else { self }
         } else if other._is_some {
             other
         } else {
diff --git a/noir_stdlib/src/scalar_mul.nr b/noir_stdlib/src/scalar_mul.nr
index 1a7f1ad707c..eee7aac39f2 100644
--- a/noir_stdlib/src/scalar_mul.nr
+++ b/noir_stdlib/src/scalar_mul.nr
@@ -6,7 +6,7 @@ struct EmbeddedCurvePoint {
 }
 
 impl EmbeddedCurvePoint {
-    fn double(self) -> EmbeddedCurvePoint { 
+    fn double(self) -> EmbeddedCurvePoint {
         embedded_curve_add(self, self)
     }
 }
diff --git a/noir_stdlib/src/schnorr.nr b/noir_stdlib/src/schnorr.nr
index 33656254550..757963d40d7 100644
--- a/noir_stdlib/src/schnorr.nr
+++ b/noir_stdlib/src/schnorr.nr
@@ -7,4 +7,4 @@ pub fn verify_signature<N>(
     message: [u8; N]
 ) -> bool
 // docs:end:schnorr_verify
-{}
\ No newline at end of file
+{}
diff --git a/noir_stdlib/src/slice.nr b/noir_stdlib/src/slice.nr
index bb5c43e497b..ea8d09d14ce 100644
--- a/noir_stdlib/src/slice.nr
+++ b/noir_stdlib/src/slice.nr
@@ -3,34 +3,34 @@ impl<T> [T] {
     /// new slice with a length one greater than the
     /// original unmodified slice.
     #[builtin(slice_push_back)]
-    pub fn push_back(self, elem: T) -> Self { }
+    pub fn push_back(self, elem: T) -> Self {}
 
     /// Push a new element to the front of the slice, returning a
     /// new slice with a length one greater than the 
     /// original unmodified slice. 
     #[builtin(slice_push_front)]
-    pub fn push_front(self, elem: T) -> Self { }
+    pub fn push_front(self, elem: T) -> Self {}
 
     /// Remove the last element of the slice, returning the
     /// popped slice and the element in a tuple
     #[builtin(slice_pop_back)]
-    pub fn pop_back(self) -> (Self, T) { }
+    pub fn pop_back(self) -> (Self, T) {}
 
     /// Remove the first element of the slice, returning the
     /// element and the popped slice in a tuple
     #[builtin(slice_pop_front)]
-    pub fn pop_front(self) -> (T, Self) { }
+    pub fn pop_front(self) -> (T, Self) {}
 
     /// Insert an element at a specified index, shifting all elements 
     /// after it to the right
     #[builtin(slice_insert)]
-    pub fn insert(self, index: u64, elem: T) -> Self { }
+    pub fn insert(self, index: u64, elem: T) -> Self {}
 
     /// Remove an element at a specified index, shifting all elements
     /// after it to the left, returning the altered slice and 
     /// the removed element
     #[builtin(slice_remove)]
-    pub fn remove(self, index: u64) -> (Self, T) { }
+    pub fn remove(self, index: u64) -> (Self, T) {}
 
     // Append each element of the `other` slice to the end of `self`.
     // This returns a new slice and leaves both input slices unchanged.
diff --git a/noir_stdlib/src/string.nr b/noir_stdlib/src/string.nr
index ad6fd19e2de..12b5a1e75ec 100644
--- a/noir_stdlib/src/string.nr
+++ b/noir_stdlib/src/string.nr
@@ -2,7 +2,7 @@ use crate::collections::vec::Vec;
 impl<N> str<N> {
     /// Converts the given string into a byte array
     #[builtin(str_as_bytes)]
-    pub fn as_bytes(self) -> [u8; N] { }
+    pub fn as_bytes(self) -> [u8; N] {}
 
     /// return a byte vector of the str content
     pub fn as_bytes_vec(self: Self) -> Vec<u8> {
diff --git a/noir_stdlib/src/test.nr b/noir_stdlib/src/test.nr
index 560cfde741c..e1c320215de 100644
--- a/noir_stdlib/src/test.nr
+++ b/noir_stdlib/src/test.nr
@@ -19,9 +19,7 @@ struct OracleMock {
 
 impl OracleMock {
     unconstrained pub fn mock<N>(name: str<N>) -> Self {
-        Self {
-            id: create_mock_oracle(name),
-        }
+        Self { id: create_mock_oracle(name) }
     }
 
     unconstrained pub fn with_params<P>(self, params: P) -> Self {
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index c8c6217de90..d6f0b1e2232 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -13,14 +13,11 @@ impl U128 {
     pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {
         // in order to handle multiplication, we need to represent the product of two u64 without overflow
         assert(crate::field::modulus_num_bits() as u32 > 128);
-        U128 {
-            lo: lo as Field,
-            hi: hi as Field,
-        }
+        U128 { lo: lo as Field, hi: hi as Field }
     }
 
     pub fn from_u64s_be(hi: u64, lo: u64) -> U128 {
-        U128::from_u64s_le(lo,hi)
+        U128::from_u64s_le(lo, hi)
     }
 
     pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {
@@ -36,16 +33,13 @@ impl U128 {
             hi += (bytes[i] as Field)*base;
             base *= 256;
         }
-        U128 {
-            lo,
-            hi,
-        }
+        U128 { lo, hi }
     }
 
     pub fn to_be_bytes(self: Self) -> [u8; 16] {
         let lo = self.lo.to_be_bytes(8);
         let hi = self.hi.to_be_bytes(8);
-        let mut bytes = [0;16];
+        let mut bytes = [0; 16];
         for i in 0..8 {
             bytes[i] = hi[i];
             bytes[i+8] = lo[i];
@@ -56,7 +50,7 @@ impl U128 {
     pub fn to_le_bytes(self: Self) -> [u8; 16] {
         let lo = self.lo.to_le_bytes(8);
         let hi = self.hi.to_le_bytes(8);
-        let mut bytes = [0;16];
+        let mut bytes = [0; 16];
         for i in 0..8 {
             bytes[i] = lo[i];
             bytes[i+8] = hi[i];
@@ -73,9 +67,9 @@ impl U128 {
 
         let mut lo = 0;
         let mut hi = 0;
-        let mut base = 1; 
+        let mut base = 1;
         if N <= 18 {
-            for i in 0..N-2 {
+            for i in 0..N - 2 {
                 lo += U128::decode_ascii(bytes[N-i-1])*base;
                 base = base*16;
             }
@@ -85,27 +79,21 @@ impl U128 {
                 base = base*16;
             }
             base = 1;
-            for i in 17..N-1 {           
+            for i in 17..N - 1 {
                 hi += U128::decode_ascii(bytes[N-i])*base;
                 base = base*16;
             }
         }
-        U128 {
-            lo: lo as Field,
-            hi: hi as Field,
-        }
+        U128 { lo: lo as Field, hi: hi as Field }
     }
 
     fn decode_ascii(ascii: u8) -> Field {
         if ascii < 58 {
             ascii - 48
+        } else if ascii < 71 {
+            ascii - 55
         } else {
-            if ascii < 71 {
-                ascii - 55
-            } else {
-                ascii - 87
-            }
-            
+            ascii - 87
         } as Field
     }
 
@@ -114,15 +102,14 @@ impl U128 {
             (U128::from_u64s_le(0, 0), self)
         } else {
             //TODO check if this can overflow?
-            let (q,r) = self.unconstrained_div(b * U128::from_u64s_le(2,0));
-            let q_mul_2 = q * U128::from_u64s_le(2,0);
+            let (q,r) = self.unconstrained_div(b * U128::from_u64s_le(2, 0));
+            let q_mul_2 = q * U128::from_u64s_le(2, 0);
             if r < b {
                 (q_mul_2, r)
             } else {
-                (q_mul_2 + U128::from_u64s_le(1,0), r - b)
+                (q_mul_2 + U128::from_u64s_le(1, 0), r - b)
             }
-
-        }  
+        }
     }
 
     pub fn from_integer<T>(i: T) -> U128 {
@@ -130,31 +117,25 @@ impl U128 {
         // Reject values which would overflow a u128
         f.assert_max_bit_size(128);
         let lo = f as u64 as Field;
-        let hi = (f-lo) / pow64;
-        U128 {
-            lo,
-            hi,
-        }
+        let hi = (f - lo) / pow64;
+        U128 { lo, hi }
     }
 
     pub fn to_integer<T>(self) -> T {
-        crate::from_field(self.lo+self.hi*pow64)
+        crate::from_field(self.lo + self.hi * pow64)
     }
 
     fn wrapping_mul(self: Self, b: U128) -> U128 {
-        let low = self.lo*b.lo;
+        let low = self.lo * b.lo;
         let lo = low as u64 as Field;
         let carry = (low - lo) / pow64;
         let high = if crate::field::modulus_num_bits() as u32 > 196 {
-            (self.lo+self.hi)*(b.lo+b.hi) - low + carry
+            (self.lo + self.hi) * (b.lo + b.hi) - low + carry
         } else {
-            self.lo*b.hi + self.hi*b.lo + carry
+            self.lo * b.hi + self.hi * b.lo + carry
         };
         let hi = high as u64 as Field;
-        U128 {
-            lo,
-            hi,
-        }
+        U128 { lo, hi }
     }
 }
 
diff --git a/test_programs/.gitignore b/test_programs/.gitignore
index a229df6197f..e98a2fb38b6 100644
--- a/test_programs/.gitignore
+++ b/test_programs/.gitignore
@@ -1,2 +1,3 @@
 acir_artifacts
-execution_success/**/crs
\ No newline at end of file
+execution_success/**/crs
+Nargo.toml
diff --git a/test_programs/compile_success_empty/closure_explicit_types/src/main.nr b/test_programs/compile_success_empty/closure_explicit_types/src/main.nr
index eec2b90b5b2..b6c8a6b7b3c 100644
--- a/test_programs/compile_success_empty/closure_explicit_types/src/main.nr
+++ b/test_programs/compile_success_empty/closure_explicit_types/src/main.nr
@@ -7,13 +7,13 @@ fn ret_closure1() -> fn[(Field,)]() -> Field {
     || x + 10
 }
 // return lamda that captures two things
-fn ret_closure2() -> fn[(Field,Field)]() -> Field {
+fn ret_closure2() -> fn[(Field, Field)]() -> Field {
     let x = 20;
     let y = 10;
     || x + y + 10
 }
 // return lamda that captures two things with different types
-fn ret_closure3() -> fn[(u32,u64)]() -> u64 {
+fn ret_closure3() -> fn[(u32, u64)]() -> u64 {
     let x: u32 = 20;
     let y: u64 = 10;
     || x as u64 + y + 10
diff --git a/test_programs/compile_success_empty/conditional_regression_579/src/main.nr b/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
index a479a7a6fbf..a517f4fdb70 100644
--- a/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
+++ b/test_programs/compile_success_empty/conditional_regression_579/src/main.nr
@@ -12,9 +12,7 @@ struct MyStruct579 {
 
 impl MyStruct579 {
     fn new(array_param: [u32; 2]) -> MyStruct579 {
-        MyStruct579 {
-            array_param: array_param
-        }
+        MyStruct579 { array_param }
     }
 }
 
diff --git a/test_programs/compile_success_empty/reexports/src/main.nr b/test_programs/compile_success_empty/reexports/src/main.nr
index bb94b21b221..ed469ff77d0 100644
--- a/test_programs/compile_success_empty/reexports/src/main.nr
+++ b/test_programs/compile_success_empty/reexports/src/main.nr
@@ -1,8 +1,6 @@
 use dep::reexporting_lib::{FooStruct, MyStruct, lib};
 
 fn main() {
-    let x: FooStruct = MyStruct {
-        inner: 0
-    };
+    let x: FooStruct = MyStruct { inner: 0 };
     assert(lib::is_struct_zero(x));
 }
diff --git a/test_programs/compile_success_empty/specialization/src/main.nr b/test_programs/compile_success_empty/specialization/src/main.nr
index 9cd32e0f1eb..30116330a86 100644
--- a/test_programs/compile_success_empty/specialization/src/main.nr
+++ b/test_programs/compile_success_empty/specialization/src/main.nr
@@ -1,11 +1,15 @@
 struct Foo<T> {}
 
 impl Foo<u32> {
-    fn foo(_self: Self) -> Field { 1 }
+    fn foo(_self: Self) -> Field {
+        1
+    }
 }
 
 impl Foo<u64> {
-    fn foo(_self: Self) -> Field { 2 }
+    fn foo(_self: Self) -> Field {
+        2
+    }
 }
 
 fn main() {
diff --git a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
index e1d601b13c9..8250b31789b 100644
--- a/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
+++ b/test_programs/execution_success/1327_concrete_in_generic/src/main.nr
@@ -10,15 +10,15 @@ struct B<T_C> {
     }
 
 impl<T_C> B<T_C> {
-        fn new(new_concrete_t_c_constructor: fn () -> T_C) -> B<T_C> {
-            B { new_concrete_t_c_constructor }
-        }
+    fn new(new_concrete_t_c_constructor: fn() -> T_C) -> B<T_C> {
+        B { new_concrete_t_c_constructor }
+    }
 
-        fn get_t_c(self) -> T_C {
-            let new_concrete_t_c_constructor = self.new_concrete_t_c_constructor;
-            new_concrete_t_c_constructor()
-        }
+    fn get_t_c(self) -> T_C {
+        let new_concrete_t_c_constructor = self.new_concrete_t_c_constructor;
+        new_concrete_t_c_constructor()
     }
+}
 // ---
 // Set<Note>
 struct C<T_D> {
@@ -26,15 +26,15 @@ struct C<T_D> {
     }
 
 impl<T_D> C<T_D> {
-        fn new (t_d_interface: MethodInterface<T_D>) -> Self {
-            C { t_d_interface }
-        }
+    fn new(t_d_interface: MethodInterface<T_D>) -> Self {
+        C { t_d_interface }
+    }
 
-        fn call_method_of_t_d(self, t_d: T_D) -> Field {
-            let some_method_on_t_d = self.t_d_interface.some_method_on_t_d;
-            some_method_on_t_d(t_d)
-        }
+    fn call_method_of_t_d(self, t_d: T_D) -> Field {
+        let some_method_on_t_d = self.t_d_interface.some_method_on_t_d;
+        some_method_on_t_d(t_d)
     }
+}
 // ---
 struct MethodInterface<T_D> {
         some_method_on_t_d: fn(T_D)->Field,
diff --git a/test_programs/execution_success/array_dynamic/src/main.nr b/test_programs/execution_success/array_dynamic/src/main.nr
index dde7bacc455..6b51095bd8c 100644
--- a/test_programs/execution_success/array_dynamic/src/main.nr
+++ b/test_programs/execution_success/array_dynamic/src/main.nr
@@ -2,8 +2,8 @@ fn main(
     x: [u32; 5],
     mut z: u32,
     t: u32,
-    index: [Field;5],
-    index2: [Field;5],
+    index: [Field; 5],
+    index2: [Field; 5],
     offset: Field,
     sublen: Field
 ) {
diff --git a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
index aabf7fc9d5c..4cbf1bd8e6d 100644
--- a/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
+++ b/test_programs/execution_success/array_dynamic_blackbox_input/src/main.nr
@@ -24,4 +24,4 @@ fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {
 
     // Regression for issue #4258
     assert(root == current);
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/array_dynamic_main_output/src/main.nr b/test_programs/execution_success/array_dynamic_main_output/src/main.nr
index ccb7016a190..50feb71f983 100644
--- a/test_programs/execution_success/array_dynamic_main_output/src/main.nr
+++ b/test_programs/execution_success/array_dynamic_main_output/src/main.nr
@@ -1,4 +1,4 @@
 fn main(mut x: [Field; 10], index: u8) -> pub [Field; 10] {
     x[index] = 0;
     x
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/assert_statement_recursive/src/main.nr b/test_programs/execution_success/assert_statement_recursive/src/main.nr
index 687a0d324ba..d89ea3d35bb 100644
--- a/test_programs/execution_success/assert_statement_recursive/src/main.nr
+++ b/test_programs/execution_success/assert_statement_recursive/src/main.nr
@@ -8,4 +8,4 @@
 fn main(x: Field, y: pub Field) {
     assert(x == y, "x and y are not equal");
     assert_eq(x, y, "x and y are not equal");
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 74949a5f785..046d7d07d5e 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -1,8 +1,8 @@
 use dep::std::bigint;
 
-fn main(mut x: [u8;5], y: [u8;5]) {
-    let a = bigint::BigInt::secpk1_fq_from_le_bytes([x[0],x[1],x[2],x[3],x[4]]);
-    let b = bigint::BigInt::secpk1_fq_from_le_bytes([y[0],y[1],y[2],y[3],y[4]]);
+fn main(mut x: [u8; 5], y: [u8; 5]) {
+    let a = bigint::BigInt::secpk1_fq_from_le_bytes([x[0], x[1], x[2], x[3], x[4]]);
+    let b = bigint::BigInt::secpk1_fq_from_le_bytes([y[0], y[1], y[2], y[3], y[4]]);
 
     let a_bytes = a.to_le_bytes();
     let b_bytes = b.to_le_bytes();
@@ -11,11 +11,11 @@ fn main(mut x: [u8;5], y: [u8;5]) {
         assert(b_bytes[i] == y[i]);
     }
 
-    let d = a*b - b;
+    let d = a * b - b;
     let d_bytes = d.to_le_bytes();
     let d1 = bigint::BigInt::secpk1_fq_from_le_bytes(597243850900842442924.to_le_bytes(10));
     let d1_bytes = d1.to_le_bytes();
     for i in 0..32 {
-        assert(d_bytes[i] == d1_bytes[i]);    
+        assert(d_bytes[i] == d1_bytes[i]);
     }
 }
diff --git a/test_programs/execution_success/brillig_cow/src/main.nr b/test_programs/execution_success/brillig_cow/src/main.nr
index 7d847e085fe..52ce8b8be3c 100644
--- a/test_programs/execution_success/brillig_cow/src/main.nr
+++ b/test_programs/execution_success/brillig_cow/src/main.nr
@@ -10,42 +10,37 @@ struct ExecutionResult {
 
 impl ExecutionResult {
     fn is_equal(self, other: ExecutionResult) -> bool {
-        (self.original == other.original) &
-        (self.modified_once == other.modified_once) &
-        (self.modified_twice == other.modified_twice)
+        (self.original == other.original)
+            & (self.modified_once == other.modified_once)
+            & (self.modified_twice == other.modified_twice)
     }
 }
 
 fn modify_in_inlined_constrained(original: [Field; ARRAY_SIZE], index: u64) -> ExecutionResult {
     let mut modified = original;
-    
+
     modified[index] = 27;
 
     let modified_once = modified;
 
     modified[index+1] = 27;
 
-    ExecutionResult {
-        original,
-        modified_once,
-        modified_twice: modified
-    }
+    ExecutionResult { original, modified_once, modified_twice: modified }
 }
 
-unconstrained fn modify_in_unconstrained(original: [Field; ARRAY_SIZE], index: u64) -> ExecutionResult {
+unconstrained fn modify_in_unconstrained(
+    original: [Field; ARRAY_SIZE],
+    index: u64
+) -> ExecutionResult {
     let mut modified = original;
-    
+
     modified[index] = 27;
 
     let modified_once = modified;
 
     modified[index+1] = 27;
 
-    ExecutionResult {
-        original,
-        modified_once,
-        modified_twice: modified
-    }
+    ExecutionResult { original, modified_once, modified_twice: modified }
 }
 
 unconstrained fn main(original: [Field; ARRAY_SIZE], index: u64, expected_result: ExecutionResult) {
diff --git a/test_programs/execution_success/brillig_cow_regression/src/main.nr b/test_programs/execution_success/brillig_cow_regression/src/main.nr
index 74aeda18261..7f3dd766480 100644
--- a/test_programs/execution_success/brillig_cow_regression/src/main.nr
+++ b/test_programs/execution_success/brillig_cow_regression/src/main.nr
@@ -47,54 +47,54 @@ struct U256 {
 }
 
 impl U256 {
-    pub fn from_bytes32(bytes : [u8;32]) -> U256 {
+    pub fn from_bytes32(bytes: [u8; 32]) -> U256 {
         // We use addition rather than a bitwise OR as the bitshifts ensure that none of the bytes overlap each other.
         let high_0 = ((bytes[0] as u64) << 56)
-                + ((bytes[1] as u64) << 48)
-                + ((bytes[2] as u64) << 40)
-                + ((bytes[3] as u64) << 32)
-                + ((bytes[4] as u64) << 24)
-                + ((bytes[5] as u64) << 16)
-                + ((bytes[6] as u64) << 8)
-                +  (bytes[7] as u64);
-        
+            + ((bytes[1] as u64) << 48)
+            + ((bytes[2] as u64) << 40)
+            + ((bytes[3] as u64) << 32)
+            + ((bytes[4] as u64) << 24)
+            + ((bytes[5] as u64) << 16)
+            + ((bytes[6] as u64) << 8)
+            + (bytes[7] as u64);
+
         let high_1 = ((bytes[8] as u64) << 56)
-                + ((bytes[9] as u64) << 48)
-                + ((bytes[10] as u64) << 40)
-                + ((bytes[11] as u64) << 32)
-                + ((bytes[12] as u64) << 24)
-                + ((bytes[13] as u64) << 16)
-                + ((bytes[14] as u64) << 8)
-                +  (bytes[15] as u64);
-        
+            + ((bytes[9] as u64) << 48)
+            + ((bytes[10] as u64) << 40)
+            + ((bytes[11] as u64) << 32)
+            + ((bytes[12] as u64) << 24)
+            + ((bytes[13] as u64) << 16)
+            + ((bytes[14] as u64) << 8)
+            + (bytes[15] as u64);
+
         let low_0 = ((bytes[16] as u64) << 56)
-                + ((bytes[17] as u64) << 48)
-                + ((bytes[18] as u64) << 40)
-                + ((bytes[19] as u64) << 32)
-                + ((bytes[20] as u64) << 24)
-                + ((bytes[21] as u64) << 16)
-                + ((bytes[22] as u64) << 8)
-                +  (bytes[23] as u64);
-        
+            + ((bytes[17] as u64) << 48)
+            + ((bytes[18] as u64) << 40)
+            + ((bytes[19] as u64) << 32)
+            + ((bytes[20] as u64) << 24)
+            + ((bytes[21] as u64) << 16)
+            + ((bytes[22] as u64) << 8)
+            + (bytes[23] as u64);
+
         let low_1 = ((bytes[24] as u64) << 56)
-                + ((bytes[25] as u64) << 48)
-                + ((bytes[26] as u64) << 40)
-                + ((bytes[27] as u64) << 32)
-                + ((bytes[28] as u64) << 24)
-                + ((bytes[29] as u64) << 16)
-                + ((bytes[30] as u64) << 8)
-                +  (bytes[31] as u64);
-
-        U256{inner : [high_0, high_1, low_0, low_1]}
+            + ((bytes[25] as u64) << 48)
+            + ((bytes[26] as u64) << 40)
+            + ((bytes[27] as u64) << 32)
+            + ((bytes[28] as u64) << 24)
+            + ((bytes[29] as u64) << 16)
+            + ((bytes[30] as u64) << 8)
+            + (bytes[31] as u64);
+
+        U256 { inner: [high_0, high_1, low_0, low_1] }
     }
 
-    pub fn to_u128_limbs(self) -> [Field;2] {
+    pub fn to_u128_limbs(self) -> [Field; 2] {
         let two_pow_64 = 2.pow_32(64);
 
         let high = (self.inner[0] as Field) * two_pow_64 + self.inner[1] as Field;
         let low  = (self.inner[2] as Field) * two_pow_64 + self.inner[3] as Field;
-        
-        [high,low]
+
+        [high, low]
     }
 }
 
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index 2f5d14583d5..ea3148915b8 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -14,7 +14,7 @@ fn main(x: u32) {
     assert(increment(x) == x + 1);
 }
 
-unconstrained fn wrapper(func: fn (u32) -> u32, param: u32) -> u32 {
+unconstrained fn wrapper(func: fn(u32) -> u32, param: u32) -> u32 {
     func(param)
 }
 
diff --git a/test_programs/execution_success/conditional_regression_661/src/main.nr b/test_programs/execution_success/conditional_regression_661/src/main.nr
index 03102eb775e..26521a88358 100644
--- a/test_programs/execution_success/conditional_regression_661/src/main.nr
+++ b/test_programs/execution_success/conditional_regression_661/src/main.nr
@@ -16,11 +16,11 @@ fn test5(a: u32) {
     }
 }
 
-fn issue_661_foo(array: [u32;4], b: u32) -> [u32;1] {
+fn issue_661_foo(array: [u32; 4], b: u32) -> [u32; 1] {
     [array[0] + b]
 }
 
-fn issue_661_bar(a: [u32;4]) -> [u32;4] {
+fn issue_661_bar(a: [u32; 4]) -> [u32; 4] {
     let mut b: [u32; 4] = [0; 4];
     b[0]=a[0]+1;
     b
diff --git a/test_programs/execution_success/databus/src/main.nr b/test_programs/execution_success/databus/src/main.nr
index 61a9637f5fe..1cf95be8a22 100644
--- a/test_programs/execution_success/databus/src/main.nr
+++ b/test_programs/execution_success/databus/src/main.nr
@@ -1,12 +1,12 @@
 use dep::std;
 
-fn main(mut x: u32, y: call_data u32, z: call_data [u32;4]) -> return_data u32 {
-  let a = z[x];
-  a+foo(y)
+fn main(mut x: u32, y: call_data u32, z: call_data [u32; 4]) -> return_data u32 {
+    let a = z[x];
+    a + foo(y)
 }
 
 // Use an unconstrained function to force the compiler to avoid inlining
 unconstrained fn foo(x: u32) -> u32 {
-  x+1
+    x + 1
 }
 
diff --git a/test_programs/execution_success/debug_logs/src/main.nr b/test_programs/execution_success/debug_logs/src/main.nr
index c628a9ae6a4..ec24b0cc8e8 100644
--- a/test_programs/execution_success/debug_logs/src/main.nr
+++ b/test_programs/execution_success/debug_logs/src/main.nr
@@ -1,4 +1,4 @@
-fn main(x: Field, y: pub Field) {    
+fn main(x: Field, y: pub Field) {
     let string = "i: {i}, j: {j}";
     println(string);
 
@@ -102,8 +102,8 @@ fn regression_2903() {
     let a = v[0];
     println(a); // will print `1`
 
-    let bytes = [ "aaa", "bbb", "ccc" ];
-    println(bytes);    
+    let bytes = ["aaa", "bbb", "ccc"];
+    println(bytes);
 }
 
 fn regression_2906() {
diff --git a/test_programs/execution_success/distinct_keyword/src/main.nr b/test_programs/execution_success/distinct_keyword/src/main.nr
index 0e55a011a48..8e9b5c008ed 100644
--- a/test_programs/execution_success/distinct_keyword/src/main.nr
+++ b/test_programs/execution_success/distinct_keyword/src/main.nr
@@ -1,4 +1,4 @@
 // Example that uses the distinct keyword
-fn main(x: pub Field) -> distinct pub [Field;2] {
+fn main(x: pub Field) -> distinct pub [Field; 2] {
     [x + 1, x]
 }
diff --git a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
index 2f410755f74..ac0359e4bb8 100644
--- a/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256k1/src/main.nr
@@ -1,11 +1,11 @@
 use dep::std;
 
 fn main(
-    message: [u8;38],
-    hashed_message: [u8;32],
-    pub_key_x: [u8;32],
-    pub_key_y: [u8;32],
-    signature: [u8;64]
+    message: [u8; 38],
+    hashed_message: [u8; 32],
+    pub_key_x: [u8; 32],
+    pub_key_y: [u8; 32],
+    signature: [u8; 64]
 ) {
     // Hash the message, since secp256k1 expects a hashed_message
     let expected = std::hash::sha256(message);
diff --git a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
index d23573d13a6..c64e390d652 100644
--- a/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
+++ b/test_programs/execution_success/ecdsa_secp256r1/src/main.nr
@@ -1,6 +1,6 @@
 use dep::std;
 
-fn main(hashed_message: [u8;32], pub_key_x: [u8;32], pub_key_y: [u8;32], signature: [u8;64]) {
+fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
     assert(valid_signature);
 }
diff --git a/test_programs/execution_success/main_bool_arg/src/main.nr b/test_programs/execution_success/main_bool_arg/src/main.nr
index 111a23ec0c2..2c50d7dee16 100644
--- a/test_programs/execution_success/main_bool_arg/src/main.nr
+++ b/test_programs/execution_success/main_bool_arg/src/main.nr
@@ -1,4 +1,4 @@
-fn main(x: bool, y: [bool;2]) {
+fn main(x: bool, y: [bool; 2]) {
     if x {
         assert(1 != 2);
     }
diff --git a/test_programs/execution_success/operator_overloading/src/main.nr b/test_programs/execution_success/operator_overloading/src/main.nr
index 3867531abca..d61e1da170e 100644
--- a/test_programs/execution_success/operator_overloading/src/main.nr
+++ b/test_programs/execution_success/operator_overloading/src/main.nr
@@ -1,4 +1,4 @@
-use dep::std::ops::{ Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr };
+use dep::std::ops::{Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr};
 use dep::std::cmp::Ordering;
 
 // x = 3, y = 9
@@ -126,10 +126,6 @@ impl Ord for Wrapper {
     }
 }
 
-
-
-
-
 struct Pair {
     x: Wrapper,
     y: Wrapper,
diff --git a/test_programs/execution_success/regression_3394/src/main.nr b/test_programs/execution_success/regression_3394/src/main.nr
index cc45487b98b..94b6c818ff2 100644
--- a/test_programs/execution_success/regression_3394/src/main.nr
+++ b/test_programs/execution_success/regression_3394/src/main.nr
@@ -3,4 +3,4 @@ use dep::std;
 fn main() {
     let x : i8 = -128;
     std::println(x);
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/regression_3607/src/main.nr b/test_programs/execution_success/regression_3607/src/main.nr
index c09211c2810..9c7ef243f60 100644
--- a/test_programs/execution_success/regression_3607/src/main.nr
+++ b/test_programs/execution_success/regression_3607/src/main.nr
@@ -5,4 +5,4 @@ fn main(mut x: u32) {
         x = (x+1) / x;
     }
     assert(x != 0);
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/regression_3889/src/main.nr b/test_programs/execution_success/regression_3889/src/main.nr
index 10b8ecabee3..402a69a10da 100644
--- a/test_programs/execution_success/regression_3889/src/main.nr
+++ b/test_programs/execution_success/regression_3889/src/main.nr
@@ -17,7 +17,6 @@ mod Baz {
     use crate::Bar::NewType;
 }
 
-
 fn main(works: Baz::Works, fails: Baz::BarStruct, also_fails: Bar::NewType) -> pub Field {
     works.a + fails.a + also_fails.a
 }
diff --git a/test_programs/execution_success/side_effects_constrain_array/src/main.nr b/test_programs/execution_success/side_effects_constrain_array/src/main.nr
index fb3c346a460..c4a62603bc3 100644
--- a/test_programs/execution_success/side_effects_constrain_array/src/main.nr
+++ b/test_programs/execution_success/side_effects_constrain_array/src/main.nr
@@ -7,11 +7,11 @@ fn main(y: pub u32) {
 
     // The assert inside the if should be hit
     if y < 10 {
-        assert(bar.inner ==  [100, 101, 102]);
+        assert(bar.inner == [100, 101, 102]);
     }
 
     // The assert inside the if should not be hit
     if y > 10 {
         assert(bar.inner == [0, 1, 2]);
     }
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/struct/src/main.nr b/test_programs/execution_success/struct/src/main.nr
index 45c5e347e5a..de08f42f79d 100644
--- a/test_programs/execution_success/struct/src/main.nr
+++ b/test_programs/execution_success/struct/src/main.nr
@@ -9,8 +9,8 @@ struct Pair {
 }
 
 impl Foo {
-    fn default(x: Field,y: Field) -> Self {
-        Self { bar: 0, array: [x,y] }
+    fn default(x: Field, y: Field) -> Self {
+        Self { bar: 0, array: [x, y] }
     }
 }
 
diff --git a/test_programs/format.sh b/test_programs/format.sh
new file mode 100755
index 00000000000..3c679b8689e
--- /dev/null
+++ b/test_programs/format.sh
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -e
+
+# These tests are incompatible with gas reporting
+excluded_dirs=("workspace" "workspace_default_member" "workspace_reexport_bug")
+
+# These tests cause failures in CI with a stack overflow for some reason.
+ci_excluded_dirs=("eddsa")
+
+current_dir=$(pwd)
+
+# We generate a Noir workspace which contains all of the test cases
+# This allows us to generate a gates report using `nargo info` for all of them at once.
+
+
+function collect_dirs {
+  test_dirs=$(ls $current_dir/$1)
+
+  for dir in $test_dirs; do
+    if [[ " ${excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    if [[ ${CI-false} = "true" ]] && [[ " ${ci_excluded_dirs[@]} " =~ " ${dir} " ]]; then
+      continue
+    fi
+
+    echo "  \"$1/$dir\"," >> Nargo.toml
+done
+}
+
+echo "[workspace]" > Nargo.toml
+echo "members = [" >> Nargo.toml
+
+collect_dirs compile_success_empty
+collect_dirs execution_success
+
+echo "]" >> Nargo.toml
+
+if [ "$1" == "check" ]; then
+  nargo fmt --check
+else
+  nargo fmt
+fi
+
+
+rm Nargo.toml