Hey everyone.

I want to share a project I've been pouring my soul into for the past 7 to 8 months. But first, a little backstory on how this even started.

Like many people, my programming journey started a couple of years ago building simple Discord bots with JavaScript, and eventually moving into frontend and cloud stuff. While I thought JS was incredible at first, the deeper I got, the more I found myself burning hours debugging the most frustrating, senseless bugs.

I started learning other technologies like TypeScript, Go, and Rust, and my mind kept going to this crazy idea: Why not just build my own programming language?

At first, I wanted to build something brutal for the backend, something to rival C. But then I asked myself: Why add another language to the pile if C and Rust are already the kings there? Then I looked at the Cloud. In my opinion, there is no undisputed king for cloud development. You either deal with massive runtime overheads, complex setups, or languages that let developers easily shoot themselves in the foot with concurrency bugs.

I was talking to a friend who is deeply involved in modern cloud tech, and I asked him what architectural focus the VM should have. He told me: "Focus it entirely on the cloud. Give it native concurrency and parallelism."

That was the spark. That is how Jabline was born.

So, what actually is Jabline?

Jabline is a dynamically-typed language (with an AOT static type checker) that compiles an AST down to bytecode and runs on a highly optimized, stack-based Virtual Machine written entirely in Go.

It is not just a toy language; it is designed specifically for Backend, Microservices, and Cloud Architectures. It takes the expressive syntax of TS/JS and combines it with the raw, lightweight concurrency of Go.

Here is what it is actually good for and why I built it this way:

1. It compiles to a single, standalone binary You do not need node_modules or massive runtime environments. You write your code, run jabline build server.jb, and the compiler tree-shakes the runner, bundles the bytecode, and outputs a single executable. You can drop this into a tiny Alpine Docker container or an AWS Lambda function, and it runs instantly.

2. Batteries are included for the Web If you want to build a backend, you should not have to install 50 third-party packages. Jabline has a robust Standard Library tailored for the web:

• std/http for fast REST APIs with Graceful Shutdown built-in.
• std/websocket for real-time chat/notification servers.
• std/db for immediate SQL persistence.

3. True, Safe Concurrency Jabline exposes Go's underlying goroutines through a simple spawn keyword, allowing you to run asynchronous background tasks effortlessly. But to prevent the classic concurrency bugs that ruin cloud servers, the VM handles the safety:

• Thread-Safe Globals: The VM uses strict Mutex isolation when closures capture variables, preventing data races.
• Built-in Semaphores: The HTTP server and spawn tasks share a dynamic limit (currently 10,000 concurrent tasks). If you get hit by a traffic spike, it queues requests gracefully instead of crashing your server (no fork bombs).

4. It consumes almost zero memory at idle A huge issue with running thousands of concurrent tasks in Node/Python is memory starvation. Jabline VMs spawn with a micro-stack of just 256 slots (around 2KB). It grows dynamically based on the function's depth up to 65k. You can run tens of thousands of concurrent WebSockets on a tiny, cheap VPS.

5. Zero-Allocation Hot Paths (GC Optimization) To make sure the language is actually fast under heavy math or loop workloads, the VM recycles its own memory. I implemented centralized sync.Pool structures. Every time a function finishes executing, its execution Frame is wiped and returned to the pool, virtually eliminating Garbage Collector pauses during deep call stacks.

6. AOT Type Checking I hated getting runtime errors in production for simple typos. Jabline has an Ahead-of-Time static type checker. You can type your variables (let x: int = 5) and if you try to return a string from a function expecting an int, the compiler catches it and aborts before it ever runs.

An example of what it looks like:

import "std/http"
import "std/db"

fn handleRequest(req: Hash): string {
    spawn {
        echo("Processing analytics in background...");
    }
    return "Hello from Jabline!";
}

let server = http.server(":8080");
server.get("/", handleRequest);

echo("Cloud Server running on port 8080...");

It has been a crazy 8 months taking this from an idea born out of JS frustration to a stable, cloud-ready VM.

I would love to hear your technical feedback, especially from the compiler and VM engineers here. How do you handle GC pressure in your interpreters, and what architectural improvements would you suggest for the VM?

GitHub Repo: https://github.com/Jabline-lang/Jabline