Yes, it's just a fun stuff.
I'm really happy to have play more.
Play more.
I'm very happy to hear about it.
Thank you.
Welcome to my call.
Does everyone hear me well?
At always this question of what happens when you design and implement the entire stack?
Because I have this obsession about operating systems from when I was really young.
So I started building like operating systems like visual by basic.
But no, I got a bit better at it and no, I built them in C++, I guess.
So quick information about me.
As I said, my name is Kenos.
By day, I mostly work on browser engine.
But by night, I like to act on the operating system.
My website is SMNX.sh.
But everything was in the QR code and I will show it again at the end of the slide.
So what are we talking about today?
We are going to talk about my OBE operating system called SKIFTSOS.
It's a game to be this kind of general purpose.
So desktop environment, operating system.
And to build on my phone number, any feature, what I will mean, reach C++ framework.
And obviously I hit POS 6 and I will fight against it.
So what are the goals of this project?
Mostly it's about having fun and learning.
But maybe do a bit of research and try some new up.
So what is the current state of the project?
Is a mainly really only stage.
Most components are mostly proof of concept, meaning that I've basically written
like the 10% of the code that provide like the 30% of the features.
It's a total around 100,000 line of code.
And it features a full desktop.
And so from now on, this talk will follow the good process of the operating system.
And we'll stop at each stages and we will discuss what each of the components and what they do and what they work.
So I have included the build stage in it because building an operating system is already kind of complicated.
So I will talk about the end of from the platform framework to the operating system.
Or we under that then in this system and finally what happened during the run time of the operating system.
So during the build time we'll talk about the build system called cut kit.
So what is cut kit?
Is this kind of cargo inspired build system and package manager for C++?
It's a brutally designed for C++ modules.
And it will mean like it's battery included.
Meaning it will support all the lifecycle of your software.
Meaning it can do linting, fusing, profiling and obviously building your project.
And what is the main idea between a kit is the kit component.
A kit component is like a loose bag of code and data and a manifest.
The describe some piece of the operating system.
For example here I have a component called karmciss.skift which is the kift OS implementation of the.
Karm system framework meaning it's the absorption over all the system APIs.
And to describe this component we use these gis owners structures.
So on the top we have like the name of the component what kind of component in it here it's library.
And then we have like this tiny predicate that tell or this component will enable only if it's here.
Only if it's in the system is skift.
But as you can see so you can it's kind of a white list kind of thing.
Then it will tell what is required. For example here it will require the silver and time.
And if we remove any it will provide a karmciss.imple.
So the implementation of karmciss.
And we can have like multiple implementation.
For example we can have like karmciss.possics that will abstract.possics under karmciss.
Okay so since we started to see a come true kutik let's continue it's calm because calm is really at the bottom at the foundation of the whole operating system.
So what is calm is it's try to be like this big general purpose of library kind of like a cute or like the dotnet framework meaning that it will try to support everything like from a basic data structures up to a full GUI applications.
And and it's split mostly into into two parts the freestanding part of the library which which mean like it's this part of the library that doesn't require any operating system that can be shared amount all the other components.
And mostly all state part that require the operating system mostly like for doing real libraries and you eyes and stuff.
And it takes inspiration again from rust go and see sharp I see the question coming about first.
Yeah. So and it's not written really in C++ it's written in C++ but it's really like this calm flavor C++.
So you know the meme like C++ with C with classes me I prefer like see with lambda modules and coroutines.
We don't use exception because since we want the framework to work at a really low level.
Well, except for now not available so we use a we use a monadic error and the link with a result type and a trauma crop.
And we make use of all the clank safety check we can use.
For example, we use a clank lifetime bound to take that reference doesn't include the object that it's it's been owned for by.
And we use a WV unsafe buffer usage that is kind like unsafe for C++ meaning you cannot use pointer or pointers anywhere in the operating system.
It can only be done in like some kind of unsafe block kind of thing.
And so this is what an yellow world in calm looks like so this is just a yellow world in use of space.
So you can see we have like beautiful C++ modules.
And another really nice specificity of calm is that it's fully async by default meaning that your entry point is a asynchronous task.
And this asynchronous task take a two object that is a system context and a constellation token.
This constellation token kind of work like six term in physics meaning that it will get three girls and try to console every downstream task.
When, for example, the user ask the comment, you have killed this, I don't want it.
It's it's spinning or it's bugging or something.
And here I just like a basic yellow world application so it just does a UI run async and then we pass it just a UI label with a yellow world.
And it's kind of a swift UI slash slash.
Just not compose inspire your library we might see a bit more after.
And obviously since we're in the macro corner of the room we might care more about RPC.
For now we don't really use an idea language.
We use these C++ structs where you just declare like your message.
Then you in this message we have a type that represent the response and then we have the parameters.
And we use the quite limited not for too long capabilities reflection of capabilities of C++ to try to generate code around this.
And although we use this is that you just have to create an IPC client.
Tell it to connect to some kind of IPC endpoint.
For example here it's Trattachel which is or UI server.
And then you can just call it using client.call async and all RPC are asynchronous.
So it will just return some premise that can be awaited and then we can continue.
And obviously no exception we use again this kind of weird macro call code try.
That kind of it's a specialization for a corrupting that's not too much of a detail right now.
So now we saw the base of the framework.
Let's talk about the bootloader.
So the bootloader is not really it's a simple RFI bootloader.
And it usually will follow my slides.
So it's a simple RFI bootloader in kind of work like a system reboot.
Basically just chain load like a RFI executable or it can load a new RFI and then jump into it.
Which will be your kernel.
It has its own tiny boot protocol called N over and over.
Which is basically just a memory map with some added attributes.
For example you can have like a range of memory.
And to this one of the memory that attach some metadata like this is a framework for and this is the size.
But it's quite limited in this way.
Oh yeah.
And finally the bootloader use the exactly the same UI library as the rest of the opening system meaning that you get this.
All this beautifully vector.
Beautiful vector graphic with sopidsalontializate font and such.
So it's really nice.
Okay.
So we saw the bootloader.
So the bootloader will load a new component called the earth microphone.
So what is the earth microphone?
It's what some people might call a pragmatic microphone.
Meaning that you don't strive for academic purity in it.
It's quite small and simple.
I think it's good for learning.
I guess because it's pretty simple.
And but it's implemented everything.
A microphone should do.
And it's a care of core kernel responsibilities.
Which by this I mean IPC preemption memory management.
And I occur dispatch.
And at that we quite simple object model.
I want to describe all of them.
We'll be quite boring.
I guess.
And it's around 25 to school.
Some people say it's better to have less or more.
Okay.
To get a bit more of the value for the code in the kernel.
Let's look at the send.
It's called meaning the Cisco that it's used to send an RPC message.
And as you can see, it's written in a really idiomatic C++.
And we use C++ to make this code quite safer.
For example, here we have a buffer.
That comes from user space.
And every buffer and data that comes from user space is wrapped in this user slide type.
And you cannot access this type.
Up until you have like kind of difference differentiated it with the width function.
And this width function takes another space.
And at the bottom it takes everything you want to access.
And with make sure that everything is map correctly.
And that the user space cannot like move data around or do nasty stuff.
You're used for memory.
And then in the body of the function we see that each task is attached a domain.
And this domain will try to get a channel based on the capabilities.
And then we use this channel to send a message and some capabilities with it.
So that's what everything for the Earth microconol.
Now the next step is the Stratas service layer.
So now we have the exit head of the kernel space and the level of itself.
And now we try to enter the system level stuff.
So Stratas is kind of a loose bag of services.
And when we enter Stratas we enter through Stratas Siem.
The Stratas component manager.
The Stratas component manager is loaded by Earth or microconol as the force executable.
And it will then directly delegate to a process called Strataiini, which is our init system.
That will then read the bunch of manifest and spawn a bunch of services.
But what are those services?
So at the bottom we have Stratas component manager as we say.
And then we have Stratas device that it's for now kind of a big service at all.
All of our device driver.
We might change that later, but right now it's like this.
Then we have the Stratas file system, which all of our virtual file system and all we access it.
Then we have Strataiini put that take your raw HID event from the Stratas device.
And then time then we do something that the UI can better understand.
It's kind of like I-bus kind of thing.
And then we have Stratas file that is for user interface.
But to discuss it, I prefer going into the next chapter.
Then we have application on top.
So the next chapter is about the ideal desktop environment.
And what is ideal is this kind of general purpose like user interface.
It's built on a custom display protocol.
And like it's kind of like way learned, but way simpler.
And it has what we call another tattoo UI.
Meaning that this UI can scale from like a smartwatch.
Up until like a full desktop environment.
And it will and all the have will be the same.
And they just like scale on based on what the device is capable of.
As we say with the butler, it has the same vector based on the pixel at tiers and with the beautiful fonts.
As the rest of the operating system.
Okay, so that's what it for the general architecture of the operating system.
Well, not all of it.
Because all we will know is that operating system are just bootloader for browser engines.
So, skip as it's own browser engine, that's called V.
And V is not really part of the general project.
It's kind of more like my daytime work that I've ported back to the operating system as a fun project.
I guess.
And it's like a full browser engine, meaning that it has like HTML and CSS.
It can render like some web pages I would show them during the demo.
We don't have Gs for now.
And I think it's pretty fast.
So the more time.
So I will use obviously a cute kid to boot my operating system.
We'll do a bunch of ninja invocation.
And we have like.
Yeah, I don't, don't look at the time.
I didn't have the time to implement RCC.
Okay, I can, I can just look at my display, I guess.
I want to full screen it.
No, it's not this.
Okay, so it does like a normal UI.
We will expect like a normal brain system.
So I can unlock it.
And let's show a bit of some application.
So, first of all, we can look at, I don't know, like, we have like,
a calculator stuff.
It does math, obviously.
But you can like switch in like into tablet mode.
And then you just like add up to UI for the new form factor.
And you can switch easily like this.
And then I can close it.
I don't think fancy here.
Then we can look at the web browser.
So I have a, I took some, some abstract of website.
Because we don't have a network stack yet.
But we can look at the homepage of the internet, I guess.
I don't know, not this one, this one.
Yes. And okay, I'll go back to Google.
Because maybe it will be a bit more interesting.
But maybe I know it doesn't work.
Okay, I'm not precise.
Okay, it's okay.
But you can see that the browser is kind of capable.
We don't have like the logo, things are not aligned.
But it's quite nice.
Okay.
And so maybe I can show you another thing.
And it crashed, I guess.
Okay.
Sorry about that.
Okay, we're back.
We're so back.
Okay.
And obviously, it can run doom, I guess.
Yeah.
Ah, in fact, you will go faster if I go into like tablet mode
because it doesn't show the rest of the UI.
Yes, because we don't have like a GPU acceleration,
it will finish on the CPU as well.
But I can play a bit of doom.
I'm not sure if I'm good at it, so I should be good at it.
Like all the old men here will be,
will be screaming, I guess.
I can kill bodies and some stuff.
Yeah, it does the thing.
You have like a audio.
No, we don't have audio yet.
Audio will be pretty funny.
Well, to be fair, Cam does support audio.
We have like basic audio stuff.
But I didn't hook it up into,
no, we don't do it there.
I won't spoil people.
Mm.
No.
I lost, I was playing.
Okay.
So we have like the frameworks,
superty, meaning if I run it,
if I run a Cam on Linux,
I will get like audio and stuff.
But in Schiff, I don't have like
audio card or driver.
Okay, then I'm done.
My this.
Okay.
Those are things, those are things.
No, it's not the SDL version.
It's a port called Pure Doom,
that it meant to be easily ported.
We don't have like a for party software running,
I said that the start of the call
I will not support politics,
at least directly.
So it's a bit harder to support software.
Okay.
I will show you another demo,
because I still use that everything can,
can,
it's based on the Cam.
And Cam can be ported to any operating system.
And do you know another operating system?
It's called UFI.
And let's say,
it just sounds like,
where it is.
Hmm.
I think I have some time,
I can,
I don't have to rush,
but let's say,
replace like the name of the bootloader,
but another software called Ver,
was a,
browser.main.
I guess it's,
it's funny,
let's say if it works.
Hmm.
I,
I'm not in the right direction.
It's right.
I feel like,
pre-built it,
it's pretty fast.
C++ module,
baby, I guess.
Sorry,
what?
I do,
I did just before,
so,
okay.
Yeah,
it's,
it's kind of ruined,
the time you have to draw,
okay, yes.
Ah, okay,
it's coming.
Yeah,
browser in the,
in the Wi,
and I think I will go back to my slides now.
Okay,
so,
beyond.
I kind of want,
full,
virtual support,
because,
since virtual has,
like,
every device class,
it will mean that we can,
like, build the rest of the,
operating system without being,
for,
having,
like, the first step is,
like,
porting the NVIDIA driver.
So,
we'll be simple,
a networking,
obviously,
on the disk of file system,
I've,
like, my high on,
like,
GFS,
because it's quite simple,
and seems interesting,
some server,
I don't remember what to talk about this.
Namespacing,
because right now,
everything is,
like, in this one big,
namespace,
but I think it's just a,
a,
as a freelancier,
such in the book,
well,
I, I I I thought,
is it already,
Well,
it's actually like a real idea.
Like, you know,
you know,
Like you need to pour on the people that try to rise,
there,
uh,
there be used on the server,
I think they will love it so,
that's about it for my toll.
So I have some special things.
I just want to thanks Matilda,
because it's my girlfriend and she
sort of forced me to do this tool,
but I kind of join,
Andre,
I also want to thank Lu here, which is my coworker and with her, I'm working on the
browser engine and I want to thank Jordan because it worked a lot of cute kit and also
all of the DVC Discord server and OSD Discord server because what's fun to show my stuff
there and get their feedback and stuff. And obviously all of you for watching this talk.
Thank you.
Mostly 36.
Oh yes.
Which architecture do it's fun?
It's fun.
Mostly on X86.
I think you can just like boot kind of the operating system.
You like reach 5, but not yet.
And it doesn't run on real hardware.
I don't see why it will not seem to use.
We might not have like keyboard interface and mouse because we don't have a USB stack.
And we rely on the PS2 fold back so they can do.
So we will not have like a real hardware.
Maybe you can have like the boot screen working.
Okay.
So I didn't like and get it on real hardware if I have PS2.
Sorry.
I didn't have PS2 in my hardware.
So the question was if you have PS2 on your hardware, it will work.
I think.
Except on the mind over.
Sure.
Okay.
You mentioned that the Windows server has custom protocol.
Yes.
Do clients sign rendering as it is used today?
Yes.
It's a fully client-sized render.
As you can see, Doom doesn't have like the bar on top because I didn't had the time to
think it down and leave some space right.
Question?
Yes.
And that was the UFI.
So the question was.
Is this the UFI from before?
Yes.
It was using GOP to access the frame buffer.
What security mechanisms does your microcode support?
Do you have capabilities or anything like that?
So the question was what are the security measures in the microconel?
The only security is like whatever is guaranteed by having the processes isolated in different
pitch tables.
And the capabilities, we have like a handle table to everything that the each task can access.
Each task has like a domain.
They can like indexing to find pointers to other objects.
It's pretty simple.
And then a domain can be like there like they can kind of represent a tree.
So you can index into the domain of another task.
If you have a capabilities to the domain of this task.
So this way you can like prepare the environment for another task and then spawn it.
Which is pretty simple or text book stuff, I guess.
Yes.
Oh yes.
Okay.
So the question was those the UFI library will run on Linux.
And yes it works.
It works everywhere.
Because I can like a suite quickly.
I can since I have a Linux I will have internet.
So I cannot show my website also.
I did the P.
I cannot type them to stress away.
So I will just I.
Okay.
I like it.
Okay.
It doesn't work.
I don't know.
Okay.
You see, it's just work on Linux.
And yeah.
Okay.
The same question that I want to ask like what's the code you managed to state.
Okay.
So the question is how does a state management not work.
So it's this like really hype and trendy way of doing it.
So it's very easy.
And then the place will be UI.
Yes.
It's mostly like a helm architecture.
Which one are we like this funds in here.
I don't want to show me it.
Okay.
The people.
Does I have the.
Contrary.
Yes.
I just wanted like you just implement like this a basic state system.
And then you have like messages.
And then you have like a reducer that applied the message under state at the right time.
So it's pretty modern.
Like it's so kind of inspired by a react and reduce kind of thing.
And all the libraries in this same vein.
So the question is.
No idea.
There's a send a question.
So.
Okay.
The question correctly.
Can you define your own component for the library?
Oh, yes.
It's just a class.
You have to subclass.
And then you can do this is for like low level stuff.
And then you can like compose them together and ask them to build them together.
So for for example, I've like this is like the simple counter application for your own
The back.
So we don't you might not see it well.
So maybe.
But it just like.
I don't know to to describe it.
But you can assemble stuff like you will do in react.
And if you have to do like a low level like event routine or painting stuff, you can just
subclass the UI node class.
And you can do whatever you want in this.
It's not like there is no.
Second class first class.
You got always in first class.
So stuff.
I mean, the same.
We don't use a need.
We don't use the ellipsi, well, we have like a basic ellipsi because the compiler requires it
So it's just like some basic string function, but it's really simple
Right now we well do use some kind of some of the classic APIs, but right now no
But I think it will be kind of complicated, since everything is like using this C++
Corrupting so you will need to find a way to translate like asynchronous code into synchronous one
I don't see a blocker, but we didn't work on it yet
I don't know my brain can only read the comics on a mess, so it's probably because of cool something I use