DEV Community: Owen Boreham

Demi: Building a Language From the Metal Up

Owen Boreham — Thu, 14 Aug 2025 00:45:09 +0000

Demi: Building a Language From the Metal Up 🚀

Demi isn’t just another language.

We’re building an entire programming ecosystem from scratch — compiler, assembler, linker, interpreter, runtime — all custom, with no LLVM, no GCC, no shortcuts.

Our vision is dual-mode execution:

Interpretation via our custom VM (Virtcomp) for rapid prototyping, live code reloads, and experimental development.
Native compilation via our own backend and linker for blazing speed, reliability, and standalone distribution.

Key Features (Vision)

🔧 Total Customization – Demi gives programmers unprecedented control over how the language works:

User-defined syntax rules – Change keywords, punctuation, and grammar to match your style or project needs.
Extensive behavioral controls – Fine-tune type systems, scoping rules, evaluation order, and more.
Custom standard libraries – Ship your own core API set, replacing or extending built-ins.
Execution model tweaks – Choose between strict, lazy, or mixed evaluation, control memory management strategies, and even define concurrency models.
Project-specific dialects – Create language variants for different projects without touching the Demi core.

Project-Based Configuration

Every Demi project has its own .demi/ config folder that defines:

Syntax and grammar customizations
Language behavior tweaks
Standard library overrides
Build and execution preferences

Configurations can be:

Hand-edited following the official documentation for total control
Auto-generated using an online configuration tool that guides you through customizing your Demi environment visually

This means every project can feel like its own language — without forking or modifying Demi itself.

Why this is Different

Custom ISA – Demi ISA (D-ISA) is our own low-level assembly language, portable across targets and designed to be human-readable.
Full toolchain in one binary – demi acts as compiler, assembler, interpreter, and linker:

demi -I file.dem          # Interpret Demi source
demi -c file.dem -o file  # Compile to native executable
demi -A file.dasm -O lib  # Assemble Demi ISA to a library/object

Independent binary formats – We’ll support ELF, PE, and Mach-O natively — no system compilers required.
Future JIT – Switch between interpreted and compiled code at runtime.

Important Note – We’re at the Very Start

Right now, Demi is in an extremely early stage:

We are actively developing the bytecode interpreter and the core shell of Virtcomp.
About 95% of the features described above are not yet implemented — they represent the long-term vision for Demi.
A contributor-friendly roadmap will be released in due time to guide newcomers through how they can get involved at each development stage.

Why Contribute Now?

You’ll be helping lay the foundation for:

A from-scratch, self-contained language stack (parser → compiler → ISA → machine code)
A platform for language innovation where syntax, runtime, and architecture are all under our control
A long-term open-source project with room for deep optimization, new CPU backends, and cross-platform systems programming challenges

We’re looking for:

Systems programmers with interest in compilers, assemblers, and linkers
Low-level hackers who love CPU architectures, binary formats, and calling conventions
Language designers who want to push the boundaries of language customization

Get Involved

GitHub: https://github.com/bobrossrtx/demi
Discord: https://discord.gg/vvhkhGkuGF

📢 Join us — we’re not just making a language, we’re making its world.

Demi & Virtcomp

Owen Boreham — Sat, 02 Aug 2025 01:44:58 +0000

Hello, Dev Community! 👋

I’m excited to introduce two interconnected projects: Demi, a customizable programming language, and VirtComp, a virtual compiler that powers Demi. Let me share the vision, current progress, and roadmap for these projects.

What is Demi?

Demi is a programming language designed to be fully customizable by developers. Whether you're working on a niche project or building software with deep API integrations, Demi adapts to your needs.

Key Features:

Customizable Syntax: Tailor the language’s syntax to suit your project.
Robust API Integration: Seamlessly connect with services and libraries.
Portable Compilation: Create portable executables using VirtComp.
Flexible Development: Demi molds itself to your workflow.

Currently, Demi is an incomplete prototype running as an interpreted language using Deno. The final version will be a compiler written in C++, integrated with VirtComp.

What is VirtComp?

VirtComp is a virtual compiler written in C++ that emulates machine instructions for a custom 32-bit CPU architecture, enabling Demi to compile into portable executables.

Key Features:

