DEV Community: Mehdi BR

I made my own Bootloader at 16. It was horrible. It was worth it.

Mehdi BR — Wed, 18 Mar 2026 06:58:22 +0000

Why I even did it

I have this obsession of wanting to understand every little thing on my computer. Every wire, every line of code, every register, I always wanted to know it all.

How I started

About 2 days before, I learned about Bootloaders and how they are the first program to run on a computer. The description alone sparked a feeling I never knew existed. I started imagining my own bootloader, my own program to be run first thing by my machine. That thought alone put me to work.

The story

That night, I started digging through UEFI documentation. I found a few videos detailing how Bootloaders speak to the firmware, I even followed a step by step tutorial video. Nothing worked, everything crashed the QeMu simulation. I couldn't even print a simple Hello World. I decided to keep pushing a few more hours before fully giving up, until i found this paper. It pointed out such a specific problem that I felt only I had. Nothing on the internet described my problem and solved it, except this paper. I couldn't tell what exactly clicked, it wasn't a grand explanation, just a small snippet of code that made me look at mine in confusion. I was doing it all wrong. I finally printed my very own hello world!

This sight alone made me the happiest person in the world at 4 in the morning. I went back to the step by step tutorial and debugged every little thing that didn't work from the video. AI couldn't help, it was just me and poorly made, horrible looking documentation: the pinnacle of computer development. Slowly, I understood how everything worked. Sure there were some parts that took 12 hours to debug, but that was all part of the ride. At the end of all that, I got to see my 3 line kernel be loaded by my own custom bootloader.

That little 123 you see at the end, that's printed from my kernel. Seeing that 123 print was the best moment of my life. I decided to run it on my real machine, not a QeMu emulator, I had to see my own Bootloader run on my machine, and for the first time ever, it worked first try. It was beautiful, seeing everything go as it should've could've made a grown man cry.

Tools I used

Making this project, I used multiple tools I made beforehand to help.
GitHub repos:

NUB (Novus UEFI Builder)
NovusDeploy
NCC (Novus C Compiler)
All made by me in C/C++. Star them if you wanna support!

Where to find the kernel/bootloader

You can find them at this GitHub repo, star it if you wanna support me and follow my journey!

How designing a CPU made me code better

Mehdi BR — Mon, 16 Mar 2026 03:53:21 +0000

Why I even started

I always looked at my computer in awe. "How does a clunk of metal do such beautiful things?" I ask myself. I always thought of them as a black box of magic, you just input data and it comes out however you want it. Until one day, I decided to truly learn how it works.

The story

I started about a year ago, with the aim of understanding how computers work at the lowest level. I started by following a simple YouTube tutorial. I just copy pasted what the creator did and it worked. At some point though, it stopped working. I panicked, I had no AI to help me because it's too dumb to work with extremely low level stuff, and I could not debug it because I copied all of it with no real knowledge. That was when I decided to give up, I did not wanna deal with debugging stuff that I did not understand.
Until about 2 months ago, I decided to stray back into that field. I dove into how a CPU handles data and instructions, and slowly, I understood how it all worked. No AI, no YouTube tutorial that I did not understand. I fully owned the CPU and the knowledge behind it.

How it helped

Making this CPU helped me understand how a computer works deep down. I stopped thinking of them as a black magic boxes and started visualizing their own unique components. The ALU, RAM, program counter... All these seem surface level stuff, but truly working with them and forcing them to interact is what makes it all click.
Understanding how a computer works is, in my opinion, essential for coding anything lower-level than python. You understand how data flows, how components interact, and how each part of your CPU speaks.
You stop looking at std functions as a spell, and start looking at them as simplified CPU instruction.

Where to find it, and where to start

You can find this project here, please star it if you wanna support me, and check other repos if you are interested in my work.
To start making your own CPU, start like me, by looking at YouTube tutorials. Don't follow it blindly, instead google each component before even building it, then try to make the component on your own after understanding what it does. When you're done building it on your own, go back to the tutorial and watch what the creator did different and how theirs is potentially better than yours.
Keep in mind, no one did this is a week or a day. Don't get mad if you don't instantly get it. It took me a whole year!

Note

I designed the CPU in Logisim, the documentation for it can be found at Novus-Core1/Documents/inst.md

Simple C++ networking libraries don't exist anymore - here's the fix.

Mehdi BR — Fri, 13 Mar 2026 17:37:50 +0000

Recap

