diff --git a/src/alt-langs/mapper.ts b/src/alt-langs/mapper.ts
index ffb2c5713..ed07063d9 100644
--- a/src/alt-langs/mapper.ts
+++ b/src/alt-langs/mapper.ts
@@ -40,4 +40,11 @@ export function mapResult(context: Context): (x: Result) => Result {
       // there is no need for a mapper in this case.
       return x => x
   }
-}
\ No newline at end of file
+}
+
+export const isSchemeLanguage = (context: Context) =>
+  context.chapter === Chapter.SCHEME_1 ||
+    context.chapter === Chapter.SCHEME_2 ||
+    context.chapter === Chapter.SCHEME_3 ||
+    context.chapter === Chapter.SCHEME_4 ||
+    context.chapter === Chapter.FULL_SCHEME
\ No newline at end of file
diff --git a/src/alt-langs/scheme/scm-slang b/src/alt-langs/scheme/scm-slang
index 23d97f8c8..908574c57 160000
--- a/src/alt-langs/scheme/scm-slang
+++ b/src/alt-langs/scheme/scm-slang
@@ -1 +1 @@
-Subproject commit 23d97f8c81bd0930570eaa26e8585cbaeb8e389c
+Subproject commit 908574c579487e33ef7230a8d037e3ad25c778e8
diff --git a/src/createContext.ts b/src/createContext.ts
index 2f5ab7dca..623c21db9 100644
--- a/src/createContext.ts
+++ b/src/createContext.ts
@@ -38,6 +38,8 @@ import { makeWrapper } from './utils/makeWrapper'
 import * as operators from './utils/operators'
 import { stringify } from './utils/stringify'
 import { schemeVisualise } from './alt-langs/scheme/scheme-mapper'
