diff --git a/.github/workflows/spellcheck.yml b/.github/workflows/spellcheck.yml
index 89fcdd12d12..83d67325775 100644
--- a/.github/workflows/spellcheck.yml
+++ b/.github/workflows/spellcheck.yml
@@ -8,6 +8,32 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  spellcheck:
-    name: Spellcheck
-    uses: noir-lang/.github/.github/workflows/spellcheck.yml@main
+  code:
+    name: Code
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Check spelling
+        uses: streetsidesoftware/cspell-action@v2
+        with:
+          strict: false # Do not fail, if a spelling mistake is found (This can be annoying for contributors)
+          incremental_files_only: true # Run this action on files which have changed in PR
+          files: |
+            **/*.{md,rs}
+
+  docs:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Check spelling
+        uses: streetsidesoftware/cspell-action@v2
+        with:
+          strict: true # Documentation has higher standards for correctness.
+          incremental_files_only: true # Run this action on files which have changed in PR
+          files: |
+            ./docs/**/*.md
diff --git a/Cargo.lock b/Cargo.lock
index 223f7eb2152..0c4638f4001 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -43,13 +43,13 @@ dependencies = [
  "acvm_blackbox_solver",
  "brillig_vm",
  "indexmap 1.9.3",
- "log",
  "num-bigint",
  "num-traits",
  "paste",
  "proptest",
  "rand",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -77,13 +77,14 @@ dependencies = [
  "const-str",
  "gloo-utils",
  "js-sys",
- "log",
  "pkg-config",
  "serde",
+ "tracing",
+ "tracing-subscriber",
+ "tracing-web",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
- "wasm-logger",
 ]
 
 [[package]]
@@ -400,17 +401,6 @@ dependencies = [
  "waitpid-any",
 ]
 
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -435,7 +425,6 @@ dependencies = [
  "const_format",
  "dirs",
  "flate2",
- "log",
  "reqwest",
  "serde",
  "serde_json",
@@ -443,6 +432,7 @@ dependencies = [
  "tempfile",
  "test-binary",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -1507,19 +1497,6 @@ dependencies = [
  "syn 2.0.26",
 ]
 
-[[package]]
-name = "env_logger"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
-dependencies = [
- "atty",
- "humantime",
- "log",
- "regex",
- "termcolor",
-]
-
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -1945,15 +1922,6 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "hermit-abi"
 version = "0.3.2"
@@ -2009,12 +1977,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
 [[package]]
 name = "hyper"
 version = "0.14.27"
@@ -2212,7 +2174,7 @@ version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
 dependencies = [
- "hermit-abi 0.3.2",
+ "hermit-abi",
  "rustix",
  "windows-sys 0.48.0",
 ]
@@ -2356,6 +2318,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
 [[package]]
 name = "memchr"
 version = "2.5.0"
@@ -2447,7 +2418,6 @@ dependencies = [
  "codespan-reporting",
  "fm",
  "iter-extended",
- "log",
  "noirc_abi",
  "noirc_driver",
  "noirc_errors",
@@ -2459,6 +2429,7 @@ dependencies = [
  "serde",
  "tempfile",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -2479,7 +2450,6 @@ dependencies = [
  "criterion",
  "dap",
  "dirs",
- "env_logger",
  "fm",
  "hex",
  "iai",
@@ -2510,7 +2480,6 @@ dependencies = [
  "tokio-util",
  "toml",
  "tower",
- "tracing",
  "tracing-appender",
  "tracing-subscriber",
 ]
@@ -2629,14 +2598,14 @@ dependencies = [
  "getrandom",
  "gloo-utils",
  "js-sys",
- "log",
  "nargo",
  "noirc_driver",
  "noirc_errors",
  "noirc_frontend",
  "serde",
+ "tracing-subscriber",
+ "tracing-web",
  "wasm-bindgen",
- "wasm-logger",
 ]
 
 [[package]]
@@ -2684,13 +2653,13 @@ dependencies = [
  "fm",
  "fxhash",
  "iter-extended",
- "log",
  "noirc_abi",
  "noirc_errors",
  "noirc_evaluator",
  "noirc_frontend",
  "rust-embed",
  "serde",
+ "tracing",
 ]
 
 [[package]]
@@ -2702,9 +2671,9 @@ dependencies = [
  "codespan",
  "codespan-reporting",
  "fm",
- "log",
  "serde",
  "serde_with",
+ "tracing",
 ]
 
 [[package]]
@@ -2715,12 +2684,12 @@ dependencies = [
  "fxhash",
  "im",
  "iter-extended",
- "log",
  "noirc_errors",
  "noirc_frontend",
  "num-bigint",
  "serde",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -2732,7 +2701,6 @@ dependencies = [
  "chumsky",
  "fm",
  "iter-extended",
- "log",
  "noirc_errors",
  "noirc_printable_type",
  "regex",
@@ -2745,6 +2713,7 @@ dependencies = [
  "strum_macros",
  "tempfile",
  "thiserror",
+ "tracing",
 ]
 
 [[package]]
@@ -2822,7 +2791,7 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi 0.3.2",
+ "hermit-abi",
  "libc",
 ]
 
@@ -3142,7 +3111,7 @@ dependencies = [
  "rand",
  "rand_chacha",
  "rand_xorshift",
- "regex-syntax",
+ "regex-syntax 0.7.4",
  "rusty-fork",
  "tempfile",
  "unarray",
@@ -3326,7 +3295,7 @@ dependencies = [
  "aho-corasick",
  "memchr",
  "regex-automata 0.3.3",
- "regex-syntax",
+ "regex-syntax 0.7.4",
 ]
 
 [[package]]
@@ -3334,6 +3303,9 @@ name = "regex-automata"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
+]
 
 [[package]]
 name = "regex-automata"
@@ -3343,9 +3315,15 @@ checksum = "39354c10dd07468c2e73926b23bb9c2caca74c5501e38a35da70406f1d923310"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax",
+ "regex-syntax 0.7.4",
 ]
 
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
 [[package]]
 name = "regex-syntax"
 version = "0.7.4"
@@ -4522,14 +4500,31 @@ version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
 dependencies = [
+ "matchers",
  "nu-ansi-term",
+ "once_cell",
+ "regex",
  "sharded-slab",
  "smallvec",
  "thread_local",
+ "tracing",
  "tracing-core",
  "tracing-log",
 ]
 
+[[package]]
+name = "tracing-web"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e6a141feebd51f8d91ebfd785af50fca223c570b86852166caa3b141defe7c"
+dependencies = [
+ "js-sys",
+ "tracing-core",
+ "tracing-subscriber",
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "trie-rs"
 version = "0.1.1"
@@ -4812,17 +4807,6 @@ dependencies = [
  "leb128",
 ]
 
-[[package]]
-name = "wasm-logger"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "074649a66bb306c8f2068c9016395fa65d8e08d2affcbf95acf3c24c3ab19718"
-dependencies = [
- "log",
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "wasmer"
 version = "4.2.3"
diff --git a/Cargo.toml b/Cargo.toml
index 59d2af2fab3..7dda111c1a5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -121,10 +121,11 @@ const_format = "0.2.30"
 num-bigint = "0.4"
 num-traits = "0.2"
 similar-asserts = "1.5.0"
-log = "0.4.17"
 tempfile = "3.6.0"
 
 tracing = "0.1.40"
+tracing-web = "0.1.3"
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 
 [profile.dev]
 # This is required to be able to run `cargo test` in acvm_js due to the `locals exceeds maximum` error.
diff --git a/acvm-repo/CHANGELOG.md b/acvm-repo/CHANGELOG.md
index 0bd38fd3307..4dc900d87a8 100644
--- a/acvm-repo/CHANGELOG.md
+++ b/acvm-repo/CHANGELOG.md
@@ -977,7 +977,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * require `Backend` to implement `Default` trait ([#223](https://github.com/noir-lang/acvm/issues/223))
 * Make GeneralOptimizer crate visible ([#220](https://github.com/noir-lang/acvm/issues/220))
 * return `PartialWitnessGeneratorStatus` from `PartialWitnessGenerator.solve` ([#213](https://github.com/noir-lang/acvm/issues/213))
-* organise operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190))
+* organize operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190))
 
 ### Features
 
@@ -1000,7 +1000,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Miscellaneous Chores
 
 * Make GeneralOptimizer crate visible ([#220](https://github.com/noir-lang/acvm/issues/220)) ([64bb346](https://github.com/noir-lang/acvm/commit/64bb346524428a0ce196826ea1e5ccde08ad6201))
-* organise operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190)) ([a619df6](https://github.com/noir-lang/acvm/commit/a619df614bbb9b2518b788b42a7553b069823a0f))
+* organize operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190)) ([a619df6](https://github.com/noir-lang/acvm/commit/a619df614bbb9b2518b788b42a7553b069823a0f))
 
 ## [0.9.0](https://github.com/noir-lang/acvm/compare/root-v0.8.1...root-v0.9.0) (2023-04-07)
 
@@ -1114,7 +1114,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * **acir:** make PublicInputs use a BTreeSet rather than Vec ([#99](https://github.com/noir-lang/acvm/issues/99))
 * refactor ToRadix to ToRadixLe and ToRadixBe ([#58](https://github.com/noir-lang/acvm/issues/58))
 * **acir:** Add keccak256 Opcode ([#91](https://github.com/noir-lang/acvm/issues/91))
-* reorganise compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88))
+* reorganize compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88))
 
 ### Features
 
@@ -1138,7 +1138,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Miscellaneous Chores
 
 * refactor ToRadix to ToRadixLe and ToRadixBe ([#58](https://github.com/noir-lang/acvm/issues/58)) ([2427a27](https://github.com/noir-lang/acvm/commit/2427a275048e598c6d651cce8348a4c55148f235))
-* reorganise compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88)) ([9329307](https://github.com/noir-lang/acvm/commit/9329307e054de202cfc55207162ad952b70d515e))
+* reorganize compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88)) ([9329307](https://github.com/noir-lang/acvm/commit/9329307e054de202cfc55207162ad952b70d515e))
 
 ## [0.4.1] - 2023-02-08
 
diff --git a/acvm-repo/acir/CHANGELOG.md b/acvm-repo/acir/CHANGELOG.md
index e31ee66379a..6551fc85262 100644
--- a/acvm-repo/acir/CHANGELOG.md
+++ b/acvm-repo/acir/CHANGELOG.md
@@ -404,7 +404,7 @@
 
 * replace `MerkleMembership` opcode with `ComputeMerkleRoot` ([#233](https://github.com/noir-lang/acvm/issues/233))
 * return `PartialWitnessGeneratorStatus` from `PartialWitnessGenerator.solve` ([#213](https://github.com/noir-lang/acvm/issues/213))
-* organise operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190))
+* organize operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190))
 
 ### Features
 
@@ -415,7 +415,7 @@
 
 ### Miscellaneous Chores
 
-* organise operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190)) ([a619df6](https://github.com/noir-lang/acvm/commit/a619df614bbb9b2518b788b42a7553b069823a0f))
+* organize operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190)) ([a619df6](https://github.com/noir-lang/acvm/commit/a619df614bbb9b2518b788b42a7553b069823a0f))
 
 ## [0.9.0](https://github.com/noir-lang/acvm/compare/acir-v0.8.1...acir-v0.9.0) (2023-04-07)
 
@@ -507,7 +507,7 @@
 * **acir:** make PublicInputs use a BTreeSet rather than Vec ([#99](https://github.com/noir-lang/acvm/issues/99))
 * refactor ToRadix to ToRadixLe and ToRadixBe ([#58](https://github.com/noir-lang/acvm/issues/58))
 * **acir:** Add keccak256 Opcode ([#91](https://github.com/noir-lang/acvm/issues/91))
-* reorganise compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88))
+* reorganize compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88))
 
 ### Features
 
@@ -518,4 +518,4 @@
 ### Miscellaneous Chores
 
 * refactor ToRadix to ToRadixLe and ToRadixBe ([#58](https://github.com/noir-lang/acvm/issues/58)) ([2427a27](https://github.com/noir-lang/acvm/commit/2427a275048e598c6d651cce8348a4c55148f235))
-* reorganise compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88)) ([9329307](https://github.com/noir-lang/acvm/commit/9329307e054de202cfc55207162ad952b70d515e))
+* reorganize compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88)) ([9329307](https://github.com/noir-lang/acvm/commit/9329307e054de202cfc55207162ad952b70d515e))
diff --git a/acvm-repo/acvm/CHANGELOG.md b/acvm-repo/acvm/CHANGELOG.md
index 29a4aa93adc..2a340f649f5 100644
--- a/acvm-repo/acvm/CHANGELOG.md
+++ b/acvm-repo/acvm/CHANGELOG.md
@@ -537,7 +537,7 @@
 * require `Backend` to implement `Default` trait ([#223](https://github.com/noir-lang/acvm/issues/223))
 * Make GeneralOptimizer crate visible ([#220](https://github.com/noir-lang/acvm/issues/220))
 * return `PartialWitnessGeneratorStatus` from `PartialWitnessGenerator.solve` ([#213](https://github.com/noir-lang/acvm/issues/213))
-* organise operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190))
+* organize operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190))
 
 ### Features
 
@@ -557,7 +557,7 @@
 ### Miscellaneous Chores
 
 * Make GeneralOptimizer crate visible ([#220](https://github.com/noir-lang/acvm/issues/220)) ([64bb346](https://github.com/noir-lang/acvm/commit/64bb346524428a0ce196826ea1e5ccde08ad6201))
-* organise operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190)) ([a619df6](https://github.com/noir-lang/acvm/commit/a619df614bbb9b2518b788b42a7553b069823a0f))
+* organize operator implementations for Expression ([#190](https://github.com/noir-lang/acvm/issues/190)) ([a619df6](https://github.com/noir-lang/acvm/commit/a619df614bbb9b2518b788b42a7553b069823a0f))
 
 ## [0.9.0](https://github.com/noir-lang/acvm/compare/acvm-v0.8.1...acvm-v0.9.0) (2023-04-07)
 
@@ -641,7 +641,7 @@
 * update `ProofSystemCompiler` to not take ownership of keys ([#111](https://github.com/noir-lang/acvm/issues/111))
 * update `ProofSystemCompiler` methods to take `&Circuit` ([#108](https://github.com/noir-lang/acvm/issues/108))
 * refactor ToRadix to ToRadixLe and ToRadixBe ([#58](https://github.com/noir-lang/acvm/issues/58))
-* reorganise compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88))
+* reorganize compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88))
 
 ### Features
 
@@ -659,4 +659,4 @@
 ### Miscellaneous Chores
 
 * refactor ToRadix to ToRadixLe and ToRadixBe ([#58](https://github.com/noir-lang/acvm/issues/58)) ([2427a27](https://github.com/noir-lang/acvm/commit/2427a275048e598c6d651cce8348a4c55148f235))
-* reorganise compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88)) ([9329307](https://github.com/noir-lang/acvm/commit/9329307e054de202cfc55207162ad952b70d515e))
+* reorganize compiler in terms of optimisers and transformers ([#88](https://github.com/noir-lang/acvm/issues/88)) ([9329307](https://github.com/noir-lang/acvm/commit/9329307e054de202cfc55207162ad952b70d515e))
diff --git a/acvm-repo/acvm/Cargo.toml b/acvm-repo/acvm/Cargo.toml
index 5fdf44cbd5e..f5819d6fa34 100644
--- a/acvm-repo/acvm/Cargo.toml
+++ b/acvm-repo/acvm/Cargo.toml
@@ -16,7 +16,7 @@ repository.workspace = true
 num-bigint.workspace = true
 num-traits.workspace = true
 thiserror.workspace = true
-log.workspace = true
+tracing.workspace = true
 
 acir.workspace = true
 brillig_vm.workspace = true
diff --git a/acvm-repo/acvm/src/compiler/optimizers/mod.rs b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
index dd27c0bb937..923756580b3 100644
--- a/acvm-repo/acvm/src/compiler/optimizers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/optimizers/mod.rs
@@ -6,6 +6,7 @@ mod unused_memory;
 
 pub(crate) use general::GeneralOptimizer;
 pub(crate) use redundant_range::RangeOptimizer;
+use tracing::info;
 
 use self::unused_memory::UnusedMemoryOptimizer;
 
@@ -23,8 +24,9 @@ pub fn optimize(acir: Circuit) -> (Circuit, AcirTransformationMap) {
 }
 
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] independent optimizations to a [`Circuit`].
+#[tracing::instrument(level = "trace", name = "optimize_acir" skip(acir))]
 pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
-    log::trace!("Start circuit optimization");
+    info!("Number of opcodes before: {}", acir.opcodes.len());
 
     // General optimizer pass
     let opcodes: Vec<Opcode> = acir
@@ -54,7 +56,7 @@ pub(super) fn optimize_internal(acir: Circuit) -> (Circuit, Vec<usize>) {
     let (acir, acir_opcode_positions) =
         range_optimizer.replace_redundant_ranges(acir_opcode_positions);
 
-    log::trace!("Finish circuit optimization");
+    info!("Number of opcodes after: {}", acir.opcodes.len());
 
     (acir, acir_opcode_positions)
 }
diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
index eef8d7bee44..c9bc91b02c7 100644
--- a/acvm-repo/acvm/src/compiler/transformers/mod.rs
+++ b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -37,13 +37,12 @@ pub fn transform(
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
 ///
 /// Accepts an injected `acir_opcode_positions` to allow transformations to be applied directly after optimizations.
+#[tracing::instrument(level = "trace", name = "transform_acir", skip(acir, acir_opcode_positions))]
 pub(super) fn transform_internal(
     acir: Circuit,
     expression_width: ExpressionWidth,
     acir_opcode_positions: Vec<usize>,
 ) -> (Circuit, Vec<usize>) {
-    log::trace!("Start circuit transformation");
-
     let mut transformer = match &expression_width {
         crate::ExpressionWidth::Unbounded => {
             let transformer = R1CSTransformer::new(acir);
@@ -209,7 +208,5 @@ pub(super) fn transform_internal(
         ..acir
     };
 
-    log::trace!("Finish circuit transformation");
-
     (acir, new_acir_opcode_positions)
 }
diff --git a/acvm-repo/acvm_js/Cargo.toml b/acvm-repo/acvm_js/Cargo.toml
index 06903fec3f5..987006f8e2b 100644
--- a/acvm-repo/acvm_js/Cargo.toml
+++ b/acvm-repo/acvm_js/Cargo.toml
@@ -25,11 +25,12 @@ wasm-bindgen.workspace = true
 wasm-bindgen-futures.workspace = true
 console_error_panic_hook.workspace = true
 gloo-utils.workspace = true
-js-sys.workspace = true
-log.workspace = true
+js-sys.workspace = true 
+tracing.workspace = true
+tracing-subscriber.workspace = true
+tracing-web.workspace = true
 
 serde = { version = "1.0.136", features = ["derive"] }
-wasm-logger = "0.2.0"
 const-str = "0.5.5"
 
 [build-dependencies]
diff --git a/acvm-repo/acvm_js/src/lib.rs b/acvm-repo/acvm_js/src/lib.rs
index ba2a37bf984..88afd1767c9 100644
--- a/acvm-repo/acvm_js/src/lib.rs
+++ b/acvm-repo/acvm_js/src/lib.rs
@@ -24,7 +24,7 @@ cfg_if::cfg_if! {
         pub use compression::{compress_witness, decompress_witness};
         pub use execute::{execute_circuit, execute_circuit_with_black_box_solver, create_black_box_solver};
         pub use js_witness_map::JsWitnessMap;
-        pub use logging::{init_log_level, LogLevel};
+        pub use logging::init_log_level;
         pub use public_witness::{get_public_parameters_witness, get_public_witness, get_return_witness};
         pub use js_execution_error::JsExecutionError;
     }
diff --git a/acvm-repo/acvm_js/src/logging.rs b/acvm-repo/acvm_js/src/logging.rs
index d939c5f8367..f5d71fae067 100644
--- a/acvm-repo/acvm_js/src/logging.rs
+++ b/acvm-repo/acvm_js/src/logging.rs
@@ -1,31 +1,26 @@
-use js_sys::JsString;
-use log::Level;
-use std::str::FromStr;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::EnvFilter;
+use tracing_web::MakeWebConsoleWriter;
 use wasm_bindgen::prelude::*;
 
-#[wasm_bindgen(typescript_custom_section)]
-const LOG_LEVEL: &'static str = r#"
-export type LogLevel = "OFF" | "ERROR" | "WARN" | "INFO" | "DEBUG" | "TRACE";
-"#;
-
-#[wasm_bindgen]
-extern "C" {
-    #[wasm_bindgen(extends = JsString, typescript_type = "LogLevel")]
-    pub type LogLevel;
-}
-
 /// Sets the package's logging level.
 ///
 /// @param {LogLevel} level - The maximum level of logging to be emitted.
 #[wasm_bindgen(js_name = initLogLevel, skip_jsdoc)]
-pub fn init_log_level(level: LogLevel) {
+pub fn init_log_level(filter: String) {
     // Set the static variable from Rust
     use std::sync::Once;
 
-    let log_level = level.as_string().unwrap();
-    let log_level = Level::from_str(&log_level).unwrap_or(Level::Error);
+    let filter: EnvFilter =
+        filter.parse().expect("Could not parse log filter while initializing logger");
+
     static SET_HOOK: Once = Once::new();
     SET_HOOK.call_once(|| {
-        wasm_logger::init(wasm_logger::Config::new(log_level));
+        let fmt_layer = tracing_subscriber::fmt::layer()
+            .with_ansi(false)
+            .without_time()
+            .with_writer(MakeWebConsoleWriter::new());
+
+        tracing_subscriber::registry().with(fmt_layer.with_filter(filter)).init();
     });
 }
diff --git a/compiler/noirc_driver/Cargo.toml b/compiler/noirc_driver/Cargo.toml
index 7f431db4398..32c418b0adb 100644
--- a/compiler/noirc_driver/Cargo.toml
+++ b/compiler/noirc_driver/Cargo.toml
@@ -22,6 +22,6 @@ fm.workspace = true
 serde.workspace = true
 fxhash.workspace = true
 rust-embed = "6.6.0"
-log.workspace = true
+tracing.workspace = true
 
 aztec_macros = { path = "../../aztec_macros" }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 926e541c2f3..7136580b770 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -18,6 +18,7 @@ use noirc_frontend::monomorphization::monomorphize;
 use noirc_frontend::node_interner::FuncId;
 use serde::{Deserialize, Serialize};
 use std::path::Path;
+use tracing::info;
 
 mod abi_gen;
 mod contract;
@@ -160,14 +161,13 @@ pub fn add_dep(
 ///
 /// This returns a (possibly empty) vector of any warnings found on success.
 /// On error, this returns a non-empty vector of warnings and error messages, with at least one error.
+#[tracing::instrument(level = "trace", skip(context))]
 pub fn check_crate(
     context: &mut Context,
     crate_id: CrateId,
     deny_warnings: bool,
     disable_macros: bool,
 ) -> CompilationResult<()> {
-    log::trace!("Start checking crate");
-
     let macros: Vec<&dyn MacroProcessor> = if disable_macros {
         vec![]
     } else {
@@ -181,8 +181,6 @@ pub fn check_crate(
         diagnostic.in_file(file_id)
     }));
 
-    log::trace!("Finish checking crate");
-
     if has_errors(&errors, deny_warnings) {
         Err(errors)
     } else {
@@ -377,6 +375,7 @@ fn compile_contract_inner(
 /// Compile the current crate using `main_function` as the entrypoint.
 ///
 /// This function assumes [`check_crate`] is called beforehand.
+#[tracing::instrument(level = "trace", skip_all, fields(function_name = context.function_name(&main_function)))]
 pub fn compile_no_check(
     context: &Context,
     options: &CompileOptions,
@@ -395,7 +394,7 @@ pub fn compile_no_check(
         force_compile || options.print_acir || options.show_brillig || options.show_ssa;
 
     if !force_compile && hashes_match {
-        log::info!("Program matches existing artifact, returning early");
+        info!("Program matches existing artifact, returning early");
         return Ok(cached_program.expect("cache must exist for hashes to match"));
     }
     let visibility = program.return_visibility;
diff --git a/compiler/noirc_errors/Cargo.toml b/compiler/noirc_errors/Cargo.toml
index 812a507550c..02e97b2c670 100644
--- a/compiler/noirc_errors/Cargo.toml
+++ b/compiler/noirc_errors/Cargo.toml
@@ -15,4 +15,4 @@ fm.workspace = true
 chumsky.workspace = true
 serde.workspace = true
 serde_with = "3.2.0"
-log.workspace = true
+tracing.workspace = true
\ No newline at end of file
diff --git a/compiler/noirc_errors/src/debug_info.rs b/compiler/noirc_errors/src/debug_info.rs
index 3ae5c193e39..ee40ced19bf 100644
--- a/compiler/noirc_errors/src/debug_info.rs
+++ b/compiler/noirc_errors/src/debug_info.rs
@@ -38,8 +38,8 @@ impl DebugInfo {
     /// The [`OpcodeLocation`]s are generated with the ACIR, but passing the ACIR through a transformation step
     /// renders the old `OpcodeLocation`s invalid. The AcirTransformationMap is able to map the old `OpcodeLocation` to the new ones.
     /// Note: One old `OpcodeLocation` might have transformed into more than one new `OpcodeLocation`.
+    #[tracing::instrument(level = "trace", skip(self, update_map))]
     pub fn update_acir(&mut self, update_map: AcirTransformationMap) {
-        log::trace!("Start debug info update");
         let old_locations = mem::take(&mut self.locations);
 
         for (old_opcode_location, source_locations) in old_locations {
@@ -47,7 +47,6 @@ impl DebugInfo {
                 self.locations.insert(new_opcode_location, source_locations.clone());
             });
         }
-        log::trace!("Finish debug info update");
     }
 
     pub fn opcode_location(&self, loc: &OpcodeLocation) -> Option<Vec<Location>> {
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index 6e7152c6d71..a8f0e8d83a9 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -17,4 +17,4 @@ thiserror.workspace = true
 num-bigint = "0.4"
 im = { version = "15.1", features = ["serde"] }
 serde.workspace = true
-log.workspace = true
+tracing.workspace = true
\ No newline at end of file
diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs
index 6a02a5f6edc..deffe84baea 100644
--- a/compiler/noirc_evaluator/src/ssa.rs
+++ b/compiler/noirc_evaluator/src/ssa.rs
@@ -23,6 +23,7 @@ use noirc_errors::debug_info::DebugInfo;
 use noirc_frontend::{
     hir_def::function::FunctionSignature, monomorphization::ast::Program, Visibility,
 };
+use tracing::{span, Level};
 
 use self::{acir_gen::GeneratedAcir, ssa_gen::Ssa};
 
@@ -42,7 +43,8 @@ pub(crate) fn optimize_into_acir(
 ) -> Result<GeneratedAcir, RuntimeError> {
     let abi_distinctness = program.return_distinctness;
 
-    log::trace!("Start SSA generation");
+    let ssa_gen_span = span!(Level::TRACE, "ssa_generation");
+    let ssa_gen_span_guard = ssa_gen_span.enter();
     let ssa_builder = SsaBuilder::new(program, print_ssa_passes)?
         .run_pass(Ssa::defunctionalize, "After Defunctionalization:")
         .run_pass(Ssa::inline_functions, "After Inlining:")
@@ -70,28 +72,23 @@ pub(crate) fn optimize_into_acir(
     let ssa = ssa_builder
         .run_pass(Ssa::fill_internal_slices, "After Fill Internal Slice Dummy Data:")
         .finish();
-    log::trace!("Finish SSA generation");
+    drop(ssa_gen_span_guard);
 
     let last_array_uses = ssa.find_last_array_uses();
 
-    log::trace!("Start ACIR generation");
-    let acir = ssa.into_acir(brillig, abi_distinctness, &last_array_uses);
-    log::trace!("Finish ACIR generation");
-
-    acir
+    ssa.into_acir(brillig, abi_distinctness, &last_array_uses)
 }
 
 /// Compiles the [`Program`] into [`ACIR`][acvm::acir::circuit::Circuit].
 ///
 /// The output ACIR is is backend-agnostic and so must go through a transformation pass before usage in proof generation.
 #[allow(clippy::type_complexity)]
+#[tracing::instrument(level = "trace", skip_all)]
 pub fn create_circuit(
     program: Program,
     enable_ssa_logging: bool,
     enable_brillig_logging: bool,
 ) -> Result<(Circuit, DebugInfo, Vec<Witness>, Vec<Witness>, Vec<SsaReport>), RuntimeError> {
-    log::trace!("Start circuit generation");
-
     let func_sig = program.main_function_signature.clone();
     let mut generated_acir =
         optimize_into_acir(program, enable_ssa_logging, enable_brillig_logging)?;
@@ -133,8 +130,6 @@ pub fn create_circuit(
     let (optimized_circuit, transformation_map) = acvm::compiler::optimize(circuit);
     debug_info.update_acir(transformation_map);
 
-    log::trace!("Finish circuit generation");
-
     Ok((optimized_circuit, debug_info, input_witnesses, return_witnesses, warnings))
 }
 
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
index 05a22ab6aad..c9eed69e77c 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs
@@ -368,6 +368,21 @@ impl AcirContext {
         rhs: AcirVar,
         typ: AcirType,
     ) -> Result<AcirVar, RuntimeError> {
+        let lhs_expr = self.var_to_expression(lhs)?;
+        let rhs_expr = self.var_to_expression(rhs)?;
+
+        if lhs_expr == rhs_expr {
+            // x ^ x == 0
+            let zero = self.add_constant(FieldElement::zero());
+            return Ok(zero);
+        } else if lhs_expr.is_zero() {
+            // 0 ^ x == x
+            return Ok(rhs);
+        } else if rhs_expr.is_zero() {
+            // x ^ 0 == x
+            return Ok(lhs);
+        }
+
         let inputs = vec![AcirValue::Var(lhs, typ.clone()), AcirValue::Var(rhs, typ)];
         let outputs = self.black_box_function(BlackBoxFunc::XOR, inputs, 1)?;
         Ok(outputs[0])
@@ -380,6 +395,18 @@ impl AcirContext {
         rhs: AcirVar,
         typ: AcirType,
     ) -> Result<AcirVar, RuntimeError> {
+        let lhs_expr = self.var_to_expression(lhs)?;
+        let rhs_expr = self.var_to_expression(rhs)?;
+
+        if lhs_expr == rhs_expr {
+            // x & x == x
+            return Ok(lhs);
+        } else if lhs_expr.is_zero() || rhs_expr.is_zero() {
+            // x & 0 == 0 and 0 & x == 0
+            let zero = self.add_constant(FieldElement::zero());
+            return Ok(zero);
+        }
+
         let bit_size = typ.bit_size();
         if bit_size == 1 {
             // Operands are booleans.
@@ -398,6 +425,16 @@ impl AcirContext {
         rhs: AcirVar,
         typ: AcirType,
     ) -> Result<AcirVar, RuntimeError> {
+        let lhs_expr = self.var_to_expression(lhs)?;
+        let rhs_expr = self.var_to_expression(rhs)?;
+        if lhs_expr.is_zero() {
+            // 0 | x == x
+            return Ok(rhs);
+        } else if rhs_expr.is_zero() {
+            // x | 0 == x
+            return Ok(lhs);
+        }
+
         let bit_size = typ.bit_size();
         if bit_size == 1 {
             // Operands are booleans
diff --git a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
index 01056355915..6a48dadaf30 100644
--- a/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs
@@ -156,6 +156,7 @@ impl AcirValue {
 }
 
 impl Ssa {
+    #[tracing::instrument(level = "trace", skip_all)]
     pub(crate) fn into_acir(
         self,
         brillig: Brillig,
diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
index 56a22fd4107..b972afa2990 100644
--- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs
@@ -266,15 +266,6 @@ impl FunctionBuilder {
         self.insert_instruction(Instruction::Call { func, arguments }, Some(result_types)).results()
     }
 
-    /// Insert ssa instructions which computes lhs << rhs by doing lhs*2^rhs
-    pub(crate) fn insert_shift_left(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
-        let base = self.field_constant(FieldElement::from(2_u128));
-        let pow = self.pow(base, rhs);
-        let typ = self.current_function.dfg.type_of_value(lhs);
-        let pow = self.insert_cast(pow, typ);
-        self.insert_binary(lhs, BinaryOp::Mul, pow)
-    }
-
     /// Insert ssa instructions which computes lhs << rhs by doing lhs*2^rhs
     /// and truncate the result to bit_size
     pub(crate) fn insert_wrapping_shift_left(
@@ -308,8 +299,9 @@ impl FunctionBuilder {
                 let one = self.numeric_constant(FieldElement::one(), Type::unsigned(1));
                 let predicate = self.insert_binary(overflow, BinaryOp::Eq, one);
                 let predicate = self.insert_cast(predicate, typ.clone());
-
-                let pow = self.pow(base, rhs);
+                // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
+                let rhs_unsigned = self.insert_cast(rhs, Type::unsigned(bit_size));
+                let pow = self.pow(base, rhs_unsigned);
                 let pow = self.insert_cast(pow, typ);
                 (FieldElement::max_num_bits(), self.insert_binary(predicate, BinaryOp::Mul, pow))
             };
@@ -323,9 +315,16 @@ impl FunctionBuilder {
     }
 
     /// Insert ssa instructions which computes lhs >> rhs by doing lhs/2^rhs
-    pub(crate) fn insert_shift_right(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId {
+    pub(crate) fn insert_shift_right(
+        &mut self,
+        lhs: ValueId,
+        rhs: ValueId,
+        bit_size: u32,
+    ) -> ValueId {
         let base = self.field_constant(FieldElement::from(2_u128));
-        let pow = self.pow(base, rhs);
+        // we can safely cast to unsigned because overflow_checks prevent bit-shift with a negative value
+        let rhs_unsigned = self.insert_cast(rhs, Type::unsigned(bit_size));
+        let pow = self.pow(base, rhs_unsigned);
         self.insert_binary(lhs, BinaryOp::Div, pow)
     }
 
diff --git a/compiler/noirc_evaluator/src/ssa/opt/array_use.rs b/compiler/noirc_evaluator/src/ssa/opt/array_use.rs
index cfa97cee551..0bb8b0112b6 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/array_use.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/array_use.rs
@@ -14,6 +14,7 @@ impl Ssa {
     /// Map arrays with the last instruction that uses it
     /// For this we simply process all the instructions in execution order
     /// and update the map whenever there is a match
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn find_last_array_uses(&self) -> HashMap<ValueId, InstructionId> {
         let mut array_use = HashMap::default();
         for func in self.functions.values() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs b/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
index cd3a509a62e..a3608f89612 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
@@ -21,6 +21,7 @@ impl Ssa {
     /// seen by loop unrolling. Furthermore, this pass cannot be a part of loop unrolling
     /// since we must go through every instruction to find all references to `assert_constant`
     /// while loop unrolling only touches blocks with loops in them.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn evaluate_assert_constant(mut self) -> Result<Ssa, RuntimeError> {
         for function in self.functions.values_mut() {
             for block in function.reachable_blocks() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index f48e6f2a129..e944d7d99d8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -40,6 +40,7 @@ impl Ssa {
     /// Performs constant folding on each instruction.
     ///
     /// See [`constant_folding`][self] module for more information.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn fold_constants(mut self) -> Ssa {
         for function in self.functions.values_mut() {
             constant_fold(function);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index 62b335be1e2..b7f154397a6 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -52,6 +52,7 @@ struct DefunctionalizationContext {
 }
 
 impl Ssa {
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn defunctionalize(mut self) -> Ssa {
         // Find all functions used as value that share the same signature
         let variants = find_variants(&self);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index 492e96dc08c..029adb10054 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -17,6 +17,7 @@ use crate::ssa::{
 impl Ssa {
     /// Performs Dead Instruction Elimination (DIE) to remove any instructions with
     /// unused results.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn dead_instruction_elimination(mut self) -> Ssa {
         for function in self.functions.values_mut() {
             dead_instruction_elimination(function);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/fill_internal_slices.rs b/compiler/noirc_evaluator/src/ssa/opt/fill_internal_slices.rs
index f5e9598114c..5ee8e42fe3a 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/fill_internal_slices.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/fill_internal_slices.rs
@@ -60,6 +60,7 @@ use acvm::FieldElement;
 use fxhash::FxHashMap as HashMap;
 
 impl Ssa {
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn fill_internal_slices(mut self) -> Ssa {
         for function in self.functions.values_mut() {
             // This pass is only necessary for generating ACIR and thus we should not
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index f0ad610948c..0e7bfff7b6b 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -163,6 +163,7 @@ impl Ssa {
     /// This pass will modify any instructions with side effects in particular, often multiplying
     /// them by jump conditions to maintain correctness even when all branches of a jmpif are inlined.
     /// For more information, see the module-level comment at the top of this file.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn flatten_cfg(mut self) -> Ssa {
         flatten_function_cfg(self.main_mut());
         self
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index b4f12b2f897..776f22b2877 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -36,6 +36,7 @@ impl Ssa {
     /// changes. This is because if the function's id later becomes known by a later
     /// pass, we would need to re-run all of inlining anyway to inline it, so we might
     /// as well save the work for later instead of performing it twice.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn inline_functions(mut self) -> Ssa {
         self.functions = btree_map(get_entry_point_functions(&self), |entry_point| {
             let new_function = InlineContext::new(&self, entry_point).inline_all(&self);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index ce205c8d883..0a49ca4ecca 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -86,6 +86,7 @@ use self::block::{Block, Expression};
 impl Ssa {
     /// Attempts to remove any load instructions that recover values that are already available in
     /// scope, and attempts to remove stores that are subsequently redundant.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn mem2reg(mut self) -> Ssa {
         for function in self.functions.values_mut() {
             let mut context = PerFunctionContext::new(function);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index d491afc3d26..a31def8fd98 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -29,6 +29,7 @@ impl Ssa {
     ///    only 1 successor then (2) also will be applied.
     ///
     /// Currently, 1 and 4 are unimplemented.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn simplify_cfg(mut self) -> Self {
         for function in self.functions.values_mut() {
             simplify_function(function);
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 50c2f5b1524..2fe9ea13cec 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -36,6 +36,7 @@ use fxhash::FxHashMap as HashMap;
 impl Ssa {
     /// Unroll all loops in each SSA function.
     /// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state.
+    #[tracing::instrument(level = "trace", skip(self))]
     pub(crate) fn unroll_loops(mut self) -> Result<Ssa, RuntimeError> {
         for function in self.functions.values_mut() {
             // Loop unrolling in brillig can lead to a code explosion currently. This can
diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index 501a03bcb5c..5724bf56e8e 100644
--- a/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -326,8 +326,8 @@ impl<'a> FunctionContext<'a> {
                         self.check_signed_overflow(result, lhs, rhs, operator, bit_size, location);
                         self.builder.insert_cast(result, result_type)
                     }
-                    BinaryOpKind::ShiftLeft => {
-                        unreachable!("shift is not supported for signed integer")
+                    BinaryOpKind::ShiftLeft | BinaryOpKind::ShiftRight => {
+                        self.check_shift_overflow(result, rhs, bit_size, location, true)
                     }
                     _ => unreachable!("operator {} should not overflow", operator),
                 }
@@ -343,8 +343,10 @@ impl<'a> FunctionContext<'a> {
 
                 if operator == BinaryOpKind::Multiply && bit_size == 1 {
                     result
-                } else if operator == BinaryOpKind::ShiftLeft {
-                    self.check_left_shift_overflow(result, rhs, bit_size, location)
+                } else if operator == BinaryOpKind::ShiftLeft
+                    || operator == BinaryOpKind::ShiftRight
+                {
+                    self.check_shift_overflow(result, rhs, bit_size, location, false)
                 } else {
                     let message = format!("attempt to {} with overflow", op_name);
                     let range_constraint = Instruction::RangeCheck {
@@ -360,26 +362,44 @@ impl<'a> FunctionContext<'a> {
         }
     }
 
-    /// Overflow checks for shift-left
-    /// We use Rust behavior for shift left:
+    /// Overflow checks for bit-shift
+    /// We use Rust behavior for bit-shift:
     /// If rhs is more or equal than the bit size, then we overflow
-    /// If not, we do not overflow and shift left with 0 when bits are falling out of the bit size
-    fn check_left_shift_overflow(
+    /// If not, we do not overflow and shift with 0 when bits are falling out of the bit size
+    fn check_shift_overflow(
         &mut self,
         result: ValueId,
         rhs: ValueId,
         bit_size: u32,
         location: Location,
+        is_signed: bool,
     ) -> ValueId {
+        let one = self.builder.numeric_constant(FieldElement::one(), Type::bool());
+        let rhs =
+            if is_signed { self.builder.insert_cast(rhs, Type::unsigned(bit_size)) } else { rhs };
+        // Bit-shift with a negative number is an overflow
+        if is_signed {
+            // We compute the sign of rhs.
+            let half_width = self.builder.numeric_constant(
+                FieldElement::from(2_i128.pow(bit_size - 1)),
+                Type::unsigned(bit_size),
+            );
+            let sign = self.builder.insert_binary(rhs, BinaryOp::Lt, half_width);
+            self.builder.set_location(location).insert_constrain(
+                sign,
+                one,
+                Some("attempt to bit-shift with overflow".to_string()),
+            );
+        }
+
         let max = self
             .builder
             .numeric_constant(FieldElement::from(bit_size as i128), Type::unsigned(bit_size));
         let overflow = self.builder.insert_binary(rhs, BinaryOp::Lt, max);
-        let one = self.builder.numeric_constant(FieldElement::one(), Type::bool());
         self.builder.set_location(location).insert_constrain(
             overflow,
             one,
-            Some("attempt to left shift with overflow".to_owned()),
+            Some("attempt to bit-shift with overflow".to_owned()),
         );
         self.builder.insert_truncate(result, bit_size, bit_size + 1)
     }
@@ -466,7 +486,6 @@ impl<'a> FunctionContext<'a> {
                     Some(message),
                 );
             }
-            BinaryOpKind::ShiftLeft => unreachable!("shift is not supported for signed integer"),
             _ => unreachable!("operator {} should not overflow", operator),
         }
     }
@@ -482,19 +501,26 @@ impl<'a> FunctionContext<'a> {
         mut rhs: ValueId,
         location: Location,
     ) -> Values {
+        let result_type = self.builder.type_of_value(lhs);
         let mut result = match operator {
             BinaryOpKind::ShiftLeft => {
-                let result_type = self.builder.current_function.dfg.type_of_value(lhs);
                 let bit_size = match result_type {
                     Type::Numeric(NumericType::Signed { bit_size })
                     | Type::Numeric(NumericType::Unsigned { bit_size }) => bit_size,
-                    _ => unreachable!("ICE: Truncation attempted on non-integer"),
+                    _ => unreachable!("ICE: left-shift attempted on non-integer"),
                 };
                 self.builder.insert_wrapping_shift_left(lhs, rhs, bit_size)
             }
-            BinaryOpKind::ShiftRight => self.builder.insert_shift_right(lhs, rhs),
+            BinaryOpKind::ShiftRight => {
+                let bit_size = match result_type {
+                    Type::Numeric(NumericType::Signed { bit_size })
+                    | Type::Numeric(NumericType::Unsigned { bit_size }) => bit_size,
+                    _ => unreachable!("ICE: right-shift attempted on non-integer"),
+                };
+                self.builder.insert_shift_right(lhs, rhs, bit_size)
+            }
             BinaryOpKind::Equal | BinaryOpKind::NotEqual
-                if matches!(self.builder.type_of_value(lhs), Type::Array(..)) =>
+                if matches!(result_type, Type::Array(..)) =>
             {
                 return self.insert_array_equality(lhs, operator, rhs, location)
             }
diff --git a/compiler/noirc_frontend/Cargo.toml b/compiler/noirc_frontend/Cargo.toml
index aa3a8e9f6b8..80d767f7f2c 100644
--- a/compiler/noirc_frontend/Cargo.toml
+++ b/compiler/noirc_frontend/Cargo.toml
@@ -22,7 +22,7 @@ serde.workspace = true
 rustc-hash = "1.1.0"
 small-ord-set = "0.1.3"
 regex = "1.9.1"
-log.workspace = true
+tracing.workspace = true
 
 [dev-dependencies]
 strum = "0.24"
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index f7154895150..e8f9f23d378 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -11,7 +11,7 @@ use crate::{
         types::Type,
     },
     node_interner::{DefinitionKind, ExprId, FuncId, TraitId, TraitImplKind, TraitMethodId},
-    BinaryOpKind, Signedness, TypeBinding, TypeBindings, TypeVariableKind, UnaryOp,
+    BinaryOpKind, TypeBinding, TypeBindings, TypeVariableKind, UnaryOp,
 };
 
 use super::{errors::TypeCheckError, TypeChecker};
@@ -1121,13 +1121,7 @@ impl<'interner> TypeChecker<'interner> {
                         span,
                     });
                 }
-                if op.is_bit_shift()
-                    && (*sign_x == Signedness::Signed || *sign_y == Signedness::Signed)
-                {
-                    Err(TypeCheckError::InvalidInfixOp { kind: "Signed integer", span })
-                } else {
-                    Ok(Integer(*sign_x, *bit_width_x))
-                }
+                Ok(Integer(*sign_x, *bit_width_x))
             }
             (Integer(..), FieldElement) | (FieldElement, Integer(..)) => {
                 Err(TypeCheckError::IntegerAndFieldBinaryOperation { span })
diff --git a/compiler/noirc_frontend/src/monomorphization/mod.rs b/compiler/noirc_frontend/src/monomorphization/mod.rs
index 52b8d5bfd79..39b05dcd5ac 100644
--- a/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -91,8 +91,8 @@ type HirType = crate::Type;
 /// Note that there is no requirement on the `main` function that can be passed into
 /// this function. Typically, this is the function named "main" in the source project,
 /// but it can also be, for example, an arbitrary test function for running `nargo test`.
+#[tracing::instrument(level = "trace", skip(main, interner))]
 pub fn monomorphize(main: node_interner::FuncId, interner: &NodeInterner) -> Program {
-    log::trace!("Start monomorphization");
     let mut monomorphizer = Monomorphizer::new(interner);
     let function_sig = monomorphizer.compile_main(main);
 
@@ -108,7 +108,6 @@ pub fn monomorphize(main: node_interner::FuncId, interner: &NodeInterner) -> Pro
     let functions = vecmap(monomorphizer.finished_functions, |(_, f)| f);
     let FuncMeta { return_distinctness, return_visibility, .. } = interner.function_meta(&main);
 
-    log::trace!("Finish monomorphization");
     Program::new(
         functions,
         function_sig,
diff --git a/compiler/wasm/Cargo.toml b/compiler/wasm/Cargo.toml
index 58ad7764fdc..7ea138b60a4 100644
--- a/compiler/wasm/Cargo.toml
+++ b/compiler/wasm/Cargo.toml
@@ -23,9 +23,8 @@ serde.workspace = true
 js-sys.workspace = true
 console_error_panic_hook.workspace = true
 gloo-utils.workspace = true
-log.workspace = true
-
-wasm-logger = "0.2.0"
+tracing-subscriber.workspace = true
+tracing-web.workspace = true
 
 # This is an unused dependency, we are adding it
 # so that we can enable the js feature in getrandom.
diff --git a/compiler/wasm/src/lib.rs b/compiler/wasm/src/lib.rs
index d0394589578..e10b992a00e 100644
--- a/compiler/wasm/src/lib.rs
+++ b/compiler/wasm/src/lib.rs
@@ -6,11 +6,12 @@
 use getrandom as _;
 
 use gloo_utils::format::JsValueSerdeExt;
-use log::Level;
+
 use noirc_driver::{GIT_COMMIT, GIT_DIRTY, NOIRC_VERSION};
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
-use wasm_bindgen::prelude::*;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::EnvFilter;
+use tracing_web::MakeWebConsoleWriter;
 
 mod compile;
 mod compile_new;
@@ -20,6 +21,7 @@ pub use compile::compile;
 
 // Expose the new Context-Centric API
 pub use compile_new::{compile_, CompilerContext, CrateIDWrapper};
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
 #[derive(Serialize, Deserialize)]
 pub struct BuildInfo {
@@ -29,14 +31,21 @@ pub struct BuildInfo {
 }
 
 #[wasm_bindgen]
-pub fn init_log_level(level: String) {
+pub fn init_log_level(filter: String) {
     // Set the static variable from Rust
     use std::sync::Once;
 
-    let log_level = Level::from_str(&level).unwrap_or(Level::Error);
+    let filter: EnvFilter =
+        filter.parse().expect("Could not parse log filter while initializing logger");
+
     static SET_HOOK: Once = Once::new();
     SET_HOOK.call_once(|| {
-        wasm_logger::init(wasm_logger::Config::new(log_level));
+        let fmt_layer = tracing_subscriber::fmt::layer()
+            .with_ansi(false)
+            .without_time()
+            .with_writer(MakeWebConsoleWriter::new());
+
+        tracing_subscriber::registry().with(fmt_layer.with_filter(filter)).init();
     });
 }
 
diff --git a/cspell.json b/cspell.json
index 5bdb04cb4b2..51e49c78e59 100644
--- a/cspell.json
+++ b/cspell.json
@@ -6,6 +6,7 @@
         "acvm",
         "aeiou",
         "appender",
+        "Arbitrum",
         "arithmetization",
         "arity",
         "arkworks",
@@ -15,21 +16,27 @@
         "bindgen",
         "bitand",
         "blackbox",
+        "bridgekeeper",
         "brillig",
         "cachix",
         "callsite",
         "callsites",
         "canonicalize",
         "castable",
+        "Celo",
         "chumsky",
         "clippy",
         "codegen",
         "codegens",
+        "Codespaces",
         "codespan",
         "coeff",
         "combinators",
         "comptime",
+        "cpus",
         "cranelift",
+        "curvegroup",
+        "databus",
         "deflatten",
         "deflattened",
         "deflattening",
@@ -40,12 +47,14 @@
         "desugared",
         "direnv",
         "eddsa",
+        "Elligator",
         "endianness",
         "envrc",
         "Flamegraph",
         "flate",
         "fmtstr",
         "foldl",
+        "foos",
         "forall",
         "foralls",
         "formatcp",
@@ -69,9 +78,11 @@
         "jmpif",
         "jmpifs",
         "jmps",
+        "Jubjub",
         "keccak",
         "krate",
         "lvalue",
+        "mathbb",
         "merkle",
         "metas",
         "monomorphization",
@@ -79,22 +90,27 @@
         "monomorphized",
         "monomorphizer",
         "monomorphizes",
+        "montcurve",
         "nand",
         "nargo",
         "newtype",
+        "nightlies",
         "nixpkgs",
         "noirc",
+        "noirjs",
         "noirup",
         "nomicfoundation",
         "pedersen",
         "peekable",
         "plonkc",
+        "PLONKish",
         "pprof",
         "preprocess",
         "prettytable",
         "println",
         "printstd",
         "pseudocode",
+        "pubkey",
         "quantile",
         "rustc",
         "rustup",
@@ -109,9 +125,12 @@
         "srem",
         "stdlib",
         "struct",
+        "structs",
         "subexpression",
         "subshell",
         "subtyping",
+        "swcurve",
+        "tecurve",
         "tempdir",
         "tempfile",
         "termcolor",
@@ -126,7 +145,13 @@
         "unnormalized",
         "unoptimized",
         "urem",
+        "USERPROFILE",
         "vecmap",
-        "wasi"
+        "wasi",
+        "Weierstraß",
+        "zshell"
+    ],
+    "ignorePaths": [
+        "./**/node_modules/**"
     ]
 }
diff --git a/docs/docs/explainers/explainer-recursion.md b/docs/docs/explainers/explainer-recursion.md
index cc431a878dc..9357d3c7341 100644
--- a/docs/docs/explainers/explainer-recursion.md
+++ b/docs/docs/explainers/explainer-recursion.md
@@ -149,7 +149,7 @@ In such a situation, and assuming Alice is first, she would skip the first part
 
 ### Aggregating proofs
 
-In some one-way interaction situations, recursiveness would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
 
 To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
 
diff --git a/docs/docs/getting_started/installation/other_install_methods.md b/docs/docs/getting_started/installation/other_install_methods.md
index 36f05657277..a532f83750e 100644
--- a/docs/docs/getting_started/installation/other_install_methods.md
+++ b/docs/docs/getting_started/installation/other_install_methods.md
@@ -83,9 +83,9 @@ Check if the installation was successful by running `nargo --version`. You shoul
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -163,7 +163,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/docs/getting_started/project_breakdown.md b/docs/docs/getting_started/project_breakdown.md
index 5a214804f7b..c4e2a9ae003 100644
--- a/docs/docs/getting_started/project_breakdown.md
+++ b/docs/docs/getting_started/project_breakdown.md
@@ -40,7 +40,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/docs/getting_started/tooling/testing.md b/docs/docs/getting_started/tooling/testing.md
index 868a061200d..5febd44e96b 100644
--- a/docs/docs/getting_started/tooling/testing.md
+++ b/docs/docs/getting_started/tooling/testing.md
@@ -25,7 +25,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/docs/how_to/how-to-recursion.md b/docs/docs/how_to/how-to-recursion.md
index 226f7e6e73d..db9ad0e99f8 100644
--- a/docs/docs/how_to/how-to-recursion.md
+++ b/docs/docs/how_to/how-to-recursion.md
@@ -53,7 +53,7 @@ For a full example on how recursive proofs work, please refer to the [noir-examp
 
 In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
 
-For recursiveness, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
 
 It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
 
@@ -159,7 +159,7 @@ const backends = {
 main: new BarretenbergBackend(circuits.main),
 recursive: new BarretenbergBackend(circuits.recursive)
 }
-const noirs = {
+const noir_programs = {
 main: new Noir(circuits.main, backends.main),
 recursive: new Noir(circuits.recursive, backends.recursive)
 }
@@ -169,7 +169,7 @@ This allows you to neatly call exactly the method you want without conflicting n
 
 ```js
 // Alice runs this 👇
-const { witness: mainWitness } = await noirs.main.execute(input)
+const { witness: mainWitness } = await noir_programs.main.execute(input)
 const proof = await backends.main.generateIntermediateProof(mainWitness)
 
 // Bob runs this 👇
@@ -178,7 +178,7 @@ const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateInterm
     proof,
     numPublicInputs,
 );
-const recursiveProof = await noirs.recursive.generateFinalProof(recursiveInputs)
+const recursiveProof = await noir_programs.recursive.generateFinalProof(recursiveInputs)
 ```
 
 :::
diff --git a/docs/docs/index.md b/docs/docs/index.md
index e1ec3362c1f..eaf8c59f935 100644
--- a/docs/docs/index.md
+++ b/docs/docs/index.md
@@ -26,7 +26,7 @@ Noir, a domain-specific language crafted for SNARK proving systems, stands out w
 and robust capabilities. Unlike conventional approaches that compile directly to a fixed NP-complete language,
 Noir takes a two-pronged path. It first compiles to an adaptable intermediate language known as ACIR. From there,
 depending on the project's needs, ACIR can be further compiled into an arithmetic circuit for integration with Aztec's
-barretenberg backend or transformed into a rank-1 constraint system suitable for R1CS backends like Arkwork's Marlin
+barretenberg backend or transformed into a rank-1 constraint system suitable for R1CS backends like Arkworks' Marlin
 backend, among others.
 
 This innovative design introduces unique challenges, yet it strategically separates the programming language from the
@@ -43,7 +43,7 @@ contracts efficiently. While the current alpha version offers this as a direct f
 to modularize this process for even greater ease of use.
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will be
-modularised in the future; however, as of the alpha, you can use the `nargo codegen-verifier` command to create a verifier contract.
+modularized in the future; however, as of the alpha, you can use the `nargo codegen-verifier` command to create a verifier contract.
 
 ### Protocol Developers
 
diff --git a/docs/docs/noir/modules_packages_crates/dependencies.md b/docs/docs/noir/modules_packages_crates/dependencies.md
index 57f0f9fd420..1e93b30781a 100644
--- a/docs/docs/noir/modules_packages_crates/dependencies.md
+++ b/docs/docs/noir/modules_packages_crates/dependencies.md
@@ -49,7 +49,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -61,17 +61,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/docs/noir/modules_packages_crates/modules.md b/docs/docs/noir/modules_packages_crates/modules.md
index f9f15aee8be..ae822a1cff4 100644
--- a/docs/docs/noir/modules_packages_crates/modules.md
+++ b/docs/docs/noir/modules_packages_crates/modules.md
@@ -11,7 +11,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/docs/noir/syntax/data_types/index.md b/docs/docs/noir/syntax/data_types/index.md
index 52e568e9b7e..01cd0431a68 100644
--- a/docs/docs/noir/syntax/data_types/index.md
+++ b/docs/docs/noir/syntax/data_types/index.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/docs/noir/syntax/mutability.md b/docs/docs/noir/syntax/mutability.md
index 58e9c1cecfb..6abfae3cfa7 100644
--- a/docs/docs/noir/syntax/mutability.md
+++ b/docs/docs/noir/syntax/mutability.md
@@ -70,11 +70,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/docs/noir/syntax/ops.md b/docs/docs/noir/syntax/ops.md
index 977c8ba1203..60425cb8994 100644
--- a/docs/docs/noir/syntax/ops.md
+++ b/docs/docs/noir/syntax/ops.md
@@ -63,7 +63,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/docs/noir/syntax/unconstrained.md b/docs/docs/noir/syntax/unconstrained.md
index 7a61d3953ef..6b3424f7993 100644
--- a/docs/docs/noir/syntax/unconstrained.md
+++ b/docs/docs/noir/syntax/unconstrained.md
@@ -6,7 +6,7 @@ keywords: [Noir programming language, unconstrained, open]
 sidebar_position: 5
 ---
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.17.0/getting_started/00_nargo_installation.md b/docs/versioned_docs/version-v0.17.0/getting_started/00_nargo_installation.md
index f4ca361d3c4..0de5597c213 100644
--- a/docs/versioned_docs/version-v0.17.0/getting_started/00_nargo_installation.md
+++ b/docs/versioned_docs/version-v0.17.0/getting_started/00_nargo_installation.md
@@ -140,9 +140,9 @@ Commands:
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
diff --git a/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md
index bc0e742fb4e..e7b1f33b339 100644
--- a/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.17.0/getting_started/02_breakdown.md
@@ -39,7 +39,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.17.0/index.md b/docs/versioned_docs/version-v0.17.0/index.md
index ddbee58f6e4..4eeeb6f1346 100644
--- a/docs/versioned_docs/version-v0.17.0/index.md
+++ b/docs/versioned_docs/version-v0.17.0/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularised in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -55,7 +55,7 @@ must be implemented for it.
 
 Noir is simple and flexible in its design, as it does not compile immediately to a fixed
 NP-complete language. Instead, Noir compiles to an intermediate language (ACIR), which itself can be compiled
-to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkwork's Marlin backend, or others).
+to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkworks' Marlin backend, or others).
 
 This in itself brings up a few challenges within the design process, but allows one to decouple the programming language completely from the backend. This is similar in theory to LLVM.
 
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/03_ops.md b/docs/versioned_docs/version-v0.17.0/language_concepts/03_ops.md
index d5caa463765..0e35ef5e584 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/03_ops.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/03_ops.md
@@ -62,7 +62,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/05_unconstrained.md b/docs/versioned_docs/version-v0.17.0/language_concepts/05_unconstrained.md
index 6b621eda3eb..097d6ee9894 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/05_unconstrained.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/05_unconstrained.md
@@ -7,7 +7,7 @@ keywords: [Noir programming language, unconstrained, open]
 
 <!-- Source material for much of this page comes from here: https://github.com/noir-lang/acvm-docs/blob/main/docs/brillig/00_intro.md -->
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/07_mutability.md b/docs/versioned_docs/version-v0.17.0/language_concepts/07_mutability.md
index ad902c42c9b..ed3fed820ec 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/07_mutability.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/07_mutability.md
@@ -69,11 +69,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types.md b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types.md
index d546cc463a8..74f573f7d3f 100644
--- a/docs/versioned_docs/version-v0.17.0/language_concepts/data_types.md
+++ b/docs/versioned_docs/version-v0.17.0/language_concepts/data_types.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md
index 75f95aaa305..2c188992616 100644
--- a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/dependencies.md
@@ -48,7 +48,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -60,17 +60,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/modules.md
index 147c9b284e8..11e60cbf35e 100644
--- a/docs/versioned_docs/version-v0.17.0/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.17.0/modules_packages_crates/modules.md
@@ -10,7 +10,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.17.0/nargo/02_testing.md b/docs/versioned_docs/version-v0.17.0/nargo/02_testing.md
index da767274efd..917c9415126 100644
--- a/docs/versioned_docs/version-v0.17.0/nargo/02_testing.md
+++ b/docs/versioned_docs/version-v0.17.0/nargo/02_testing.md
@@ -24,7 +24,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.17.0/noir_js/reference/01_noirjs.md b/docs/versioned_docs/version-v0.17.0/noir_js/reference/01_noirjs.md
index 11fef2bf8b5..3480fbfedad 100644
--- a/docs/versioned_docs/version-v0.17.0/noir_js/reference/01_noirjs.md
+++ b/docs/versioned_docs/version-v0.17.0/noir_js/reference/01_noirjs.md
@@ -90,7 +90,7 @@ This async method generates a witness and a proof given an object as input.
 ### Syntax
 
 ```js
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ### Parameters
diff --git a/docs/versioned_docs/version-v0.17.0/noir_js/reference/02_bb_backend.md b/docs/versioned_docs/version-v0.17.0/noir_js/reference/02_bb_backend.md
index f444eab1772..958cabd6289 100644
--- a/docs/versioned_docs/version-v0.17.0/noir_js/reference/02_bb_backend.md
+++ b/docs/versioned_docs/version-v0.17.0/noir_js/reference/02_bb_backend.md
@@ -41,7 +41,7 @@ constructor(acirCircuit, (numberOfThreads = 1));
 
 | Parameter         | Type              | Description                                                                                                                                                                                                                             |
 | ----------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `acirCircuit`     | Object            | A circuit represented in a `json` format, containing the ABI and bytecode Tipically obtained by running [`nargo compile`](../../nargo/01_commands.md). This is the same circuit expected to be passed to [the Noir class](01_noirjs.md) |
+| `acirCircuit`     | Object            | A circuit represented in a `json` format, containing the ABI and bytecode typically obtained by running [`nargo compile`](../../nargo/01_commands.md). This is the same circuit expected to be passed to [the Noir class](01_noirjs.md) |
 | `numberOfThreads` | Number (optional) | The number of threads to be used by the backend. Defaults to 1.                                                                                                                                                                         |
 
 ### Usage
diff --git a/docs/versioned_docs/version-v0.19.0/getting_started/00_nargo_installation.md b/docs/versioned_docs/version-v0.19.0/getting_started/00_nargo_installation.md
index 349756d60c0..7d3c88c7693 100644
--- a/docs/versioned_docs/version-v0.19.0/getting_started/00_nargo_installation.md
+++ b/docs/versioned_docs/version-v0.19.0/getting_started/00_nargo_installation.md
@@ -140,9 +140,9 @@ Commands:
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -220,7 +220,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md
index 9a17f5d6360..d28a54a1600 100644
--- a/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.0/getting_started/02_breakdown.md
@@ -39,7 +39,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.19.0/index.md b/docs/versioned_docs/version-v0.19.0/index.md
index 4e2f4043892..93944f92bf5 100644
--- a/docs/versioned_docs/version-v0.19.0/index.md
+++ b/docs/versioned_docs/version-v0.19.0/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularised in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -55,7 +55,7 @@ must be implemented for it.
 
 Noir is simple and flexible in its design, as it does not compile immediately to a fixed
 NP-complete language. Instead, Noir compiles to an intermediate language (ACIR), which itself can be compiled
-to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkwork's Marlin backend, or others).
+to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkworks' Marlin backend, or others).
 
 This in itself brings up a few challenges within the design process, but allows one to decouple the programming language completely from the backend. This is similar in theory to LLVM.
 
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/03_ops.md b/docs/versioned_docs/version-v0.19.0/language_concepts/03_ops.md
index d5caa463765..0e35ef5e584 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/03_ops.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/03_ops.md
@@ -62,7 +62,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/05_unconstrained.md b/docs/versioned_docs/version-v0.19.0/language_concepts/05_unconstrained.md
index 6b621eda3eb..097d6ee9894 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/05_unconstrained.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/05_unconstrained.md
@@ -7,7 +7,7 @@ keywords: [Noir programming language, unconstrained, open]
 
 <!-- Source material for much of this page comes from here: https://github.com/noir-lang/acvm-docs/blob/main/docs/brillig/00_intro.md -->
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/07_mutability.md b/docs/versioned_docs/version-v0.19.0/language_concepts/07_mutability.md
index ad902c42c9b..ed3fed820ec 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/07_mutability.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/07_mutability.md
@@ -69,11 +69,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types.md b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types.md
index d546cc463a8..74f573f7d3f 100644
--- a/docs/versioned_docs/version-v0.19.0/language_concepts/data_types.md
+++ b/docs/versioned_docs/version-v0.19.0/language_concepts/data_types.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md
index 75f95aaa305..2c188992616 100644
--- a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/dependencies.md
@@ -48,7 +48,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -60,17 +60,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/modules.md
index 147c9b284e8..11e60cbf35e 100644
--- a/docs/versioned_docs/version-v0.19.0/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.19.0/modules_packages_crates/modules.md
@@ -10,7 +10,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.19.0/nargo/02_testing.md b/docs/versioned_docs/version-v0.19.0/nargo/02_testing.md
index da767274efd..917c9415126 100644
--- a/docs/versioned_docs/version-v0.19.0/nargo/02_testing.md
+++ b/docs/versioned_docs/version-v0.19.0/nargo/02_testing.md
@@ -24,7 +24,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.19.0/noir_js/reference/01_noirjs.md b/docs/versioned_docs/version-v0.19.0/noir_js/reference/01_noirjs.md
index ccdd53f2bcc..2e90779ceab 100644
--- a/docs/versioned_docs/version-v0.19.0/noir_js/reference/01_noirjs.md
+++ b/docs/versioned_docs/version-v0.19.0/noir_js/reference/01_noirjs.md
@@ -94,7 +94,7 @@ This async method generates a witness and a proof given an object as input.
 ### Syntax
 
 ```js
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ### Parameters
diff --git a/docs/versioned_docs/version-v0.19.0/noir_js/reference/02_bb_backend.md b/docs/versioned_docs/version-v0.19.0/noir_js/reference/02_bb_backend.md
index f444eab1772..958cabd6289 100644
--- a/docs/versioned_docs/version-v0.19.0/noir_js/reference/02_bb_backend.md
+++ b/docs/versioned_docs/version-v0.19.0/noir_js/reference/02_bb_backend.md
@@ -41,7 +41,7 @@ constructor(acirCircuit, (numberOfThreads = 1));
 
 | Parameter         | Type              | Description                                                                                                                                                                                                                             |
 | ----------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `acirCircuit`     | Object            | A circuit represented in a `json` format, containing the ABI and bytecode Tipically obtained by running [`nargo compile`](../../nargo/01_commands.md). This is the same circuit expected to be passed to [the Noir class](01_noirjs.md) |
+| `acirCircuit`     | Object            | A circuit represented in a `json` format, containing the ABI and bytecode typically obtained by running [`nargo compile`](../../nargo/01_commands.md). This is the same circuit expected to be passed to [the Noir class](01_noirjs.md) |
 | `numberOfThreads` | Number (optional) | The number of threads to be used by the backend. Defaults to 1.                                                                                                                                                                         |
 
 ### Usage
diff --git a/docs/versioned_docs/version-v0.19.0/noir_js/reference/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.19.0/noir_js/reference/noir_js/classes/Noir.md
index a8a0bb451c1..1d7b54a9dca 100644
--- a/docs/versioned_docs/version-v0.19.0/noir_js/reference/noir_js/classes/Noir.md
+++ b/docs/versioned_docs/version-v0.19.0/noir_js/reference/noir_js/classes/Noir.md
@@ -95,7 +95,7 @@ Generates a witness and a proof given an object as input.
 #### Example
 
 ```typescript
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ***
diff --git a/docs/versioned_docs/version-v0.19.1/getting_started/00_nargo_installation.md b/docs/versioned_docs/version-v0.19.1/getting_started/00_nargo_installation.md
index 349756d60c0..7d3c88c7693 100644
--- a/docs/versioned_docs/version-v0.19.1/getting_started/00_nargo_installation.md
+++ b/docs/versioned_docs/version-v0.19.1/getting_started/00_nargo_installation.md
@@ -140,9 +140,9 @@ Commands:
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -220,7 +220,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md
index 9a17f5d6360..d28a54a1600 100644
--- a/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.1/getting_started/02_breakdown.md
@@ -39,7 +39,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.19.1/index.md b/docs/versioned_docs/version-v0.19.1/index.md
index 4e2f4043892..93944f92bf5 100644
--- a/docs/versioned_docs/version-v0.19.1/index.md
+++ b/docs/versioned_docs/version-v0.19.1/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularised in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -55,7 +55,7 @@ must be implemented for it.
 
 Noir is simple and flexible in its design, as it does not compile immediately to a fixed
 NP-complete language. Instead, Noir compiles to an intermediate language (ACIR), which itself can be compiled
-to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkwork's Marlin backend, or others).
+to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkworks' Marlin backend, or others).
 
 This in itself brings up a few challenges within the design process, but allows one to decouple the programming language completely from the backend. This is similar in theory to LLVM.
 
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/03_ops.md b/docs/versioned_docs/version-v0.19.1/language_concepts/03_ops.md
index d5caa463765..0e35ef5e584 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/03_ops.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/03_ops.md
@@ -62,7 +62,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/05_unconstrained.md b/docs/versioned_docs/version-v0.19.1/language_concepts/05_unconstrained.md
index 6b621eda3eb..097d6ee9894 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/05_unconstrained.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/05_unconstrained.md
@@ -7,7 +7,7 @@ keywords: [Noir programming language, unconstrained, open]
 
 <!-- Source material for much of this page comes from here: https://github.com/noir-lang/acvm-docs/blob/main/docs/brillig/00_intro.md -->
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/07_mutability.md b/docs/versioned_docs/version-v0.19.1/language_concepts/07_mutability.md
index ad902c42c9b..ed3fed820ec 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/07_mutability.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/07_mutability.md
@@ -69,11 +69,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types.md b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types.md
index d546cc463a8..74f573f7d3f 100644
--- a/docs/versioned_docs/version-v0.19.1/language_concepts/data_types.md
+++ b/docs/versioned_docs/version-v0.19.1/language_concepts/data_types.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md
index 75f95aaa305..2c188992616 100644
--- a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/dependencies.md
@@ -48,7 +48,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -60,17 +60,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/modules.md
index 147c9b284e8..11e60cbf35e 100644
--- a/docs/versioned_docs/version-v0.19.1/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.19.1/modules_packages_crates/modules.md
@@ -10,7 +10,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.19.1/nargo/02_testing.md b/docs/versioned_docs/version-v0.19.1/nargo/02_testing.md
index da767274efd..917c9415126 100644
--- a/docs/versioned_docs/version-v0.19.1/nargo/02_testing.md
+++ b/docs/versioned_docs/version-v0.19.1/nargo/02_testing.md
@@ -24,7 +24,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.19.1/noir_js/reference/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.19.1/noir_js/reference/noir_js/classes/Noir.md
index a8a0bb451c1..1d7b54a9dca 100644
--- a/docs/versioned_docs/version-v0.19.1/noir_js/reference/noir_js/classes/Noir.md
+++ b/docs/versioned_docs/version-v0.19.1/noir_js/reference/noir_js/classes/Noir.md
@@ -95,7 +95,7 @@ Generates a witness and a proof given an object as input.
 #### Example
 
 ```typescript
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ***
diff --git a/docs/versioned_docs/version-v0.19.2/getting_started/00_nargo_installation.md b/docs/versioned_docs/version-v0.19.2/getting_started/00_nargo_installation.md
index 349756d60c0..7d3c88c7693 100644
--- a/docs/versioned_docs/version-v0.19.2/getting_started/00_nargo_installation.md
+++ b/docs/versioned_docs/version-v0.19.2/getting_started/00_nargo_installation.md
@@ -140,9 +140,9 @@ Commands:
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -220,7 +220,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md
index 9a17f5d6360..d28a54a1600 100644
--- a/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.2/getting_started/02_breakdown.md
@@ -39,7 +39,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.19.2/index.md b/docs/versioned_docs/version-v0.19.2/index.md
index 4e2f4043892..93944f92bf5 100644
--- a/docs/versioned_docs/version-v0.19.2/index.md
+++ b/docs/versioned_docs/version-v0.19.2/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularised in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -55,7 +55,7 @@ must be implemented for it.
 
 Noir is simple and flexible in its design, as it does not compile immediately to a fixed
 NP-complete language. Instead, Noir compiles to an intermediate language (ACIR), which itself can be compiled
-to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkwork's Marlin backend, or others).
+to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkworks' Marlin backend, or others).
 
 This in itself brings up a few challenges within the design process, but allows one to decouple the programming language completely from the backend. This is similar in theory to LLVM.
 
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/03_ops.md b/docs/versioned_docs/version-v0.19.2/language_concepts/03_ops.md
index d5caa463765..0e35ef5e584 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/03_ops.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/03_ops.md
@@ -62,7 +62,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/05_unconstrained.md b/docs/versioned_docs/version-v0.19.2/language_concepts/05_unconstrained.md
index 6b621eda3eb..097d6ee9894 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/05_unconstrained.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/05_unconstrained.md
@@ -7,7 +7,7 @@ keywords: [Noir programming language, unconstrained, open]
 
 <!-- Source material for much of this page comes from here: https://github.com/noir-lang/acvm-docs/blob/main/docs/brillig/00_intro.md -->
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/07_mutability.md b/docs/versioned_docs/version-v0.19.2/language_concepts/07_mutability.md
index ad902c42c9b..ed3fed820ec 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/07_mutability.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/07_mutability.md
@@ -69,11 +69,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types.md b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types.md
index d546cc463a8..74f573f7d3f 100644
--- a/docs/versioned_docs/version-v0.19.2/language_concepts/data_types.md
+++ b/docs/versioned_docs/version-v0.19.2/language_concepts/data_types.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md
index 75f95aaa305..2c188992616 100644
--- a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/dependencies.md
@@ -48,7 +48,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -60,17 +60,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/modules.md
index 147c9b284e8..11e60cbf35e 100644
--- a/docs/versioned_docs/version-v0.19.2/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.19.2/modules_packages_crates/modules.md
@@ -10,7 +10,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.19.2/nargo/02_testing.md b/docs/versioned_docs/version-v0.19.2/nargo/02_testing.md
index da767274efd..917c9415126 100644
--- a/docs/versioned_docs/version-v0.19.2/nargo/02_testing.md
+++ b/docs/versioned_docs/version-v0.19.2/nargo/02_testing.md
@@ -24,7 +24,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.19.2/noir_js/reference/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.19.2/noir_js/reference/noir_js/classes/Noir.md
index a8a0bb451c1..1d7b54a9dca 100644
--- a/docs/versioned_docs/version-v0.19.2/noir_js/reference/noir_js/classes/Noir.md
+++ b/docs/versioned_docs/version-v0.19.2/noir_js/reference/noir_js/classes/Noir.md
@@ -95,7 +95,7 @@ Generates a witness and a proof given an object as input.
 #### Example
 
 ```typescript
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ***
diff --git a/docs/versioned_docs/version-v0.19.3/getting_started/00_nargo_installation.md b/docs/versioned_docs/version-v0.19.3/getting_started/00_nargo_installation.md
index 349756d60c0..7d3c88c7693 100644
--- a/docs/versioned_docs/version-v0.19.3/getting_started/00_nargo_installation.md
+++ b/docs/versioned_docs/version-v0.19.3/getting_started/00_nargo_installation.md
@@ -140,9 +140,9 @@ Commands:
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -220,7 +220,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md
index 9a17f5d6360..7a7fb876c35 100644
--- a/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.3/getting_started/02_breakdown.md
@@ -39,7 +39,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter'"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.19.3/index.md b/docs/versioned_docs/version-v0.19.3/index.md
index 4e2f4043892..93944f92bf5 100644
--- a/docs/versioned_docs/version-v0.19.3/index.md
+++ b/docs/versioned_docs/version-v0.19.3/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularised in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -55,7 +55,7 @@ must be implemented for it.
 
 Noir is simple and flexible in its design, as it does not compile immediately to a fixed
 NP-complete language. Instead, Noir compiles to an intermediate language (ACIR), which itself can be compiled
-to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkwork's Marlin backend, or others).
+to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkworks' Marlin backend, or others).
 
 This in itself brings up a few challenges within the design process, but allows one to decouple the programming language completely from the backend. This is similar in theory to LLVM.
 
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/03_ops.md b/docs/versioned_docs/version-v0.19.3/language_concepts/03_ops.md
index d5caa463765..0e35ef5e584 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/03_ops.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/03_ops.md
@@ -62,7 +62,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/05_unconstrained.md b/docs/versioned_docs/version-v0.19.3/language_concepts/05_unconstrained.md
index 6b621eda3eb..097d6ee9894 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/05_unconstrained.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/05_unconstrained.md
@@ -7,7 +7,7 @@ keywords: [Noir programming language, unconstrained, open]
 
 <!-- Source material for much of this page comes from here: https://github.com/noir-lang/acvm-docs/blob/main/docs/brillig/00_intro.md -->
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/07_mutability.md b/docs/versioned_docs/version-v0.19.3/language_concepts/07_mutability.md
index ad902c42c9b..ed3fed820ec 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/07_mutability.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/07_mutability.md
@@ -69,11 +69,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types.md b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types.md
index d546cc463a8..74f573f7d3f 100644
--- a/docs/versioned_docs/version-v0.19.3/language_concepts/data_types.md
+++ b/docs/versioned_docs/version-v0.19.3/language_concepts/data_types.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md
index 75f95aaa305..2c188992616 100644
--- a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/dependencies.md
@@ -48,7 +48,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -60,17 +60,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/modules.md
index 147c9b284e8..11e60cbf35e 100644
--- a/docs/versioned_docs/version-v0.19.3/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.19.3/modules_packages_crates/modules.md
@@ -10,7 +10,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.19.3/nargo/02_testing.md b/docs/versioned_docs/version-v0.19.3/nargo/02_testing.md
index da767274efd..917c9415126 100644
--- a/docs/versioned_docs/version-v0.19.3/nargo/02_testing.md
+++ b/docs/versioned_docs/version-v0.19.3/nargo/02_testing.md
@@ -24,7 +24,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.19.3/noir_js/reference/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.19.3/noir_js/reference/noir_js/classes/Noir.md
index a8a0bb451c1..1d7b54a9dca 100644
--- a/docs/versioned_docs/version-v0.19.3/noir_js/reference/noir_js/classes/Noir.md
+++ b/docs/versioned_docs/version-v0.19.3/noir_js/reference/noir_js/classes/Noir.md
@@ -95,7 +95,7 @@ Generates a witness and a proof given an object as input.
 #### Example
 
 ```typescript
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ***
diff --git a/docs/versioned_docs/version-v0.19.4/getting_started/00_nargo_installation.md b/docs/versioned_docs/version-v0.19.4/getting_started/00_nargo_installation.md
index 349756d60c0..7d3c88c7693 100644
--- a/docs/versioned_docs/version-v0.19.4/getting_started/00_nargo_installation.md
+++ b/docs/versioned_docs/version-v0.19.4/getting_started/00_nargo_installation.md
@@ -140,9 +140,9 @@ Commands:
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -220,7 +220,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md b/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md
index 9a17f5d6360..d28a54a1600 100644
--- a/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md
+++ b/docs/versioned_docs/version-v0.19.4/getting_started/02_breakdown.md
@@ -39,7 +39,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.19.4/index.md b/docs/versioned_docs/version-v0.19.4/index.md
index 4e2f4043892..93944f92bf5 100644
--- a/docs/versioned_docs/version-v0.19.4/index.md
+++ b/docs/versioned_docs/version-v0.19.4/index.md
@@ -34,7 +34,7 @@ Noir can be used for a variety of purposes.
 ### Solidity Developers
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will
-be modularised in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
+be modularized in the future; however, as of the alpha, you can use the [`nargo codegen-verifier`](./nargo/commands#nargo-codegen-verifier) command to create
 a verifier contract.
 
 ### Protocol Developers
@@ -55,7 +55,7 @@ must be implemented for it.
 
 Noir is simple and flexible in its design, as it does not compile immediately to a fixed
 NP-complete language. Instead, Noir compiles to an intermediate language (ACIR), which itself can be compiled
-to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkwork's Marlin backend, or others).
+to an arithmetic circuit (if choosing to target Aztec's barretenberg backend) or a rank-1 constraint system (if choosing to target an R1CS backend like Arkworks' Marlin backend, or others).
 
 This in itself brings up a few challenges within the design process, but allows one to decouple the programming language completely from the backend. This is similar in theory to LLVM.
 
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/03_ops.md b/docs/versioned_docs/version-v0.19.4/language_concepts/03_ops.md
index d5caa463765..0e35ef5e584 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/03_ops.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/03_ops.md
@@ -62,7 +62,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/05_unconstrained.md b/docs/versioned_docs/version-v0.19.4/language_concepts/05_unconstrained.md
index 6b621eda3eb..097d6ee9894 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/05_unconstrained.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/05_unconstrained.md
@@ -7,7 +7,7 @@ keywords: [Noir programming language, unconstrained, open]
 
 <!-- Source material for much of this page comes from here: https://github.com/noir-lang/acvm-docs/blob/main/docs/brillig/00_intro.md -->
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/07_mutability.md b/docs/versioned_docs/version-v0.19.4/language_concepts/07_mutability.md
index ad902c42c9b..ed3fed820ec 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/07_mutability.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/07_mutability.md
@@ -69,11 +69,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types.md b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types.md
index d546cc463a8..74f573f7d3f 100644
--- a/docs/versioned_docs/version-v0.19.4/language_concepts/data_types.md
+++ b/docs/versioned_docs/version-v0.19.4/language_concepts/data_types.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md
index 75f95aaa305..2c188992616 100644
--- a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/dependencies.md
@@ -48,7 +48,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -60,17 +60,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/modules.md
index 147c9b284e8..11e60cbf35e 100644
--- a/docs/versioned_docs/version-v0.19.4/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.19.4/modules_packages_crates/modules.md
@@ -10,7 +10,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.19.4/nargo/02_testing.md b/docs/versioned_docs/version-v0.19.4/nargo/02_testing.md
index da767274efd..917c9415126 100644
--- a/docs/versioned_docs/version-v0.19.4/nargo/02_testing.md
+++ b/docs/versioned_docs/version-v0.19.4/nargo/02_testing.md
@@ -24,7 +24,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.19.4/noir_js/reference/noir_js/classes/Noir.md b/docs/versioned_docs/version-v0.19.4/noir_js/reference/noir_js/classes/Noir.md
index e54116fb1d8..c54468891af 100644
--- a/docs/versioned_docs/version-v0.19.4/noir_js/reference/noir_js/classes/Noir.md
+++ b/docs/versioned_docs/version-v0.19.4/noir_js/reference/noir_js/classes/Noir.md
@@ -95,7 +95,7 @@ Generates a witness and a proof given an object as input.
 #### Example
 
 ```typescript
-async generateFinalproof(input)
+async generateFinalProof(input)
 ```
 
 ***
diff --git a/docs/versioned_docs/version-v0.22.0/explainers/explainer-recursion.md b/docs/versioned_docs/version-v0.22.0/explainers/explainer-recursion.md
index cc431a878dc..9357d3c7341 100644
--- a/docs/versioned_docs/version-v0.22.0/explainers/explainer-recursion.md
+++ b/docs/versioned_docs/version-v0.22.0/explainers/explainer-recursion.md
@@ -149,7 +149,7 @@ In such a situation, and assuming Alice is first, she would skip the first part
 
 ### Aggregating proofs
 
-In some one-way interaction situations, recursiveness would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
+In some one-way interaction situations, recursion would allow for aggregation of simple proofs that don't need to be immediately verified on-chain or elsewhere.
 
 To give a practical example, a barman wouldn't need to verify a "proof-of-age" on-chain every time he serves alcohol to a customer. Instead, the architecture would comprise two circuits:
 
diff --git a/docs/versioned_docs/version-v0.22.0/getting_started/installation/other_install_methods.md b/docs/versioned_docs/version-v0.22.0/getting_started/installation/other_install_methods.md
index 36f05657277..a532f83750e 100644
--- a/docs/versioned_docs/version-v0.22.0/getting_started/installation/other_install_methods.md
+++ b/docs/versioned_docs/version-v0.22.0/getting_started/installation/other_install_methods.md
@@ -83,9 +83,9 @@ Check if the installation was successful by running `nargo --version`. You shoul
 
 ### Option 3: Compile from Source
 
-Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating ssues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
+Due to the large number of native dependencies, Noir projects uses [Nix](https://nixos.org/) and [direnv](https://direnv.net/) to streamline the development experience. It helps mitigating issues commonly associated with dependency management, such as conflicts between required package versions for different projects (often referred to as "dependency hell").
 
-Combined with direnv, which automatically sets or unsets environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
+Combined with direnv, which automatically sets or clears environment variables based on the directory, it further simplifies the development process by seamlessly integrating with the developer's shell, facilitating an efficient and reliable workflow for managing and deploying Noir projects with multiple dependencies.
 
 #### Setting up your environment
 
@@ -163,7 +163,7 @@ Advanced: If you aren't using direnv nor launching your editor within the subshe
 
 ### Option 4: WSL (for Windows)
 
-The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed nativerly. However, it is available by using Windows Subsystem for Linux (WSL).
+The default backend for Noir (Barretenberg) doesn't provide Windows binaries at this time. For that reason, Noir cannot be installed natively. However, it is available by using Windows Subsystem for Linux (WSL).
 
 Step 1: Follow the instructions [here](https://learn.microsoft.com/en-us/windows/wsl/install) to install and run WSL.
 
diff --git a/docs/versioned_docs/version-v0.22.0/getting_started/project_breakdown.md b/docs/versioned_docs/version-v0.22.0/getting_started/project_breakdown.md
index 5a214804f7b..c4e2a9ae003 100644
--- a/docs/versioned_docs/version-v0.22.0/getting_started/project_breakdown.md
+++ b/docs/versioned_docs/version-v0.22.0/getting_started/project_breakdown.md
@@ -40,7 +40,7 @@ Example Nargo.toml:
 
 ```toml
 [package]
-name = "noirstarter"
+name = "noir_starter"
 type = "bin"
 authors = ["Alice"]
 compiler_version = "0.9.0"
diff --git a/docs/versioned_docs/version-v0.22.0/getting_started/tooling/testing.md b/docs/versioned_docs/version-v0.22.0/getting_started/tooling/testing.md
index 868a061200d..5febd44e96b 100644
--- a/docs/versioned_docs/version-v0.22.0/getting_started/tooling/testing.md
+++ b/docs/versioned_docs/version-v0.22.0/getting_started/tooling/testing.md
@@ -25,7 +25,7 @@ fn test_add() {
 ```
 
 Running `nargo test` will test that the `test_add` function can be executed while satisfying the all
-the contraints which allows you to test that add returns the expected values. Test functions can't
+the constraints which allows you to test that add returns the expected values. Test functions can't
 have any arguments currently.
 
 ### Test fail
diff --git a/docs/versioned_docs/version-v0.22.0/how_to/how-to-recursion.md b/docs/versioned_docs/version-v0.22.0/how_to/how-to-recursion.md
index 226f7e6e73d..db9ad0e99f8 100644
--- a/docs/versioned_docs/version-v0.22.0/how_to/how-to-recursion.md
+++ b/docs/versioned_docs/version-v0.22.0/how_to/how-to-recursion.md
@@ -53,7 +53,7 @@ For a full example on how recursive proofs work, please refer to the [noir-examp
 
 In a common NoirJS app, you need to instantiate a backend with something like `const backend = new Backend(circuit)`. Then you feed it to the `noir_js` interface.
 
-For recursiveness, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
+For recursion, this doesn't happen, and the only need for `noir_js` is only to `execute` a circuit and get its witness and return value. Everything else is not interfaced, so it needs to happen on the `backend` object.
 
 It is also recommended that you instantiate the backend with as many threads as possible, to allow for maximum concurrency:
 
@@ -159,7 +159,7 @@ const backends = {
 main: new BarretenbergBackend(circuits.main),
 recursive: new BarretenbergBackend(circuits.recursive)
 }
-const noirs = {
+const noir_programs = {
 main: new Noir(circuits.main, backends.main),
 recursive: new Noir(circuits.recursive, backends.recursive)
 }
@@ -169,7 +169,7 @@ This allows you to neatly call exactly the method you want without conflicting n
 
 ```js
 // Alice runs this 👇
-const { witness: mainWitness } = await noirs.main.execute(input)
+const { witness: mainWitness } = await noir_programs.main.execute(input)
 const proof = await backends.main.generateIntermediateProof(mainWitness)
 
 // Bob runs this 👇
@@ -178,7 +178,7 @@ const { proofAsFields, vkAsFields, vkHash } = await backends.main.generateInterm
     proof,
     numPublicInputs,
 );
-const recursiveProof = await noirs.recursive.generateFinalProof(recursiveInputs)
+const recursiveProof = await noir_programs.recursive.generateFinalProof(recursiveInputs)
 ```
 
 :::
diff --git a/docs/versioned_docs/version-v0.22.0/index.md b/docs/versioned_docs/version-v0.22.0/index.md
index e1ec3362c1f..eaf8c59f935 100644
--- a/docs/versioned_docs/version-v0.22.0/index.md
+++ b/docs/versioned_docs/version-v0.22.0/index.md
@@ -26,7 +26,7 @@ Noir, a domain-specific language crafted for SNARK proving systems, stands out w
 and robust capabilities. Unlike conventional approaches that compile directly to a fixed NP-complete language,
 Noir takes a two-pronged path. It first compiles to an adaptable intermediate language known as ACIR. From there,
 depending on the project's needs, ACIR can be further compiled into an arithmetic circuit for integration with Aztec's
-barretenberg backend or transformed into a rank-1 constraint system suitable for R1CS backends like Arkwork's Marlin
+barretenberg backend or transformed into a rank-1 constraint system suitable for R1CS backends like Arkworks' Marlin
 backend, among others.
 
 This innovative design introduces unique challenges, yet it strategically separates the programming language from the
@@ -43,7 +43,7 @@ contracts efficiently. While the current alpha version offers this as a direct f
 to modularize this process for even greater ease of use.
 
 Noir currently includes a command to create a Solidity contract which verifies your Noir program. This will be
-modularised in the future; however, as of the alpha, you can use the `nargo codegen-verifier` command to create a verifier contract.
+modularized in the future; however, as of the alpha, you can use the `nargo codegen-verifier` command to create a verifier contract.
 
 ### Protocol Developers
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md
index 57f0f9fd420..1e93b30781a 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/dependencies.md
@@ -49,7 +49,7 @@ For example, this file structure has a library and binary crate
 │   ├── Nargo.toml
 │   └── src
 │       └── main.nr
-└── liba
+└── lib_a
     ├── Nargo.toml
     └── src
         └── lib.nr
@@ -61,17 +61,17 @@ Inside of the binary crate, you can specify:
 # Nargo.toml
 
 [dependencies]
-libA = { path = "../liba" }
+lib_a = { path = "../lib_a" }
 ```
 
 ## Importing dependencies
 
 You can import a dependency to a Noir file using the following syntax. For example, to import the
-ecrecover-noir library and local liba referenced above:
+ecrecover-noir library and local lib_a referenced above:
 
 ```rust
 use dep::ecrecover;
-use dep::libA;
+use dep::lib_a;
 ```
 
 You can also import only the specific parts of dependency that you want to use, like so:
diff --git a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/modules.md b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/modules.md
index f9f15aee8be..ae822a1cff4 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/modules.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/modules_packages_crates/modules.md
@@ -11,7 +11,7 @@ Noir's module system follows the same convention as the _newer_ version of Rust'
 
 ## Purpose of Modules
 
-Modules are used to organise files. Without modules all of your code would need to live in a single
+Modules are used to organize files. Without modules all of your code would need to live in a single
 file. In Noir, the compiler does not automatically scan all of your files to detect modules. This
 must be done explicitly by the developer.
 
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/index.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/index.md
index 52e568e9b7e..01cd0431a68 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/index.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/data_types/index.md
@@ -93,4 +93,4 @@ fn main() {
 
 ### BigInt
 
-You can acheive BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
+You can achieve BigInt functionality using the [Noir BigInt](https://github.com/shuklaayush/noir-bigint) library.
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/mutability.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/mutability.md
index 58e9c1cecfb..6abfae3cfa7 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/mutability.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/mutability.md
@@ -70,11 +70,11 @@ fn main(x : Field, y : [Field; N]) {
 
     assert(res == y[0]);
 
-    let res2 = x * mysubmodule::N;
+    let res2 = x * my_submodule::N;
     assert(res != res2);
 }
 
-mod mysubmodule {
+mod my_submodule {
     use dep::std;
 
     global N: Field = 10;
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/ops.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/ops.md
index 977c8ba1203..60425cb8994 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/ops.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/ops.md
@@ -63,7 +63,7 @@ fn main(x : Field) {
 
 Noir has no support for the logical operators `||` and `&&`. This is because encoding the
 short-circuiting that these operators require can be inefficient for Noir's backend. Instead you can
-use the bitwise operators `|` and `&` which operate indentically for booleans, just without the
+use the bitwise operators `|` and `&` which operate identically for booleans, just without the
 short-circuiting.
 
 ```rust
diff --git a/docs/versioned_docs/version-v0.22.0/noir/syntax/unconstrained.md b/docs/versioned_docs/version-v0.22.0/noir/syntax/unconstrained.md
index 7a61d3953ef..6b3424f7993 100644
--- a/docs/versioned_docs/version-v0.22.0/noir/syntax/unconstrained.md
+++ b/docs/versioned_docs/version-v0.22.0/noir/syntax/unconstrained.md
@@ -6,7 +6,7 @@ keywords: [Noir programming language, unconstrained, open]
 sidebar_position: 5
 ---
 
-Unconstrained functions are functions which do not constrain any of the included computation and allow for non-determinisitic computation.
+Unconstrained functions are functions which do not constrain any of the included computation and allow for non-deterministic computation.
 
 ## Why?
 
diff --git a/test_programs/execution_success/bit_shifts_runtime/src/main.nr b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
index a2c873a7e7f..33d68765598 100644
--- a/test_programs/execution_success/bit_shifts_runtime/src/main.nr
+++ b/test_programs/execution_success/bit_shifts_runtime/src/main.nr
@@ -5,4 +5,15 @@ fn main(x: u64, y: u64) {
     // runtime shifts on runtime values
     assert(x << y == 128);
     assert(x >> y == 32);
+
+    // Bit-shift with signed integers
+    let mut a :i8 = y as i8;
+    let mut b: i8 = x as i8;
+    assert(b << 1 == -128);
+    assert(b >> 2 == 16);
+    assert(b >> a == 32);
+    a = -a;
+    assert(a << 7 == -128);
+    assert(a << -a == -2);
+
 }
diff --git a/test_programs/execution_success/global_consts/src/main.nr b/test_programs/execution_success/global_consts/src/main.nr
index a749ec77da6..70c7a745a22 100644
--- a/test_programs/execution_success/global_consts/src/main.nr
+++ b/test_programs/execution_success/global_consts/src/main.nr
@@ -55,17 +55,17 @@ fn main(
     let t: [Field; T_LEN] = [N, M];
     assert(t[1] == 32);
 
-    assert(15 == mysubmodule::my_helper());
+    assert(15 == my_submodule::my_helper());
 
-    let add_submodules_N = mysubmodule::N + foo::bar::N;
+    let add_submodules_N = my_submodule::N + foo::bar::N;
     assert(15 == add_submodules_N);
-    let add_from_bar_N = mysubmodule::N + foo::bar::from_bar(1);
+    let add_from_bar_N = my_submodule::N + foo::bar::from_bar(1);
     assert(15 == add_from_bar_N);
-    // Example showing an array filled with (mysubmodule::N + 2) 0's
-    let sugared = [0; mysubmodule::N + 2];
-    assert(sugared[mysubmodule::N + 1] == 0);
+    // Example showing an array filled with (my_submodule::N + 2) 0's
+    let sugared = [0; my_submodule::N + 2];
+    assert(sugared[my_submodule::N + 1] == 0);
 
-    let arr: [Field; mysubmodule::N] = [N; 10];
+    let arr: [Field; my_submodule::N] = [N; 10];
     assert((arr[0] == 5) & (arr[9] == 5));
 
     foo::from_foo(d);
@@ -80,7 +80,7 @@ fn arrays_neq(a: [Field; M], b: [Field; M]) {
     assert(a != b);
 }
 
-mod mysubmodule {
+mod my_submodule {
     global N: Field = 10;
     global L: Field = 50;
 
diff --git a/test_programs/execution_success/submodules/src/main.nr b/test_programs/execution_success/submodules/src/main.nr
index 813f3a26a20..f937af74627 100644
--- a/test_programs/execution_success/submodules/src/main.nr
+++ b/test_programs/execution_success/submodules/src/main.nr
@@ -1,11 +1,11 @@
-use mysubmodule::my_helper;
+use my_submodule::my_helper;
 
 fn main(x: u1, y: u1) {
     my_helper();
-    mysubmodule::my_bool_or(x, y);
+    my_submodule::my_bool_or(x, y);
 }
 
-mod mysubmodule {
+mod my_submodule {
     pub fn my_bool_or(x: u1, y: u1) {
         assert(x | y == 1);
     }
diff --git a/tooling/backend_interface/Cargo.toml b/tooling/backend_interface/Cargo.toml
index 32c5d28e3b0..2d991f9ae6c 100644
--- a/tooling/backend_interface/Cargo.toml
+++ b/tooling/backend_interface/Cargo.toml
@@ -16,7 +16,7 @@ thiserror.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 bb_abstraction_leaks.workspace = true
-log.workspace = true
+tracing.workspace = true
 
 tempfile.workspace = true
 
diff --git a/tooling/backend_interface/src/cli/write_vk.rs b/tooling/backend_interface/src/cli/write_vk.rs
index 8d4aa9cc7e3..da9fc04cbef 100644
--- a/tooling/backend_interface/src/cli/write_vk.rs
+++ b/tooling/backend_interface/src/cli/write_vk.rs
@@ -12,6 +12,7 @@ pub(crate) struct WriteVkCommand {
 }
 
 impl WriteVkCommand {
+    #[tracing::instrument(level = "trace", name = "vk_generation", skip_all)]
     pub(crate) fn run(self, binary_path: &Path) -> Result<(), BackendError> {
         let mut command = std::process::Command::new(binary_path);
 
diff --git a/tooling/backend_interface/src/lib.rs b/tooling/backend_interface/src/lib.rs
index 8ed164fc217..c15383086eb 100644
--- a/tooling/backend_interface/src/lib.rs
+++ b/tooling/backend_interface/src/lib.rs
@@ -12,6 +12,7 @@ pub use bb_abstraction_leaks::ACVM_BACKEND_BARRETENBERG;
 use bb_abstraction_leaks::BB_VERSION;
 use cli::VersionCommand;
 pub use download::download_backend;
+use tracing::warn;
 
 const BACKENDS_DIR: &str = ".nargo/backends";
 
@@ -115,7 +116,7 @@ impl Backend {
 
                 // If version doesn't match then download the correct version.
                 Ok(version_string) => {
-                    log::warn!("`{ACVM_BACKEND_BARRETENBERG}` version `{version_string}` is different from expected `{BB_VERSION}`. Downloading expected version...");
+                    warn!("`{ACVM_BACKEND_BARRETENBERG}` version `{version_string}` is different from expected `{BB_VERSION}`. Downloading expected version...");
                     let bb_url = std::env::var("BB_BINARY_URL")
                         .unwrap_or_else(|_| bb_abstraction_leaks::BB_DOWNLOAD_URL.to_owned());
                     download_backend(&bb_url, binary_path)?;
@@ -123,7 +124,7 @@ impl Backend {
 
                 // If `bb` fails to report its version, then attempt to fix it by re-downloading the binary.
                 Err(_) => {
-                    log::warn!("Could not determine version of `{ACVM_BACKEND_BARRETENBERG}`. Downloading expected version...");
+                    warn!("Could not determine version of `{ACVM_BACKEND_BARRETENBERG}`. Downloading expected version...");
                     let bb_url = std::env::var("BB_BINARY_URL")
                         .unwrap_or_else(|_| bb_abstraction_leaks::BB_DOWNLOAD_URL.to_owned());
                     download_backend(&bb_url, binary_path)?;
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index 01842a81da9..595cd7e2020 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -6,6 +6,7 @@ use acvm::acir::{circuit::Circuit, native_types::WitnessMap};
 use acvm::ExpressionWidth;
 use acvm::FieldElement;
 use tempfile::tempdir;
+use tracing::warn;
 
 use crate::cli::{
     GatesCommand, InfoCommand, ProofAsFieldsCommand, ProveCommand, VerifyCommand,
@@ -42,13 +43,14 @@ impl Backend {
         if let Ok(expression_width) = self.get_backend_info() {
             expression_width
         } else {
-            log::warn!(
+            warn!(
                 "No valid backend found, ExpressionWidth defaulting to Bounded with a width of 3"
             );
             ExpressionWidth::Bounded { width: 3 }
         }
     }
 
+    #[tracing::instrument(level = "trace", skip_all)]
     pub fn prove(
         &self,
         circuit: &Circuit,
@@ -89,6 +91,7 @@ impl Backend {
         Ok(proof)
     }
 
+    #[tracing::instrument(level = "trace", skip_all)]
     pub fn verify(
         &self,
         proof: &[u8],
diff --git a/tooling/debugger/README.md b/tooling/debugger/README.md
index 964784cb730..0ec3b6f0cd4 100644
--- a/tooling/debugger/README.md
+++ b/tooling/debugger/README.md
@@ -315,25 +315,105 @@ Finished execution
 
 Upon quitting the debugger after a solved circuit, the resulting circuit witness gets saved, equivalent to what would happen if we had run the same circuit with `nargo execute`.
 
-## VS Code extension
 
-We're working on extending Noir's official VS Code extension so it uses the editor's debugger facilities to debug Noir programs. 
+# Testing experimental features
 
-This section will soon show how to load the extension from sources, in order to test the debugger.
+There's a number of features that are in active development and that can't yet be merged to the main branch for different reasons. In this section we detail what those features are and how to try them out.
 
+## Build from experimental branch at fork
 
-## Variable value inspection (unstable)
+Build Nargo by pulling the source version from https://github.com/manastech/noir/tree/dap-with-vars.
 
-To enable the inspection of variable values at runtime from the debugger, we're in the process of instrumenting the compiler to track and collect the necessary mappings between source code level variable names and ACIR/Brillig state. 
+This will result in a Nargo binary being written to `PROJECT_ROOT/target/debug/nargo`. We will use this path later, so keep it at hand or export it to a an env var. For example:
 
-At the time of writing, there are still some parts of the language that haven't been fully instrumented, which means certain programs will crash when compiled with this.
+`export NARGO_EXP=PROJECT_ROOT/target/debug/nargo`
 
-It is however possible to try out this feature, both from the REPL and VS Code, by building Nargo from branch https://github.com/manastech/noir/tree/dap-with-vars.
+## About the experimental features
 
-We'll soon expand this section with details on how to do so for the adventurous.
+There are currently 2 experimental features in the debugger:
 
+- Variables inspection
+- Stacktrace inspection
 
-## Towards debugging contracts 
+NOTE: Supporting variables inspection requires extensive instrumentation of the compiler, handling all cases of variable creation, types, and value assignment. At the time of writing this README, some cases are still not supported. For example, if your program uses slices or references, this compiler version might panic when trying to compile them, or at some point during the debugger step-by-step execution. This is the main reason why this feature has not yet been merged into master. 
+
+## Trying out REPL experimental features
+
+To try out these features, go through the same steps as described at the REPL Debugger section above, but instead of using `nargo debug` use `$NARGO_EXP debug` (assuming you exported your custom built Nargo binary to NARGO_EXP). 
+
+When entering `help` on this version, you'll find two new commands:
+
+```
+...
+stacktrace                       display the current stack trace
+...
+vars                             show variable values available at this point
+                                   in execution
+```
+
+Running `vars` will print the current variables in scope, and its current values:
+
+```
+At /mul_1/src/main.nr:6:5
+  1    // Test unsafe integer multiplication with overflow: 12^8 = 429 981 696
+  2    // The circuit should handle properly the growth of the bit size
+  3    fn main(mut x: u32, y: u32, z: u32) {
+  4        x *= y;
+  5        x *= x; //144
+  6 ->     x *= x; //20736
+  7        x *= x; //429 981 696
+  8        assert(x == z);
+  9    }
+> vars
+y:UnsignedInteger { width: 32 }=Field(4), z:UnsignedInteger { width: 32 }=Field(2¹⁶×6561), x:UnsignedInteger { width: 32 }=Field(2⁴×9)
+> 
+```
+
+Running `stacktrace` will print information about the current frame in the stacktrace:
+
+```
+> stacktrace
+Frame #0, opcode 12: EXPR [ (1, _5, _5) (-1, _6) 0 ]
+At /1_mul/src/main.nr:6:5
+  1    // Test unsafe integer multiplication with overflow: 12^8 = 429 981 696
+  2    // The circuit should handle properly the growth of the bit size
+  3    fn main(mut x: u32, y: u32, z: u32) {
+  4        x *= y;
+  5        x *= x; //144
+  6 ->     x *= x; //20736
+  7        x *= x; //429 981 696
+  8        assert(x == z);
+  9    }
+> 
+```
+
+## Testing the VS Code extension (experimental)
+
+There is a fork of the official Noir Visual Studio extension which enables the debugger in VS Code. This fork is at: https://github.com/manastech/vscode-noir/tree/dap-support.
+
+In this section, we'll explain how to test the VS Code Noir debugger combining that extension fork with the experimental features branch discussed above.
+
+1. First, get a copy of the extension source code from https://github.com/manastech/vscode-noir/tree/dap-support.
+
+2. Package the extension by running `npm run package`.
+
+3. Open the root folder of the extension on VS Code.
+
+4. From VS Code, press fn+F5. This will open a new VS Code window with the extension loaded from source. 
+
+5. Go to Code -> Settings -> Extensions -> Noir Language Server. Look for the property `Nargo Path` and enter the path to the experimental build you got as a result of following the steps at [Trying out REPL experimental features](#trying-out-repl-experimental-features).
+
+6. At the VS Code sidebar, go to the debugger section (see screenshot). Click "Add configuration". Overwrite the `projectFolder` property with the absolute path to the Nargo project you want to debug.
+
+<img width="473" alt="Screenshot 2023-12-18 at 14 37 38" src="https://github.com/manastech/noir/assets/651693/cdad9ee1-8164-4c33-ab24-2584016088f0">
+
+7. Go to a Noir file you want to debug. Navigate again to the debug section of VS Code, and click the "play" icon.
+
+The debugger should now have started. Current features exposed to the debugger include different kinds of stepping interactions, variable inspection and stacktraces. At the time of writing, Brillig registers and memory are not being exposed, but they will soon be.  
+
+![Screen Recording 2023-12-18 at 14 14 28](https://github.com/manastech/noir/assets/651693/36b4becb-953a-4158-9c5a-7a185673f54f)
+
+## Towards debugging contracts
 
 ### Contracts Runtime
 
diff --git a/tooling/nargo/Cargo.toml b/tooling/nargo/Cargo.toml
index f0733d7ad44..d60f9d3ea28 100644
--- a/tooling/nargo/Cargo.toml
+++ b/tooling/nargo/Cargo.toml
@@ -24,7 +24,7 @@ iter-extended.workspace = true
 serde.workspace = true
 thiserror.workspace = true
 codespan-reporting.workspace = true
-log.workspace = true
+tracing.workspace = true
 rayon = "1.8.0"
 
 [dev-dependencies]
diff --git a/tooling/nargo/src/ops/execute.rs b/tooling/nargo/src/ops/execute.rs
index 2ac85781410..4fc7f7b599f 100644
--- a/tooling/nargo/src/ops/execute.rs
+++ b/tooling/nargo/src/ops/execute.rs
@@ -7,13 +7,13 @@ use crate::NargoError;
 
 use super::foreign_calls::ForeignCallExecutor;
 
+#[tracing::instrument(level = "trace", skip_all)]
 pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
     circuit: &Circuit,
     initial_witness: WitnessMap,
     blackbox_solver: &B,
     foreign_call_executor: &mut F,
 ) -> Result<WitnessMap, NargoError> {
-    log::trace!("Start circuit execution");
     let mut acvm = ACVM::new(blackbox_solver, &circuit.opcodes, initial_witness);
 
     loop {
@@ -55,8 +55,5 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver, F: ForeignCallExecutor>(
         }
     }
 
-    let solved_witness = acvm.finalize();
-
-    log::trace!("Finish circuit execution");
-    Ok(solved_witness)
+    Ok(acvm.finalize())
 }
diff --git a/tooling/nargo_cli/Cargo.toml b/tooling/nargo_cli/Cargo.toml
index 65d3599bf35..f280682e15c 100644
--- a/tooling/nargo_cli/Cargo.toml
+++ b/tooling/nargo_cli/Cargo.toml
@@ -46,7 +46,6 @@ hex.workspace = true
 similar-asserts.workspace = true
 termcolor = "1.1.2"
 color-eyre = "0.6.2"
-env_logger = "0.9.0"
 tokio = { version = "1.0", features = ["io-std"] }
 dap.workspace = true
 
@@ -55,8 +54,7 @@ backend-interface = { path = "../backend_interface" }
 bb_abstraction_leaks.workspace = true
 
 # Logs
-tracing.workspace = true
-tracing-subscriber = "0.3.18"
+tracing-subscriber.workspace = true
 tracing-appender = "0.2.3"
 
 [target.'cfg(not(unix))'.dependencies]
diff --git a/tooling/nargo_cli/src/main.rs b/tooling/nargo_cli/src/main.rs
index 7eeca2ab2b0..3f797b0bf0c 100644
--- a/tooling/nargo_cli/src/main.rs
+++ b/tooling/nargo_cli/src/main.rs
@@ -14,22 +14,27 @@ mod errors;
 use std::env;
 
 use color_eyre::config::HookBuilder;
-use env_logger::{Builder, Env};
+
 use tracing_appender::rolling;
+use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
 
 const PANIC_MESSAGE: &str = "This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.\nIf there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml";
 
 fn main() {
-    let env = Env::default().filter_or("NOIR_LOG", "error"); // Default to 'error' if NOIR_LOG is not set
-    Builder::from_env(env).init();
-
     // Setup tracing
     if let Ok(log_dir) = env::var("NARGO_LOG_DIR") {
         let debug_file = rolling::daily(log_dir, "nargo-log");
         tracing_subscriber::fmt()
+            .with_span_events(FmtSpan::ACTIVE)
             .with_writer(debug_file)
             .with_ansi(false)
-            .with_max_level(tracing::Level::TRACE)
+            .with_env_filter(EnvFilter::from_default_env())
+            .init();
+    } else {
+        tracing_subscriber::fmt()
+            .with_span_events(FmtSpan::ACTIVE)
+            .with_ansi(true)
+            .with_env_filter(EnvFilter::from_env("NOIR_LOG"))
             .init();
     }
 
diff --git a/tooling/noirc_abi_wasm/src/lib.rs b/tooling/noirc_abi_wasm/src/lib.rs
index 281ec712c39..5557cc917bf 100644
--- a/tooling/noirc_abi_wasm/src/lib.rs
+++ b/tooling/noirc_abi_wasm/src/lib.rs
@@ -27,7 +27,7 @@ use js_witness_map::JsWitnessMap;
 #[wasm_bindgen(typescript_custom_section)]
 const INPUT_MAP: &'static str = r#"
 export type Field = string | number | boolean;
-export type InputValue = Field | Field[] | InputMap | InputMap[];
+export type InputValue = Field | InputMap | (Field | InputMap)[];
 export type InputMap = { [key: string]: InputValue };
 "#;