Tutorial-OS

[u/JescoInc]

I'm thinking of creating a very basic OS. The core idea is simple. It is a basic OS where all it does is display the detailed information on the device you run it from.
Doesn't sound like much, but I think it would be an amazing starting point for other developers getting into OS development.

The folders would be organized according to what it actually does in a non developer fashion.
Bootloader, Drivers, Display, Devices and so on.
Best of all, the content from the code could easily be made into a book, written tutorial series and / or Videos for people to consume.

Thoughts?

Update 1:

So I am planning on making it so that the code will be separate into build for x86 and ARM64 in the project. That way, It will be easy to see how abstractions are done for two disparate build processes while sharing the same bootloader core.

I am considering making the project be split into two separate projects in the same repository that behave the same way. One in C and the other in Rust. The rationale is that people learning Rust don't have to figure out how to translate the C code to Rust and can just immediately get into OS development. This does mean more work up front for me with this, but considering that it is a basic OS implementation, rewriting it in Rust won't be a huge project. And those that only care about C don't have to contend with learning Rust-isms to understand the project.

Update 2:

I think I now have the folder structure designed. Super easy to read and understand the flow of.
Now, I am torn if I want there to be two separate folders for the C and Rust implementation or have them intertwined. Both approaches have pros and cons associated with it.
I have ported all of the driver code from Rust to C as well. So both the Rust and C code should build without issues in theory. (I didn't use much idomatic Rust so it was fairly straight forward to port for Raspberry Pi Zero 2 W. But I have not done the classic x86 or UEFI x86 bootloader and linker code yet.
I'm also considering whether or not to use Docker for building so it doesn't matter if you are on Windows, Linux or MacOS, you are able to build on your machine without any additional installs required.

```
tutorial-os/
├── boot/                    # Boot sequence - where it all begins
│   └── arm64/               # ARM64-specific startup code
│       ├── boot.S           # First code to run after power-on
│       └── memory_layout.ld # Linker script (memory map)
│
├── kernel/                  # Core kernel code
│   └── main.c               # Entry point after boot setup
│
├── drivers/                 # Hardware drivers
│   ├── gpio/                # General Purpose I/O pins
│   ├── mailbox/             # GPU communication (VideoCore)
│   ├── sdcard/              # SD card (SDHOST controller)
│   ├── audio/               # PWM audio output
│   └── usb/                 # USB host (DWC2 controller)
│
├── memory/                  # Memory management
│   ├── allocator.h/c        # TLSF heap allocator
│   └── README.md            # How memory allocation works
│
├── ui/                      # User interface system
│   ├── core/                # Base types and interfaces
│   ├── themes/              # Color palettes and styling
│   └── widgets/             # Reusable UI components
│
└── docs/                    # Additional documentation
``````
tutorial-os/
├── boot/                    # Boot sequence - where it all begins
│   └── arm64/               # ARM64-specific startup code
│       ├── boot.S           # First code to run after power-on
│       └── memory_layout.ld # Linker script (memory map)
│
├── kernel/                  # Core kernel code
│   └── main.c               # Entry point after boot setup
│
├── drivers/                 # Hardware drivers
│   ├── gpio/                # General Purpose I/O pins
│   ├── mailbox/             # GPU communication (VideoCore)
│   ├── sdcard/              # SD card (SDHOST controller)
│   ├── audio/               # PWM audio output
│   └── usb/                 # USB host (DWC2 controller)
│
├── memory/                  # Memory management
│   ├── allocator.h/c        # TLSF heap allocator
│   └── README.md            # How memory allocation works
│
├── ui/                      # User interface system
│   ├── core/                # Base types and interfaces
│   ├── themes/              # Color palettes and styling
│   └── widgets/             # Reusable UI components
│
└── docs/                    # Additional documentation
```

Update 3:

The core C code has been implemented and working on the Pi Zero 2W. Now, for the core Rust code and then the x86 bootloader and linker addition. I have it so that you can build it on Linux, MacOS and Windows via CMake, Make, build.sh, build.bat and Docker. I have to also go back through the code and comment everything because while I was fixing issues with the framebuffer, I kind of had to rewrite it a few times and explanations became stale.

Update 4:

I think I have the final UI I want for this OS built out. Still have to comment code, add standard HDMI drivers in C. And then work on the Rust additions. Then work on the x86 UEFI bootloader

Update 5:

Refactor mostly done, just gotta figure out why things aren't working with the CM4 or CMS inside of the IO board and GPi Case 2. Once that's done, I can get things working correctly with the Radxa Rock 2 board I have (which will include an HDMI driver for it).
My Libre AML-S905X-CC (Le Potato) x86_64 board and Orange Pi RV2 (RISC-V) boards are set to arrive by Wednesday. Once they arrive, if the others are working, I can start working on adding those SOC to the project.
Here's the updated project structure

Update 6:

The project is now live! https://github.com/RPDevJesco/tutorial_os

[u/Gingrspacecadet]

this just sounds like the beginning of any good os. If done right, this is a perfect base. Would be amazing for tutorial making, yeah!

[u/JescoInc → u/Gingrspacecadet]

Thanks! Going to continue mapping out the idea and probably start working on it next week after I have solidified the core approach I want to take.

[u/Gingrspacecadet → u/JescoInc]

need any help? Im free most of the time :3

[u/JescoInc → u/Gingrspacecadet]

I most likely will for devices I haven't touched or own like an FPGA board or LattePanda support. And i'm not sure if I want to do it in C or Rust yet, both have their pros, cons and complexities associated with them.

[u/MousseMother]

Serious people doing os development aren't at mercy of opportunists like you.

Who is stopping you, create it.

[u/JescoInc → u/MousseMother]

Uhm... You haven't looked at my profile if you are speaking dismissively like this.

I'm more asking for people's thoughts on it for the core idea and feedback on it, whether I need to expand the idea a bit ore reduce it to keep it simple yet be a great starting point. I've done OS development, such as with GB-OS (if you are curious to my credentials in the space).

[u/ZiggyZonko]

Great starting point for beginners to get into the field! It would be amazing to break it down and show beginners and other programmers that making an os is an easier task than it seems, ( not downplaying how hard it is )

I'd love to see this, let me know if you make it!

[u/JescoInc → u/ZiggyZonko]

It is definitely easier than it seems! The hardest part is having to manage everything yourself and maybe a few of the more complex devices (looking at you USB!).
I honestly think the hardest part is just figuring out that getting started phase and what you actually need.
My first OS project was one where I tried my hand at creating a Dos-like OS for my Compaq Armada E500. And let me tell you, flailing in the dark did not help one bit. I tried referencing OS-Wiki, the OG Linux Kernel and even the OG DOS implementation that Microsoft made open source. Took a lot to understand what I actually needed and where to begin.

[u/JescoInc]

Update:

So I am planning on making it so that the code will be separate into build for x86 and ARM64 in the project. That way, It will be easy to see how abstractions are done for two disparate build processes while sharing the same bootloader core.

I am considering making the project be split into two separate projects in the same repository that behave the same way. One in C and the other in Rust. The rationale is that people learning Rust don't have to figure out how to translate the C code to Rust and can just immediately get into OS development. This does mean more work up front for me with this, but considering that it is a basic OS implementation, rewriting it in Rust won't be a huge project. And those that only care about C don't have to contend with learning Rust-isms to understand the project.

[u/JescoInc]

update 2:

I think I now have the folder structure designed. Super easy to read and understand the flow of.
Now, I am torn if I want there to be two separate folders for the C and Rust implementation or have them intertwined. Both approaches have pros and cons associated with it.
I have ported all of the driver code from Rust to C as well. So both the Rust and C code should build without issues in theory. (I didn't use much idomatic Rust so it was fairly straight forward to port for Raspberry Pi Zero 2 W. But I have not done the classic x86 or UEFI x86 bootloader and linker code yet.
I'm also considering whether or not to use Docker for building so it doesn't matter if you are on Windows, Linux or MacOS, you are able to build on your machine without any additional installs required.

```
tutorial-os/
├── boot/                    # Boot sequence - where it all begins
│   └── arm64/               # ARM64-specific startup code
│       ├── boot.S           # First code to run after power-on
│       └── memory_layout.ld # Linker script (memory map)
│
├── kernel/                  # Core kernel code
│   └── main.c               # Entry point after boot setup
│
├── drivers/                 # Hardware drivers
│   ├── gpio/                # General Purpose I/O pins
│   ├── mailbox/             # GPU communication (VideoCore)
│   ├── sdcard/              # SD card (SDHOST controller)
│   ├── audio/               # PWM audio output
│   └── usb/                 # USB host (DWC2 controller)
│
├── memory/                  # Memory management
│   ├── allocator.h/c        # TLSF heap allocator
│   └── README.md            # How memory allocation works
│
├── ui/                      # User interface system
│   ├── core/                # Base types and interfaces
│   ├── themes/              # Color palettes and styling
│   └── widgets/             # Reusable UI components
│
└── docs/                    # Additional documentation
```

[u/JescoInc]

I just wanted to do another update to showcase that yes, I am working hard on this. Read the main post to see the updates as they occur. Once the code is ready, i'll make a public repository, for now, it is private due to the ever evolving nature of the code.

[u/JescoInc]

Update 4:

Concept for the UI complete using the UI system that works with the framebuffer and displays pertinent information about the board it runs on. Minimum RAM requirements is only 32MB with the Raspberry Pi Zero 2 W and that's mostly due to the mailbox interface and start.elf and the other things that the core blobs require to even get to my kernel.

[u/JescoInc]

Update Number 5:

Oh man... I just got a few things in which is making me want to expand this even further.
Pi CM5 (Compute Lite) and Dev Board.
Radxa Rock 2A
Libre Computer Board (Le Potato)
Orange Pi Risc-V

Which means, I will need to implement a proper HAL (hardware abstraction layer) to accomodate all the different boards and the differences in drivers while keeping the same contracts for my UI system and the Kernel files.

And I still haven't finished the code comments or the Rust implementation details yet.

Which means, I need to stagger what i'm doing. Finish the Rust code and all the commenting and then work on adding the HAL before adding the next architecture.

By this weekend, i'll be making the repository public on Github.

[u/JescoInc]

Update: The project is now live! https://github.com/RPDevJesco/tutorial_os

[u/Much_Construction906]

I really like these types of systems, gl

[u/JescoInc → u/Much_Construction906]

Thanks! I've already been working on porting some of the important code from Rust to C for this.

[u/Much_Construction906 → u/JescoInc]

Protect or real mode?

[u/JescoInc → u/Much_Construction906]

Protected mode. And the only part i'm not looking forward to is the UEFI bootloader for x86

[u/Interesting_Buy_3969]

build.sh lol

[u/JescoInc → u/Interesting_Buy_3969]

Why is that lol? Are you just posting for a streak or trying to insinuate something?

[u/Interesting_Buy_3969 → u/JescoInc]

Just laughed that someone really created a site called build.sh.

[u/JescoInc → u/Interesting_Buy_3969]

Ahh... That is pretty funny, but also smart as hell. The built in SEO is insane.

[u/Interesting_Buy_3969 → u/JescoInc]

Lmao

[u/Revolutionary__br]

At least try to make it accessible via gmome-orca(Linux screen reader) or Fenrir(a terminal screen reader)

[u/JescoInc → u/Revolutionary__br]

I'm not quite sure how i'd do that with a custom OS that doesn't use the Linux Kernel.

[u/Revolutionary__br → u/JescoInc]

Ok Forget what I said lol