About 4 days ago, I posted a blog about my networking library, NovusNet, found here.

The problem

C++ networking libraries fall into 2 categories: Either too complex for simple use, or easy but unreliable. NovusNet fills a gap: Simple, secure, and fast.

What I added since then

Now, NovusNet offers a perfectly secure connection between 2 devices. Fully encrypted and limited access with passwords. Another big thing is the inclusion of NFTP, my own file transfer protocol, now integrated into the library. NFTP transfers any size file across the network safely and quickly.

Usage

Server-side:

#include "nn.hpp"
#include <iostream>
#include <chrono>
int main(){
    //runServer() now takes an additional variable: string password.
    runServer(9090, "YOUR_PASSWORD");
    // onMessage listens for any incoming message
    onMessage([](int clientN, std::string msg){
        // if the client announces a file is coming, receive it
        if(msg == "SENDING_FILE"){
            //recvFile() takes the download folder, and the client id.
            recvFile("Downloads", clientN); // saves to Downloads folder
        }
    });
    // keeps main() alive without tanking CPU
    while(true){
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

Client-side:

// Client-side file sender
#include "nn.hpp"
#include <iostream>
int main(){
    // connect to server with ip, port, and password
    int client = runClient("127.0.0.1", 9090, "PassTest");
    // receive and store the clientID assigned by the server
    std::string msg = recvMsg(client);
    int clientID = std::stoi(msg);
    // announce to the server that a file is incoming
    sendMsg("SENDING_FILE", clientID);
    // send the file
    // sendFile() takes filepath and clientID assigned by the server.
    sendFile("image.png", clientID);
    return 0;
}

Where it's going

As time goes, I'll update this library until it's perfect. I will move onto another project once this is done. Check it out on NovusNet and star it if you wanna support! If you want a clearer explanation, check NovusChat, it's a side project made purely on NovusNet to showcase the library's ability and simplicity.

I made my own C++ networking library at 16: here's how.

Mehdi BR — Mon, 09 Mar 2026 18:14:58 +0000

The Problem

Around a week ago, I wanted to focus on networking to start working on a home lab project. During this, I thought to myself: "Are there any simple libraries out there?" So I took to searching, I only found big libraries like Boost.Asio that are way too overkill for my needs, and honestly, too hard for me, or any beginner/intermediate developer, to understand. So I decided to make my own simple library, NovusNet, focused towards people of the same niche as me, people that don't need the complexity of larger libraries.

The idea

Before I even started coding, I sat down and thought to myself: "What do I want this library to be?" Simple, I needed it to be easy to understand, not have complex stuff that you don't need, and overall be as beginner friendly as possible without making it slow and unsafe.

The build

With the keyboard at my fingertips, I began coding, it was super simple at first, just setting up sockets and shoving them into functions. But as hours went by, I started to want more features. I dove into threads to start multi-client handling, which alone took me about 2 days of straight coding. I dove into OpenSSL to encrypt every connection, which took me around a day of googling new stuff. All that led the project to where it is now.
Setting up networking has never been so easy:

Server-side

#include "nn.hpp"
#include <iostream>
#include <chrono>

int main(){
    runServer(9090);
    //"onMessage" returns clientN and msg of any received message from any client.
    onMessage([](int clientN, std::string msg){
        //more detailed logic can go on here depending on what you wanna do.
        std::cout << "Client " << clientN << ": " << msg << "\n";
    });
    while(true){
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

Client-side

#include "nn.hpp"
#include <iostream>

int main(){
    std::string msg;
    //runClient(ip,port) connects to a server
    int client = runClient("127.0.0.1", 9090);
    //receive client id and assign it for later use
    msg = recvMsg(client);
    int clientFD = std::stoi(msg);
    std::cout<<clientFD<<'\n';
    while(true){
        std::getline(std::cin,msg);
        //sendMsg(string msg) sends data as a string
        sendMsg(msg,1);
    }
    return 0;
}

Results

NovusNet is now far easier to setup than any other pure c++ networking library. The average person making a home lab or a simple multiplayer game never needed a library as big as the ones currently available, they just needed something easy, fast, and secure.

What I learned

Working on this project taught me a lot about callbacks, lambdas, threads, and sockets. It also taught to make my own solution when I can't find someone else's.

Overall

I'm 16 and this is my first major project along with some other smaller ones on GitHub. If you're a beginner who believes networking is out of reach, it's not. You can find my project at NovusNet. If you wanna support me, go check it out and star it!