DEV Community: Jishith Mp

Update on Zen — we now have a package ecosystem

Jishith Mp — Sun, 28 Jun 2026 03:12:42 +0000

A few weeks back I shared some early Zen code examples. Since then, a lot has changed. We're now at v1.1.1 and the language actually has real tooling.

What's new:

Full CLI with package management

zen publish - publish packages directly from CLI
zen install - install packages from the registry
zen list - browse all published packages with pagination

Language improvements

Struct support with literals and returns
Regex with POSIX ERE (matchRegex)
File I/O with binary support
FFI bindings to C functions
162 stdlib functions across math, strings, fs, os, http, crypto, path utilities

Package Registry (v1.0.0)

JWT-based authentication
GitHub-hosted packages
Support for both runnable apps and libraries
Semantic versioning

The reactive variables concept from the first post is still there (that was my favorite feature), and now you can actually write real programs and share them with the community.

Full docs: https://jishith-dev.github.io/zen-doc/site/

Install: curl -fsSL https://raw.githubusercontent.com/jishith-dev/Zen/main/install.sh | bash

Next up: HTTP server APIs, better imports, and whatever the community asks for.

Open to feedback and collaborators 💻

✨

zen #programming #compiler #llvm #packagemanager #opensource #programminglanguage

I made a programming language called Zen, wanted to share some examples

Jishith Mp — Sat, 13 Jun 2026 16:37:51 +0000

Hey, I've been working on this for a while now and finally feel okay sharing some code examples.

Zen is a statically typed language that compiles to native binaries through LLVM. Still a work in progress but the core stuff works.

One thing I'm kind of proud of is reactive variables. It's a first class feature where a variable automatically recomputes when something it depends on changes:

int cartItems = 3
int pricePerItem = 50
reactive int total = cartItems * pricePerItem

screen(`Total: $${total}`)   # 150

cartItems = 5
screen(`Total: $${total}`)   # 250, updates automatically

pricePerItem = 60
screen(`Total: $${total}`)   # 300

no event listeners or anything, it just stays in sync. got the idea from how spreadsheet cells work honestly

also has a standard library with time, fs, sys etc. here's a small example using both:

fn greet() {
    string t = time.time()
    List<string> parts = split(t, ":")
    int hour = Int(parts[0])

    string greeting = ""

    if (hour < 12) {
        greeting = "Good Morning"
    } else if (hour < 17) {
        greeting = "Good Afternoon"
    } else {
        greeting = "Good Evening"
    }

    screen(greeting + ", Welcome to Zen!")
}

greet()

and file I/O:

string path = "notes.txt"
string content = "Zen is minimal, fast, and fun to write."

fs.writeFile(path, content)

string data = fs.readFile(path)
screen(`File content: ${data}`)

fs.appendFile(path, " — written in Zen.")

string updated = fs.readFile(path)
screen(`Updated: ${updated}`)

anyway the full pipeline works, lexer parser AST LLVM IR native binary and a CLI. still lots to do but it's at a point where I can actually write real programs in it.

docs if anyone wants to look: https://jishith-dev.github.io/zen-doc/site/

open to feedback, especially on the syntax.

How I Built My Own Programming Language from Scratch

Jishith Mp — Thu, 11 Jun 2026 18:41:10 +0000

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:

Zen Documentation

Website:

Zen 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

programming #opensource #compilers #llvm #javascript