Custom CPU Architecture: Optimized for portability.
Modular I/O System: Supports console I/O, file access, and more.
Visual Debugger: Offers real-time debugging capabilities.
Extensibility: Developers can expand functionality by adding devices or instructions.

VirtComp ensures programs written in Demi are portable and deployable across systems.

The Vision

The goal is for Demi to evolve into a compiled language, powered by VirtComp. This transformation will result in an executable capable of compiling source code into portable machine code, fostering efficient and customizable software development.

Current Progress

VirtComp: Functional with modular I/O systems, a custom CPU architecture, and a visual debugger. Documentation and tests are available.
Demi: Operational as an interpreted prototype. It includes examples, a REPL mode, and a VS Code extension for syntax highlighting. The final version will be rewritten in C++.

Roadmap

Phase 1: Foundation (In Progress)

Develop VirtComp as a functional virtual compiler.
Prototype Demi as an interpreted language using Deno.
Update: While initial functionality exists, implementation, features, and refinements are ongoing.

Phase 2: Integration

Integrate Demi with VirtComp to enable compilation.
Expand documentation and examples.

Phase 3: Alpha Release (ETA: Q1 2026)

Release Demi as a compiled language.
Provide tools for syntax customization, API integration, and system extensions.

Phase 4: Community Development (Q2 2026)

Host hackathons and foster contributions.

Phase 5: Stable Release (Q4 2026)

Launch stable versions of Demi and VirtComp.

How to Get Involved

Developers: Contribute to the codebase and share ideas.
Sponsors: Support the project to accelerate development.
Users: Explore the prototype and provide feedback.

Check out the repos:

VirtComp: GitHub
Demi-Lang: GitHub

Let’s create a future where programming languages adapt to their users. 🚀

Join the discussion and connect with the community on Discord! https://discord.gg/w9vxvfcrXp

How to get started with .NET

Owen Boreham — Mon, 17 Jan 2022 02:26:06 +0000

I am very new to blogging, so I thought I would write a little bit about myself. I am a software developer, programming since October 2020.
I have worked on a number of projects, ranging from small to large scale, and I have been working on a number of different languages.
The reason I am writing this blog is to share my experiences with the .NET platform, and how you can get started with it too!

I'm not a professional programmer, I just like to write code and learn new things. The approach I took to learning to code was average,
I had been playing with HTML and CSS, then I moved to JavaScript, then I started playing with React. I have learned a lot of things since then,
ranging from Low level programming in C to modern JavaScript, to the latest frameworks like React. I had always struggled to get started with .NET and
C#. It had always felt like a daunting task, mainly because I had never worked with C# before, and the people I have seen using it were amazing.

After I finally decided to learn C#, I was able to get started with it. I was able to write a simple program in Visual Studio, and I was able to
get it to run. I felt a great sense of accomplishment, but also disappointment, I was thinking about how I could have done better, started earlier.
It was no different to learning another language, like Python, JavaScript, or even C. Now I am going to take you through the process of getting started with
.NET.

How to get started with .NET

First of, we are going to start with something extremely simple. We are going to create a simple Console Application. There is just one small, but important
step we must take before we can start writing code. Now unfortunately, if you use a Linux based system, you will need to install the .NET Core SDK, which can
be tedious. You can download the SDK from the following link: https://www.microsoft.com/net/core

On Windows or MacOS, you can install Visual Studio, which comes with the .NET Core SDK already installed. You can download Visual Studio from the following
link: https://visualstudio.microsoft.com/downloads

This article is directed at windows users, but you can also use Visual Studio on MacOS. If you are using Linux, you will need to use another IDE/Text Editor
and the dotnet CLI. You can download the dotnet CLI from the following link: https://dotnet.microsoft.com/download

Creating a project

In Visual Studio, you can create a new project by clicking new->project. You can also create a new project by right clicking on the solution explorer, and
then clicking new->project. You will be prompted to select the type of project you want to create, pick the Console Application, and then you will be prompted
to name the project, and choose the location where you want to save it. Once you have created the project, you will be able to start writing code.

You should be greeted with the following code:

using System;

namespace BoilerPlateConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

The code you see above is called boilerplate code. This is code that is automatically generated by Visual Studio when you create a new project. You can
run the project, and it will run the code you see above. The will then see "Hello World!" printed to the console. Good job! You have just created your
first .NET project!

