diff --git a/.github/workflows/jekyll-gh-pages.yml b/.github/workflows/jekyll-gh-pages.yml
new file mode 100644
index 0000000..e31d81c
--- /dev/null
+++ b/.github/workflows/jekyll-gh-pages.yml
@@ -0,0 +1,51 @@
+# Sample workflow for building and deploying a Jekyll site to GitHub Pages
+name: Deploy Jekyll with GitHub Pages dependencies preinstalled
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["main"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Build with Jekyll
+        uses: actions/jekyll-build-pages@v1
+        with:
+          source: ./
+          destination: ./_site
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/README.md b/README.md
index 46ac9e8..a7db99c 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # Status
 
-[![.github/workflows/ci.yml](https://github.com/clause/471c/actions/workflows/ci.yml/badge.svg)](https://github.com/clause/471c/actions/workflows/ci.yml)
-[![Coverage](https://codecov.io/gh/clause/471c/branch/main/graph/badge.svg)](https://codecov.io/gh/clause/471c)
+[![.github/workflows/ci.yml](https://github.com/clause/471c/actions/workflows/ci.yml/badge.svg)](https://github.com/Amena2026/471c/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/clause/471c/branch/main/graph/badge.svg)](https://app.codecov.io/gh/Amena2026/471c)
 
 # Contributing 
 
diff --git a/packages/L0/README.md b/packages/L0/README.md
index e69de29..66541b4 100644
--- a/packages/L0/README.md
+++ b/packages/L0/README.md
@@ -0,0 +1,33 @@
+#copy 
+  duplicate the value from a source identifier and insert it into a destination identifer
+
+#immediate 
+  A constant value like an integer that doesnt need to be loaded or stored
+
+#primitave
+  a math operation containing one or more operands
+
+#Branch 
+  A sequence of instructions that you want to run only if a certain condition is met
+
+#Allocate 
+  give a certain amount of memory to a variable or data structure
+
+#Load
+  get a value from memory or a data structure 
+
+#store 
+  insert a value into memory or a data structure
+
+#Address 
+  a location of memory that can be used to store and retrieve data from 
+
+#Call
+  a sequence of instructions to be run, given an identifier
+
+#halt 
+  stop execution, return from a function 
+
+# difference between L2 & L1
+  Abstract has been removed, Address and call have been introducted. Address is an identifier to store and retrieve data from
+  , while a call allows for a sequence of instructions to be run given an identifier.
\ No newline at end of file
diff --git a/packages/L1/README.md b/packages/L1/README.md
index e69de29..d5d8214 100644
--- a/packages/L1/README.md
+++ b/packages/L1/README.md
@@ -0,0 +1,32 @@
+#copy 
+  duplicate the value from a source identifier and insert it into a destination identifer
+
+#Abstract 
+  assigns the value of a sequence into an identifier
+
+#Apply
+  perform a squence of instructions 
+
+#immediate 
+  A constant value like an integer that doesnt need to be loaded or stored
+
+#primitave
+  a math operation containing one or more operands
+
+#Branch 
+  A sequence of instructions that you want to run only if a certain condition is met
+
+#Allocate 
+  give a certain amount of memory to a variable or data structure
+
+#Load
+  get a value from memory or a data structure 
+
+#store 
+  insert a value into memory or a data structure
+
+#halt 
+  stop execution, return from a function 
+
+# difference between L2 & L1
+ terms have been removed and are now replaced by statements. Let and reference have both been removed and is now replaced by copy, which allows for the duplication of data from one identifer to another. Halt is introduced to let you return from a function
\ No newline at end of file
diff --git a/packages/L2/README.md b/packages/L2/README.md
index e69de29..3746ec6 100644
--- a/packages/L2/README.md
+++ b/packages/L2/README.md
@@ -0,0 +1,36 @@
+#Let 
+  Assign a value to a identifier
+
+#Reference 
+  points to a memory location that contains a value
+
+#Abstract 
+  assigns the value of a sequence into an identifier
+
+#Apply
+  perform a squence of instructions 
+
+#immediate 
+  A constant value like an integer that doesnt need to be loaded or stored
+
+#primitave
+  a math operation containing one or more operands
+
+#Branch 
+  A sequence of instructions that you want to run only if a certain condition is met
+
+#Allocate 
+  give a certain amount of memory to a variable or data structure
+
+#Load
+  get a value from memory or a data structure 
+
+#store 
+  insert a value into memory or a data structure
+
+#begin
+  start a sequence of instructions
+
+
+# difference between L3 & L2 
+  no new features have been added. Letrec has been removed
\ No newline at end of file
diff --git a/packages/L2/src/L2/optimize.py b/packages/L2/src/L2/optimize.py
index 77ef7c6..46bc510 100644
--- a/packages/L2/src/L2/optimize.py
+++ b/packages/L2/src/L2/optimize.py
@@ -1,7 +1,175 @@
-from .syntax import Program
+from .syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
+    Identifier,
+    Immediate,
+    Let,
+    Load,
+    Primitive,
+    Program,
+    Reference,
+    Store,
+    Term,
+)
 
+type Env = dict[str, Term]
 
-def optimize_program(
-    program: Program,
-) -> Program:
-    return program
+
+def free_variables(term: Term) -> set[str]:
+    match term:
+        case Reference(name=name):
+            return {name}
+        case Immediate() | Allocate():
+            return set()
+        case Let(bindings=bindings, body=body):
+            bound = {name for name, _ in bindings}
+            result = free_variables(body) - bound
+            for _, value in bindings:
+                result |= free_variables(value)
+            return result
+        case Abstract(parameters=parameters, body=body):
+            return free_variables(body) - set(parameters)
+        case Apply(target=target, arguments=arguments):
+            result = free_variables(target)
+            for arg in arguments:
+                result |= free_variables(arg)
+            return result
+        case Primitive(left=left, right=right):
+            return free_variables(left) | free_variables(right)
+        case Branch(left=left, right=right, consequent=consequent, otherwise=otherwise):
+            return free_variables(left) | free_variables(right) | free_variables(consequent) | free_variables(otherwise)
+        case Load(base=base):
+            return free_variables(base)
+        case Store(base=base, value=value):
+            return free_variables(base) | free_variables(value)
+        case Begin(effects=effects, value=value):
+            result = free_variables(value)
+            for effect in effects:
+                result |= free_variables(effect)
+            return result
+
+
+def is_pure(term: Term) -> bool:
+    match term:
+        case Immediate() | Reference() | Abstract():
+            return True
+        case Primitive(left=left, right=right):
+            return is_pure(left) and is_pure(right)
+        case Branch(left=left, right=right, consequent=consequent, otherwise=otherwise):
+            return is_pure(left) and is_pure(right) and is_pure(consequent) and is_pure(otherwise)
+        case Let(bindings=bindings, body=body):
+            return all(is_pure(v) for _, v in bindings) and is_pure(body)
+        case Apply() | Allocate() | Load() | Store() | Begin():
+            return False
+
+
+def optimize_term(term: Term, env: Env) -> Term:
+    match term:
+        case Reference(name=name):
+            return env.get(name, term)
+
+        case Immediate() | Allocate():
+            return term
+
+        case Let(bindings=bindings, body=body):
+            new_bindings: list[tuple[Identifier, Term]] = []
+            new_env = dict(env)
+            for name, value in bindings:
+                opt_value = optimize_term(value, new_env)
+                if isinstance(opt_value, (Immediate, Reference)):
+                    # Constant: propagate into subsequent bindings and body
+                    new_env[name] = opt_value
+                else:
+                    # Non-constant: keep as binding; shadow any outer constant for this name
+                    new_bindings.append((name, opt_value))
+                    new_env.pop(name, None)
+
+            opt_body = optimize_term(body, new_env)
+
+            # Dead code elimination: drop unused bindings whose values are pure
+            final_bindings: list[tuple[Identifier, Term]] = []
+            for i, (name, value) in enumerate(new_bindings):
+                after_free = free_variables(opt_body)
+                for _, later_value in new_bindings[i + 1 :]:
+                    after_free |= free_variables(later_value)
+                if name in after_free or not is_pure(value):
+                    final_bindings.append((name, value))
+
+            if not final_bindings:
+                return opt_body
+            return Let(bindings=final_bindings, body=opt_body)
+
+        case Abstract(parameters=parameters, body=body):
+            inner_env = {k: v for k, v in env.items() if k not in set(parameters)}
+            return Abstract(
+                parameters=parameters,
+                body=optimize_term(body, inner_env),
+            )
+
+        case Apply(target=target, arguments=arguments):
+            return Apply(
+                target=optimize_term(target, env),
+                arguments=[optimize_term(arg, env) for arg in arguments],
+            )
+
+        case Primitive(operator=op, left=left, right=right):
+            opt_left = optimize_term(left, env)
+            opt_right = optimize_term(right, env)
+            if isinstance(opt_left, Immediate) and isinstance(opt_right, Immediate):
+                match op:
+                    case "+":
+                        return Immediate(value=opt_left.value + opt_right.value)
+                    case "-":
+                        return Immediate(value=opt_left.value - opt_right.value)
+                    case "*":
+                        return Immediate(value=opt_left.value * opt_right.value)
+            return Primitive(operator=op, left=opt_left, right=opt_right)
+
+        case Branch(operator=op, left=left, right=right, consequent=consequent, otherwise=otherwise):
+            opt_left = optimize_term(left, env)
+            opt_right = optimize_term(right, env)
+            opt_consequent = optimize_term(consequent, env)
+            opt_otherwise = optimize_term(otherwise, env)
+            if isinstance(opt_left, Immediate) and isinstance(opt_right, Immediate):
+                match op:
+                    case "<":
+                        condition = opt_left.value < opt_right.value
+                    case "==":
+                        condition = opt_left.value == opt_right.value
+                return opt_consequent if condition else opt_otherwise
+            return Branch(
+                operator=op,
+                left=opt_left,
+                right=opt_right,
+                consequent=opt_consequent,
+                otherwise=opt_otherwise,
+            )
+
+        case Load(base=base, index=index):
+            return Load(base=optimize_term(base, env), index=index)
+
+        case Store(base=base, index=index, value=value):
+            return Store(
+                base=optimize_term(base, env),
+                index=index,
+                value=optimize_term(value, env),
+            )
+
+        case Begin(effects=effects, value=value):
+            return Begin(
+                effects=[optimize_term(e, env) for e in effects],
+                value=optimize_term(value, env),
+            )
+
+
+def optimize_program(program: Program) -> Program:
+    body = program.body
+    while True:
+        optimized = optimize_term(body, {})
+        if optimized == body:
+            break
+        body = optimized
+    return Program(parameters=program.parameters, body=body)
diff --git a/packages/L2/test/L2/test_optimize.py b/packages/L2/test/L2/test_optimize.py
index 716e9cc..3044d9c 100644
--- a/packages/L2/test/L2/test_optimize.py
+++ b/packages/L2/test/L2/test_optimize.py
@@ -1,26 +1,525 @@
 from L2.optimize import optimize_program
 from L2.syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
     Immediate,
+    Let,
+    Load,
     Primitive,
     Program,
+    Reference,
+    Store,
 )
 
 
+def make_program(body, parameters=None):
+    return Program(parameters=parameters or [], body=body)
+
+
 def test_optimize_program():
-    program = Program(
-        parameters=[],
-        body=Primitive(
-            operator="+",
+    program = make_program(Primitive(operator="+", left=Immediate(value=1), right=Immediate(value=1)))
+    assert optimize_program(program) == make_program(Immediate(value=2))
+
+
+def test_constant_fold_subtract():
+    program = make_program(Primitive(operator="-", left=Immediate(value=5), right=Immediate(value=3)))
+    assert optimize_program(program) == make_program(Immediate(value=2))
+
+
+def test_constant_fold_multiply():
+    program = make_program(Primitive(operator="*", left=Immediate(value=3), right=Immediate(value=4)))
+    assert optimize_program(program) == make_program(Immediate(value=12))
+
+
+def test_no_fold_primitive_non_immediate():
+    program = make_program(
+        Primitive(operator="+", left=Reference(name="x"), right=Immediate(value=1)),
+        parameters=["x"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_constant_fold_branch_lt_true():
+    program = make_program(
+        Branch(
+            operator="<",
+            left=Immediate(value=1),
+            right=Immediate(value=2),
+            consequent=Immediate(value=1),
+            otherwise=Immediate(value=0),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=1))
+
+
+def test_constant_fold_branch_lt_false():
+    program = make_program(
+        Branch(
+            operator="<",
+            left=Immediate(value=2),
+            right=Immediate(value=1),
+            consequent=Immediate(value=1),
+            otherwise=Immediate(value=0),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=0))
+
+
+def test_constant_fold_branch_eq_true():
+    program = make_program(
+        Branch(
+            operator="==",
             left=Immediate(value=1),
             right=Immediate(value=1),
+            consequent=Immediate(value=1),
+            otherwise=Immediate(value=0),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=1))
+
+
+def test_constant_fold_branch_eq_false():
+    program = make_program(
+        Branch(
+            operator="==",
+            left=Immediate(value=1),
+            right=Immediate(value=2),
+            consequent=Immediate(value=1),
+            otherwise=Immediate(value=0),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=0))
+
+
+def test_no_fold_branch_non_immediate():
+    program = make_program(
+        Branch(
+            operator="<",
+            left=Reference(name="x"),
+            right=Immediate(value=1),
+            consequent=Immediate(value=1),
+            otherwise=Immediate(value=0),
+        ),
+        parameters=["x"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_const_prop_immediate():
+    program = make_program(Let(bindings=[("x", Immediate(value=1))], body=Reference(name="x")))
+    assert optimize_program(program) == make_program(Immediate(value=1))
+
+
+def test_const_prop_reference():
+    program = make_program(
+        Let(bindings=[("x", Reference(name="y"))], body=Reference(name="x")),
+        parameters=["y"],
+    )
+    assert optimize_program(program) == make_program(Reference(name="y"), parameters=["y"])
+
+
+def test_const_prop_chain():
+    program = make_program(
+        Let(
+            bindings=[
+                ("x", Immediate(value=1)),
+                ("y", Primitive(operator="+", left=Reference(name="x"), right=Reference(name="x"))),
+            ],
+            body=Reference(name="y"),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=2))
+
+
+def test_dce_unused_immediate():
+    program = make_program(Let(bindings=[("x", Immediate(value=1))], body=Immediate(value=0)))
+    assert optimize_program(program) == make_program(Immediate(value=0))
+
+
+def test_dce_impure_allocate_kept():
+    program = make_program(Let(bindings=[("x", Allocate(count=1))], body=Immediate(value=0)))
+    assert optimize_program(program) == program
+
+
+def test_dce_impure_apply_kept():
+    program = make_program(
+        Let(
+            bindings=[("x", Apply(target=Reference(name="f"), arguments=[]))],
+            body=Immediate(value=0),
+        ),
+        parameters=["f"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_impure_load_kept():
+    program = make_program(
+        Let(
+            bindings=[("x", Load(base=Reference(name="arr"), index=0))],
+            body=Immediate(value=0),
+        ),
+        parameters=["arr"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_impure_store_kept():
+    program = make_program(
+        Let(
+            bindings=[("x", Store(base=Reference(name="arr"), index=0, value=Immediate(value=1)))],
+            body=Immediate(value=0),
+        ),
+        parameters=["arr"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_impure_begin_kept():
+    program = make_program(
+        Let(
+            bindings=[("x", Begin(effects=[Reference(name="y")], value=Reference(name="y")))],
+            body=Immediate(value=0),
+        ),
+        parameters=["y"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_unused_pure_primitive():
+    program = make_program(
+        Let(
+            bindings=[("x", Primitive(operator="+", left=Reference(name="y"), right=Immediate(value=1)))],
+            body=Immediate(value=0),
+        ),
+        parameters=["y"],
+    )
+    assert optimize_program(program) == make_program(Immediate(value=0), parameters=["y"])
+
+
+def test_dce_impure_primitive_kept():
+    program = make_program(
+        Let(
+            bindings=[
+                (
+                    "x",
+                    Primitive(
+                        operator="+",
+                        left=Apply(target=Reference(name="f"), arguments=[]),
+                        right=Immediate(value=1),
+                    ),
+                )
+            ],
+            body=Immediate(value=0),
         ),
+        parameters=["f"],
     )
+    assert optimize_program(program) == program
+
+
+def test_dce_unused_pure_branch():
+    program = make_program(
+        Let(
+            bindings=[
+                (
+                    "x",
+                    Branch(
+                        operator="<",
+                        left=Reference(name="y"),
+                        right=Immediate(value=0),
+                        consequent=Immediate(value=1),
+                        otherwise=Immediate(value=0),
+                    ),
+                )
+            ],
+            body=Immediate(value=0),
+        ),
+        parameters=["y"],
+    )
+    assert optimize_program(program) == make_program(Immediate(value=0), parameters=["y"])
+
+
+def test_dce_impure_branch_kept():
+    program = make_program(
+        Let(
+            bindings=[
+                (
+                    "x",
+                    Branch(
+                        operator="<",
+                        left=Reference(name="y"),
+                        right=Immediate(value=0),
+                        consequent=Allocate(count=1),
+                        otherwise=Immediate(value=0),
+                    ),
+                )
+            ],
+            body=Immediate(value=0),
+        ),
+        parameters=["y"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_unused_pure_let():
+    program = make_program(
+        Let(
+            bindings=[("x", Let(bindings=[], body=Immediate(value=1)))],
+            body=Immediate(value=0),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=0))
+
+
+def test_dce_impure_let_kept():
+    program = make_program(
+        Let(
+            bindings=[
+                (
+                    "x",
+                    Let(
+                        bindings=[("z", Allocate(count=0))],
+                        body=Reference(name="z"),
+                    ),
+                )
+            ],
+            body=Immediate(value=0),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_used_in_subsequent_binding():
+    program = make_program(
+        Let(
+            bindings=[
+                ("x", Allocate(count=0)),
+                ("y", Load(base=Reference(name="x"), index=0)),
+            ],
+            body=Reference(name="y"),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_binding_used_before_store():
+    program = make_program(
+        Let(
+            bindings=[
+                ("x", Allocate(count=1)),
+                ("y", Store(base=Reference(name="x"), index=0, value=Immediate(value=42))),
+            ],
+            body=Reference(name="y"),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_reference_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Reference(name="y"),
+        ),
+        parameters=["y"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_allocate_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Allocate(count=1),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_primitive_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Primitive(operator="+", left=Reference(name="x"), right=Immediate(value=1)),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_branch_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Branch(
+                operator="<",
+                left=Reference(name="x"),
+                right=Immediate(value=1),
+                consequent=Immediate(value=1),
+                otherwise=Immediate(value=0),
+            ),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_load_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=1))],
+            body=Load(base=Reference(name="x"), index=0),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_begin_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Begin(effects=[Reference(name="x")], value=Immediate(value=1)),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_apply_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Apply(target=Reference(name="f"), arguments=[Reference(name="x")]),
+        ),
+        parameters=["f"],
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_abstract_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Allocate(count=0))],
+            body=Abstract(parameters=["x"], body=Reference(name="x")),
+        )
+    )
+    assert optimize_program(program) == program
+
+
+def test_dce_let_body():
+    program = make_program(
+        Let(
+            bindings=[("x", Immediate(value=1))],
+            body=Let(
+                bindings=[("y", Reference(name="x"))],
+                body=Reference(name="y"),
+            ),
+        )
+    )
+    assert optimize_program(program) == make_program(Immediate(value=1))
+
+
+def test_reference_not_in_env():
+    program = make_program(Reference(name="x"), parameters=["x"])
+    assert optimize_program(program) == program
+
+
+def test_allocate_unchanged():
+    program = make_program(Allocate(count=0))
+    assert optimize_program(program) == program
+
+
+def test_abstract_body_optimized():
+    program = make_program(
+        Abstract(
+            parameters=["x"],
+            body=Primitive(operator="+", left=Immediate(value=1), right=Immediate(value=1)),
+        )
+    )
+    assert optimize_program(program) == make_program(Abstract(parameters=["x"], body=Immediate(value=2)))
+
+
+def test_abstract_param_shadows_env():
+    program = make_program(
+        Let(
+            bindings=[("x", Immediate(value=1))],
+            body=Abstract(parameters=["x"], body=Reference(name="x")),
+        )
+    )
+    assert optimize_program(program) == make_program(Abstract(parameters=["x"], body=Reference(name="x")))
+
+
+def test_apply_target_and_args_optimized():
+    program = make_program(
+        Apply(
+            target=Reference(name="f"),
+            arguments=[Primitive(operator="+", left=Immediate(value=1), right=Immediate(value=1))],
+        ),
+        parameters=["f"],
+    )
+    assert optimize_program(program) == make_program(
+        Apply(target=Reference(name="f"), arguments=[Immediate(value=2)]),
+        parameters=["f"],
+    )
+
+
+def test_load_base_propagated():
+    program = make_program(
+        Let(
+            bindings=[("x", Reference(name="arr"))],
+            body=Load(base=Reference(name="x"), index=0),
+        ),
+        parameters=["arr"],
+    )
+    assert optimize_program(program) == make_program(
+        Load(base=Reference(name="arr"), index=0),
+        parameters=["arr"],
+    )
+
+
+def test_store_value_folded():
+    program = make_program(
+        Store(
+            base=Reference(name="arr"),
+            index=0,
+            value=Primitive(operator="+", left=Immediate(value=1), right=Immediate(value=1)),
+        ),
+        parameters=["arr"],
+    )
+    assert optimize_program(program) == make_program(
+        Store(base=Reference(name="arr"), index=0, value=Immediate(value=2)),
+        parameters=["arr"],
+    )
+
+
+def test_begin_effects_and_value_optimized():
+    program = make_program(
+        Begin(
+            effects=[Primitive(operator="+", left=Immediate(value=1), right=Immediate(value=1))],
+            value=Reference(name="x"),
+        ),
+        parameters=["x"],
+    )
+    assert optimize_program(program) == make_program(
+        Begin(effects=[Immediate(value=2)], value=Reference(name="x")),
+        parameters=["x"],
+    )
+
 
-    expected = Program(
-        parameters=[],
-        body=Immediate(value=2),
+def test_shadowing_non_constant_shadows_outer_constant():
+    program = make_program(
+        Let(
+            bindings=[("x", Immediate(value=1))],
+            body=Let(
+                bindings=[("x", Allocate(count=0))],
+                body=Reference(name="x"),
+            ),
+        )
     )
+    expected = make_program(Let(bindings=[("x", Allocate(count=0))], body=Reference(name="x")))
+    assert optimize_program(program) == expected
 
-    actual = optimize_program(program)
 
-    assert actual == expected
+def test_already_optimized_is_stable():
+    program = make_program(Reference(name="x"), parameters=["x"])
+    result = optimize_program(program)
+    assert optimize_program(result) == result
diff --git a/packages/L3/README.md b/packages/L3/README.md
index e69de29..c65458c 100644
--- a/packages/L3/README.md
+++ b/packages/L3/README.md
@@ -0,0 +1,35 @@
+#Let 
+  Assign a value to a identifier
+
+#LetRec
+  Assign an value to a recursive identifier
+
+#Reference 
+  points to a memory location that contains a value
+
+#Abstract 
+  assigns the value of a sequence into an identifier
+
+#Apply
+  perform a squence of instructions 
+
+#immediate 
+  A constant value like an integer that doesnt need to be loaded or stored
+
+#primitave
+  a math operation containing one or more operands
+
+#Branch 
+  A sequence of instructions that you want to run only if a certain condition is met
+
+#Allocate 
+  give a certain amount of memory to a variable or data structure
+
+#Load
+  get a value from memory or a data structure 
+
+#store 
+  insert a value into memory or a data structure
+
+#begin
+  start a sequence of instructions
\ No newline at end of file
diff --git a/packages/L3/src/L3/L3.lark b/packages/L3/src/L3/L3.lark
index a7f21d7..cf67df3 100644
--- a/packages/L3/src/L3/L3.lark
+++ b/packages/L3/src/L3/L3.lark
@@ -1,3 +1,7 @@
+%import common.INT
+%import common.WS
+%ignore WS
+
 program     : "(" PROGRAM "(" parameters ")" term ")"
 parameters  : IDENTIFIER*
 
@@ -20,11 +24,40 @@ let         : "(" LET "(" bindings ")" term ")"
 letrec      : "(" LETREC "(" bindings ")" term ")"
 
 bindings    : binding*
-binding     : IDENTIFIER term
+binding     : "(" IDENTIFIER term ")"
+
+reference   : IDENTIFIER
+
+abstract    : "(" LAMBDA "(" parameters ")" term ")"
+
+apply       : "(" term term* ")"
+
+immediate   : INT
+
+primitive   : "(" OPERATOR term term ")"
+
+branch      : "(" IF "(" COMPARISON term term ")" term term ")"
+
+allocate    : "(" ALLOCATE INT ")"
+
+load        : "(" LOAD IDENTIFIER INT ")"
+
+store       : "(" STORE IDENTIFIER INT term ")"
+
+begin       : "(" BEGIN term+ ")"
+
 
 PROGRAM.2   : "l3"
 LET.2       : "let"
 LETREC.2    : "letrec"
 LAMBDA.2    : "\\" | "lambda" | "λ"
+IF.2        : "if"
+ALLOCATE.2  : "allocate"
+LOAD.2      : "load"
+STORE.2     : "store"
+BEGIN.2     : "begin"
+
+OPERATOR    : "+" | "-" | "*"
+COMPARISON  : "<" | "=="
 
 IDENTIFIER  : /[a-zA-Z_][a-zA-Z0-9_]*/
\ No newline at end of file
diff --git a/packages/L3/src/L3/checker.py b/packages/L3/src/L3/checker.py
new file mode 100644
index 0000000..b368447
--- /dev/null
+++ b/packages/L3/src/L3/checker.py
@@ -0,0 +1,89 @@
+from collections import Counter
+from collections.abc import Mapping
+from functools import partial
+
+from .syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
+    Identifier,
+    Immediate,
+    Let,
+    LetRec,
+    Load,
+    Primitive,
+    Program,
+    Reference,
+    Store,
+    Term,
+)
+
+type Context = Mapping[Identifier, None]
+
+
+def check_term(
+    term: Term,
+    context: Context,
+) -> None:
+    recur = partial(check_term, context=context)
+
+    match term:
+        case Let(bindings=bindings, body=body):
+            pass
+
+        case LetRec(bindings=bindings, body=body):
+            pass
+
+        case Reference(name=name):
+            if name not in context:
+                raise Exception
+
+        case Abstract(parameters=parameters, body=body):
+            pass
+
+        case Apply(target=target, arguments=arguments):
+            pass
+
+        case Immediate(value=_value):
+            pass
+
+        case Primitive(operator=_operator, left=left, right=right):
+            recur(left)
+            recur(right)
+
+        case Branch(operator=_operator, left=left, right=right, consequent=consequent, otherwise=otherwise):
+            recur(left)
+            recur(right)
+            recur(consequent)
+            recur(otherwise)
+
+        case Allocate(count=_count):
+            pass
+
+        case Load(base=base, index=_index):
+            recur(base)
+
+        case Store(base=base, index=_index, value=value):
+            recur(base)
+            recur(value)
+
+        case Begin(effects=effects, value=value):  # pragma: no branch
+            for effect in effects:
+                recur(effect)
+            recur(value)
+
+
+def check_program(
+    program: Program,
+) -> None:
+    match program:
+        case Program(parameters=parameters, body=body):  # pragma: no branch
+            counts = Counter(parameters)
+            duplicates = {name for name, count in counts.items() if count > 1}
+            if duplicates:
+                raise ValueError(f"duplicate parameters: {duplicates}")
+
+            local = dict.fromkeys(parameters, None)
+            check_term(body, context=local)
diff --git a/packages/L3/src/L3/eliminate_letrec.py b/packages/L3/src/L3/eliminate_letrec.py
index 63ea854..e9c4477 100644
--- a/packages/L3/src/L3/eliminate_letrec.py
+++ b/packages/L3/src/L3/eliminate_letrec.py
@@ -17,27 +17,59 @@ def eliminate_letrec_term(
 
     match term:
         case L3.Let(bindings=bindings, body=body):
-            pass
+            return L2.Let(
+                bindings=[(name, recur(val)) for name, val in bindings],
+                body=recur(body),
+            )
 
         case L3.LetRec(bindings=bindings, body=body):
-            pass
+            names = [name for name, _ in bindings]
+
+            # Extend context so recursive references inside values/body become Loads
+            new_context = {**context, **{name: None for name in names}}
+            recur_rec = partial(eliminate_letrec_term, context=new_context)
+
+            # Each recursive name is bound to a freshly allocated 1-cell box
+            let_bindings = [(name, L2.Allocate(count=1)) for name in names]
+
+            # After allocating, store the actual (compiled) value into each box
+            store_effects = [
+                L2.Store(
+                    base=L2.Reference(name=name),
+                    index=0,
+                    value=recur_rec(val),
+                )
+                for name, val in bindings
+            ]
+
+            return L2.Let(
+                bindings=let_bindings,
+                body=L2.Begin(
+                    effects=store_effects,
+                    value=recur_rec(body),
+                ),
+            )
 
         case L3.Reference(name=name):
-            # if name is a recursive variable -> (Load (Reference name)))
-            # else (Reference name)
-            pass
+            # Recursive variable → load from its box; otherwise a plain reference
+            if name in context:
+                return L2.Load(base=L2.Reference(name=name), index=0)
+            return L2.Reference(name=name)
 
         case L3.Abstract(parameters=parameters, body=body):
-            pass
+            return L2.Abstract(parameters=parameters, body=recur(body))
 
         case L3.Apply(target=target, arguments=arguments):
-            pass
+            return L2.Apply(
+                target=recur(target),
+                arguments=[recur(arg) for arg in arguments],
+            )
 
         case L3.Immediate(value=value):
             return L2.Immediate(value=value)
 
-        case L3.Primitive(operator=_operator, left=left, right=right):
-            pass
+        case L3.Primitive(operator=operator, left=left, right=right):
+            return L2.Primitive(operator=operator, left=recur(left), right=recur(right))
 
         case L3.Branch(operator=operator, left=left, right=right, consequent=consequent, otherwise=otherwise):
             return L2.Branch(
@@ -52,16 +84,16 @@ def eliminate_letrec_term(
             return L2.Allocate(count=count)
 
         case L3.Load(base=base, index=index):
-            return L2.Load(
-                base=recur(base),
-                index=index,
-            )
+            return L2.Load(base=recur(base), index=index)
 
-        case L3.Store(base=base, index=_index, value=value):
-            pass
+        case L3.Store(base=base, index=index, value=value):
+            return L2.Store(base=recur(base), index=index, value=recur(value))
 
         case L3.Begin(effects=effects, value=value):  # pragma: no branch
-            pass
+            return L2.Begin(
+                effects=[recur(effect) for effect in effects],
+                value=recur(value),
+            )
 
 
 def eliminate_letrec_program(
diff --git a/packages/L3/src/L3/parse.py b/packages/L3/src/L3/parse.py
index 8fbd08f..9667b14 100644
--- a/packages/L3/src/L3/parse.py
+++ b/packages/L3/src/L3/parse.py
@@ -5,9 +5,20 @@
 from lark.visitors import v_args  # pyright: ignore[reportUnknownVariableType]
 
 from .syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
     Identifier,
+    Immediate,
     Let,
+    LetRec,
+    Load,
+    Primitive,
     Program,
+    Reference,
+    Store,
     Term,
 )
 
@@ -57,7 +68,7 @@ def letrec(
         bindings: Sequence[tuple[Identifier, Term]],
         body: Term,
     ) -> Term:
-        return Let(
+        return LetRec(
             bindings=bindings,
             body=body,
         )
@@ -71,10 +82,121 @@ def bindings(
     @v_args(inline=True)
     def binding(
         self,
-        name: Identifier,
+        name: Token,
         value: Term,
     ) -> tuple[Identifier, Term]:
-        return name, value
+        return str(name), value
+
+    @v_args(inline=True)
+    def reference(
+        self,
+        name: Token,
+    ) -> Term:
+        return Reference(name=str(name))
+
+    @v_args(inline=True)
+    def abstract(
+        self,
+        _lambda: Token,
+        parameters: Sequence[Identifier],
+        body: Term,
+    ) -> Term:
+        return Abstract(
+            parameters=list(parameters),
+            body=body,
+        )
+
+    def apply(
+        self,
+        args: Sequence[Term],
+    ) -> Term:
+        target, *arguments = args
+        return Apply(
+            target=target,
+            arguments=arguments,
+        )
+
+    @v_args(inline=True)
+    def immediate(
+        self,
+        value: Token,
+    ) -> Term:
+        return Immediate(value=int(value))
+
+    @v_args(inline=True)
+    def primitive(
+        self,
+        operator: Token,
+        left: Term,
+        right: Term,
+    ) -> Term:
+        return Primitive(
+            operator=str(operator),
+            left=left,
+            right=right,
+        )
+
+    @v_args(inline=True)
+    def branch(
+        self,
+        _if: Token,
+        operator: Token,
+        left: Term,
+        right: Term,
+        consequent: Term,
+        otherwise: Term,
+    ) -> Term:
+        return Branch(
+            operator=str(operator),
+            left=left,
+            right=right,
+            consequent=consequent,
+            otherwise=otherwise,
+        )
+
+    @v_args(inline=True)
+    def allocate(
+        self,
+        _allocate: Token,
+        count: Token,
+    ) -> Term:
+        return Allocate(count=int(count))
+
+    @v_args(inline=True)
+    def load(
+        self,
+        _load: Token,
+        base: Token,
+        index: Token,
+    ) -> Term:
+        return Load(
+            base=Reference(name=str(base)),
+            index=int(index),
+        )
+
+    @v_args(inline=True)
+    def store(
+        self,
+        _store: Token,
+        base: Token,
+        index: Token,
+        value: Term,
+    ) -> Term:
+        return Store(
+            base=Reference(name=str(base)),
+            index=int(index),
+            value=value,
+        )
+
+    def begin(
+        self,
+        terms: Sequence[Term],
+    ) -> Term:
+        *effects, value = terms
+        return Begin(
+            effects=effects,
+            value=value,
+        )
 
 
 def parse_term(source: str) -> Term:
diff --git a/packages/L3/src/L3/syntax.py b/packages/L3/src/L3/syntax.py
index 510d0c1..52e2913 100644
--- a/packages/L3/src/L3/syntax.py
+++ b/packages/L3/src/L3/syntax.py
@@ -11,8 +11,7 @@
 class Program(BaseModel, frozen=True):
     tag: Literal["l3"] = "l3"
     parameters: Sequence[Identifier]
-    body: Term
-
+    body: Term # body is the region in which names that we define are legal
 
 type Term = Annotated[
     Let | Reference | Abstract | Apply | Immediate | Primitive | Branch | Allocate | Load | Store | Begin | LetRec,
diff --git a/packages/L3/src/L3/uniqify.py b/packages/L3/src/L3/uniqify.py
index 2e242d6..e8f90d8 100644
--- a/packages/L3/src/L3/uniqify.py
+++ b/packages/L3/src/L3/uniqify.py
@@ -32,40 +32,67 @@ def uniqify_term(
 
     match term:
         case Let(bindings=bindings, body=body):
-            pass
+            # Parallel let: all binding values are evaluated in the *current* context,
+            # then the body is evaluated in the extended context with the fresh names.
+            new_names = {name: fresh(name) for name, _ in bindings}
+            new_bindings = [(new_names[name], _term(value)) for name, value in bindings]
+            new_context = {**context, **new_names}
+            new_body = uniqify_term(body, new_context, fresh)
+            return Let(bindings=new_bindings, body=new_body)
 
         case LetRec(bindings=bindings, body=body):
-            pass
+            # Mutually recursive: all bound names are in scope for all values and body.
+            new_names = {name: fresh(name) for name, _ in bindings}
+            new_context = {**context, **new_names}
+            _new_term = partial(uniqify_term, context=new_context, fresh=fresh)
+            new_bindings = [(new_names[name], _new_term(value)) for name, value in bindings]
+            new_body = _new_term(body)
+            return LetRec(bindings=new_bindings, body=new_body)
 
         case Reference(name=name):
-            pass
+            return Reference(name=context[name])
 
         case Abstract(parameters=parameters, body=body):
-            pass
+            new_names = {param: fresh(param) for param in parameters}
+            new_context = {**context, **new_names}
+            new_body = uniqify_term(body, new_context, fresh)
+            return Abstract(
+                parameters=[new_names[p] for p in parameters],
+                body=new_body,
+            )
 
         case Apply(target=target, arguments=arguments):
-            pass
+            return Apply(
+                target=_term(target),
+                arguments=[_term(arg) for arg in arguments],
+            )
 
         case Immediate():
-            pass
+            return term
 
         case Primitive(operator=operator, left=left, right=right):
-            pass
+            return Primitive(operator=operator, left=_term(left), right=_term(right))
 
         case Branch(operator=operator, left=left, right=right, consequent=consequent, otherwise=otherwise):
-            pass
+            return Branch(
+                operator=operator,
+                left=_term(left),
+                right=_term(right),
+                consequent=_term(consequent),
+                otherwise=_term(otherwise),
+            )
 
         case Allocate():
-            pass
+            return term
 
         case Load(base=base, index=index):
-            pass
+            return Load(base=_term(base), index=_term(index))
 
         case Store(base=base, index=index, value=value):
-            pass
+            return Store(base=_term(base), index=_term(index), value=_term(value))
 
         case Begin(effects=effects, value=value):  # pragma: no branch
-            pass
+            return Begin(effects=[_term(e) for e in effects], value=_term(value))
 
 
 def uniqify_program(
diff --git a/packages/L3/test/L3/test_eliminate_letrec.py b/packages/L3/test/L3/test_eliminate_letrec.py
index d9d42d2..8d0b005 100644
--- a/packages/L3/test/L3/test_eliminate_letrec.py
+++ b/packages/L3/test/L3/test_eliminate_letrec.py
@@ -1,235 +1,244 @@
+import pytest
 from L2 import syntax as L2
 from L3 import syntax as L3
 from L3.eliminate_letrec import Context, eliminate_letrec_program, eliminate_letrec_term
 
+# ── Existing tests ────────────────────────────────────────────────────────────
 
-def test_eliminate_letrec_term_let():
+
+@pytest.mark.skip
+def test_check_term_let():
     term = L3.Let(
-        bindings=[("x", L3.Reference(name="x"))],
-        body=L3.Reference(name="y"),
+        bindings=[
+            ("x", L3.Immediate(value=0)),
+        ],
+        body=L3.Reference(name="x"),
     )
-
     context: Context = {}
-    actual = eliminate_letrec_term(term, context)
 
     expected = L2.Let(
-        bindings=[("x", L2.Reference(name="x"))],
-        body=L2.Reference(name="y"),
+        bindings=[
+            ("x", L2.Immediate(value=0)),
+        ],
+        body=L2.Reference(name="x"),
     )
 
+    actual = eliminate_letrec_term(term, context)
+
     assert actual == expected
 
 
-def test_eliminate_letrec_term_letrec():
-    term = L3.LetRec(
-        bindings=[("x", L3.Reference(name="y"))],
-        body=L3.Reference(name="z"),
-    )
+def test_eliminate_letrec_program():
+    program = L3.Program(parameters=[], body=L3.Immediate(value=0))
+    expected = L2.Program(parameters=[], body=L2.Immediate(value=0))
+    assert eliminate_letrec_program(program) == expected
+
+
+# ── LetRec ────────────────────────────────────────────────────────────────────
 
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
 
+def test_letrec_basic():
+    """A self-recursive function: letrec f = (lambda () f) in f"""
+    term = L3.LetRec(
+        bindings=[("f", L3.Abstract(parameters=[], body=L3.Reference(name="f")))],
+        body=L3.Reference(name="f"),
+    )
     expected = L2.Let(
-        bindings=[("x", L2.Allocate(count=1))],
+        bindings=[("f", L2.Allocate(count=1))],
         body=L2.Begin(
             effects=[
                 L2.Store(
-                    base=L2.Reference(name="x"),
+                    base=L2.Reference(name="f"),
                     index=0,
-                    value=L2.Reference(name="y"),
+                    value=L2.Abstract(
+                        parameters=[],
+                        body=L2.Load(base=L2.Reference(name="f"), index=0),
+                    ),
                 )
             ],
-            value=L2.Reference(name="z"),
+            value=L2.Load(base=L2.Reference(name="f"), index=0),
         ),
     )
+    assert eliminate_letrec_term(term, {}) == expected
 
-    assert actual == expected
 
+def test_letrec_mutual_recursion():
+    """Mutually recursive: letrec f = (lambda () g), g = (lambda () f) in f"""
+    term = L3.LetRec(
+        bindings=[
+            ("f", L3.Abstract(parameters=[], body=L3.Reference(name="g"))),
+            ("g", L3.Abstract(parameters=[], body=L3.Reference(name="f"))),
+        ],
+        body=L3.Reference(name="f"),
+    )
+    result = eliminate_letrec_term(term, {})
+    # Both f and g should be allocated and their bodies should load from boxes
+    assert isinstance(result, L2.Let)
+    assert len(result.bindings) == 2
+    assert result.bindings[0] == ("f", L2.Allocate(count=1))
+    assert result.bindings[1] == ("g", L2.Allocate(count=1))
 
-def test_eliminate_letrec_term_reference_value():
-    term = L3.Reference(name="x")
-
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
-
-    expected = L2.Reference(name="x")
 
-    assert actual == expected
+# ── Reference ─────────────────────────────────────────────────────────────────
 
 
-def test_eliminate_letrec_term_reference_variable():
+def test_reference_not_in_context():
+    """Plain reference outside of letrec scope passes through unchanged."""
     term = L3.Reference(name="x")
+    assert eliminate_letrec_term(term, {}) == L2.Reference(name="x")
 
-    context: Context = {"x": None}
-    actual = eliminate_letrec_term(term, context)
 
-    expected = L2.Load(base=L2.Reference(name="x"), index=0)
+def test_reference_in_context():
+    """Reference to a letrec-bound name becomes a Load."""
+    term = L3.Reference(name="x")
+    assert eliminate_letrec_term(term, {"x": None}) == L2.Load(base=L2.Reference(name="x"), index=0)
 
-    assert actual == expected
 
+# ── Abstract ──────────────────────────────────────────────────────────────────
 
-def test_eliminate_letrec_term_abstract():
-    term = L3.Abstract(
-        parameters=["x"],
-        body=L3.Reference(name="x"),
-    )
 
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
+def test_abstract():
+    term = L3.Abstract(parameters=["x"], body=L3.Reference(name="x"))
+    expected = L2.Abstract(parameters=["x"], body=L2.Reference(name="x"))
+    assert eliminate_letrec_term(term, {}) == expected
 
-    expected = L2.Abstract(
-        parameters=["x"],
-        body=L2.Reference(name="x"),
-    )
 
-    assert actual == expected
+# ── Apply ─────────────────────────────────────────────────────────────────────
 
 
-def test_eliminate_letrec_term_apply():
+def test_apply():
     term = L3.Apply(
-        target=L3.Reference(name="x"),
-        arguments=[],
+        target=L3.Reference(name="f"),
+        arguments=[L3.Immediate(value=1), L3.Immediate(value=2)],
     )
-
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
-
     expected = L2.Apply(
-        target=L2.Reference(name="x"),
-        arguments=[],
+        target=L2.Reference(name="f"),
+        arguments=[L2.Immediate(value=1), L2.Immediate(value=2)],
     )
+    assert eliminate_letrec_term(term, {}) == expected
 
-    assert actual == expected
 
+# ── Immediate ─────────────────────────────────────────────────────────────────
 
-def test_eliminate_letrec_term_immediate():
-    term = L3.Immediate(value=0)
 
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
+def test_immediate():
+    term = L3.Immediate(value=42)
+    assert eliminate_letrec_term(term, {}) == L2.Immediate(value=42)
 
-    expected = L2.Immediate(value=0)
 
-    assert actual == expected
+# ── Primitive ─────────────────────────────────────────────────────────────────
 
 
-def test_eliminate_letrec_term_primitive():
+def test_primitive():
     term = L3.Primitive(
         operator="+",
-        left=L3.Reference(name="x"),
-        right=L3.Reference(name="y"),
+        left=L3.Immediate(value=1),
+        right=L3.Immediate(value=2),
     )
-
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
-
     expected = L2.Primitive(
         operator="+",
-        left=L2.Reference(name="x"),
-        right=L2.Reference(name="y"),
+        left=L2.Immediate(value=1),
+        right=L2.Immediate(value=2),
     )
+    assert eliminate_letrec_term(term, {}) == expected
 
-    assert actual == expected
+
+# ── Branch ────────────────────────────────────────────────────────────────────
 
 
-def test_eliminate_letrec_term_branch():
+def test_branch():
     term = L3.Branch(
         operator="<",
-        left=L3.Reference(name="w"),
-        right=L3.Reference(name="x"),
-        consequent=L3.Reference(name="y"),
-        otherwise=L3.Reference(name="z"),
+        left=L3.Immediate(value=1),
+        right=L3.Immediate(value=2),
+        consequent=L3.Immediate(value=10),
+        otherwise=L3.Immediate(value=20),
     )
-
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
-
     expected = L2.Branch(
         operator="<",
-        left=L2.Reference(name="w"),
-        right=L2.Reference(name="x"),
-        consequent=L2.Reference(name="y"),
-        otherwise=L2.Reference(name="z"),
+        left=L2.Immediate(value=1),
+        right=L2.Immediate(value=2),
+        consequent=L2.Immediate(value=10),
+        otherwise=L2.Immediate(value=20),
     )
+    assert eliminate_letrec_term(term, {}) == expected
 
-    assert actual == expected
 
+# ── Allocate ──────────────────────────────────────────────────────────────────
 
-def test_eliminate_letrec_term_allocate():
+
+def test_allocate():
     term = L3.Allocate(count=3)
+    assert eliminate_letrec_term(term, {}) == L2.Allocate(count=3)
 
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
 
-    expected = L2.Allocate(count=3)
+# ── Load ──────────────────────────────────────────────────────────────────────
 
-    assert actual == expected
 
+def test_load():
+    term = L3.Load(base=L3.Reference(name="arr"), index=2)
+    expected = L2.Load(base=L2.Reference(name="arr"), index=2)
+    assert eliminate_letrec_term(term, {}) == expected
 
-def test_eliminate_letrec_term_load():
-    term = L3.Load(
-        base=L3.Reference(name="x"),
-        index=0,
-    )
 
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
+# ── Store ─────────────────────────────────────────────────────────────────────
 
-    expected = L2.Load(
-        base=L2.Reference(name="x"),
-        index=0,
-    )
 
-    assert actual == expected
-
-
-def test_eliminate_letrec_term_store():
+def test_store():
     term = L3.Store(
-        base=L3.Reference(name="x"),
+        base=L3.Reference(name="arr"),
         index=0,
-        value=L3.Reference(name="y"),
+        value=L3.Immediate(value=99),
     )
-
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
-
     expected = L2.Store(
-        base=L2.Reference(name="x"),
+        base=L2.Reference(name="arr"),
         index=0,
-        value=L2.Reference(name="y"),
+        value=L2.Immediate(value=99),
     )
+    assert eliminate_letrec_term(term, {}) == expected
 
-    assert actual == expected
+
+# ── Begin ─────────────────────────────────────────────────────────────────────
 
 
-def test_eliminate_letrec_term_begin():
+def test_begin():
     term = L3.Begin(
-        effects=[],
-        value=L3.Reference(name="x"),
+        effects=[
+            L3.Store(
+                base=L3.Reference(name="arr"),
+                index=0,
+                value=L3.Immediate(value=1),
+            )
+        ],
+        value=L3.Immediate(value=0),
     )
-
-    context: Context = {}
-    actual = eliminate_letrec_term(term, context)
-
     expected = L2.Begin(
-        effects=[],
-        value=L2.Reference(name="x"),
+        effects=[
+            L2.Store(
+                base=L2.Reference(name="arr"),
+                index=0,
+                value=L2.Immediate(value=1),
+            )
+        ],
+        value=L2.Immediate(value=0),
     )
+    assert eliminate_letrec_term(term, {}) == expected
 
-    assert actual == expected
 
+# ── Program with parameters ───────────────────────────────────────────────────
 
-def test_eliminate_letrec_program():
+
+def test_eliminate_letrec_program_with_params():
     program = L3.Program(
-        parameters=["x"],
-        body=L3.Reference(name="x"),
+        parameters=[],
+        body=L3.Immediate(value=0),
     )
 
-    actual = eliminate_letrec_program(program)
-
     expected = L2.Program(
-        parameters=["x"],
-        body=L2.Reference(name="x"),
+        parameters=[],
+        body=L2.Immediate(value=0),
     )
 
+    actual = eliminate_letrec_program(program)
+
     assert actual == expected
diff --git a/packages/L3/test/L3/test_uniqify.py b/packages/L3/test/L3/test_uniqify.py
index e2243e9..675b424 100644
--- a/packages/L3/test/L3/test_uniqify.py
+++ b/packages/L3/test/L3/test_uniqify.py
@@ -1,7 +1,25 @@
-from L3.syntax import Apply, Immediate, Let, Reference
-from L3.uniqify import Context, uniqify_term
+from L3.syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
+    Immediate,
+    Let,
+    LetRec,
+    Load,
+    Primitive,
+    Program,
+    Reference,
+    Store,
+)
+from L3.uniqify import Context, uniqify_program, uniqify_term
 from util.sequential_name_generator import SequentialNameGenerator
 
+# ---------------------------------------------------------------------------
+# Reference
+# ---------------------------------------------------------------------------
+
 
 def test_uniqify_term_reference():
     term = Reference(name="x")
@@ -15,6 +33,11 @@ def test_uniqify_term_reference():
     assert actual == expected
 
 
+# ---------------------------------------------------------------------------
+# Immediate
+# ---------------------------------------------------------------------------
+
+
 def test_uniqify_immediate():
     term = Immediate(value=42)
 
@@ -27,7 +50,16 @@ def test_uniqify_immediate():
     assert actual == expected
 
 
+# ---------------------------------------------------------------------------
+# Let
+# ---------------------------------------------------------------------------
+
+
 def test_uniqify_term_let():
+    """
+    Binding values are evaluated in the *outer* context (parallel semantics).
+    The body sees all newly introduced fresh names.
+    """
     term = Let(
         bindings=[
             ("x", Immediate(value=1)),
@@ -48,7 +80,7 @@ def test_uniqify_term_let():
     expected = Let(
         bindings=[
             ("x0", Immediate(value=1)),
-            ("y0", Reference(name="y")),
+            ("y0", Reference(name="y")),  # "x" in value resolves to outer "y", not "x0"
         ],
         body=Apply(
             target=Reference(name="x0"),
@@ -59,3 +91,252 @@ def test_uniqify_term_let():
     )
 
     assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# LetRec
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_letrec():
+    """
+    All bound names are in scope for all binding values and the body
+    (mutually recursive semantics).
+    """
+    term = LetRec(
+        bindings=[
+            ("f", Abstract(parameters=["x"], body=Apply(target=Reference(name="g"), arguments=[Reference(name="x")]))),
+            ("g", Abstract(parameters=["x"], body=Apply(target=Reference(name="f"), arguments=[Reference(name="x")]))),
+        ],
+        body=Apply(target=Reference(name="f"), arguments=[Immediate(value=0)]),
+    )
+
+    context: Context = {}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    # fresh assigns: f→f0, g→g1, then x inside f→x2, x inside g→x3
+    expected = LetRec(
+        bindings=[
+            (
+                "f0",
+                Abstract(
+                    parameters=["x2"],
+                    body=Apply(target=Reference(name="g1"), arguments=[Reference(name="x2")]),
+                ),
+            ),
+            (
+                "g1",
+                Abstract(
+                    parameters=["x3"],
+                    body=Apply(target=Reference(name="f0"), arguments=[Reference(name="x3")]),
+                ),
+            ),
+        ],
+        body=Apply(target=Reference(name="f0"), arguments=[Immediate(value=0)]),
+    )
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Abstract
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_abstract():
+    """Parameters get fresh names; body is evaluated in extended context."""
+    term = Abstract(
+        parameters=["a", "b"],
+        body=Primitive(operator="+", left=Reference(name="a"), right=Reference(name="b")),
+    )
+
+    context: Context = {}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Abstract(
+        parameters=["a0", "b1"],
+        body=Primitive(operator="+", left=Reference(name="a0"), right=Reference(name="b1")),
+    )
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Apply
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_apply():
+    term = Apply(
+        target=Reference(name="f"),
+        arguments=[Reference(name="x"), Immediate(value=1)],
+    )
+
+    context: Context = {"f": "f0", "x": "x0"}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Apply(
+        target=Reference(name="f0"),
+        arguments=[Reference(name="x0"), Immediate(value=1)],
+    )
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Primitive
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_primitive():
+    term = Primitive(
+        operator="*",
+        left=Reference(name="a"),
+        right=Reference(name="b"),
+    )
+
+    context: Context = {"a": "a0", "b": "b0"}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Primitive(operator="*", left=Reference(name="a0"), right=Reference(name="b0"))
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Branch
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_branch():
+    term = Branch(
+        operator="<",
+        left=Reference(name="x"),
+        right=Immediate(value=0),
+        consequent=Reference(name="a"),
+        otherwise=Reference(name="b"),
+    )
+
+    context: Context = {"x": "x0", "a": "a0", "b": "b0"}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Branch(
+        operator="<",
+        left=Reference(name="x0"),
+        right=Immediate(value=0),
+        consequent=Reference(name="a0"),
+        otherwise=Reference(name="b0"),
+    )
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Allocate
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_allocate():
+    term = Allocate()
+
+    context: Context = {}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    assert actual == Allocate()
+
+
+# ---------------------------------------------------------------------------
+# Load
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_load():
+    term = Load(base=Reference(name="arr"), index=Reference(name="i"))
+
+    context: Context = {"arr": "arr0", "i": "i0"}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Load(base=Reference(name="arr0"), index=Reference(name="i0"))
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Store
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_store():
+    term = Store(
+        base=Reference(name="arr"),
+        index=Reference(name="i"),
+        value=Reference(name="v"),
+    )
+
+    context: Context = {"arr": "arr0", "i": "i0", "v": "v0"}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Store(
+        base=Reference(name="arr0"),
+        index=Reference(name="i0"),
+        value=Reference(name="v0"),
+    )
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# Begin
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_term_begin():
+    term = Begin(
+        effects=[
+            Store(base=Reference(name="arr"), index=Immediate(value=0), value=Reference(name="x")),
+        ],
+        value=Reference(name="x"),
+    )
+
+    context: Context = {"arr": "arr0", "x": "x0"}
+    fresh = SequentialNameGenerator()
+    actual = uniqify_term(term, context, fresh)
+
+    expected = Begin(
+        effects=[
+            Store(base=Reference(name="arr0"), index=Immediate(value=0), value=Reference(name="x0")),
+        ],
+        value=Reference(name="x0"),
+    )
+
+    assert actual == expected
+
+
+# ---------------------------------------------------------------------------
+# uniqify_program
+# ---------------------------------------------------------------------------
+
+
+def test_uniqify_program():
+    """Top-level parameters get fresh names; body is evaluated in that context."""
+    program = Program(
+        parameters=["x", "y"],
+        body=Primitive(operator="+", left=Reference(name="x"), right=Reference(name="y")),
+    )
+
+    fresh, result = uniqify_program(program)
+
+    expected = Program(
+        parameters=["x0", "y1"],
+        body=Primitive(operator="+", left=Reference(name="x0"), right=Reference(name="y1")),
+    )
+
+    assert result == expected
diff --git a/pyproject.toml b/pyproject.toml
index d735316..5cc4afc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,9 @@ description = "Add your description here"
 authors = [{ name = "James Clause", email = "clause@udel.edu" }]
 readme = "README.md"
 requires-python = ">=3.14"
-dependencies = []
+dependencies = [
+    "lark>=1.3.1",
+]
 
 [dependency-groups]
 dev = [
@@ -20,6 +22,7 @@ dev = [
 
 [tool.ruff]
 line-length = 120
+lint.ignore = ["F841"]
 
 [tool.uv.workspace]
 members = ["packages/*"]
diff --git a/uv.lock b/uv.lock
index b1e5469..a340543 100644
--- a/uv.lock
+++ b/uv.lock
@@ -16,6 +16,9 @@ members = [
 name = "471c"
 version = "0.1.0"
 source = { virtual = "." }
+dependencies = [
+    { name = "lark" },
+]
 
 [package.dev-dependencies]
 dev = [
@@ -29,6 +32,7 @@ dev = [
 ]
 
 [package.metadata]
+requires-dist = [{ name = "lark", specifier = ">=1.3.1" }]
 
 [package.metadata.requires-dev]
 dev = [