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

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.

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).

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:

1. Web as an Afterthought: Most systems languages treat WASM like a secondary target, requiring hacks or bloated toolchains.
2. Over-Complexity: Modern languages often pile on features—sometimes at the cost of simplicity and developer experience.

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?

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.

🚀 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

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.

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):

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:

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.

🌐 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.

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

🙏 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?

Thanks for reading this far! 🌕— @makalin

Would love to hear your thoughts, ideas, or critiques. Let’s build something awesome together!