Writing Code

I know what you are probably thinking, why haven't we written any code yet? Well, the answer is that we haven't needed to. First we need to decide what
we want out code to do. I will show you how to write a small program that will print a list of films. This will include the title, the year, and the director.

We will create a new class called Film, and then we will create a new method called PrintFilmInfo which will print the title, year, and director of the film.
We will also create a List of films, and then we will add a few films to the list.

Lets get started with writing code:

using System;
using System.Collections.Generic;

namespace BoilerPlateConsoleApp
{
    class Film
    {
        public string Title { get; set; }
        public int Year { get; set; }
        public string Director { get; set; }

        public void PrintFilmInfo()
        {
            Console.WriteLine($"Title: {Title}");
            Console.WriteLine($"Year: {Year}");
            Console.WriteLine($"Director: {Director}");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<Film> films = new List<Film>();
            films.Add(new Film() { Title = "The Shawshank Redemption", Year = 1994, Director = "Frank Darabont" });
            films.Add(new Film() { Title = "The GodFather Part II", Year = 1974, Director = "Francis Ford Coppola" });
            films.Add(new Film() { Title = "The Dark Night", Year = 2008, Director = "Christopher Nolan" });

            foreach (var film in films)
            {
                film.PrintFilmInfo();
            }
        }
    }
}

This is the complete code for the film list. You can run the code to see the output. Might I also mention that I have used the foreach loop to print out
the films. This is a very common loop in C#, and it is very easy to use. You can use it to loop through a list of items, and then print out the items.
The List<Film> is a data structure that is used to store a list of items. The Film class is a class that we created to store information about a film.
Inside of the Film class, we have three properties, Title, Year, and Director. Properties are like variables, and they are used to store information.

I'm not going to go into nitty gritty details about what is going on here, as I expect you to be familiar with some of the concepts already. I really recommend
reading up on the C# language, and reading the documentation, at https://docs.microsoft.com/dotnet/csharp to get a better understanding of what is going on here.

I fully understand that dotnet can be a bit confusing at first, but I hope that this article will help you get started with .NET. I hope you enjoyed the article!

Contact

If you have any questions, comments, or concerns, feel free to contact me at https://www.owenboreham.tech/contact

JS - What are Closures

Owen Boreham — Sat, 19 Jun 2021 14:24:23 +0000

About me:

Hi there, my name is Owen Boreham, and most people call me by my username... "Bobrossrtx". At the time of posting this, I am a 15 year old teenager hoping to be a get into college for Computer Science. Anyway that is enough about me, lets talk about closures...

summary

I will talk about what closures are and when they are used in this article. All credit of this knowledge comes from Fireship and you can check out his website here.

Closures

Closures are JavaScript functions access variables from the global scope, for example...

// Lexical environment
let myVar = "Hello World";

// Function
function hello() {
  console.log(myVar); // Captures the myVar variable
}

hello()

In order to call a function in your code, the JS interpreter needs to know about the function itself and any other data from the surrounding environment that it depends on.

Take for example a pure function that only depends on it's own arguments.

// No external data
function pureFunc(a, b) {
  return a + b;
}

What we have here is a fully self contained closed expression. When it is called, it gets pushed onto the call stack where it will be executed and its internal data (arguments) will be kept in memory until it is popped back off the call stack.

But what if that function references data from outside of it's own scope like from the global environment or an outer function.

// Parent scope
let b = 3; // free variable

// This is a Closure
function impureFunc(a) {
  // Function scope
  return a + b; // Captures `b` variable
}

This leaves us with an open expression that references other free variables from the environment. In order for the interpreter to call this function and also know the value of these free variables it creates a closure to store in the Heap, this is a place in memory that can be later accessed. Unlike the call stack where the it is short lived, the Heap can keep data indefinitely then decide to remove that data when it is no longer needed by using a garbage collector.

So a closure is not just a function, it is a function combined with the outer state or lexical environment. Closures do require more memory and processing power than a pure function but you will come over many practical reasons why to use them.

Socials

Twitter: @bobrossrtx
YouTube: Owen Boreham
Medium: @bobrossrtx
dev: bobrossrtx
Github: @bobrossrtx