Martiiin's site

Portfolio

here are some of the projects ive worked on, check out the github repos for more details and source code!!

BorealOS - An X86_64 operating system written in C++

BorealOS is an operating system ive been working on with a friend for a while now, its goal is a unix like operating system, to learn more about how operating systems work!! it started in C back in early 2025, but after realising we both made a good few mistakes at the start, we decided to rewrite it in mid 2025 still in C, then again in late 2025, but this time in C++ purely for classes & namespaces, as the C codebase was getting a bit hard to manage, and it proved to be the right choice as the codebase is much easier to manage and work with now, and we can implement features faster and with less bugs.

currently it has these features:

it is still very early in development, and is not yet usable, but you can check out the github repo. you can read more about the VFS too. its concept is a prefix tree where filesystems are mounted under <ident>:/ and then you can access files under that, for example if you mount a filesystem with the ident fs1 then you can access files under fs1:/path/to/file. The spec also includes some details on system information files, which expose information about the system, for example system:/devices/cpu would expose information about the cpu.

at the moment we are working on a file system driver, which will then allow us to implement more features on top of that, like a shell and eventually more drivers. our goal is to have a “usable” operating system, with a gui and a few applications ported! Definitely the project im most proud of, and the one ive learned most from!

github | vfs spec | status: in active development

Oxylang - C like programming language

Oxylang is a programming language i made over the course of a few months, with the spec being drafted mid 2025, and implemented early 2026, its core idea is that it is a simple c like language but with less ambiguity, and a more modern syntax. it does not have any safety features, and is designed to be simple but still familiar to c!!

the compiler itself was made in c#, for ease of development and makes use of the QbeGenerator below.

it ditches the c type system where variables might be 8, 16, or 64 bits based on what your architecture or compiler thinks is best, and instead uses a simple type system where you have i8, i16, i32, i64, u8, u16, u32, u64, f32 and f64. it also has a simple module system, where you can @export functions, types and variables, which then can be imported!

it is not feature complete, nor stable, but you can check out the github repo and the spec! to compile code you need the Oxylang.Build project, which is a cli tool that manages compilation.

Example:

 1import "std" as std;
 2@extern @symbol("printf") fn printf(format: ptr<u8>, ...) -> i32;
 3
 4@entry
 5fn main(argc: i32, argv: ptr<ptr<u8>>) -> u8 {
 6    let x: i32 = 42;
 7    let y: ptr<u8> = "Hello, Oxy. X: %d\n";
 8    printf(y, x);
 9
10    let math = 3.14 * 2.0; // f64
11    let math_f32: f32 = 3.14f * 2.0f; // f32
12
13    // %f is for f64, so we need to cast math_f32 to f64 (assuming 64 bit architecture)
14    printf("Math: %f, Math_f32: %f\n", math, cast<f64>(math_f32)); 
15
16    for (let i = 0; i < 5; i = i + 1) {
17        printf("Loop iteration: %d\n", i);
18    }
19
20    while (x > 0) {
21        printf("While loop, x: %d\n", x);
22        x = x - 1;
23    }
24
25    std::println("This is a line printed using the standard library's println function.");
26
27    return 0u8;
28}

learned a lot making this language, and it was a real fun project to work on but i quickly realised some architectural decisions i made early on that made it hard to continue development, so ill probably be trying again with a revised specification and architecture, but for now this is what i have, and im proud of it!!

github | status: not actively developed, but not archived

QbeGenerator - A qbe IR generator

QbeGenerator is a project to replicate the llvm style builder pattern, but for qbe, which is a simple intermediate representation that can compile to machine code.

i needed this because qbe does not expose a builder, and only parses from text files which in my opinion, is annoying to generate and lacks type safety and clear error messages, so i made this project to generate qbe IR from a more programmatic API.

example:

 1using QbeGenerator;
 2
 3var module = new QbeModule();
 4
 5var fmt = module.AddGlobal("%d\n");
 6
 7var main = module.AddFunction("main", QbeFunctionFlags.Export, QbePrimitive.Int32(false));
 8var entry = main.BuildEntryBlock();
 9{
10    entry.Call("printf", false, null, 1, fmt, new QbeLiteral(QbePrimitive.Int32(true), 42));
11    entry.Return(new QbeLiteral(QbePrimitive.Int32(false), 0));
12}

outputs 42 and returns 0 when compiled and run.

the API itself is made to be used by other compilers, which need verbose and explicit control over the IR generation. check out the code generator in Oxylang for a more advanced example of how QbeGenerator can be used

i also made a C++ variant of this project, which has a similar API (has its differences, but the core concepts are the same) and can be found here!

 1#include "Qbe.h"
 2
 3Qbe::Module module(true); // 64-bit module
 4
 5// declare printf, with varargs
 6auto printf = module.defineFunction("printf", Qbe::Int32, {Qbe::Local("fmt", Qbe::Pointer)}, true); 
 7
 8// declare the main function with the entry point flag
 9auto main = module.addFunction("main", Qbe::Int32, {}, false, Qbe::FunctionFlags::EntryPoint);
10{
11    auto block = main->entryPoint();
12    block->addCall(printf, {module.addGlobal("Hello, World!\\n")});
13    block->addReturn(Qbe::CreateLiteral(0));
14}
15
16auto qbeCode = module.emit();

outputs Hello, World! and returns 0 when compiled and run.

github c# | github c++ | status: stable enough for use, and in maintenance

SmoothLife - A smooth life simulation

SmoothLife is a project where i implemented a smooth life simulation, which is a variation of the Game of Life, but instead of having discrete cells that are either alive or dead, it has a continuous grid where each cell has a value between 0 and 1, which represents how alive it is. The rules of the simulation are also different, and are based on a smooth transition between alive and dead states, which creates more interesting patterns and dynamics.

i started this back in late 2024, as during that time i was using a lot of opengl for 3d rendering. i used c# and opengl 4.3 with compute shaders to implement this project, and it was a fun experiment to learn more about compute shaders & cellular automata. compute shaders are very cool to work with, and they allow for very fast simulations of cellular automata like this, as they can run on the GPU and take advantage of its parallel processing power.

id like to revisit this project someday, but instead use vulkan and add more features, and possibility of different rulesets and different types of simulations.

github | status: archived, not actively developed