+import { cset_apply, cset_eval } from './cse-machine/scheme-macros'
+import { Transformers } from './cse-machine/interpreter'
 
 export class LazyBuiltIn {
   func: (...arg0: any) => any
@@ -117,6 +119,7 @@ const createEmptyRuntime = () => ({
   nodes: [],
   control: null,
   stash: null,
+  transformers: new Transformers(),
   objectCount: 0,
   envSteps: -1,
   envStepsTotal: 0,
@@ -450,16 +453,14 @@ export const importBuiltins = (context: Context, externalBuiltIns: CustomBuiltIn
   if (context.chapter <= +Chapter.SCHEME_1 && context.chapter >= +Chapter.FULL_SCHEME) {
     switch (context.chapter) {
       case Chapter.FULL_SCHEME:
+        // Introduction to eval
+        // eval metaprocedure
+        defineBuiltin(context, '$scheme_ZXZhbA$61$$61$(xs)', cset_eval)
+
       case Chapter.SCHEME_4:
         // Introduction to call/cc
         defineBuiltin(context, 'call$47$cc(f)', call_with_current_continuation)
 
-      // Introduction to eval
-
-      // Scheme apply
-      // ^ is needed in Schemes 2 and 3 to apply to call functions with rest parameters,
-      // so we move it there.
-
       case Chapter.SCHEME_3:
         // Introduction to mutable values, streams
 
@@ -497,10 +498,6 @@ export const importBuiltins = (context: Context, externalBuiltIns: CustomBuiltIn
         defineBuiltin(context, 'list$45$$62$vector(xs)', scheme_libs.list$45$$62$vector)
 
       case Chapter.SCHEME_2:
-        // Splicing builtin resolvers
-        // defineBuiltin(context, '$36$make$45$splice(expr)', scheme_libs.make_splice)
-        // defineBuiltin(context, '$36$resolve$45$splice(xs)', scheme_libs.resolve_splice)
-
         // Scheme pairs
         defineBuiltin(context, 'cons(left, right)', scheme_libs.cons)
         defineBuiltin(context, 'xcons(right, left)', scheme_libs.xcons)
@@ -622,11 +619,16 @@ export const importBuiltins = (context: Context, externalBuiltIns: CustomBuiltIn
         defineBuiltin(context, 'list$45$$62$string(xs)', scheme_libs.list$45$$62$string)
 
         // Scheme apply is needed here to help in the definition of the Scheme Prelude.
-        defineBuiltin(context, 'apply(f, ...args)', scheme_libs.apply, 2)
+        defineBuiltin(context, 'apply(f, ...args)', cset_apply, 2)
 
       case Chapter.SCHEME_1:
         // Display
-        defineBuiltin(context, 'display(val)', (val: any) => display(schemeVisualise(val)))
+        defineBuiltin(
+          context,
+          'display(val, prepend = undefined)',
+          (val: any, ...str: string[]) => display(schemeVisualise(val), ...str),
+          1
+        )
         defineBuiltin(context, 'newline()', () => display(''))
 
         // I/O
diff --git a/src/cse-machine/__tests__/__snapshots__/cset-machine-apply.ts.snap b/src/cse-machine/__tests__/__snapshots__/cset-machine-apply.ts.snap
new file mode 100644
index 000000000..e640dd35d
--- /dev/null
+++ b/src/cse-machine/__tests__/__snapshots__/cset-machine-apply.ts.snap
@@ -0,0 +1,84 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`eval of strings: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval \\"hello\\")
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": "hello",
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`incorrect use of apply throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (apply)
+  ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Expected 2 arguments, but got 0.",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`incorrect use of apply throws error (last argument not a list): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (apply + 1 2 3)
+  ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Last argument of apply must be a list",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`multi-operand apply: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define args '(1 2 3 4 5))
+    (apply + 6 7 8 9 10 args)
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 55n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`two-operand apply: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define args '(1 2))
+    (apply + args)
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 3n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
diff --git a/src/cse-machine/__tests__/__snapshots__/cset-machine-eval.ts.snap b/src/cse-machine/__tests__/__snapshots__/cset-machine-eval.ts.snap
new file mode 100644
index 000000000..1d4858bf9
--- /dev/null
+++ b/src/cse-machine/__tests__/__snapshots__/cset-machine-eval.ts.snap
@@ -0,0 +1,224 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`eval of application: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(+ 1 2))
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 3n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of begin: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(begin 1 2 3))
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 3n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of booleans: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval #t)
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": true,
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of define: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define x 1))
+    x
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 1n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of empty list: expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '())
+  ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Cannot evaluate null",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of if: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(if #t 1 2))
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 1n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of lambda: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(lambda (x) x))
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": [Function],
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of numbers: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval 1)
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 1n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of quote: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(quote (1 2 3)))
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": Array [
+    SchemeInteger {
+      "numberType": 1,
+      "value": 1n,
+    },
+    Array [
+      SchemeInteger {
+        "numberType": 1,
+        "value": 2n,
+      },
+      Array [
+        SchemeInteger {
+          "numberType": 1,
+          "value": 3n,
+        },
+        null,
+      ],
+    ],
+  ],
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of set!: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define x 2)
+    (eval '(set! x 1))
+    x
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 1n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of strings: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval \\"hello\\")
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": "hello",
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`eval of symbols: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define hello 1)
+    (eval 'hello)
+  ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 1n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
diff --git a/src/cse-machine/__tests__/__snapshots__/cset-machine-macros.ts.snap b/src/cse-machine/__tests__/__snapshots__/cset-machine-macros.ts.snap
new file mode 100644
index 000000000..44a337150
--- /dev/null
+++ b/src/cse-machine/__tests__/__snapshots__/cset-machine-macros.ts.snap
@@ -0,0 +1,97 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`definition of a macro: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define-syntax my-let
+      (syntax-rules ()
+        ((_ ((var expr) ...) body ...)
+         ((lambda (var ...) body ...) expr ...))))
+    ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": undefined,
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`failed usage of a macro (no matching pattern): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define-syntax my-let
+      (syntax-rules ()
+        ((_ ((var expr) ...) body ...)
+         ((lambda (var ...) body ...) expr ...))))
+    (my-let ((x 1) y)
+      (+ x y))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: No matching transformer found for macro my-let",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`use of a macro: expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (define-syntax my-let
+      (syntax-rules ()
+        ((_ ((var expr) ...) body ...)
+         ((lambda (var ...) body ...) expr ...))))
+    (my-let ((x 1) (y 2))
+      (+ x y))
+    ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 3n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`use of a more complex macro (recursive): expectResult 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+(define-syntax define-match
+    (syntax-rules ()
+        ; vars is a pair
+        ((_ (front . rest) val)
+         (begin
+            (if (not (pair? val))
+                (error \\"define-match: vars and vals do not match\\"))
+            (define-match front (car val))
+            (define-match rest (cdr val))))
+        ; vars is nil
+        ((_ () val)
+         ; do nothing
+         (if #f #f))
+        ; vars is a single symbol
+        ((_ sym val)
+         (define sym val))))
+  (define-match ((x y) z) '((1 2) 3))
+  (+ x y z)
+    ",
+  "displayResult": Array [],
+  "numErrors": 0,
+  "parsedErrors": "",
+  "result": SchemeInteger {
+    "numberType": 1,
+    "value": 6n,
+  },
+  "resultStatus": "finished",
+  "visualiseListResult": Array [],
+}
+`;
diff --git a/src/cse-machine/__tests__/__snapshots__/cset-machine.ts.snap b/src/cse-machine/__tests__/__snapshots__/cset-machine.ts.snap
new file mode 100644
index 000000000..fc7301ef5
--- /dev/null
+++ b/src/cse-machine/__tests__/__snapshots__/cset-machine.ts.snap
@@ -0,0 +1,376 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`evaluating a poorly formed begin throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(begin))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: begin requires at least 1 argument!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define throws error (attempt to redefine special form): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define (if x y) 4))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Cannot shadow special form if with a definition!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define throws error (ill formed define-function): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define (x 1 2 3) 4))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Invalid arguments for lambda!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define requires at least 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define throws error (too many arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define x 1 2 3))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define requires 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (attempt to shadow special form): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax if 4))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Cannot shadow special form if with a macro!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define-syntax requires 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (list is not syntax-rules): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x (foo bar)))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define-syntax requires a syntax-rules transformer!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (no syntax-rules list): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x 1))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define-syntax requires a syntax-rules transformer!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (syntax is not a symbol): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax 1 4))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define-syntax requires a symbol!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (syntax-rules has non-list rules): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x (syntax-rules (x) 1)))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Invalid syntax-rules rule!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (syntax-rules has non-symbol literals): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x (syntax-rules (1 2) (1 1))))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Invalid syntax-rules literals!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (syntax-rules has poor literals list): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x (syntax-rules x (1 1))))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Invalid syntax-rules literals!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (syntax-rules too few arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x (syntax-rules)))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: syntax-rules requires at least 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed define-syntax throws error (too many arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(define-syntax x 1 2 3))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: define-syntax requires 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed if throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(if))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: if requires at least 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed if throws error (too many arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(if #t 1 2 3))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: if requires at most 3 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed lambda throws error: expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(lambda (1 2 3) x))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Invalid arguments for lambda!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed quote throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(quote))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: quote requires 1 argument!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed quote throws error (too many arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(quote x y))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: quote requires 1 argument!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed set! throws error (attempt to set! special form): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(set! if 4))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Cannot overwrite special form if with a value!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed set! throws error (insufficient arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(set!))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: set! requires 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a poorly formed set! throws error (too many arguments): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(set! x 1 2 3))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: set! requires 2 arguments!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating a syntax-rules expression (should not exist outside of define-syntax): expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '(syntax-rules (x) (1 1)))
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: syntax-rules must only exist within define-syntax!",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
+
+exports[`evaluating null throws error: expectParsedError 1`] = `
+Object {
+  "alertResult": Array [],
+  "code": "
+    (eval '())
+    ",
+  "displayResult": Array [],
+  "numErrors": 1,
+  "parsedErrors": "Error: Cannot evaluate null",
+  "result": undefined,
+  "resultStatus": "error",
+  "visualiseListResult": Array [],
+}
+`;
diff --git a/src/cse-machine/__tests__/continuations.ts b/src/cse-machine/__tests__/continuations.ts
index b82e82ff9..ae957fee3 100644
--- a/src/cse-machine/__tests__/continuations.ts
+++ b/src/cse-machine/__tests__/continuations.ts
@@ -1,5 +1,6 @@
+import { mockContext } from '../../mocks/context'
 import { Call_cc, Continuation, isCallWithCurrentContinuation } from '../continuations'
-import { Control, Stash } from '../interpreter'
+import { Control, Stash, Transformers } from '../interpreter'
 
 test('call/cc is a singleton', () => {
   expect(Call_cc.get()).toBe(Call_cc.get())
@@ -15,6 +16,6 @@ test('isCallWithCurrentContinuation works on call/cc only', () => {
 })
 
 test('Continuation toString', () => {
-  const cont = new Continuation(new Control(), new Stash(), [])
+  const cont = new Continuation(mockContext(), new Control(), new Stash(), [], new Transformers())
   expect(cont.toString()).toBe('continuation')
 })
diff --git a/src/cse-machine/__tests__/cse-machine-callcc.ts b/src/cse-machine/__tests__/cse-machine-callcc.ts
index f26b52683..2249a1799 100644
--- a/src/cse-machine/__tests__/cse-machine-callcc.ts
+++ b/src/cse-machine/__tests__/cse-machine-callcc.ts
@@ -2,7 +2,7 @@ import { Chapter, Variant } from '../../types'
 import { expectParsedError, expectResult } from '../../utils/testing'
 
 // Continuation tests for Scheme
-const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
+const optionECScm = { chapter: Chapter.SCHEME_4, variant: Variant.EXPLICIT_CONTROL }
 
 test('basic call/cc works', () => {
   return expectResult(
diff --git a/src/cse-machine/__tests__/cse-machine-runtime-context.ts b/src/cse-machine/__tests__/cse-machine-runtime-context.ts
index f5edfac8b..4c3e48e0a 100644
--- a/src/cse-machine/__tests__/cse-machine-runtime-context.ts
+++ b/src/cse-machine/__tests__/cse-machine-runtime-context.ts
@@ -5,7 +5,7 @@ import { parse } from '../../parser/parser'
 import { runCodeInSource } from '../../runner'
 import { Chapter, RecursivePartial } from '../../types'
 import { stripIndent } from '../../utils/formatters'
-import { Control, Stash, generateCSEMachineStateStream } from '../interpreter'
+import { Control, Transformers, Stash, generateCSEMachineStateStream } from '../interpreter'
 
 const getContextFrom = async (code: string, steps?: number) => {
   const context = mockContext(Chapter.SOURCE_4)
@@ -24,6 +24,7 @@ const evaluateCode = (code: string) => {
   context.runtime.isRunning = true
   context.runtime.control = new Control(program as es.Program)
   context.runtime.stash = new Stash()
+  context.runtime.transformers = new Transformers()
 
   const CSEState = generateCSEMachineStateStream(
     context,
diff --git a/src/cse-machine/__tests__/cset-machine-apply.ts b/src/cse-machine/__tests__/cset-machine-apply.ts
new file mode 100644
index 000000000..c13c7b93f
--- /dev/null
+++ b/src/cse-machine/__tests__/cset-machine-apply.ts
@@ -0,0 +1,62 @@
+import { Chapter, Variant } from '../../types'
+import { expectParsedError, expectResult } from '../../utils/testing'
+
+// apply tests for Scheme
+const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
+
+test('two-operand apply', () => {
+  return expectResult(
+    `
+    (define args '(1 2))
+    (apply + args)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 3n,
+            }
+          `)
+})
+
+test('multi-operand apply', () => {
+  return expectResult(
+    `
+    (define args '(1 2 3 4 5))
+    (apply + 6 7 8 9 10 args)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 55n,
+            }
+          `)
+})
+
+test('eval of strings', () => {
+  return expectResult(
+    `
+    (eval "hello")
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"hello"`)
+})
+
+test('incorrect use of apply throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (apply)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Expected 2 arguments, but got 0."`)
+})
+
+test('incorrect use of apply throws error (last argument not a list)', () => {
+  return expectParsedError(
+    `
+    (apply + 1 2 3)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Last argument of apply must be a list"`)
+})
diff --git a/src/cse-machine/__tests__/cset-machine-eval.ts b/src/cse-machine/__tests__/cset-machine-eval.ts
new file mode 100644
index 000000000..95c1ef4a9
--- /dev/null
+++ b/src/cse-machine/__tests__/cset-machine-eval.ts
@@ -0,0 +1,172 @@
+import { Chapter, Variant } from '../../types'
+import { expectParsedError, expectResult } from '../../utils/testing'
+
+// CSET tests for Scheme
+const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
+
+test('eval of numbers', () => {
+  return expectResult(
+    `
+    (eval 1)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 1n,
+            }
+          `)
+})
+
+test('eval of booleans', () => {
+  return expectResult(
+    `
+    (eval #t)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`true`)
+})
+
+test('eval of strings', () => {
+  return expectResult(
+    `
+    (eval "hello")
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"hello"`)
+})
+
+test('eval of symbols', () => {
+  return expectResult(
+    `
+    (define hello 1)
+    (eval 'hello)
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 1n,
+            }
+          `)
+})
+
+test('eval of empty list', () => {
+  return expectParsedError(
+    `
+    (eval '())
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Cannot evaluate null"`)
+})
+
+test('eval of define', () => {
+  return expectResult(
+    `
+    (eval '(define x 1))
+    x
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 1n,
+            }
+          `)
+})
+
+test('eval of lambda', () => {
+  return expectResult(
+    `
+    (eval '(lambda (x) x))
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`[Function]`)
+})
+
+test('eval of if', () => {
+  return expectResult(
+    `
+    (eval '(if #t 1 2))
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 1n,
+            }
+          `)
+})
+
+test('eval of begin', () => {
+  return expectResult(
+    `
+    (eval '(begin 1 2 3))
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 3n,
+            }
+          `)
+})
+
+test('eval of set!', () => {
+  return expectResult(
+    `
+    (define x 2)
+    (eval '(set! x 1))
+    x
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 1n,
+            }
+          `)
+})
+
+test('eval of application', () => {
+  return expectResult(
+    `
+    (eval '(+ 1 2))
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 3n,
+            }
+          `)
+})
+
+test('eval of quote', () => {
+  return expectResult(
+    `
+    (eval '(quote (1 2 3)))
+  `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            Array [
+              SchemeInteger {
+                "numberType": 1,
+                "value": 1n,
+              },
+              Array [
+                SchemeInteger {
+                  "numberType": 1,
+                  "value": 2n,
+                },
+                Array [
+                  SchemeInteger {
+                    "numberType": 1,
+                    "value": 3n,
+                  },
+                  null,
+                ],
+              ],
+            ]
+          `)
+})
diff --git a/src/cse-machine/__tests__/cset-machine-macros.ts b/src/cse-machine/__tests__/cset-machine-macros.ts
new file mode 100644
index 000000000..751c2cc83
--- /dev/null
+++ b/src/cse-machine/__tests__/cset-machine-macros.ts
@@ -0,0 +1,81 @@
+import { Chapter, Variant } from '../../types'
+import { expectParsedError, expectResult } from '../../utils/testing'
+
+// CSET tests for Scheme Macros
+const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
+
+test('definition of a macro', () => {
+  return expectResult(
+    `
+    (define-syntax my-let
+      (syntax-rules ()
+        ((_ ((var expr) ...) body ...)
+         ((lambda (var ...) body ...) expr ...))))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`undefined`)
+})
+
+test('use of a macro', () => {
+  return expectResult(
+    `
+    (define-syntax my-let
+      (syntax-rules ()
+        ((_ ((var expr) ...) body ...)
+         ((lambda (var ...) body ...) expr ...))))
+    (my-let ((x 1) (y 2))
+      (+ x y))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 3n,
+            }
+          `)
+})
+
+test('use of a more complex macro (recursive)', () => {
+  return expectResult(
+    `
+(define-syntax define-match
+    (syntax-rules ()
+        ; vars is a pair
+        ((_ (front . rest) val)
+         (begin
+            (if (not (pair? val))
+                (error "define-match: vars and vals do not match"))
+            (define-match front (car val))
+            (define-match rest (cdr val))))
+        ; vars is nil
+        ((_ () val)
+         ; do nothing
+         (if #f #f))
+        ; vars is a single symbol
+        ((_ sym val)
+         (define sym val))))
+  (define-match ((x y) z) '((1 2) 3))
+  (+ x y z)
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`
+            SchemeInteger {
+              "numberType": 1,
+              "value": 6n,
+            }
+          `)
+})
+
+test('failed usage of a macro (no matching pattern)', () => {
+  return expectParsedError(
+    `
+    (define-syntax my-let
+      (syntax-rules ()
+        ((_ ((var expr) ...) body ...)
+         ((lambda (var ...) body ...) expr ...))))
+    (my-let ((x 1) y)
+      (+ x y))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: No matching transformer found for macro my-let"`)
+})
diff --git a/src/cse-machine/__tests__/cset-machine.ts b/src/cse-machine/__tests__/cset-machine.ts
new file mode 100644
index 000000000..aaeedf3ee
--- /dev/null
+++ b/src/cse-machine/__tests__/cset-machine.ts
@@ -0,0 +1,231 @@
+import { Chapter, Variant } from '../../types'
+import { expectParsedError } from '../../utils/testing'
+
+// CSET tests for Scheme (mostly error testing for
+// the runtime verification of scheme syntax forms.)
+const optionECScm = { chapter: Chapter.FULL_SCHEME, variant: Variant.EXPLICIT_CONTROL }
+
+test('evaluating null throws error', () => {
+  return expectParsedError(
+    `
+    (eval '())
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Cannot evaluate null"`)
+})
+
+test('evaluating a poorly formed lambda throws error', () => {
+  return expectParsedError(
+    `
+    (eval '(lambda (1 2 3) x))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Invalid arguments for lambda!"`)
+})
+
+test('evaluating a poorly formed define throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(define))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define requires at least 2 arguments!"`)
+})
+
+test('evaluating a poorly formed define throws error (too many arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(define x 1 2 3))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define requires 2 arguments!"`)
+})
+
+test('evaluating a poorly formed define throws error (ill formed define-function)', () => {
+  return expectParsedError(
+    `
+    (eval '(define (x 1 2 3) 4))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Invalid arguments for lambda!"`)
+})
+
+test('evaluating a poorly formed define throws error (attempt to redefine special form)', () => {
+  return expectParsedError(
+    `
+    (eval '(define (if x y) 4))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Cannot shadow special form if with a definition!"`)
+})
+
+test('evaluating a poorly formed set! throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(set!))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: set! requires 2 arguments!"`)
+})
+
+test('evaluating a poorly formed set! throws error (too many arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(set! x 1 2 3))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: set! requires 2 arguments!"`)
+})
+
+test('evaluating a poorly formed set! throws error (attempt to set! special form)', () => {
+  return expectParsedError(
+    `
+    (eval '(set! if 4))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Cannot overwrite special form if with a value!"`)
+})
+
+test('evaluating a poorly formed if throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(if))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: if requires at least 2 arguments!"`)
+})
+
+test('evaluating a poorly formed if throws error (too many arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(if #t 1 2 3))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: if requires at most 3 arguments!"`)
+})
+
+test('evaluating a poorly formed begin throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(begin))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: begin requires at least 1 argument!"`)
+})
+
+test('evaluating a poorly formed quote throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(quote))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: quote requires 1 argument!"`)
+})
+
+test('evaluating a poorly formed quote throws error (too many arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(quote x y))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: quote requires 1 argument!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (insufficient arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define-syntax requires 2 arguments!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (too many arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x 1 2 3))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define-syntax requires 2 arguments!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (syntax is not a symbol)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax 1 4))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define-syntax requires a symbol!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (attempt to shadow special form)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax if 4))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Cannot shadow special form if with a macro!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (no syntax-rules list)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x 1))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define-syntax requires a syntax-rules transformer!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (list is not syntax-rules)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x (foo bar)))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: define-syntax requires a syntax-rules transformer!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (syntax-rules too few arguments)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x (syntax-rules)))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: syntax-rules requires at least 2 arguments!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (syntax-rules has poor literals list)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x (syntax-rules x (1 1))))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Invalid syntax-rules literals!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (syntax-rules has non-symbol literals)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x (syntax-rules (1 2) (1 1))))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Invalid syntax-rules literals!"`)
+})
+
+test('evaluating a poorly formed define-syntax throws error (syntax-rules has non-list rules)', () => {
+  return expectParsedError(
+    `
+    (eval '(define-syntax x (syntax-rules (x) 1)))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: Invalid syntax-rules rule!"`)
+})
+
+test('evaluating a syntax-rules expression (should not exist outside of define-syntax)', () => {
+  return expectParsedError(
+    `
+    (eval '(syntax-rules (x) (1 1)))
+    `,
+    optionECScm
+  ).toMatchInlineSnapshot(`"Error: syntax-rules must only exist within define-syntax!"`)
+})
diff --git a/src/cse-machine/__tests__/patterns.ts b/src/cse-machine/__tests__/patterns.ts
new file mode 100644
index 000000000..798a011f6
--- /dev/null
+++ b/src/cse-machine/__tests__/patterns.ts
@@ -0,0 +1,53 @@
+import { match } from '../patterns'
+import { _Symbol } from '../../alt-langs/scheme/scm-slang/src/stdlib/base'
+
+function makeList(...args: any[]) {
+  return args.reduceRight((acc, x) => {
+    return [x, acc]
+  }, null)
+}
+
+test('match works on exactly equal items', () => {
+  const result = match(1, 1, [])
+  expect(result).toEqual(true)
+})
+
+test('match works on exactly equal lists', () => {
+  const result = match(makeList(1, 2, 3), makeList(1, 2, 3), [])
+  expect(result).toEqual(true)
+})
+
+test('match works on exactly equal improper lists', () => {
+  const result = match([1, 2], [1, 2], [])
+  expect(result).toEqual(true)
+})
+
+test('match works on a symbol', () => {
+  const result = match(makeList(1, 2, 3), makeList(1, new _Symbol('x'), 3), [])
+  expect(result).toEqual(true)
+})
+
+test('match works on a symbol with anything', () => {
+  const result = match(makeList(1, 2, 3), new _Symbol('x'), [])
+  expect(result).toEqual(true)
+})
+
+test('match works on a pair (improper list)', () => {
+  const result = match(makeList(1, 2, 3), [new _Symbol('head'), new _Symbol('tail')], [])
+  expect(result).toEqual(true)
+})
+
+test('match fails when input does not match literal pattern', () => {
+  const result = match(makeList(1, 2, 3), 4, [])
+  expect(result).toEqual(false)
+})
+
+test('match fails when input does not match syntax literal', () => {
+  const result = match(makeList(1, 2, 3), new _Symbol('x'), ['x'])
+  expect(result).toEqual(false)
+})
+
+test('match fails when input does not match list', () => {
+  const result = match(1, makeList(1, 2, 3), [])
+  expect(result).toEqual(false)
+})
diff --git a/src/cse-machine/closure.ts b/src/cse-machine/closure.ts
index 42dc64784..0d6217a5f 100644
--- a/src/cse-machine/closure.ts
+++ b/src/cse-machine/closure.ts
@@ -3,6 +3,7 @@ import * as es from 'estree'
 
 import {
   currentEnvironment,
+  currentTransformers,
   hasReturnStatement,
   isBlockStatement,
   isStatementSequence,
@@ -10,7 +11,7 @@ import {
 } from '../cse-machine/utils'
 import { Context, Environment, StatementSequence, Value } from '../types'
 import * as ast from '../utils/ast/astCreator'
-import { Control, Stash, generateCSEMachineStateStream } from './interpreter'
+import { Control, Transformers, Stash, generateCSEMachineStateStream } from './interpreter'
 import { envInstr } from './instrCreator'
 
 const closureToJS = (value: Closure, context: Context) => {
@@ -37,8 +38,12 @@ const closureToJS = (value: Closure, context: Context) => {
     newContext.runtime.control = new Control()
     // Also need the env instruction to return back to the current environment at the end.
     // The call expression won't create one as there is only one item in the control.
-    newContext.runtime.control.push(envInstr(currentEnvironment(context), node), node)
+    newContext.runtime.control.push(
+      envInstr(currentEnvironment(context), currentTransformers(context), node),
+      node
+    )
     newContext.runtime.stash = new Stash()
+    newContext.runtime.transformers = context.runtime.transformers
     const gen = generateCSEMachineStateStream(
       newContext,
       newContext.runtime.control,
@@ -84,6 +89,7 @@ export default class Closure extends Callable {
   public static makeFromArrowFunction(
     node: es.ArrowFunctionExpression,
     environment: Environment,
+    transformers: Transformers,
     context: Context,
     dummyReturn?: boolean,
     predefined?: boolean
@@ -104,6 +110,7 @@ export default class Closure extends Callable {
     const closure = new Closure(
       ast.blockArrowFunction(node.params as es.Identifier[], functionBody, node.loc),
       environment,
+      transformers,
       context,
       predefined
     )
@@ -135,6 +142,7 @@ export default class Closure extends Callable {
   constructor(
     public node: es.ArrowFunctionExpression,
     public environment: Environment,
+    public transformers: Transformers,
     context: Context,
     isPredefined?: boolean
   ) {
diff --git a/src/cse-machine/continuations.ts b/src/cse-machine/continuations.ts
index 5d0b1f888..09b06d7fd 100644
--- a/src/cse-machine/continuations.ts
+++ b/src/cse-machine/continuations.ts
@@ -1,7 +1,38 @@
 import * as es from 'estree'
 
-import { Environment } from '../types'
-import { Control, Stash } from './interpreter'
+import { Context, Environment } from '../types'
+import { Control, Stash, Transformers } from './interpreter'
+import { uniqueId } from './utils'
+
+/**
+ * A dummy function used to detect for the apply function object.
+ * If the interpreter sees this specific function, it applies the function
+ * with the given arguments to apply.
+ *
+ * We need this to be a metaprocedure so that it can properly handle
+ * the arguments passed to it, even if they are continuations.
+ */
+export class Apply extends Function {
+  private static instance: Apply = new Apply()
+
+  private constructor() {
+    super()
+  }
+
+  public static get(): Apply {
+    return Apply.instance
+  }
+
+  public toString(): string {
+    return 'apply'
+  }
+}
+
+export const apply = Apply.get()
+
+export function isApply(value: any): boolean {
+  return value === apply
+}
 
 /**
  * A dummy function used to detect for the call/cc function object.
@@ -42,12 +73,24 @@ export class Continuation extends Function {
   private control: Control
   private stash: Stash
   private env: Environment[]
+  private transformers: Transformers
 
-  constructor(control: Control, stash: Stash, env: Environment[]) {
+  /** Unique ID defined for continuation */
+  public readonly id: string
+
+  constructor(
+    context: Context,
+    control: Control,
+    stash: Stash,
+    env: Environment[],
+    transformers: Transformers
+  ) {
     super()
     this.control = control.copy()
     this.stash = stash.copy()
     this.env = [...env]
+    this.transformers = transformers
+    this.id = uniqueId(context)
   }
 
   // As the continuation needs to be immutable (we can call it several times)
@@ -64,9 +107,17 @@ export class Continuation extends Function {
     return [...this.env]
   }
 
+  public getTransformers(): Transformers {
+    return this.transformers
+  }
+
   public toString(): string {
     return 'continuation'
   }
+
+  public equals(other: Continuation): boolean {
+    return this === other
+  }
 }
 
 /**
diff --git a/src/cse-machine/instrCreator.ts b/src/cse-machine/instrCreator.ts
index c360f00f5..3e29846a0 100644
--- a/src/cse-machine/instrCreator.ts
+++ b/src/cse-machine/instrCreator.ts
@@ -18,6 +18,7 @@ import {
   UnOpInstr,
   WhileInstr
 } from './types'
+import { Transformers } from './interpreter'
 
 export const resetInstr = (srcNode: Node): Instr => ({
   instrType: InstrType.RESET,
@@ -90,9 +91,14 @@ export const branchInstr = (
   srcNode
 })
 
-export const envInstr = (env: Environment, srcNode: Node): EnvInstr => ({
+export const envInstr = (
+  env: Environment,
+  transformers: Transformers,
+  srcNode: Node
+): EnvInstr => ({
   instrType: InstrType.ENVIRONMENT,
   env,
+  transformers,
   srcNode
 })
 
diff --git a/src/cse-machine/interpreter.ts b/src/cse-machine/interpreter.ts
index 15c98912f..364fe8bbf 100644
--- a/src/cse-machine/interpreter.ts
+++ b/src/cse-machine/interpreter.ts
@@ -52,6 +52,7 @@ import {
   createEnvironment,
   createProgramEnvironment,
   currentEnvironment,
+  currentTransformers,
   declareFunctionsAndVariables,
   declareIdentifier,
   defineVariable,
@@ -74,9 +75,14 @@ import {
   popEnvironment,
   pushEnvironment,
   reduceConditional,
+  setTransformers,
   setVariable,
   valueProducing
 } from './utils'
+import { isApply, isEval, schemeEval } from './scheme-macros'
+import { Transformer } from './patterns'
+import { isSchemeLanguage } from '../alt-langs/mapper'
+import { flattenList, isList } from './macro-utils'
 
 type CmdEvaluator = (
   command: ControlItem,
@@ -171,6 +177,53 @@ export class Stash extends Stack<Value> {
   }
 }
 
+/**
+ * The T component is a dictionary of mappings from syntax names to
+ * their corresponding syntax rule transformers (patterns).
+ *
+ * Similar to the E component, there is a matching
+ * "T" environment tree that is used to store the transformers.
+ * as such, we need to track the transformers and update them with the environment.
+ */
+export class Transformers {
+  private parent: Transformers | null
+  private items: Map<string, Transformer[]>
+  public constructor(parent?: Transformers) {
+    this.parent = parent || null
+    this.items = new Map<string, Transformer[]>()
+  }
+
+  // only call this if you are sure that the pattern exists.
+  public getPattern(name: string): Transformer[] {
+    // check if the pattern exists in the current transformer
+    if (this.items.has(name)) {
+      return this.items.get(name) as Transformer[]
+    }
+    // else check if the pattern exists in the parent transformer
+    if (this.parent) {
+      return this.parent.getPattern(name)
+    }
+    // should not get here. use this properly.
+    throw new Error(`Pattern ${name} not found in transformers`)
+  }
+
+  public hasPattern(name: string): boolean {
+    // check if the pattern exists in the current transformer
+    if (this.items.has(name)) {
+      return true
+    }
+    // else check if the pattern exists in the parent transformer
+    if (this.parent) {
+      return this.parent.hasPattern(name)
+    }
+    return false
+  }
+
+  public addPattern(name: string, item: Transformer[]): void {
+    this.items.set(name, item)
+  }
+}
+
 /**
  * Function to be called when a program is to be interpreted using
  * the explicit control evaluator.
@@ -192,6 +245,11 @@ export function evaluate(program: es.Program, context: Context, options: IOption
     context.runtime.isRunning = true
     context.runtime.control = new Control(program)
     context.runtime.stash = new Stash()
+    // set a global transformer if it does not exist.
+    context.runtime.transformers = context.runtime.transformers
+      ? context.runtime.transformers
+      : new Transformers()
+
     return runCSEMachine(
       context,
       context.runtime.control,
@@ -334,11 +392,11 @@ export function* generateCSEMachineStateStream(
 
   // Push first node to be evaluated into context.
   // The typeguard is there to guarantee that we are pushing a node (which should always be the case)
-  if (command && isNode(command)) {
+  if (command !== undefined && isNode(command)) {
     context.runtime.nodes.unshift(command)
   }
 
-  while (command) {
+  while (command !== undefined) {
     // Return to capture a snapshot of the control and stash after the target step count is reached
     if (!isPrelude && steps === envSteps) {
       yield { stash, control, steps }
@@ -377,9 +435,12 @@ export function* generateCSEMachineStateStream(
         // With the new evaluator, we don't return a break
         // return new CSEBreak()
       }
-    } else {
+    } else if (isInstr(command)) {
       // Command is an instruction
       cmdEvaluators[command.instrType](command, context, control, stash, isPrelude)
+    } else {
+      // this is a scheme value
+      schemeEval(command, context, control, stash, isPrelude)
     }
 
     // Push undefined into the stack if both control and stash is empty
@@ -463,7 +524,13 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       !(isInstr(next) && next.instrType === InstrType.ENVIRONMENT) &&
       !control.canAvoidEnvInstr()
     ) {
-      control.push(instr.envInstr(currentEnvironment(context), command))
+      control.push(
+        instr.envInstr(
+          currentEnvironment(context),
+          context.runtime.transformers as Transformers,
+          command
+        )
+      )
     }
 
     const environment = createBlockEnvironment(context, 'blockEnvironment')
@@ -762,6 +829,7 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     const closure: Closure = Closure.makeFromArrowFunction(
       command,
       currentEnvironment(context),
+      currentTransformers(context),
       context,
       true,
       isPrelude
@@ -785,7 +853,7 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
   [InstrType.RESET]: function (command: Instr, context: Context, control: Control, stash: Stash) {
     // Keep pushing reset instructions until marker is found.
     const cmdNext: ControlItem | undefined = control.pop()
-    if (cmdNext && (isNode(cmdNext) || cmdNext.instrType !== InstrType.MARKER)) {
+    if (cmdNext && (!isInstr(cmdNext) || cmdNext.instrType !== InstrType.MARKER)) {
       control.push(instr.resetInstr(command.srcNode))
     }
   },
@@ -931,6 +999,49 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       handleRuntimeError(context, new errors.CallingNonFunctionValue(func, command.srcNode))
     }
 
+    if (isApply(func)) {
+      // Check for number of arguments mismatch error
+      checkNumberOfArguments(context, func, args, command.srcNode)
+
+      // get the procedure from the arguments
+      const proc = args[0]
+      // get the last list from the arguments
+      // (and it should be a list)
+      const last = args[args.length - 1]
+      if (!isList(last)) {
+        handleRuntimeError(
+          context,
+          new errors.ExceptionError(new Error('Last argument of apply must be a list'))
+        )
+      }
+      // get the rest of the arguments between the procedure and the last list
+      const rest = args.slice(1, args.length - 1)
+      // convert the last list to an array
+      const lastAsArray = flattenList(last)
+      // combine the rest and the last list
+      const combined = [...rest, ...lastAsArray]
+
+      // push the items back onto the stash
+      stash.push(proc)
+      stash.push(...combined)
+
+      // prepare a function call for the procedure
+      control.push(instr.appInstr(combined.length, command.srcNode))
+      return
+    }
+
+    if (isEval(func)) {
+      // Check for number of arguments mismatch error
+      checkNumberOfArguments(context, func, args, command.srcNode)
+
+      // get the AST from the arguments
+      const AST = args[0]
+
+      // move it to the control
+      control.push(AST)
+      return
+    }
+
     if (isCallWithCurrentContinuation(func)) {
       // Check for number of arguments mismatch error
       checkNumberOfArguments(context, func, args, command.srcNode)
@@ -939,6 +1050,7 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       const contControl = control.copy()
       const contStash = stash.copy()
       const contEnv = context.runtime.environments.slice()
+      const contTransformers = currentTransformers(context)
 
       // at this point, the extra CALL instruction
       // has been removed from the control stack.
@@ -947,9 +1059,15 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       // and additionally, call/cc itself has been removed from the stash.
 
       // as such, there is no further need to modify the
-      // copied C, S and E!
-
-      const continuation = new Continuation(contControl, contStash, contEnv)
+      // copied C, S, E and T!
+
+      const continuation = new Continuation(
+        context,
+        contControl,
+        contStash,
+        contEnv,
+        contTransformers
+      )
 
       // Get the callee
       const cont_callee: Value = args[0]
@@ -971,26 +1089,17 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       // Check for number of arguments mismatch error
       checkNumberOfArguments(context, func, args, command.srcNode)
 
-      // const dummyContCallExpression = makeDummyContCallExpression('f', 'cont')
-
-      // // Restore the state of the stash,
-      // // but replace the function application instruction with
-      // // a resume continuation instruction
-      // stash.push(func)
-      // // we need to push the arguments back onto the stash
-      // // as well
-      // stash.push(...args)
-      // control.push(instr.resumeContInstr(command.numOfArgs, dummyContCallExpression))
-
       // get the C, S, E from the continuation
       const contControl = func.getControl()
       const contStash = func.getStash()
       const contEnv = func.getEnv()
+      const contTransformers = func.getTransformers()
 
       // update the C, S, E of the current context
       control.setTo(contControl)
       stash.setTo(contStash)
       context.runtime.environments = contEnv
+      setTransformers(context, contTransformers)
 
       // push the arguments back onto the stash
       stash.push(...args)
@@ -1006,12 +1115,18 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       // Push ENVIRONMENT instruction if needed - if next control stack item
       // exists and is not an environment instruction, OR the control only contains
       // environment indepedent items
+      // if the current language is a scheme language, don't avoid the environment instruction
+      // as schemers like using the REPL, and that always assumes that the environment is reset
+      // to the main environment.
       if (
-        next &&
-        !(isInstr(next) && next.instrType === InstrType.ENVIRONMENT) &&
-        !control.canAvoidEnvInstr()
+        (next &&
+          !(isInstr(next) && next.instrType === InstrType.ENVIRONMENT) &&
+          !control.canAvoidEnvInstr()) ||
+        isSchemeLanguage(context)
       ) {
-        control.push(instr.envInstr(currentEnvironment(context), command.srcNode))
+        control.push(
+          instr.envInstr(currentEnvironment(context), currentTransformers(context), command.srcNode)
+        )
       }
 
       // Create environment for function parameters if the function isn't nullary.
@@ -1037,6 +1152,9 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
         control.push(func.node.body)
       }
 
+      // we need to update the transformers environment here.
+      const newTransformers = new Transformers(func.transformers)
+      setTransformers(context, newTransformers)
       return
     }
 
@@ -1119,6 +1237,8 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
     while (currentEnvironment(context).id !== command.env.id) {
       popEnvironment(context)
     }
+    // restore transformers environment
+    setTransformers(context, command.transformers)
   },
 
   [InstrType.ARRAY_LITERAL]: function (
diff --git a/src/cse-machine/macro-utils.ts b/src/cse-machine/macro-utils.ts
new file mode 100644
index 000000000..195399f09
--- /dev/null
+++ b/src/cse-machine/macro-utils.ts
@@ -0,0 +1,101 @@
+import { List, Pair } from '../stdlib/list'
+
+/**
+ * Low-level check for a list.
+ * @param value any value
+ * @returns whether the value is a list
+ */
+export function isList(value: any): value is List {
+  if (value === null) {
+    return true
+  }
+  return Array.isArray(value) && value.length === 2 && isList(value[1])
+}
+
+/**
+ * Turn a list into an array.
+ * @param value a list
+ * @returns
+ */
+export function flattenList(value: List): any[] {
+  if (value === null) {
+    return []
+  }
+  return [value[0], ...flattenList(value[1])]
+}
+
+/**
+ * Convert an array into a list.
+ * @param arr
+ * @returns
+ */
+export function arrayToList(arr: any[]): List {
+  return arrayToImproperList(arr, null) as List
+}
+
+/**
+ * Convert an array into an improper list.
+ * @param arr
+ * @param last
+ * @returns
+ */
+export function arrayToImproperList(arr: any[], last: any): any {
+  if (arr.length === 0) {
+    return last
+  }
+  const pair: any[] = [arr[0], arrayToImproperList(arr.slice(1), last)] as any[]
+  ;(pair as any).pair = true
+  return pair
+}
+
+/**
+ * Check if a value is an improper list.
+ * We force an improper list to be an array of two elements.
+ * @param value
+ * @returns
+ */
+export function isImproperList(value: any): value is Pair<any, any> {
+  if (value === null) {
+    return false
+  }
+  return Array.isArray(value) && value.length === 2 && !isList(value[1])
+}
+
+/**
+ * Check if a value is a pair.
+ * @param value
+ * @returns
+ */
+export function isPair(value: any): value is Pair<any, any> {
+  return Array.isArray(value) && value.length === 2
+}
+
+/**
+ * Convert an improper list into an array and a terminator.
+ * @param value
+ * @returns
+ */
+export function flattenImproperList(value: any): [any[], any] {
+  let items = []
+  let working = value
+  while (working instanceof Array && working.length === 2) {
+    items.push(working[0])
+    working = working[1]
+  }
+  return [items, working]
+}
+
+/**
+ * Get the length of an improper list.
+ * @param value
+ * @returns
+ */
+export function improperListLength(value: any): number {
+  let length = 0
+  let working = value
+  while (isPair(working)) {
+    length++
+    working = working[1]
+  }
+  return length
+}
diff --git a/src/cse-machine/patterns.ts b/src/cse-machine/patterns.ts
new file mode 100644
index 000000000..6ccaa6cec
--- /dev/null
+++ b/src/cse-machine/patterns.ts
@@ -0,0 +1,563 @@
+// a single transformer stored within the transformers component
+// will be henceforth referred to as a "transformer".
+// it consists of a set of literals used as additional syntax,
+// a pattern (for a list to match against)
+// and a final template (for the list to be transformed into).
+import { List, Pair } from '../stdlib/list'
+import { _Symbol } from '../alt-langs/scheme/scm-slang/src/stdlib/base'
+import {
+  arrayToImproperList,
+  arrayToList,
+  flattenList,
+  improperListLength,
+  isImproperList,
+  isPair,
+  isList
+} from './macro-utils'
+import { atomic_equals, is_number } from '../alt-langs/scheme/scm-slang/src/stdlib/core-math'
+
+// a single pattern stored within the patterns component
+// may have several transformers attributed to it.
+export class Transformer {
+  literals: string[]
+  pattern: List
+  template: List
+
+  constructor(literals: string[], pattern: List, template: List) {
+    this.literals = literals
+    this.pattern = pattern
+    this.template = template
+  }
+}
+
+// given a matching transformer,
+// the macro_transform() function will transform a list
+// into the template of the transformer.
+export function macro_transform(input: any, transformer: Transformer): any {
+  const collected = collect(input, transformer.pattern, transformer.literals)
+  return transform(transformer.template, collected)
+}
+
+// we use the match() function to match a list against a pattern and literals
+// and verify if it is a match.
+export function match(input: any, pattern: any, literals: string[]): boolean {
+  // we should compare the input and pattern based on the possible forms of pattern:
+  // 1. an identifier
+  // 2. a literal such as null, a number, a string, or a boolean
+  // 3. (<pattern>+)
+  // 4. (<pattern>+ . <pattern>)
+  // 5. (<pattern>+ ... <pattern>+)
+  // 6. (<pattern>+ ... <pattern>+ . <pattern>)
+
+  // case 1
+  if (pattern instanceof _Symbol && literals.includes(pattern.sym)) {
+    return input instanceof _Symbol && input.sym === pattern.sym
+  }
+
+  if (pattern instanceof _Symbol) {
+    return !(input instanceof _Symbol && literals.includes(input.sym))
+  }
+
+  // case 2
+  if (pattern === null) {
+    return input === null
+  }
+
+  if (is_number(pattern)) {
+    return is_number(input) && atomic_equals(input, pattern)
+  }
+
+  if (typeof pattern === 'string' || typeof pattern === 'boolean' || typeof pattern === 'number') {
+    return input === pattern
+  }
+
+  // case 3 and 5
+  if (isList(pattern)) {
+    if (!isList(input)) {
+      return false
+    }
+    const inputList = flattenList(input)
+    const patternList = flattenList(pattern)
+    // there can be a single ellepsis in the pattern, but it must be behind some element.
+    // scan the pattern for the ... symbol.
+    // we will need the position of the ... symbol to compare the front and back of the list.
+    const ellipsisIndex = patternList.findIndex(
+      elem => elem instanceof _Symbol && elem.sym === '...'
+    )
+
+    // case 5
+    if (ellipsisIndex !== -1) {
+      // if the input is shorter than the pattern (minus the ... and matching pattern), it can't match.
+      if (inputList.length < patternList.length - 2) {
+        return false
+      }
+
+      const frontPatternLength = ellipsisIndex - 1
+      const ellipsisPattern = patternList[ellipsisIndex - 1]
+      const backPatternLength = patternList.length - ellipsisIndex - 1
+
+      // compare the front of the list with the front of the pattern as per normal
+      for (let i = 0; i < frontPatternLength; i++) {
+        if (!match(inputList[i], patternList[i], literals)) {
+          return false
+        }
+      }
+
+      // compare the items that should be captured by the ellipsis
+      for (let i = frontPatternLength; i < inputList.length - backPatternLength; i++) {
+        if (!match(inputList[i], ellipsisPattern, literals)) {
+          return false
+        }
+      }
+
+      // now we can compare the back of the list with the rest of the patterns
+      for (let i = inputList.length - backPatternLength; i < inputList.length; i++) {
+        if (
+          !match(inputList[i], patternList[i - (inputList.length - patternList.length)], literals)
+        ) {
+          return false
+        }
+      }
+
+      // else all is good and return true
+      return true
+    }
+
+    // case 3
+    if (inputList.length !== patternList.length) {
+      return false
+    }
+    for (let i = 0; i < inputList.length; i++) {
+      if (!match(inputList[i], patternList[i], literals)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  // case 4 and 6
+  if (isImproperList(pattern)) {
+    // if the input is not a pair, it can't match.
+    if (!isPair(input)) {
+      return false
+    }
+
+    let currEllipsisPattern
+    let currentPattern = pattern
+    let currentInput = input
+    let ellipsisFound = false
+
+    // iterate through currentPattern while it is a pair
+    while (isPair(currentPattern)) {
+      if (!isPair(currentInput)) {
+        return false
+      }
+      const [headPattern, tailPattern] = currentPattern
+      const [headInput, tailInput] = currentInput
+
+      // we can lookahead to see if the ellipsis symbol is the next pattern element.
+      if (
+        isPair(tailPattern) &&
+        tailPattern[0] instanceof _Symbol &&
+        tailPattern[0].sym === '...'
+      ) {
+        ellipsisFound = true
+        currEllipsisPattern = headPattern
+        // skip ahead to the (cddr pattern) for the next iteration
+        // the cddr is what "remains" of the pattern after the ellipsis.
+        currentPattern = tailPattern[1]
+        continue
+      }
+
+      // if the ellipis is found, continue to match the pattern until the ellipsis is exhausted.
+      // (this is done by comparing the length of the input to the length of the remaining pattern)
+      if (ellipsisFound && improperListLength(currentInput) > improperListLength(currentPattern)) {
+        // match the headInput with the currEllipsisPattern
+        if (!match(headInput, currEllipsisPattern, literals)) {
+          return false
+        }
+        currentInput = tailInput // move to the next input
+        continue
+      }
+
+      // if the ellipsis symbol is not found, or we have already matched the ellipsis pattern,
+      // match the headInput with the headPattern
+      if (!match(headInput, headPattern, literals)) {
+        return false
+      }
+      currEllipsisPattern = headPattern
+      currentPattern = tailPattern
+      currentInput = tailInput
+    }
+    // now we can compare the last item in the pattern with the rest of the input
+    return match(currentInput, currentPattern, literals)
+  }
+
+  return false
+}
+
+// once a pattern is matched, we need to collect all of the matched variables.
+// ONLY called on matching patterns.
+export function collect(input: any, pattern: any, literals: string[]): Map<string, any[]> {
+  const collected = new Map<string, (List | _Symbol)[]>()
+  // we should compare the input and pattern based on the possible forms of pattern:
+  // 1. an identifier
+  // 2. a literal such as null, a number, a string, or a boolean
+  // 3. (<pattern>+)
+  // 4. (<pattern>+ . <pattern>)
+  // 5. (<pattern>+ ... <pattern>+)
+  // 6. (<pattern>+ ... <pattern>+ . <pattern>)
+
+  // case 1
+  if (pattern instanceof _Symbol && !literals.includes(pattern.sym)) {
+    if (!collected.has(pattern.sym)) {
+      collected.set(pattern.sym, [])
+    }
+    collected.get(pattern.sym)?.push(input)
+    return collected
+  }
+
+  // case 2
+  if (pattern === null) {
+    return collected
+  }
+
+  if (is_number(pattern)) {
+    return collected
+  }
+
+  if (typeof pattern === 'string' || typeof pattern === 'boolean' || typeof pattern === 'number') {
+    return collected
+  }
+
+  // cases 3 and 5
+  if (isList(pattern)) {
+    const inputList = flattenList(input)
+    const patternList = flattenList(pattern)
+    const ellipsisIndex = patternList.findIndex(
+      elem => elem instanceof _Symbol && elem.sym === '...'
+    )
+
+    // case 5
+    if (ellipsisIndex !== -1) {
+      const frontPatternLength = ellipsisIndex - 1
+      const ellipsisPattern = patternList[ellipsisIndex - 1]
+      const backPatternLength = patternList.length - ellipsisIndex - 1
+
+      for (let i = 0; i < frontPatternLength; i++) {
+        const val = collect(inputList[i], patternList[i], literals)
+        for (let [key, value] of val) {
+          if (!collected.has(key)) {
+            collected.set(key, [])
+          }
+          collected.get(key)?.push(...value)
+        }
+      }
+
+      for (let i = frontPatternLength; i < inputList.length - backPatternLength; i++) {
+        const val = collect(inputList[i], ellipsisPattern, literals)
+        for (let [key, value] of val) {
+          if (!collected.has(key)) {
+            collected.set(key, [])
+          }
+          collected.get(key)?.push(...value)
+        }
+      }
+
+      for (let i = inputList.length - backPatternLength; i < inputList.length; i++) {
+        const val = collect(
+          inputList[i],
+          patternList[i - (inputList.length - patternList.length)],
+          literals
+        )
+        for (let [key, value] of val) {
+          if (!collected.has(key)) {
+            collected.set(key, [])
+          }
+          collected.get(key)?.push(...value)
+        }
+      }
+      return collected
+    }
+
+    // case 3
+    for (let i = 0; i < inputList.length; i++) {
+      const val = collect(inputList[i], patternList[i], literals)
+      for (let [key, value] of val) {
+        if (!collected.has(key)) {
+          collected.set(key, [])
+        }
+        collected.get(key)?.push(...value)
+      }
+    }
+    return collected
+  }
+
+  // case 4 and 6
+  if (isImproperList(pattern)) {
+    let currEllipsisPattern
+    let currentPattern = pattern
+    let currentInput = input
+    let ellipsisFound = false
+
+    // iterate through currentPattern while it is a pair
+    while (isPair(currentPattern)) {
+      const [headPattern, tailPattern] = currentPattern
+      const [headInput, tailInput] = currentInput
+
+      // we can lookahead to see if the ellipsis symbol is the next pattern element.
+      if (
+        isPair(tailPattern) &&
+        tailPattern[0] instanceof _Symbol &&
+        tailPattern[0].sym === '...'
+      ) {
+        ellipsisFound = true
+        currEllipsisPattern = headPattern
+        // skip ahead to the (cddr pattern) for the next iteration
+        // the cddr is what "remains" of the pattern after the ellipsis.
+        currentPattern = tailPattern[1]
+        continue
+      }
+
+      // if the ellipis is found, continue to match the pattern until the ellipsis is exhausted.
+      // (this is done by comparing the length of the input to the length of the remaining pattern)
+      // it may be the case that the ellipsis pattern is not matched at all.
+      if (ellipsisFound && improperListLength(currentInput) > improperListLength(currentPattern)) {
+        const val = collect(headInput, currEllipsisPattern, literals)
+        for (let [key, value] of val) {
+          if (!collected.has(key)) {
+            collected.set(key, [])
+          }
+          collected.get(key)?.push(...value)
+        }
+        currentInput = tailInput // move to the next input
+        continue
+      }
+
+      // if the ellipsis symbol is not found, or we have already matched the ellipsis pattern,
+      // match the headInput with the headPattern
+      const val = collect(headInput, headPattern, literals)
+      for (let [key, value] of val) {
+        if (!collected.has(key)) {
+          collected.set(key, [])
+        }
+        collected.get(key)?.push(...value)
+      }
+      currEllipsisPattern = headPattern
+      currentPattern = tailPattern
+      currentInput = tailInput
+    }
+    // now we can compare the last item in the pattern with the rest of the input
+    const val = collect(currentInput, currentPattern, literals)
+    for (let [key, value] of val) {
+      if (!collected.has(key)) {
+        collected.set(key, [])
+      }
+      collected.get(key)?.push(...value)
+    }
+    return collected
+  }
+
+  return collected
+}
+
+// when matched against a pattern, we use the transform() function
+// to transform the list into the template.
+// returns a list, a pair, or any value, as determined by the template.
+export function transform(
+  template: any,
+  collected: Map<string, any[]>,
+  indexToCollect: number = 0
+): any {
+  // there are 5 possible forms of the template:
+  // 1. an identifier
+  // 2. a literal such as null, a number, a string, or a boolean
+  // 3. (... <template>)
+  // 4. (<element>+)
+  // 5. (<element>+ . <template>)
+  // where <element> is <template> | <template> ...
+
+  // case 1
+  if (template instanceof _Symbol) {
+    if (collected.has(template.sym)) {
+      // get the item from the collected list,
+      // remove it from the collected list,
+      // and return it.
+      const item = (collected.get(template.sym) as any[])[indexToCollect]
+      return item
+    }
+    return template
+  }
+
+  // case 2
+  if (template === null) {
+    return null
+  }
+
+  if (
+    typeof template === 'string' ||
+    typeof template === 'boolean' ||
+    typeof template === 'number'
+  ) {
+    return template
+  }
+
+  if (is_number(template)) {
+    return template
+  }
+
+  // case 3
+  if (
+    isList(template) &&
+    template !== null &&
+    template[0] instanceof _Symbol &&
+    template[0].sym === '...'
+  ) {
+    // parser should ensure that the ellipsis is followed by a single value.
+    // this value is the template to be used.
+    // get the cadr of the template and return it.
+    return template[1][0]
+  }
+
+  // collects all items in an ellipsis template to be used in the final list.
+  // helper function for dealing with ellipsis templates.
+  function deepFlatten(pair: Pair<any, any>): _Symbol[] {
+    const items: _Symbol[] = []
+    function flattenHelper(item: any) {
+      if (item instanceof _Symbol && item.sym !== '...') {
+        items.push(item)
+      } else if (item === null) {
+        return
+      } else if (item instanceof Array && item.length === 2) {
+        // based on the usage of (... <value>),
+        // and our previous discussion on the viability
+        // of ... within the ellipsis template
+        // we can assume that any ellipsis used is used to halt macro expansion of <value>.
+        if (item[0] instanceof _Symbol && item[0].sym === '...') {
+          // do not collect any items here, this halts the collection
+          return
+        }
+        // if its a pair, traverse both car and cdr
+        flattenHelper(item[0])
+        flattenHelper(item[1])
+      }
+    }
+    flattenHelper(pair)
+    return items
+  }
+
+  // case 4
+  if (isList(template)) {
+    const templateList = flattenList(template)
+    const transformedList: any[] = []
+    for (let i = 0; i < templateList.length; i++) {
+      if (templateList[i] instanceof _Symbol && templateList[i].sym === '...') {
+        // if the ellipsis symbol is found, we can skip ahead to the next template
+        // as the ellipsis symbol is not used in the transformation.
+        continue
+      }
+      // lookahead for the ellipsis symbol
+      if (
+        i + 1 < templateList.length &&
+        templateList[i + 1] instanceof _Symbol &&
+        templateList[i + 1].sym === '...'
+      ) {
+        const currEllipsisPattern = templateList[i]
+        const items = deepFlatten(currEllipsisPattern)
+        // add items to the transformed list
+        // until the templates are exhausted.
+        let currIndex = 0
+        while (true) {
+          // check if all items are exhausted
+          let itemsAreExhausted = false
+          for (let j = 0; j < items.length; j++) {
+            if (!collected.has(items[j].sym)) {
+              itemsAreExhausted = true
+              break
+            }
+            if (
+              collected.has(items[j].sym) &&
+              currIndex >= (collected.get(items[j].sym) as any[]).length
+            ) {
+              itemsAreExhausted = true
+              break
+            }
+          }
+          if (itemsAreExhausted) {
+            break
+          }
+          // apply the last ellipsis template again
+          transformedList.push(transform(currEllipsisPattern, collected, currIndex))
+          currIndex++
+        }
+        continue
+      }
+      transformedList.push(transform(templateList[i], collected))
+    }
+    return arrayToList(transformedList)
+  }
+
+  // case 5
+  if (isImproperList(template)) {
+    let currEllipsisPattern: any = undefined
+    let currentPattern = template
+
+    let collectedItems: any[] = []
+
+    // iterate through currentPattern while it is a pair
+    while (isPair(currentPattern)) {
+      const [headPattern, tailPattern] = currentPattern
+
+      // we can lookahead to see if the ellipsis symbol is the next pattern element.
+      if (
+        isPair(tailPattern) &&
+        tailPattern[0] instanceof _Symbol &&
+        tailPattern[0].sym === '...'
+      ) {
+        currEllipsisPattern = headPattern
+        // skip ahead to the (cddr pattern) for the next iteration
+        // the cddr is what "remains" of the pattern after the ellipsis.
+        currentPattern = tailPattern[1]
+        continue
+      }
+
+      // if a current ellipsis pattern exists, we continue collecting items from it until it is exhausted.
+      // then we undefine the current ellipsis pattern.
+      if (currEllipsisPattern !== undefined) {
+        const items = deepFlatten(currEllipsisPattern)
+        let currIndex = 0
+        while (true) {
+          // check if all items are exhausted
+          let itemsAreExhausted = false
+          for (let i = 0; i < items.length; i++) {
+            if (!collected.has(items[i].sym)) {
+              itemsAreExhausted = true
+              break
+            }
+            if (
+              collected.has(items[i].sym) &&
+              currIndex >= (collected.get(items[i].sym) as any[]).length
+            ) {
+              itemsAreExhausted = true
+              break
+            }
+          }
+          if (itemsAreExhausted) {
+            break
+          }
+          // add the ellipsis pattern to the collected items
+          collectedItems.push(transform(currEllipsisPattern, collected, currIndex))
+          currIndex++
+        }
+        currEllipsisPattern = undefined
+        continue
+      }
+      collectedItems.push(transform(headPattern, collected))
+      currentPattern = tailPattern
+    }
+    // now we can compare the last item in the pattern with the rest of the input
+    const val = transform(currentPattern, collected)
+    return arrayToImproperList(collectedItems, val)
+  }
+  return template
+}
diff --git a/src/cse-machine/scheme-macros.ts b/src/cse-machine/scheme-macros.ts
new file mode 100644
index 000000000..ce8e7f769
--- /dev/null
+++ b/src/cse-machine/scheme-macros.ts
@@ -0,0 +1,664 @@
+import * as es from 'estree'
+import * as errors from '../errors/errors'
+import { List } from '../stdlib/list'
+import { _Symbol } from '../alt-langs/scheme/scm-slang/src/stdlib/base'
+import { is_number, SchemeNumber } from '../alt-langs/scheme/scm-slang/src/stdlib/core-math'
+import { Context } from '..'
+import { Control, Stash } from './interpreter'
+import { currentTransformers, getVariable, handleRuntimeError } from './utils'
+import { Transformer, macro_transform, match } from './patterns'
+import {
+  arrayToImproperList,
+  arrayToList,
+  flattenImproperList,
+  isImproperList
+} from './macro-utils'
+import { ControlItem } from './types'
+import { encode } from '../alt-langs/scheme/scm-slang/src'
+import { popInstr } from './instrCreator'
+import { flattenList, isList } from './macro-utils'
+
+// this needs to be better but for now it's fine
+export type SchemeControlItems = List | _Symbol | SchemeNumber | boolean | string
+
+/**
+ * A metaprocedure used to detect for the apply function object.
+ * If the interpreter sees this specific function,
+ * it will take all of the operands, and apply the second to second last operands as well as the last operand (must be a list)
+ * to the first operand (which must be a function).
+ */
+export class Apply extends Function {
+  private static instance: Apply = new Apply()
+
+  private constructor() {
+    super()
+  }
+
+  public static get(): Apply {
+    return Apply.instance
+  }
+
+  public toString(): string {
+    return 'apply'
+  }
+}
+
+export const cset_apply = Apply.get()
+
+export function isApply(value: any): boolean {
+  return value === cset_apply
+}
+
+/**
+ * A metaprocedure used to detect for the eval function object.
+ * If the interpreter sees this specific function,
+ * it will transfer its operand to the control component.
+ */
+export class Eval extends Function {
+  private static instance: Eval = new Eval()
+
+  private constructor() {
+    super()
+  }
+
+  public static get(): Eval {
+    return Eval.instance
+  }
+
+  public toString(): string {
+    return 'eval'
+  }
+}
+
+export const cset_eval = Eval.get()
+
+export function isEval(value: any): boolean {
+  return value === cset_eval
+}
+
+function isSpecialForm(sym: _Symbol): boolean {
+  return [
+    'lambda',
+    'define',
+    'set!',
+    'if',
+    'begin',
+    'quote',
+    'quasiquote',
+    'define-syntax',
+    'syntax-rules',
+    'eval'
+  ].includes(sym.sym)
+}
+
+export function schemeEval(
+  command: SchemeControlItems,
+  context: Context,
+  control: Control,
+  stash: Stash,
+  isPrelude: boolean
+) {
+  const transformers = currentTransformers(context)
+  // scheme CSE machine will only ever encounter
+  // lists or primitives like symbols, booleans or strings.
+  // if its a list, we can parse the list and evaluate each item as necessary
+  // if its a symbol, we can look up the symbol in the environment.
+  // for either of these operations, if our list matches some pattern in
+  // the T component, then we can apply the corresponding rule.
+
+  // if its a number, boolean, or string, we can just shift the value
+  // onto the stash.
+
+  if (command === null) {
+    return handleRuntimeError(context, new errors.ExceptionError(new Error('Cannot evaluate null')))
+  }
+
+  if (isList(command)) {
+    // do something
+    const parsedList = flattenList(command)
+    const elem = parsedList[0]
+    // do work based on the first element of the list.
+    // it should match some symbol "define", "set", "lambda", etc...
+    // or if it doesn't match any of these, then it is a function call.
+    if (elem instanceof _Symbol) {
+      // check if elem matches any defined syntax in the T component.
+      // if it does, then apply the corresponding rule.
+      if (transformers.hasPattern(elem.sym)) {
+        // get the relevant transformers
+        const transformerList: Transformer[] = transformers.getPattern(elem.sym)
+
+        // find the first matching transformer
+        for (const transformer of transformerList) {
+          // check if the transformer matches the list
+          try {
+            if (match(command, transformer.pattern, transformer.literals)) {
+              // if it does, apply the transformer
+              const transformedMacro = macro_transform(command as List, transformer)
+              control.push(transformedMacro as ControlItem)
+              return
+            }
+          } catch (e) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(
+                new Error(
+                  'Error in macro-expanding ' +
+                    elem.sym +
+                    '! Are the template and pattern well formed?'
+                )
+              )
+            )
+          }
+        }
+
+        // there is an error if we get to here
+        return handleRuntimeError(
+          context,
+          new errors.ExceptionError(
+            new Error('No matching transformer found for macro ' + elem.sym)
+          )
+        )
+      }
+
+      // else, this is a standard special form.
+      // we attempt to piggyback on the standard CSE machine to
+      // handle the basic special forms.
+      // however, for more advanced stuff like quotes or definitions,
+      // the logic will be handled here.
+      switch (parsedList[0].sym) {
+        case 'lambda':
+          if (parsedList.length < 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('lambda requires at least 2 arguments!'))
+            )
+          }
+          // return a lambda expression that takes
+          // in the arguments, and returns the body
+          // as an eval of the body.
+          const args = parsedList[1]
+
+          let argsList: _Symbol[] = []
+          let rest: _Symbol | null = null
+          if (args instanceof _Symbol) {
+            // if the args is a symbol, then it is a variadic function.
+            // we can just set the args to a list of the symbol.
+            rest = args
+          } else if (isImproperList(args)) {
+            ;[argsList, rest] = flattenImproperList(args)
+            argsList.forEach((arg: any) => {
+              if (!(arg instanceof _Symbol)) {
+                return handleRuntimeError(
+                  context,
+                  new errors.ExceptionError(new Error('Invalid arguments for lambda!'))
+                )
+              }
+              return
+            })
+            if (rest !== null && !(rest instanceof _Symbol)) {
+              return handleRuntimeError(
+                context,
+                new errors.ExceptionError(new Error('Invalid arguments for lambda!'))
+              )
+            }
+          } else if (isList(args)) {
+            argsList = flattenList(args) as _Symbol[]
+            argsList.forEach((arg: any) => {
+              if (!(arg instanceof _Symbol)) {
+                return handleRuntimeError(
+                  context,
+                  new errors.ExceptionError(new Error('Invalid arguments for lambda!'))
+                )
+              }
+              return
+            })
+          } else {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('Invalid arguments for lambda!'))
+            )
+          }
+
+          // convert the args to estree pattern
+          const params: (es.Identifier | es.RestElement)[] = argsList.map(arg =>
+            makeDummyIdentifierNode(encode(arg.sym))
+          )
+
+          let body_elements = parsedList.slice(2)
+          let body: List = arrayToList([new _Symbol('begin'), ...body_elements])
+
+          // if there is a rest argument, we need to wrap it in a rest element.
+          // we also need to add another element to the body,
+          // to convert the rest element into a list.
+          if (rest !== null) {
+            params.push({
+              type: 'RestElement',
+              argument: makeDummyIdentifierNode(encode(rest.sym))
+            })
+            body = arrayToList([
+              new _Symbol('begin'),
+              arrayToList([
+                new _Symbol('set!'),
+                rest,
+                arrayToList([new _Symbol('vector->list'), rest])
+              ]),
+              ...body_elements
+            ])
+          }
+
+          // estree ArrowFunctionExpression
+          const lambda = {
+            type: 'ArrowFunctionExpression',
+            params: params,
+            body: convertToEvalExpression(body)
+          }
+
+          control.push(lambda as es.ArrowFunctionExpression)
+          return
+
+        case 'define':
+          if (parsedList.length < 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('define requires at least 2 arguments!'))
+            )
+          }
+          const variable = parsedList[1]
+          if (isList(variable)) {
+            // then this define is actually a function definition
+            const varList = flattenList(variable)
+            const name = varList[0]
+            const params = varList.slice(1)
+            const body = parsedList.slice(2)
+
+            const define_function = arrayToList([
+              new _Symbol('define'),
+              name,
+              arrayToList([new _Symbol('lambda'), arrayToList(params), ...body])
+            ])
+            control.push(define_function as any)
+            return
+          } else if (isImproperList(variable)) {
+            const [varList, rest] = flattenImproperList(variable)
+            const name = varList[0]
+            const params = varList.slice(1)
+            const body = parsedList.slice(2)
+
+            const define_function = arrayToList([
+              new _Symbol('define'),
+              name,
+              arrayToList([new _Symbol('lambda'), arrayToImproperList(params, rest), ...body])
+            ])
+            control.push(define_function as any)
+            return
+          } else if (!(variable instanceof _Symbol)) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('Invalid variable for define!'))
+            )
+          }
+          if (parsedList.length !== 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('define requires 2 arguments!'))
+            )
+          }
+          // make sure variable does not shadow a special form
+          if (isSpecialForm(variable) && !isPrelude) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(
+                new Error('Cannot shadow special form ' + variable.sym + ' with a definition!')
+              )
+            )
+          }
+          const value = parsedList[2]
+          // estree VariableDeclaration
+          const definition = {
+            type: 'VariableDeclaration',
+            kind: 'let',
+            declarations: [
+              {
+                type: 'VariableDeclarator',
+                id: makeDummyIdentifierNode(encode(variable.sym)),
+                init: convertToEvalExpression(value)
+              }
+            ]
+          }
+
+          control.push(definition as es.VariableDeclaration)
+          return
+        case 'set!':
+          if (parsedList.length !== 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('set! requires 2 arguments!'))
+            )
+          }
+          const set_variable = parsedList[1]
+          if (!(set_variable instanceof _Symbol)) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('Invalid arguments for set!'))
+            )
+          }
+          // make sure set_variable does not shadow a special form
+          if (isSpecialForm(set_variable) && !isPrelude) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(
+                new Error('Cannot overwrite special form ' + set_variable.sym + ' with a value!')
+              )
+            )
+          }
+          const set_value = parsedList[2]
+
+          // estree AssignmentExpression
+          const assignment = {
+            type: 'AssignmentExpression',
+            operator: '=',
+            left: makeDummyIdentifierNode(encode(set_variable.sym)),
+            right: convertToEvalExpression(set_value)
+          }
+
+          control.push(assignment as es.AssignmentExpression)
+          return
+        case 'if':
+          if (parsedList.length < 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('if requires at least 2 arguments!'))
+            )
+          }
+          if (parsedList.length > 4) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('if requires at most 3 arguments!'))
+            )
+          }
+          const condition = parsedList[1]
+          const consequent = parsedList[2]
+          // check if there is an alternate
+          const alternate = parsedList.length > 3 ? parsedList[3] : undefined
+
+          // evaluate the condition with truthy
+          const truthyCondition = arrayToList([new _Symbol('truthy'), condition])
+
+          // estree ConditionalExpression
+          const conditional = {
+            type: 'ConditionalExpression',
+            test: convertToEvalExpression(truthyCondition),
+            consequent: convertToEvalExpression(consequent),
+            alternate: alternate ? convertToEvalExpression(alternate) : undefined
+          }
+
+          control.push(conditional as es.ConditionalExpression)
+          return
+        case 'begin':
+          // begin is a sequence of expressions
+          // that are evaluated in order.
+          // push the expressions to the control in reverse
+          // order.
+          if (parsedList.length < 2) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('begin requires at least 1 argument!'))
+            )
+          }
+
+          control.push(parsedList[parsedList.length - 1])
+          for (let i = parsedList.length - 2; i > 0; i--) {
+            control.push(popInstr(makeDummyIdentifierNode('pop')))
+            control.push(parsedList[i])
+          }
+          return
+        case 'quote':
+          // quote is a special form that returns the expression
+          // as is, without evaluating it.
+          // we can just push the expression to the stash.
+          if (parsedList.length !== 2) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('quote requires 1 argument!'))
+            )
+          }
+          stash.push(parsedList[1])
+          return
+        // case 'quasiquote': quasiquote is implemented as a macro.
+        case 'define-syntax':
+          if (parsedList.length !== 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('define-syntax requires 2 arguments!'))
+            )
+          }
+          // parse the pattern and template here,
+          // generate a list of transformers from it,
+          // and add it to the Patterns component.
+          const syntaxName = parsedList[1]
+          if (!(syntaxName instanceof _Symbol)) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('define-syntax requires a symbol!'))
+            )
+          }
+          // make sure syntaxName does not shadow a special form
+          if (isSpecialForm(syntaxName) && !isPrelude) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(
+                new Error('Cannot shadow special form ' + syntaxName.sym + ' with a macro!')
+              )
+            )
+          }
+          const syntaxRules = parsedList[2]
+          if (!isList(syntaxRules)) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(
+                new Error('define-syntax requires a syntax-rules transformer!')
+              )
+            )
+          }
+
+          // at this point, we assume that syntax-rules is verified
+          // and parsed correctly already.
+          const syntaxRulesList = flattenList(syntaxRules)
+          if (
+            !(syntaxRulesList[0] instanceof _Symbol) ||
+            syntaxRulesList[0].sym !== 'syntax-rules'
+          ) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(
+                new Error('define-syntax requires a syntax-rules transformer!')
+              )
+            )
+          }
+          if (syntaxRulesList.length < 3) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('syntax-rules requires at least 2 arguments!'))
+            )
+          }
+          if (!isList(syntaxRulesList[1])) {
+            return handleRuntimeError(
+              context,
+              new errors.ExceptionError(new Error('Invalid syntax-rules literals!'))
+            )
+          }
+          const literalList = flattenList(syntaxRulesList[1])
+          const literals: string[] = literalList.map((literal: _Symbol) => {
+            if (!(literal instanceof _Symbol)) {
+              return handleRuntimeError(
+                context,
+                new errors.ExceptionError(new Error('Invalid syntax-rules literals!'))
+              )
+            }
+            return literal.sym
+          })
+          const rules = syntaxRulesList.slice(2)
+          // rules are set as a list of patterns and templates.
+          // we need to convert these into transformers.
+          const transformerList: Transformer[] = rules.map(rule => {
+            if (!isList(rule)) {
+              return handleRuntimeError(
+                context,
+                new errors.ExceptionError(new Error('Invalid syntax-rules rule!'))
+              )
+            }
+            const ruleList = flattenList(rule)
+            const pattern = ruleList[0]
+            const template = ruleList[1]
+            return new Transformer(literals, pattern, template)
+          })
+          // now we can add the transformers to the transformers component.
+          transformers.addPattern(syntaxName.sym, transformerList)
+
+          // for consistency with scheme expecting undefined return values, push undefined to the stash.
+          stash.push(undefined)
+          return
+        case 'syntax-rules':
+          // syntax-rules is a special form that is used to define
+          // a set of transformers.
+          // it isn't meant to be evaluated outside of a define-syntax.
+          // throw an error.
+          return handleRuntimeError(
+            context,
+            new errors.ExceptionError(
+              new Error('syntax-rules must only exist within define-syntax!')
+            )
+          )
+      }
+    }
+    // if we get to this point, then it is a function call.
+    // convert it into an es.CallExpression and push it to the control.
+    const procedure = parsedList[0]
+    const args = parsedList.slice(1)
+    const appln = {
+      type: 'CallExpression',
+      optional: false,
+      callee: convertToEvalExpression(procedure) as es.Expression,
+      arguments: args.map(convertToEvalExpression) // unfortunately, each one needs to be converted.
+    }
+    control.push(appln as es.CallExpression)
+    return
+  } else if (command instanceof _Symbol) {
+    // get the value of the symbol from the environment
+    // associated with this symbol.
+    const encodedName = encode(command.sym)
+    stash.push(getVariable(context, encodedName, makeDummyIdentifierNode(command.sym)))
+    return
+  }
+  // if we get to this point of execution, it is just some primitive value.
+  // just push it to the stash.
+  stash.push(command)
+  return
+}
+
+export function makeDummyIdentifierNode(name: string): es.Identifier {
+  return {
+    type: 'Identifier',
+    name
+  }
+}
+
+/**
+ * Convert a scheme expression (that is meant to be evaluated)
+ * into an estree expression, using eval.
+ * this will let us avoid the "hack" of storing Scheme lists
+ * in estree nodes.
+ * @param expression
+ * @returns estree expression
+ */
+export function convertToEvalExpression(expression: SchemeControlItems): es.CallExpression {
+  function convertToEstreeExpression(expression: SchemeControlItems): es.Expression {
+    /*
+    cases to consider:
+    - list
+    - pair/improper list
+    - symbol
+    - number
+    - boolean
+    - string
+    */
+    if (isList(expression)) {
+      // make a call expression to list
+      // with the elements of the list as its arguments.
+      const args = flattenList(expression).map(convertToEstreeExpression)
+      return {
+        type: 'CallExpression',
+        optional: false,
+        callee: {
+          type: 'Identifier',
+          name: 'list'
+        },
+        arguments: args
+      }
+    } else if (isImproperList(expression)) {
+      // make a call to cons
+      // with the car and cdr as its arguments.
+      const [car, cdr] = expression as [SchemeControlItems, SchemeControlItems]
+      return {
+        type: 'CallExpression',
+        optional: false,
+        callee: {
+          type: 'Identifier',
+          name: 'cons'
+        },
+        arguments: [convertToEstreeExpression(car), convertToEstreeExpression(cdr)]
+      }
+    } else if (expression instanceof _Symbol) {
+      // make a call to string->symbol
+      // with the symbol name as its argument.
+      return {
+        type: 'CallExpression',
+        optional: false,
+        callee: {
+          type: 'Identifier',
+          name: encode('string->symbol')
+        },
+        arguments: [
+          {
+            type: 'Literal',
+            value: expression.sym
+          }
+        ]
+      }
+    } else if (is_number(expression)) {
+      // make a call to string->number
+      // with the number toString() as its argument.
+      return {
+        type: 'CallExpression',
+        optional: false,
+        callee: {
+          type: 'Identifier',
+          name: encode('string->number')
+        },
+        arguments: [
+          {
+            type: 'Literal',
+            value: (expression as any).toString()
+          }
+        ]
+      }
+    }
+    // if we're here, then it is a boolean or string.
+    // just return the literal value.
+    return {
+      type: 'Literal',
+      value: expression as boolean | string
+    }
+  }
+
+  // make a call expression to eval with the single expression as its component.
+  return {
+    type: 'CallExpression',
+    optional: false,
+    callee: {
+      type: 'Identifier',
+      name: encode('eval')
+    },
+    arguments: [convertToEstreeExpression(expression) as es.Expression]
+  }
+}
diff --git a/src/cse-machine/types.ts b/src/cse-machine/types.ts
index c4b5903fb..316578368 100644
--- a/src/cse-machine/types.ts
+++ b/src/cse-machine/types.ts
@@ -2,6 +2,8 @@ import * as es from 'estree'
 
 import { Environment, Node } from '../types'
 import Closure from './closure'
