Radiant Log #006

In the last few months I’ve had a lot of time to think about computing, and about how I want to spend the next ten years of my life. It’s been four months since I haven’t written a line of code, as I realized I had jumped in too quickly from my previous project into Radiant, without a proper break. Now that I’ve taken the time off, I’m able to ease myself back into the project with a clearer head. One of the big questions with such a massive endeavour is always where do I start? I decided to start with a new programming language originally, but does this still make sense? And once that’s done, what’s the next step? This is what I’d like to discuss here.

When John Backus, with his team of early computer pioneers created Fortran in the 1950s, they were essentially starting from scratch. There was no widely used high level language at the time. Fortran was one of the first third-generation languages invented. There were no preconceptions as to what that should look like: they worked from a clean slate and Fortran is still in use, 68 years later in big part because of its incredible performance in numerical computation.

High-level programming languages have accumulated a lot of implicit knowledge about the hardware and operating systems on which they are designed to run on. This is mostly seen in their standard libraries and tooling, as basic language syntax and semantics has not fundamentally changed.

main() {
    auto c;
    while (1) {
        while ((c = getchar()) != ' ') {
            if (putchar(c) == '*n') exit();
        }
        putchar('*n');
        while ((c = getchar()) == ' '); /* skip blanks */
        if (putchar(c) == '*n') exit(); /* done when newline */
    }
}

For Radiant, starting fresh will give me the opportunity to think more progressively about the whole system, and not be beholden to the abstractions chosen for existing platforms. The Radiant deserves its own language, designed with its principles and philosophy in mind.

When it comes to the question of the OS, I’ve decided to take a different approach. In many ways, the OS is the most complicated piece of the puzzle; though interestingly, it is not the most essential. Early computers such as the Atari as well as video game consoles throughout the 90s lacked what we would call an operating system today. The PlayStation 2 (2000) might have been the first console to run a minimalistic modern OS; effectively a way to manage your memory card and launch media. Yet these devices had many elements of a computer: input handling, sound, graphics and storage. Primarily, what they were missing was the ability to seamlessly run multiple, unrelated tasks at once (preemptive multitasking) with a user interface to manage these tasks.

Coming back to the Radiant, I’ve been thinking of following that same journey, starting with a high-level language and writing software that interfaces directly with the hardware, and only once those interfaces are well established will it make sense to start working on an operating system.

I’ve therefore outlined a rough software roadmap leading up to the OS, that should be achievable within two years. This is Phase 1 of the project.

Phase 1.

The following are the software components that need to be written in order, with each component depending on the one before it.

R’ compiler in C

This is the initial stage where we build a basic compiler for the R’ language, using a host language, like C. The goal is to create a functional compiler that can translate R’ source code into RISC-V machine code, serving as the foundational tool for all subsequent steps in the development process.

R’ compiler in R’

In this step, we will use the R’ compiler to compile itself. This process, known as bootstrapping validates the compiler’s functionality and allows us to perform all future development in R’ instead of C, making the entire toolchain self-hosted.

Radiance compiler in R’

Building on the bootstrapped R’ compiler, we will implement the full Radiance language. This involves adding all the necessary features and syntax for implementing the standard library.

Standard library

Provides core functionality for the Radiance language that isn’t built into the language itself. It will include core data structures, I/O, string manipulation, memory management, etc.

Bootloader

The bootloader is the very first piece of code that runs when the system powers on. Its purpose is to perform low-level hardware initialization, such as setting up the CPU, memory, and any necessary registers, before handing over control to an OS or bare-metal program. This will allow us to run Radiance code on real hardware.

Hardware abstraction layer (HAL)

The HAL provides a common, standardized interface to all the hardware. It will be implemented through various device drivers that handle specific things like graphics controllers and sound chips. This layer also manages hardware events such as interrupts and timers,

2D Graphics library

Includes all the higher-level functions for drawing to the screen. It will use the HAL to provide capabilities for drawing shapes, sprites, and text, abstracting the complexities of the specific graphics hardware.

UI library

Building upon the 2D graphics library, we provide all the tools needed for creating user interfaces. It will include basic interactive elements such as buttons, dropdowns, and text fields.

A first application

At this stage we have everything we need to develop a first application using Radiance and its standard library, and booted on the Radiance OS.

By tackling these components from scratch, I can ensure they are not influenced by the implicit assumptions or accumulated legacy of existing operating systems.

Once the language and HAL reach stability, developing the operating system becomes the natural progression. Many of the foundational components will likely migrate into this OS layer, but this milestone also opens an exciting possibility: creating user-facing software that boots directly on the Radiant hardware!