I Built My Own Programming Language and its Virtual Machine In Python & Go!

Fusen — Tue, 24 Jun 2025 20:25:57 +0000

Ever looked at your code and wondered what really happens when you hit "run"? I mean, deep down, past the libraries and frameworks, how does your if statement actually... if? That curiosity bug bit me hard, and it led me down a rabbit hole that ended with me building my own programming language and virtual machine from scratch, using nothing but Python. I call it Pyle.

So, Why Build a Whole Language?

Pyle isn't here to compete with Python, JavaScript, or any of the giants. The world probably doesn't need another programming language from me (not to mention written in Python). But I needed to build one. I wanted to tear away the layers of abstraction and see the guts. How does text turn into something a computer understands? How does a + b actually work?

Pyle is my personal laboratory for exploring these questions. It’s an educational project, first and foremost.

But this isn't my first time creating a language. My journey started with CupScript, a classic tree-walk interpreter. I remember piecing it together, trying to absorb every detail from a YouTube series, making tweaks here and there but never feeling quite satisfied. Then came FCL – more of a joke, really – where I took "functional programming language" so literally that everything was a function. Good times.

All of these were in Python, the language I knew best back then. But the itch to see how these concepts would perform in something faster was always there. That led to my third attempt, DUSL. I had ambitions for DUSL, maybe for scripting or small automation tasks. Life, as it does, got in the way, and a million bugs remained unfixed.

Through all this, I was aware of stack-based virtual machines. I knew they were the engine behind many interpreted languages and generally faster than just walking an AST. But I hadn't dived deep. After finally taking that plunge and learning more, I started prototyping in Python again. And that’s how Pyle came to be. It's a stepping stone, really. The grand plan is to eventually rewrite Pyle in Go, both for that performance boost and to deepen my own understanding of Go.

Update, wrote the Go version here: https://github.com/Fus3n/pyle

From Text File to Execution

The Lexer (or Tokenizer): This is the first stop. Imagine it as a meticulous librarian who reads your .pyle script character by character and groups them into meaningful "words" or tokens. So, let x = 10; becomes something like KEYWORD(let), IDENTIFIER(x), OPERATOR(=), NUMBER(10), PUNCTUATION(;). No understanding of what it means yet, just breaking it down.
The Parser: Now that we have tokens, the parser steps in. This stage is like a grammar expert. It takes the stream of tokens and tries to build a structured representation, an Abstract Syntax Tree (AST). Think of it as an upside-down tree where each node represents a part of your code's structure – an assignment, an expression, a function call. If your code doesn't make grammatical sense (like let = x 10), the parser throws a fit.
The Compiler: This is where the magic starts to get really interesting. The compiler walks through the AST and translates it into a simpler, more machine-friendly language: Pyle Bytecode. This isn't the machine code your CPU runs directly, but a custom set of instructions I designed specifically for Pyle's own little virtual brain. For instance, echo(a + b) might become a sequence of opcodes like PUSH_VAR(a), PUSH_VAR(b), ADD, CALL_BUILTIN(echo). Seeing my high-level Pyle code turn into these compact instructions was a huge "aha!" moment.
The Stack-Based Virtual Machine (VM): This is the engine that actually runs the bytecode. My Pyle VM is a stack-based machine. Imagine a stack of plates: it pushes values onto this stack, performs operations (like ADD which takes the top two values, adds them, and pushes the result back), manages function calls, and generally brings the bytecode to life. It reads each bytecode instruction and does what it says.

What Can Pyle Actually Do?

It's still a learning project, but Pyle can handle the basics:

Variables (let for mutable, const for immutable)
Numbers, strings, booleans, and even arrays (lists)
The usual arithmetic (+, -, *, /), logical (and, or, not), and comparison operators
if/else statements, while loops, and for-in loops (with ranges for now)
Defining and calling your own functions, complete with return statements and even keyword arguments!
A really fun one: importpy("module_name") lets you import actual Python modules. So, const math = importpy("math"); echo(math.pi); totally works! Most of this interactivity with python types is possible because of pythons dynamicity.
Some built-ins like echo(), len(), scan() for input, and perf_counter().

