Hey folks! 👋 I wanted to share a project I’ve been quietly working on: a programming language called Lumen. It's still early days, but it's already compiling to native code and WebAssembly, and I thought some of you might find it interesting — or have feedback to help shape where it’s going. Lumen For anyone fascinated by language design, compilers, or just pushing the boundaries of modern development, Lumen is my attempt to rethink what a lightweight, high-performance, cross-platform language can look like. 🛠️ What Is Lumen? Lumen is a statically typed, compiled programming language designed with three core principles: performance, portability, and simplicity. Built on top of LLVM, it compiles directly to native machine code, while also offering first-class support for WebAssembly (WASM). statically typed, compiled programming language performance portability simplicity LLVM WebAssembly (WASM) The vision? A language that’s as comfortable building low-level system tools as it is running seamlessly in the browser. Imagine writing core logic once and deploying it everywhere—from servers to embedded devices to web apps. If Rust feels too heavy for small projects, or if JavaScript feels too dynamic and slow for critical code paths, Lumen aims to strike a balance. ⚙️ Why I Started Lumen I’ve always been intrigued by languages that prioritize control and speed, but I kept running into two frustrations: Web as an Afterthought: Most systems languages treat WASM like a secondary target, requiring hacks or bloated toolchains.
Over-Complexity: Modern languages often pile on features—sometimes at the cost of simplicity and developer experience. Web as an Afterthought: Most systems languages treat WASM like a secondary target, requiring hacks or bloated toolchains. Web as an Afterthought: Over-Complexity: Modern languages often pile on features—sometimes at the cost of simplicity and developer experience. Over-Complexity: So, I asked myself: Can I design a language where WASM is native, not an add-on?
How minimal can a language and its standard library be, while remaining practical?
Is it possible to leverage LLVM’s power without drowning developers in complexity? Can I design a language where WASM is native, not an add-on? WASM is native How minimal can a language and its standard library be, while remaining practical? Is it possible to leverage LLVM’s power without drowning developers in complexity? Lumen is my answer to those questions—a language where you can: Write lean, predictable code.
Target both native and web with ease.
Focus on essentials, not boilerplate. Write lean, predictable code. Target both native and web with ease. Focus on essentials, not boilerplate. 🚀 Features (So Far) ✅ LLVM-based native compilation
✅ Out-of-the-box WebAssembly support
✅ Static typing for safety and performance
✅ Lightweight cross-platform standard library (C for native, JS glue for WASM)
🧪 Planned: Module system, async/await, macros, and better memory management tools ✅ LLVM-based native compilation LLVM-based native compilation ✅ Out-of-the-box WebAssembly support Out-of-the-box WebAssembly support ✅ Static typing for safety and performance Static typing for safety and performance ✅ Lightweight cross-platform standard library (C for native, JS glue for WASM) Lightweight cross-platform standard library 🧪 Planned: Module system, async/await, macros, and better memory management tools Planned: Unlike many languages, Lumen encourages understanding what your code compiles down to—bridging high-level productivity with low-level awareness. 📂 Project Structure & Design Philosophy stdlib/ → Core C standard library, designed to be minimal but effective across platforms.
wasm_imports.js → Lightweight JavaScript glue code, ensuring smooth browser integration.
main.ll → Example of writing directly in LLVM IR, showcasing how Lumen interacts with its backend. stdlib/ → Core C standard library, designed to be minimal but effective across platforms. stdlib/ wasm_imports.js → Lightweight JavaScript glue code, ensuring smooth browser integration. wasm_imports.js main.ll → Example of writing directly in LLVM IR, showcasing how Lumen interacts with its backend. main.ll Currently, I'm focusing on keeping things transparent—no mysterious black boxes. Developers should feel empowered to peek under the hood. 🧪 Example Build Flow Here’s how simple it is to go from source to execution: Native Build (Linux/macOS): Native Build (Linux/macOS): clang -c stdlib/lumen_std.c -o lumen_std.o
llc main.ll -filetype=obj -o main.o
clang main.o lumen_std.o -o lumen_exec
./lumen_exec clang -c stdlib/lumen_std.c -o lumen_std.o
llc main.ll -filetype=obj -o main.o
clang main.o lumen_std.o -o lumen_exec
./lumen_exec WebAssembly Build: WebAssembly Build: emcc stdlib/lumen_std.c -O3 -s SIDE_MODULE=1 -o lumen_std.wasm
llc main.ll -march=wasm32 -filetype=obj -o main.o
wasm-ld main.o lumen_std.wasm -o lumen_combined.wasm --no-entry emcc stdlib/lumen_std.c -O3 -s SIDE_MODULE=1 -o lumen_std.wasm
llc main.ll -march=wasm32 -filetype=obj -o main.o
wasm-ld main.o lumen_std.wasm -o lumen_combined.wasm --no-entry No complicated pipelines—just clean, direct compilation. 🧭 Roadmap Here’s what’s coming next: ⏳ Module & Import System: Structured, scalable codebases.
⏳ Async/Await: Modern concurrency without threads.
⏳ Custom Syntax Layer: Moving beyond manual LLVM IR.
⏳ Interactive Playground: Test Lumen code directly in the browser.
⏳ Memory Safety Tools: Optional borrow checker or lightweight GC. ⏳ Module & Import System: Structured, scalable codebases. Module & Import System: ⏳ Async/Await: Modern concurrency without threads. Async/Await: ⏳ Custom Syntax Layer: Moving beyond manual LLVM IR. Custom Syntax Layer: ⏳ Interactive Playground: Test Lumen code directly in the browser. Interactive Playground: ⏳ Memory Safety Tools: Optional borrow checker or lightweight GC. Memory Safety Tools: 🌐 Why Lumen Matters In a world where languages are either too heavy or too limited, Lumen is about balance: Fast like C, but safer.
Portable like JavaScript, but compiled.
Powerful like Rust, but simpler. Fast like C, but safer. Fast like C Portable like JavaScript, but compiled. Portable like JavaScript Powerful like Rust, but simpler. Powerful like Rust It’s not here to replace giants—it’s here for developers who want control without complexity. 📎 Check It Out If this sounds interesting, you can explore the source here: 🔗 GitHub – makalin/Lumen GitHub – makalin/Lumen 🙏 Feedback & Collaboration I’m sharing Lumen early because I believe great tools grow with community input. Whether you’re passionate about compilers, curious about LLVM, or just want to discuss language design philosophies—I'd love to hear from you. Questions I’m pondering: Should Lumen adopt a Rust-like borrow checker, or stay minimal?
How deep should WASM integration go—custom APIs, or keep it lean?
What’s the right balance between features and simplicity? Should Lumen adopt a Rust-like borrow checker, or stay minimal? Rust-like borrow checker How deep should WASM integration go—custom APIs, or keep it lean? What’s the right balance between features and simplicity? Thanks for reading this far! 🌕— @makalin Would love to hear your thoughts, ideas, or critiques. Let’s build something awesome together!

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Hot off the press! This story contains factual information about a recent event.

I’m Building a New Programming Language Called Lumen – Here’s Why and How

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

ECUre: The AI-Powered Guardian Securing Your Car's Electronic Control Units from Malware

A Conversation with Roberto Ierusalimschy, Creator of Lua

A Deep Look Into The Service Template Compiler Solution In Python

Analyzing Python Compilers: CPython Vs. Cython Vs. PyPy

Building Your Own Programming Language

ECUre: The AI-Powered Guardian Securing Your Car's Electronic Control Units from Malware

A Conversation with Roberto Ierusalimschy, Creator of Lua

A Deep Look Into The Service Template Compiler Solution In Python

Analyzing Python Compilers: CPython Vs. Cython Vs. PyPy

Building Your Own Programming Language

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps