I Built a Programming Language Called Zen
Building a programming language had been something I wanted to do for a long time.
What I didn't realize when I started was how much work exists beyond parsing a few tokens and generating some code. A language is not just a parser or a compiler backend. It is tooling, developer experience, documentation, installation, error handling, runtime support, and countless design decisions.
After multiple attempts and many lessons learned, I'm excited to share Zen.
Why a Third Attempt?
Zen is not the first language project I started.
My first attempts taught me a lot, but they never reached a stage where I felt comfortable sharing them publicly. The architecture was incomplete, important components were missing, and the overall developer experience wasn't where I wanted it to be.
Instead of abandoning the idea, I kept iterating.
Each attempt helped me better understand:
Compiler architecture
Language design
LLVM
Runtime integration
Tooling and usability
Error handling
Project structure
Zen is the result of those lessons.
What Is Zen?
Zen is a programming language with its own compiler pipeline and LLVM-based backend.
The goal was not just to generate code, but to create a complete language ecosystem that developers can actually install and use.
Zen currently includes:
Lexer
Parser
AST generation
LLVM IR generation
Native executable generation through LLVM
Runtime integration
Standard library integration
Command-line tooling
Installation system
Documentation website
Compiler Pipeline
The compilation process follows a traditional compiler architecture:
Source Code
↓
Lexer
↓
Parser
↓
AST
↓
LLVM IR Generation
↓
LLVM Optimization
↓
Object Files
↓
Native Executable
LLVM handles optimization and machine code generation, allowing Zen to produce native binaries.
Command Line Interface
Zen provides several commands for development and inspection:
zen run
zen build
zen ir
zen ast
zen tokens
zen clean
This allows users to inspect different stages of compilation while also supporting normal build and execution workflows.
Installation
One of my goals was making the language easy to install.
Zen can be installed with a single command:
curl -fsSL https://raw.githubusercontent.com/Jishith-dev/Zen/main/install.sh | bash
The installer:
Checks required dependencies
Downloads Zen
Builds runtime components
Builds standard library objects
Sets up the CLI
Documentation
A language is only as useful as its documentation.
I spent significant time building documentation and a dedicated website so that users can quickly understand the language and get started.
Documentation:
Website:
Challenges
Building Zen involved solving many problems that are easy to underestimate:
Designing compiler architecture
Managing LLVM integration
Runtime linking
Module handling
Error reporting
Cross-platform installation
Documentation structure
Developer experience
Many of these challenges were not obvious when I started.
What I Learned
The biggest lesson was that building a programming language is much more than code generation.
A usable language requires:
Consistent design decisions
Good tooling
Clear documentation
Reliable installation
Helpful diagnostics
Iteration and patience
The compiler itself is only one piece of the overall system.
What's Next?
Zen is stable, but there is still plenty to improve.
Planned future work includes:
Testing framework support (zen test)
Built-in examples (zen example)
Better diagnostics
Additional language features
Tooling improvements
Performance enhancements
Final Thoughts
This project started as an experiment and evolved through multiple iterations before becoming a complete system.
Creating Zen taught me more about compilers, tooling, architecture, and software engineering than I expected when I began.
If you're interested in programming languages, compiler development, or LLVM-based systems, I'd love to hear your feedback.
Links
Documentation: Zen Documentation
Website: Zen website
GitHub: github