A Quick Showcase

This example defines a function to check for prime numbers and then uses importpy to get a random number to test.
Using JavaScript syntax highlighter as the syntax is very similar.

// Function to check if a number is prime
fn is_prime(n) {
    if n <= 1 {
        return false;
    }
    if n <= 3 {
        return true;
    }
    if n % 2 == 0 or n % 3 == 0 {
        return false;
    }
    let i = 5;
    while i * i <= n {
        if n % i == 0 or n % (i + 2) == 0 {
            return false;
        }
        i = i + 6;
    }
    return true;
}

// Let's use a Python module to get a random number
const random = importpy("random");
let test_num = random.randint(1, 100);

echo("Checking if", test_num, "is prime...");

if is_prime(test_num) {
    echo(test_num, "is a prime number!");
} else {
    echo(test_num, "is not a prime number.");
}

echo("--- Primes up to 20 ---");
for i in 0:21 {
    if is_prime(i) {
        echo(i);
    }
}

The Real Payoff: Understanding

Building Pyle has been an incredible learning experience. It’s one thing to read about compilers or VMs, and another entirely to wrestle with operator precedence in your parser or debug your VM's stack handling. It’s given me a much deeper appreciation for the tools and languages I use every day.

If you've ever been curious about what goes on under the hood, I can't recommend a project like this enough. It doesn't have to be perfect or feature-complete. The goal is the journey and the understanding you gain along the way.

The whole thing is up on GitHub if you want to check it out: https://github.com/Fus3n/pyle-python

Written in Go version: https://github.com/Fus3n/pyle

Gem-Assist: Your Command-Line Personal Assistant

Fusen — Wed, 12 Mar 2025 09:55:52 +0000

Hey everyone! I wanted to share a project I've been working on called Gem-Assist. It's a command-line personal assistant that integrates both proprietary and local models to provide access to over 30+ tools.

Overview

Gem-Assist is a Python-based tool designed to help with a variety of tasks. Whether you need to fetch data, automate routines, or manage projects. It works seamlessly with popular AI models (using litellm) and offers a wide range of tools to make your workflow smoother.

Repository: Gem-Assist on GitHub

Key Features

AI Integration: Supports integration with popular AI models such as Gemini 2.0 Flash, Gemini API, Litellm, and Ollama.
Tool-based architecture: Equipped with a variety of tools for tasks like:
- Web searching (DuckDuckGo)
- File system operations (listing directories, reading/writing files, etc.)
- System information retrieval
- Reddit interaction
- Running shell commands
- And more!
Customizable: Easily configure the assistant's behavior and extend its capabilities with new tools.
Simple Chat Interface: Interact with the assistant through a straightforward command-line chat interface.
Memory: Can save notes between conversation and remember them.
Saving Conversation: Save and load previous conversations.
Commands: Supports creating/executing (code), use /commands for more information.
Extension: For now you are required to write some code to extend its capabilities like adding commands to CommandExecutor or making new tools, there should be enough examples in gem/builtin_commands.py for commands and utility.py for tools

Getting Started

To get started with Gem-Assist, clone the repository and follow the installation instructions provided in the README file. The default branch is master, and you can find the latest updates and contributions from the community.

git clone https://github.com/Fus3n/gem-assist
cd gem-assist

Community and Contributions

Gem-Assist is an open-source project, and contributions are always welcome. Whether you're a developer, tester, or just someone with great ideas, you can contribute to the project by submitting issues, suggesting features, or creating pull requests.

Conclusion

Gem-Assist is more than just a command-line tool; it's a comprehensive assistant designed to enhance productivity and streamline tasks. With its robust features and active development, it stands out as a useful tool for anyone looking to integrate AI into their daily workflow. It is ultimately made for you to customize, add more tools or commands to be as personalized as possible, as it is for me.

For more information and to start using Gem-Assist, visit the GitHub repository.

Hope you find it useful!

Forem: Fusen