+import { SchemeControlItems } from './scheme-macros'
+import { Transformers } from './interpreter'
 
 export enum InstrType {
   RESET = 'Reset',
@@ -69,6 +71,7 @@ export interface BranchInstr extends BaseInstr {
 
 export interface EnvInstr extends BaseInstr {
   env: Environment
+  transformers: Transformers
 }
 
 export interface ArrLitInstr extends BaseInstr {
@@ -84,7 +87,7 @@ export type Instr =
   | EnvInstr
   | ArrLitInstr
 
-export type ControlItem = (Node | Instr) & {
+export type ControlItem = (Node | Instr | SchemeControlItems) & {
   isEnvDependent?: boolean
 }
 
diff --git a/src/cse-machine/utils.ts b/src/cse-machine/utils.ts
index cd10faea6..e45454531 100644
--- a/src/cse-machine/utils.ts
+++ b/src/cse-machine/utils.ts
@@ -4,11 +4,11 @@ import { isArray, isFunction } from 'lodash'
 import { Context } from '..'
 import * as errors from '../errors/errors'
 import { RuntimeSourceError } from '../errors/runtimeSourceError'
-import type { Environment, Node, StatementSequence, Value } from '../types'
+import { Chapter, type Environment, type Node, type StatementSequence, type Value } from '../types'
 import * as ast from '../utils/ast/astCreator'
 import Heap from './heap'
 import * as instr from './instrCreator'
-import { Control } from './interpreter'
+import { Control, Transformers } from './interpreter'
 import {
   AppInstr,
   EnvArray,
@@ -21,6 +21,26 @@ import {
 } from './types'
 import Closure from './closure'
 import { Continuation, isCallWithCurrentContinuation } from './continuations'
+import { isApply, isEval } from './scheme-macros'
+import { _Symbol } from '../alt-langs/scheme/scm-slang/src/stdlib/base'
+import { is_number } from '../alt-langs/scheme/scm-slang/src/stdlib/core-math'
+
+/**
+ * Typeguard for commands to check if they are scheme values.
+ *
+ * @param command A ControlItem
+ * @returns true if the ControlItem is a scheme value, false otherwise.
+ */
+export const isSchemeValue = (command: ControlItem): boolean => {
+  return (
+    command === null ||
+    typeof command === 'string' ||
+    typeof command === 'boolean' ||
+    isArray(command) ||
+    command instanceof _Symbol ||
+    is_number(command)
+  )
+}
 
 /**
  * Typeguard for Instr to distinguish between program statements and instructions.
@@ -29,6 +49,10 @@ import { Continuation, isCallWithCurrentContinuation } from './continuations'
  * @returns true if the ControlItem is an instruction and false otherwise.
  */
 export const isInstr = (command: ControlItem): command is Instr => {
+  // this prevents us from reading properties of null
+  if (isSchemeValue(command)) {
+    return false
+  }
   return (command as Instr).instrType !== undefined
 }
 
@@ -39,6 +63,10 @@ export const isInstr = (command: ControlItem): command is Instr => {
  * @returns true if the ControlItem is a Node or StatementSequence, false if it is an instruction.
  */
 export const isNode = (command: ControlItem): command is Node => {
+  // this prevents us from reading properties of null
+  if (isSchemeValue(command)) {
+    return false
+  }
   return (command as Node).type !== undefined
 }
 
@@ -242,7 +270,7 @@ export const envChanging = (command: ControlItem): boolean => {
       type === 'ArrowFunctionExpression' ||
       (type === 'ExpressionStatement' && command.expression.type === 'ArrowFunctionExpression')
     )
-  } else {
+  } else if (isInstr(command)) {
     const type = command.instrType
     return (
       type === InstrType.ENVIRONMENT ||
@@ -251,6 +279,12 @@ export const envChanging = (command: ControlItem): boolean => {
       type === InstrType.ARRAY_ASSIGNMENT ||
       (type === InstrType.APPLICATION && (command as AppInstr).numOfArgs > 0)
     )
+  } else {
+    // TODO deal with scheme control items
+    // for now, as per the CSE machine paper,
+    // we decide to ignore environment optimizations
+    // for scheme control items :P
+    return true
   }
 }
 
@@ -270,6 +304,16 @@ export const isSimpleFunction = (node: any) => {
   }
 }
 
+/**
+ * Transformers
+ */
+export const currentTransformers = (context: Context) =>
+  context.runtime.transformers as Transformers
+
+export const setTransformers = (context: Context, transformers: Transformers) => {
+  context.runtime.transformers = transformers
+}
+
 /**
  * Environments
  */
@@ -424,7 +468,12 @@ export function defineVariable(
 ) {
   const environment = currentEnvironment(context)
 
-  if (environment.head[name] !== UNASSIGNED_CONST && environment.head[name] !== UNASSIGNED_LET) {
+  // we disable this check for full scheme due to the inability to scan for variables before usage
+  if (
+    environment.head[name] !== UNASSIGNED_CONST &&
+    environment.head[name] !== UNASSIGNED_LET &&
+    context.chapter !== Chapter.FULL_SCHEME
+  ) {
     return handleRuntimeError(context, new errors.VariableRedeclaration(node, name, !constant))
   }
 
@@ -523,6 +572,24 @@ export const checkNumberOfArguments = (
       )
     }
     return undefined
+  } else if (isEval(callee)) {
+    // eval should have a single argument
+    if (args.length !== 1) {
+      return handleRuntimeError(
+        context,
+        new errors.InvalidNumberOfArguments(exp, 1, args.length, false)
+      )
+    }
+    return undefined
+  } else if (isApply(callee)) {
+    // apply should have at least two arguments
+    if (args.length < 2) {
+      return handleRuntimeError(
+        context,
+        new errors.InvalidNumberOfArguments(exp, 2, args.length, false)
+      )
+    }
+    return undefined
   } else if (callee instanceof Continuation) {
     // Continuations have variadic arguments,
     // and so we can let it pass
@@ -912,11 +979,32 @@ export function isEnvDependent(item: ControlItem | null | undefined): boolean {
   if (item === null || item === undefined) {
     return false
   }
+
+  // Scheme primitives are not environment dependent.
+  if (typeof item === 'string' || typeof item === 'boolean') {
+    return false
+  }
+
+  // Scheme symbols represent identifiers, which are environment dependent.
+  if (item instanceof _Symbol) {
+    return true
+  }
+
+  // We assume no optimisations for scheme lists.
+  if (isArray(item)) {
+    return true
+  }
+
   // If result is already calculated, return it
   if (item.isEnvDependent !== undefined) {
     return item.isEnvDependent
   }
-  const setter = isNode(item) ? propertySetter.get(item.type) : propertySetter.get(item.instrType)
+
+  const setter = isNode(item)
+    ? propertySetter.get(item.type)
+    : isInstr(item)
+    ? propertySetter.get(item.instrType)
+    : undefined
 
   if (setter) {
     return setter(item)?.isEnvDependent ?? false
diff --git a/src/mocks/context.ts b/src/mocks/context.ts
index 7e19650ad..32bfcda21 100644
--- a/src/mocks/context.ts
+++ b/src/mocks/context.ts
@@ -5,6 +5,7 @@ import OldClosure from '../interpreter/closure'
 import Closure from '../cse-machine/closure'
 import { createBlockEnvironment } from '../interpreter/interpreter'
 import { Chapter, Context, Environment, Variant } from '../types'
+import { Transformers } from '../cse-machine/interpreter'
 
 export function mockContext(
   chapter: Chapter = Chapter.SOURCE_1,
@@ -68,7 +69,24 @@ export function mockClosure(cseMachineClosure: true): Closure
 export function mockClosure(cseMachineClosure?: false): OldClosure
 export function mockClosure(cseMachineClosure?: boolean): Closure | OldClosure {
   const context = createContext()
-  return new (cseMachineClosure ? Closure : OldClosure)(
+  if (cseMachineClosure) {
+    return new Closure(
+      {
+        type: 'ArrowFunctionExpression',
+        expression: true,
+        loc: null,
+        params: [],
+        body: {
+          type: 'BlockStatement',
+          body: []
+        }
+      } as es.ArrowFunctionExpression,
+      mockEnvironment(context),
+      mockTransformers(),
+      context
+    )
+  }
+  return new OldClosure(
     {
       type: 'ArrowFunctionExpression',
       expression: true,
@@ -87,3 +105,7 @@ export function mockClosure(cseMachineClosure?: boolean): Closure | OldClosure {
 export function mockEnvironment(context: Context, name = 'blockEnvironment'): Environment {
   return createBlockEnvironment(context, name)
 }
+
+export function mockTransformers(): any {
+  return new Transformers()
+}
diff --git a/src/runner/__tests__/modules.ts b/src/runner/__tests__/modules.ts
index 488cdab65..552b21e99 100644
--- a/src/runner/__tests__/modules.ts
+++ b/src/runner/__tests__/modules.ts
@@ -1,12 +1,12 @@
 import { mockContext } from '../../mocks/context'
-import { Chapter } from '../../types'
+import { Chapter, Variant } from '../../types'
 import { stripIndent } from '../../utils/formatters'
 import { expectFinishedResult } from '../../utils/testing'
 import { runCodeInSource } from '../sourceRunner'
 
 jest.mock('../../modules/loader/loaders')
 
-type DescribeCase = [string, Chapter[], string]
+type DescribeCase = [string, Chapter[], Variant[], string]
 const describeCases: DescribeCase[] = [
   [
     'javascript',
@@ -19,11 +19,21 @@ const describeCases: DescribeCase[] = [
       Chapter.FULL_TS,
       Chapter.LIBRARY_PARSER
     ],
+    [
+      Variant.DEFAULT,
+      Variant.DEFAULT,
+      Variant.DEFAULT,
+      Variant.DEFAULT,
+      Variant.DEFAULT,
+      Variant.DEFAULT,
+      Variant.DEFAULT
+    ],
     'import { foo } from "one_module"; foo();'
   ],
   [
     'python',
     [Chapter.PYTHON_1],
+    [Variant.DEFAULT],
     stripIndent`
     from one_module import foo
     foo()
@@ -32,20 +42,29 @@ const describeCases: DescribeCase[] = [
   [
     'scheme',
     [Chapter.SCHEME_1, Chapter.SCHEME_2, Chapter.SCHEME_3, Chapter.SCHEME_4, Chapter.FULL_SCHEME],
+    [
+      Variant.EXPLICIT_CONTROL,
+      Variant.EXPLICIT_CONTROL,
+      Variant.EXPLICIT_CONTROL,
+      Variant.EXPLICIT_CONTROL,
+      Variant.EXPLICIT_CONTROL
+    ],
     '(import "one_module" (foo)) (foo)'
   ]
 ]
 
 describe.each(describeCases)(
   'Ensuring that %s chapters are able to load modules',
-  (_, chapters, code) => {
+  (_, chapters, variants, code) => {
     const chapterCases = chapters.map(chapterVal => {
       const [chapterName] = Object.entries(Chapter).find(([, value]) => value === chapterVal)!
-      return [`Testing ${chapterName}`, chapterVal] as [string, Chapter]
+      const index = chapters.indexOf(chapterVal)
+      const variant = variants[index]
+      return [`Testing ${chapterName}`, chapterVal, variant] as [string, Chapter, Variant]
     })
 
-    test.each(chapterCases)('%s', async (_, chapter) => {
-      const context = mockContext(chapter)
+    test.each(chapterCases)('%s', async (_, chapter, variant) => {
+      const context = mockContext(chapter, variant)
       const { result } = await runCodeInSource(code, context)
 
       expectFinishedResult(result)
diff --git a/src/stdlib/scheme.prelude.ts b/src/stdlib/scheme.prelude.ts
index c444049fb..479f7fe4a 100644
--- a/src/stdlib/scheme.prelude.ts
+++ b/src/stdlib/scheme.prelude.ts
@@ -92,9 +92,46 @@ export const scheme3Prelude = `
 `
 
 export const scheme4Prelude = `
-;; empty for now
+(define call-with-current-continuation call/cc)
 `
 
 export const schemeFullPrelude = `
-(define call-with-current-continuation call/cc)
+(define-syntax let
+    (syntax-rules ()
+        ((_ ((name val) ...) body restbody ...) 
+         ((lambda (name ...) body restbody ...) val ...))
+    
+        ;; taken from https://stackoverflow.com/questions/78177041/is-there-a-way-to-implement-named-let-as-macro-to-make-it-work-with-petrofsky-le
+        ((_ name ((id init) ...) body0 body1 ...)
+         (((lambda (h)
+            ((lambda (x) (h (lambda a (apply (x x) a))))
+             (lambda (x) (h (lambda a (apply (x x) a))))))
+             (lambda (name) (lambda (id ...) body0 body1 ...))) init ...))))
+
+(define-syntax quasiquote
+    (syntax-rules (unquote unquote-splicing)
+        ((_ (unquote x)) x)
+        ((_ ((unquote-splicing x) . rest))
+            (append x (quasiquote rest)))
+        ((_ (a . rest))
+            (cons (quasiquote a) (quasiquote rest)))        
+        ((_ x) (quote x))))
+        
+(define-syntax cond
+  (syntax-rules (else)
+    ((_) (if #f #f))
+
+    ((_ (else val rest ...))
+     (begin val rest ...))
+
+    ((_ (test val rest ...))
+     (if test
+         (begin val rest ...)
+         (cond))) 
+
+    ((_ (test val rest ...) next-clauses ...)
+     (if test
+         (begin val rest ...)
+         (cond next-clauses ...)))))
+
 `
diff --git a/src/types.ts b/src/types.ts
index 7dd4374ea..0fce4275a 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -10,7 +10,7 @@ import * as es from 'estree'
 
 import { EnvTree } from './createContext'
 import Heap from './cse-machine/heap'
-import { Control, Stash } from './cse-machine/interpreter'
+import { Control, Stash, Transformers } from './cse-machine/interpreter'
 import type { ModuleFunctions } from './modules/moduleTypes'
 import { Representation } from './alt-langs/mapper'
 
@@ -146,6 +146,7 @@ export interface Context<T = any> {
 
   /** Runtime Specific state */
   runtime: {
+    transformers?: Transformers
     break: boolean
     debuggerOn: boolean
     isRunning: boolean