An educational compiler project translating academic Computer Science theory into a working plain-English general-purpose compiler that compiles directly to zero-overhead x64 assembly.
Compiler Engineering & Programming Language Design
Doodle concept visual
Implemented a full general-purpose compiler toolchain to learn how high-level readable instructions translate directly to CPU registers and machine instructions.
The hero image is loaded from the MDX coverImage field. Replace the demo URL with your own gameplay capture, PixiJS canvas screenshot, or rendered artwork.
High-to-Low Translation
Learning Focus
Recursive Descent (AST)
Parser Type
Automata & Grammars
CSE Application
Why We Created Lish: Demystifying the Black Box
In a typical Computer Science & Engineering (CSE) curriculum, compiler design and automata theory are often taught as dense mathematical abstractions. Students memorize state machines, context-free grammars (CFGs), and register allocation algorithms, but rarely get to build a working general-purpose programming language compiler from scratch.
Lish (Language of Intent and Software Harmony) was created to bridge this academic gap. The core aim of the project was learning by building: taking the compiler theory taught in university degrees and applying it to a concrete, high-performance general-purpose language toolchain.
By designing a general-purpose language that reads like standard English but compiles directly to low-level x64 machine code, the project served as a hands-on vehicle to learn exactly how high-level logic and modern language features are parsed, optimized, and executed by hardware.
From Theory to Practice: Implementing CSE Concepts
Building Lish required putting classical Computer Science concepts into practical action:
1. Lexical Analysis & State Machines (Lexing)
Academic theory teaches that lexers use Finite State Automata (FSA) to convert characters into logical tokens. In Lish, this concept was applied to parse natural English text. The compiler identifies keywords like let, be, and repeat, while dynamically filtering out superficial grammar words (like "the", "to", "please") that humans use for readability but computers do not need.
Lish translates natural sentences into structured data by implementing a Context-Free Grammar. The parser processes tokens into an Abstract Syntax Tree (AST) using a recursive descent parser. This tree maps parent-child relationships between operators and operands, converting linear text into a hierarchy of execution.
One of the key learning milestones of Lish was understanding how compilers bridge the distance between frontends (what the developer writes) and backends (what the machine runs). Lish uses LLVM Intermediate Representation as a type-safe buffer, allowing the compiler to perform general optimizations before target code emission.
Mapping High-Level Code to Raw Silicon (Low-Level Translation)
A central objective of the Lish project was understanding how low-level registers and memory segments function. Here is how high-level statements are converted to assembly instructions:
Case Study: Variable Allocation & Math
When writing variables and arithmetic in Lish:
let a be 10
let b be 20
let result be a + b
The compiler translates this high-level code into three main compiler actions:
Register Binding: The compiler maps variables a and b to CPU registers EAX and EBX.
Instruction Selection: It emits the hardware add instruction.
Generated Assembly:
mov eax, 10 ; Load literal 10 into register EAX
mov ebx, 20 ; Load literal 20 into register EBX
add eax, ebx ; Perform hardware addition
mov [result], eax; Store calculated sum in memory offset
By outputting pure assembly, the project illustrates how simple CPU operations form the execution engine behind complex human logic in a modern, general-purpose language.
The Core Academic Takeaway
The Lish project shows that compilers are not magical black boxes. By applying university-level Computer Science algorithms — from tokenizers and parsing trees to code emission and register constraints — Lish demonstrates how to design a modern, general-purpose language that prioritizes human expression without sacrificing low-level machine efficiency.
Doodle concept visual
