diff --git a/book/src/constants.md b/book/src/constants.md
index dcced3fce..04b0e0866 100644
--- a/book/src/constants.md
+++ b/book/src/constants.md
@@ -34,5 +34,5 @@ pub fn add_constant(&mut self, value: Field, span: Span) -> CellVar {
 
 Note that the `Value` keep track of the constant as well.
 
-Warning: gadgets must all handle constants gracefuly.
+Warning: gadgets must all handle constants gracefully.
 That is, they must constrain constants themselves (by calling `CircuitWriter::add_constant`).
diff --git a/book/src/literals.md b/book/src/literals.md
index 2d4a1f55f..794c7b257 100644
--- a/book/src/literals.md
+++ b/book/src/literals.md
@@ -32,7 +32,7 @@ Approach 1. is not elegant, because it means that it is not clear from the signa
 The user of the function will only get warned when trying to compile the program.
 
 Approach 2. is interesting, because we already have such a type internally to track literals: a `BigInt`.
-The name is a bit misleading in the case of array accesses, because we additionaly enforce that it is NOT a big integer, but rather a 32-bit integer (`u32` in Rust).
+The name is a bit misleading in the case of array accesses, because we additionally enforce that it is NOT a big integer, but rather a 32-bit integer (`u32` in Rust).
 
 ## Implementing a literal type
 
diff --git a/book/src/public-outputs.md b/book/src/public-outputs.md
index 01e8aad88..0db9245b0 100644
--- a/book/src/public-outputs.md
+++ b/book/src/public-outputs.md
@@ -2,7 +2,7 @@
 
 Public outputs are usually part of the public inputs in Plonk.
 
-In noname, public ouputs are treated differently than the public inputs for one reason: unlike (real) public inputs they cannot be computed directly during witness generation (proving).
+In noname, public outputs are treated differently than the public inputs for one reason: unlike (real) public inputs they cannot be computed directly during witness generation (proving).
 
 This is because public inputs are listed first in the circuit. During witness generation, we go through each rows and evaluate the values of the cells to construct the execution trace. 
 When we reach the public output part of the public input, we do not yet have enough information to construct the values.
diff --git a/book/src/spans.md b/book/src/spans.md
index af0d63a42..d8eeaf806 100644
--- a/book/src/spans.md
+++ b/book/src/spans.md
@@ -9,7 +9,7 @@ pub struct Span(pub usize, pub usize);
 which represents a location in the original source code:
 
 * the first number is the offset in the source code file
-* the second numebr if the length of the span (e.g. 1 character)
+* the second number if the length of the span (e.g. 1 character)
 
 We start tracking spans in the lexer, and then pass them around to the parser, and then to the compiler. Even gates and wirings have spans associated with them so that we can easily debug those.
 
diff --git a/src/cli/cmd_build_and_check.rs b/src/cli/cmd_build_and_check.rs
index 974a70ef1..741330c2d 100644
--- a/src/cli/cmd_build_and_check.rs
+++ b/src/cli/cmd_build_and_check.rs
@@ -86,7 +86,7 @@ pub fn cmd_build(args: CmdBuild) -> miette::Result<()> {
         "could not write prover params to `{prover_params}`"
     ))?;
 
-    println!("successfuly built");
+    println!("successfully built");
 
     //
     Ok(())
@@ -268,7 +268,7 @@ pub fn cmd_test(args: CmdTest) -> miette::Result<()> {
     let compiled_circuit = compile(&sources, tast, !args.no_double)?;
 
     let (prover_index, verifier_index) = compile_to_indexes(compiled_circuit)?;
-    println!("successfuly compiled");
+    println!("successfully compiled");
 
     // print ASM
     let asm = prover_index.asm(&sources, args.debug);
diff --git a/src/parser/types.rs b/src/parser/types.rs
index a82b7c949..dfd5ab221 100644
--- a/src/parser/types.rs
+++ b/src/parser/types.rs
@@ -1056,7 +1056,7 @@ impl Stmt {
                 kind: TokenKind::Keyword(Keyword::If),
                 span: _,
             }) => {
-                // TODO: wait, this should be implemented as an expresssion! not a statement
+                // TODO: wait, this should be implemented as an expression! not a statement
                 panic!("if statements are not implemented yet. Use if expressions instead (e.g. `x = if cond {{ 1 }} else {{ 2 }};`)");
             }