I Over-Engineered My First Project: Bridging TypeScript and Zig with Bun! 🚀

Owen — Mon, 16 Mar 2026 02:29:06 +0000

Hello, hello! It's me Owen again!

I've been inactive for awhile and thought maybe I should post again (Even if this is my second post fully). Some people say that coding project should start with To-do lists, REST APIs, Generators, etc.

Instead, I decided to dive completely into the deep end. I wanted to build something fast, learn about memory management, and figure out how different languages talk to each other.

So, I built Dunena—a high-performance, hybrid-architecture monorepo. It leverages Bun and TypeScript for the web layer, and delegates heavy CPU tasks to Zig via a Foreign Function Interface (FFI). Oh, and I deployed it on Kubernetes. Because why not? 😅 (But don't worry about that since I'm still new to Docker and Kubernetes.)

🔗 Check out the Dunena Repository on GitHub here!
🔗 Check the documentation here!

Here is a breakdown of what I built, how it works, and the massive amount of things I learned along the way.

🏗️ What is Dunena?

At its core, Dunena is a backend platform designed to handle requests quickly and efficiently. It features routing, WebSockets, pub/sub services, and a caching layer.

But the real magic is under the hood. I wanted the rapid development speed of TypeScript, but I didn't want Node/Bun to get bogged down by heavy computations like compression, bloom filters, or complex stat calculations.

The Tech Stack:

Runtime & Monorepo Manager: Bun 🥟
Primary Language: TypeScript (Strict mode)
High-Performance Core: Zig ⚡
Database: SQLite 🗄️
Deployment: Docker & Kubernetes 🐳 (Again I'm new to this so bare in mind)

🧠 The Architecture

The coolest (and scariest) part of this project is the FFI bridge. Here is how a request goes from TypeScript to near bare-metal execution in Zig.

First, I write the high-performance logic in Zig and export it using the C Application Binary Interface (ABI):

// zig/src/exports.zig
const std = @import("std");

// Exporting a function so Bun can read it via the C ABI
export fn compute_heavy_stats(input_val: i32) i32 {
    // Imagine some incredibly complex, CPU-blocking math here
    var result = input_val * 42; 
    return result;
}

Then, in my TypeScript platform package, I use Bun's native dlopen to load the compiled Zig shared library and bridge the function:

// packages/platform/src/bridge/ffi.ts
import { dlopen, FFIType, suffix } from "bun:ffi";

// Load the compiled Zig library
const path = `../../zig/zig-out/lib/libdunena_core.${suffix}`;

const { symbols } = dlopen(path, {
  compute_heavy_stats: {
    args: [FFIType.i32],
    returns: FFIType.i32,
  },
});

// Now I can call Zig directly from TypeScript!
export function runStats(input: number): number {
    return symbols.compute_heavy_stats(input);
}

When a client hits my Bun server (apps/server/src/index.ts), the platform handles the API routing, hands the heavy computation off to Zig, and returns the result instantly.

🤖 The "AI" Elephant in the Room

I want to be totally transparent: I used AI coding agents to help build this. Using tools like Claude and Gemini was incredible for speeding up the boilerplate, setting up the monorepo structure, and scaffolding the initial file architecture. It felt like having a senior developer sitting next to me typing out the boring stuff.

However... AI agents are terrifyingly bad at manually managing memory across an FFI boundary.

If the AI changed a data type in Zig but forgot to update the exact corresponding FFI definition in TypeScript, the server would just crash with a memory access violation. The AI helped me move fast, but I still had to do the brutal, hair-pulling debugging and fixing. Figuring out how to safely pass pointers, prevent memory leaks, and get Kubernetes to play nice with an attached SQLite volume was all human effort. It taught me not to blindly trust generated code, especially when dealing with low-level systems.

🧗 The Biggest Challenges

1. Managing Memory Across the Void
When you pass data between TypeScript and Zig, there are no safety nets. Bun’s garbage collector has no idea what Zig is doing. Learning how to manually manage memory and use defer statements in Zig was a huge hurdle!

2. SQLite in Kubernetes
Deploying an SQLite database (which is essentially a physical file) attached to a K8s pod via Persistent Volume Claims (PVC) was tricky. It works great for a single pod, but I quickly realized that if I scale this horizontally, I might run into database locking issues.

🚀 What's Next?

This project is far from "finished." I'm currently maintaining this project on my own, but would love to see anyone who'd try and contribute!

Let's Connect!

Since this is my first major project, I would absolutely love any feedback, code reviews, or advice from the community.

🔗 Check out the code on GitHub
🔗 Check the documentation here!

Have you ever tried mixing languages like this or fighting with FFI boundaries? Let me know in the comments! 👇

Elba Lang

Owen — Sun, 19 Oct 2025 04:08:36 +0000

Elba — A modern, statically-typed programming language with multiple compilation backends

GitHub → OwenBellowen/elba

As someone deeply interested in programming languages, compilers, and full-stack systems (yes, that’s me: a student, TypeScript/Zig/Rust dev), I’m excited to introduce Elba — a project I’ve been working on that brings together clarity, performance, and tooling in one language.

Note: I have no intentions yet on making this into a full project. Although I would continue working on this.

🚀 What is Elba?

Elba is a statically-typed programming language designed for clarity, performance, and developer productivity.

It offers:

Static type checking with type inference — so you get all the safety of static typing without always writing verbose annotations.
Generics — write reusable, type-safe code.
Union types, optional types (T?) for null safety — fewer runtime surprises.
A module system, first-class functions, rich arrays, structs with methods.
Multiple backends: AST interpreter for quick prototyping, IR interpreter for faster execution, a C code generator, and an LLVM backend for native performance.
A standard library covering math, strings, and more.

In short: think “modern language with the expressiveness of high-level code” + “compiled speed” + “tooling and REPL to iterate fast”.

✨ Why build Elba?

Because I believe we can push the boundaries of what a new language can offer. Specifically:

Type safety meets productivity: We want the benefits of static typing (fewer bugs) without getting bogged down in ceremony.
Multiple backend flexibility: Sometimes you just want a quick REPL or interpreter; other times you need native speed. Elba gives you both.
For compiler / language-enthusiasts: If you love messing around with languages, building tooling, or exploring alternative type systems (hello Zig and Rust fans), this is a playground.
Modern developer experience: REPL, error-reporting, benchmarking, IR visualization — all included.

🛠️ Getting Started

Prerequisites

Zig (version 0.15.2 or later)
(Optional) LLVM 20 for native backend
(Optional) GCC or Clang for C code generation

Build from source

You can follow the setup on the README.md or below:

git clone https://github.com/OwenBellowen/elba.git
cd elba
zig build
./zig-out/bin/elba --version

Quick Test

./zig-out/bin/elba examples/hello_world.elba
./zig-out/bin/elba repl

Full documentation and more examples live in the examples/ directory and the repo’s docs.

💡 Example code snippet

Here’s a small example showing Elba’s generics + optional types:

// examples/generic_example.elba

fn swap<T>(a: T?, b: T?): (T?, T?) {
    return (b, a)
}

struct Pair<T> {
    first: T,
    second: T,

    fn new(f: T, s: T): Pair<T> {
        return Pair { first: f, second: s }
    }

    fn swap(self): Pair<T> {
        return Pair.new(self.second, self.first)
    }
}

fn main() {
    let maybeNum: i64? = 42
    let maybeNil: i64? = null

    let (x, y) = swap(maybeNum, maybeNil)
    print("x = {x}, y = {y}")

    let p = Pair.new("hello", "world")
    let p2 = p.swap()
    print("swapped: {p2.first}, {p2.second}")
}

DEV Community: Owen