Introduction to Kernel

IronKernel is a dialect of John N. Shutt’s Kernel language for .NET. If you know Scheme, Kernel will feel familiar — until vau rearranges what you think “special forms” are.

What is Kernel?

Kernel is a Scheme-like Lisp designed so that almost everything manipulable is first-class: not only functions and lists, but combiners (things you call) and environments (where names live). That makes it more homoiconic than classic Scheme: the mechanisms of evaluation are values you can pass around.

Scheme separates “special forms” (built into the evaluator) from procedures. Kernel collapses that distinction. The primitive operative $vau / vau constructs new operatives that receive their operands unevaluated, plus the dynamic environment of the call site.

Quote is just a library operative

(define quote (vau (x) _ x))
(quote (do not evaluate me))
; ⇒ (do not evaluate me)

The vau insight

A lambda evaluates its arguments, then runs a body. A vau does not evaluate operands. It binds the raw trees and an environment argument, then runs its body — which may selectively eval those trees.

Operative — combiner that sees raw operands (like a fexpr done right).
Applicative — combiner that evaluates arguments first; wrap turns an operative into one.
lambda — in IronKernel’s stdlib, sugar for (wrap (vau …)).

Same combiner, two calling conventions

(define show-raw (vau (x) _ x))
(show-raw (+ 1 2))
; ⇒ (+ 1 2)          ; tree, not 3

(define show-val (wrap show-raw))
(show-val (+ 1 2))
; ⇒ 3                ; arguments evaluated first

Why IronKernel?

Iron stands for I run on .NET. The implementation is a hybrid CLR compiler: programs lower through a Core IR and Expression trees where safe, with a trampolined CPS interpreter preserving full Kernel semantics — vau, first-class eval, environments, call/cc, and delimited shift/reset.

Interop is part of the language surface: construct CLR objects, call methods, and read properties without leaving S-expressions.

.NET from Kernel

(. System.Console WriteLine
   (. System.String Format "ticks={0}"
      (.get (.get System.DateTime UtcNow) Ticks)))

Surface syntax notes

IronKernel keeps parentheses — on purpose. A few surface choices diverge from Scheme:

(a & b) — improper lists use &, not .
[1 2 3] — vector literals
:keyword — keyword atoms
#inert — Kernel’s inert value (like “no interesting result”)
λ / ϝ — aliases for lambda / vau

Next steps

Run your first program, walk through the language guide for progressive examples, or jump to the operator reference when you need a precise signature.