Dusk OS is a 32-bit Forth and big brother to Collapse OS. Its primary purpose is to be maximally useful during the first stage of civilizational collapse, that is, when we can't produce modern computers anymore but that there's still many modern computers around.
It does so by aggressively prioritizing simplicity at the cost of unorthodox constraints, while also aiming to make operators happy.
Dusk OS innovates by having an "almost C" compiler allowing it to piggy-back on UNIX C code, through a modest porting effort, to reach its goals and stay true to its design constraints with a minimal effort.
The end result is a system that has a very high "power density", high enough to issue a challenge to the conventional software culture.
You can read on for more details, but the impatient among you might prefer taking the Dusk Tour.
List of ported codebases:
puff() algorithm from zlibList of homegrown applications:
$ git checkout v19
$ make dusk
$ ./dusk -f fs/home/codesz.fs
Kilobytes of code in Dusk OS
Everything except /doc /data /tests 728
Documentation 714
Boot payload minus HAL 50
C compiler 49
Oberon compiler 43
Oberon system 98
Lisp 16
Text Editor 13
All USB drivers 62
EFI drivers 14
This script 3
CPU-specific... i386 amd64 arm riscv m68k
Assembler 11 same 5 14 5
Kernel 10 9 13 14 9
HAL 6 6 7 8 7
EFI interface 4 4
As a reference, running wc -c *.c *.h lib/* include/* on TinyCC
0.9.27's source code yields 1420 kilobytes of code.
Dusk OS's git repository is hosted on sourcehut. The regular way of
getting it will be to clone the repository from there. You can try to run it
directly from the master branch or you can target one of its
releases using the release tags (for example v11).
More information about how to build and run Dusk OS is available in the root README as well as in its documentation.
Becoming a Dusk operator is an involving process. It's possible that you're interested in tasting a bit of Dusk's power before you dive into this wonderful adventure of learning Forth and Dusk. You're in luck, there's the Dusk Tour which doesn't require prior Forth knowledge and allows you to dip your toes in it.
For deployments to actual machines, there's also the Dusk OS Deployments collection that can be of use.
There is also the option of building Dusk Packages on top of other OSes. You can look at Dusk Packages examples for a quick start.
I began a sabbatical from working on modern technology in 2023, which I hope to extend indefinitely. To that end, I've put up a service offering that I hope might help me towards that goal. On that front, I have good reasons to be optimistic as the sponsors ball is already rolling!
Moreover, I believe that my work on Dusk OS and Collapse OS could be significant enough to some people that it could end up being philanthropically funded. If you're rich and inspired by this work, please consider it.
Most modern operating systems can do whatever we want them to do. Why do we need another one? Simplicity.
It's difficult to predict post-collapse conditions, but we can suppose that many operators will need to use their machines in novel and creative ways. Hackability of the operating system then becomes paramount. Open source modern operating systems all can be modified to fit its user's needs, but their complexity limits the likelihood that the user is able to do so. A simpler OS increases this likelihood.
But we can't have our cake and eat it too, right? Either you have a simple toy OS or a complex one. Well, maybe not?
Its instigator (and, I guess, some of its authors and sponsors too) believes that in the history of computing, Forth has been under-explored. Its approach to simplicity is, I think, revolutionary. It has significant shortcomings when system specifications become more complex (Forth hates complexity and doesn't manage it well), but I believe it possible to elegantly marry it with languages that like complexity better.
This mix could provide the operator with computing powers rarely seen with other approaches. We've got to try it.
While the primary purpose of this operating system is related to civilizational collapse, it's also in big part a reaction to the modern software stack. That stack is disgustingly complicated. It's a product of the compounded effect of a software culture that breeds complexity and had the opportunity to build upon itself over decades, unchecked and unchallenged, oozing its inscrutable pus at every corner.
The further we let that culture creep out, the harder it is to get out of it. Hardware follows it dutifully -- and in the same spirit of spurious complexity -- making clean slate approaches more and more out of reach... but not impossible yet!
Dusk OS has an amazing "power density", that is, it packs a lot of power in a very small package. This density allows it to do many things that the modern stack can do at a fraction of the complexity cost.
It is partly intended as a wake up call to software developers: the regular way to develop software today is stupid and wasteful and has been for the last 30 years. This stupidity and wastefulness feeds itself and makes us design bigger and stupider1 hardware to cater to bigger and stupider software.
We don't need this. All this sweat, tears and blood (because yes, blood is involved in having a global supply chain enabling these crazily complex machines we produce) is futile because the conventional approach to computing is an evolutionary dead end.
There are other ways and we urgently need to explore them. Forth is such a way. It had a hard time adapting to bigger machines because of its affinity for simplicity which makes it a bad fit to spurious hardware complexity.
Dusk OS aims to bridge that gap and be a Forth that, yes, is a bit more complex than your run-of-the-mill Forth, but is careful to keep that very high "power density" making Forth revolutionary and use that spurious power that modern hardware gives us, thus competing better, feature-wise, with the modern software stack.
One thing that makes Dusk OS special is that it boots from a tiny kernel weighting less than 4 kilobytes. From this tiny core, on boot, it builds its way up, from source code, to a system that has a functional C compiler, which then allows it to bootstrap itself some more, from source code.
This peculiarity of Dusk OS has interesting properties. The nicest one, in my humble opinion, is that this allows us to sidestep the entire problems of binary compatibility and relocation and only deal with source compatibility. So, no ELF, no binutils, only code that is designed to run from where it was generated in the first place. This is so much simpler!
Object files? Global symbols? Nah. C functions are simple Forth words.
Dusk features what we call the Harmonized Assembly Layer (HAL for short). This is a cross-CPU assembler, on which the C compiler relies, which prioritizes implementation and usage simplicity, but is also designed to generate efficient native code.
Dusk OS self-hosts in about 500 lines of assembly and a few hundred lines of Forth (the exact number depends on the target machine). From there, it bootstraps to DuskCC, which is roughly 1200 lines of Forth code. To my knowledge, Dusk OS is unique in that regard.
You can pick any C compiler that requires POSIX and it will automatically require orders of magnitude more lines of code to bootstrap because you need that POSIX system in addition to the C compiler. So even if you pick a small C compiler such as tcc, you still need a POSIX system to build it, which is usually in the millions of LOCs.
To be fair, Dusk OS is not the first project thinking of optimizing that path. Efforts at making our modern software world bootstrappable lead to an "almost C", M2-Planet with a feature set comparable to DuskCC with very few lines of code. M2-Planet itself is about 5K lines of code and the various stages that lead to it are generally a few hundred lines each. The project initially ran on top of regular kernels (as in "fat kernels with lots of code"), but some bare metal stages (1, 2) were created and now this little chain end up being comparable to Dusk in terms of lines of code. Still more than Dusk, but in the same ballpark.
Although this path is short and technically leads you to an "almost C" compiler, you can hardly use it because it has no "real kernel" (those bare metal stages mentioned above are enough to compile M2-Planet, but really not much else, they're extremely limited) and no shell. You'll need those if you want to use your shiny compiler.
One of your best picks, should you try this path, would be Fiwix, a minimal POSIX i386 kernel weighting less than 50K lines of C+asm. But then, M2-Planet is not enough. You need to compile tcc (which M2-Planet can compile after having applied a few patches) which weights 80K. Userspace is worse. Bash+coreutils are 400K, even busybox is 190K. We still end up with a pretty minimal and simple system, but it's still a lot more code than Dusk.
So, unless someone tells me about some option I don't know about, DuskCC is quite innovative on the aspect of self-hosting path length.
The code generated by Dusk OS holds pretty well to modern compilers with fancy optimizations and millions of lines of code.
In a Byte Sieve benchmark done on a i386 NetBSD system,
the DuskCC version of the sieve is almost as fast as GCC's unoptimized build and
the HAL's translation of the Sieve algorithm blows past GCC's unoptimized build
to nearly reach the speed of GCC -O2!
And it gets better! HAL's design allows efficiency to naturally "bubble up" to
higher level code with impressive results. For example, there's the
"charcount" example which pits Dusk's rfind against POSIX's
regex(3). For this particular and simple use case (count occurrences of
characters range in a big file), Dusk is 15% faster than Debian bookworm amd64's
regex(3) implementation.
Dusk OS doesn't have users, but operators. What's the difference? Control. You use a phone, you use a coffee machine, hell you even use a car these days. But you operate a bulldozer, you operate a crane, you operate a plane.
You use Linux, you use Windows. You operate Dusk OS.
Can you operate Linux? Sure, if you're some kind of god2, in the same way that you can operate a Tesla if you're a top Tesla engineer. But you're much more likely to be able to operate a landmower than a Tesla.
When you operate a system, there is no problem that can arise that will make you powerless. Sure, you can have a hardware failure that hopelessly breaks your system, but at least you'll be able to identify that failure and know for sure that there is no software solution or workaround. That's control.
The Dusk operator is someone who's creative, close to hardware, can read a datasheet. Dusk shines when one wants to poke around the hardware without limit.
It compares favorably to other more complete OSes because there's no concurrent process to mess with your poking and the driver structure is more approachable, hackable due to its stricter scope and savvier target audience. Also, there is no "userland". Every tool that Dusk provides or that the operator builds can be directly used on system memory. No middleman.
Let's use an example. Let's say you're on a notebook that runs on a chipset of Intel's ICHn family. You read the datasheet and see "oh, nice, there's an SPI interface in there. Maybe that it's not hooked to anything on the notebook, let's play with it."
Now, that chipset is very, very central to the computer. There are good chances, on a BSD or Linux system, that if you begin poking around its registers, you'll step on someone else toes and crash the system because, for example, of some other process that needed to read from disk at the same time.
In Dusk, you could completely break the SATA controller, you'll still be golden as long as you don't access mass storage. Because Dusk doesn't have concurrency, you have tight control over what happen or doesn't happen on the machine, so all you need to do is to avoid words that access mass storage. That gives you ample wiggling space for your hacking session.
To be clear: this is also possible with a custom made BSD or Linux, but you're going to have to strip a lot of pieces from your distro before you get there and some of those pieces might be useful debugging tools which will be difficult to retrofit because they need a wider system. You'll also need a higher cognitive space to fit BSD/Linux wider abstractions in your mind.
If you want to link to this website, please use http:// links rather than
https:// ones. While http:// links are trivially "upgradable" to HTTPS, the
opposite is not.
Right now, this website is hosted on a service (sourcehut pages) that doesn't
offer the option of not using SSL, but eventually, it's possible that this
website ends up being served by a machine running Dusk OS. In that case, it
will not be served under SSL and all https:// links will be broken.
in the sense of "smartness per transistor". In a 6502, each transistor is more expertly placed and useful than in a modern processor, where we just cram more of them. Also, each transistor does "stupider" things as software quality degrades. Sure, you can run smart software on stupid hardware, but that hardware has been specifically designed, through sweat and blood, to cater to the stupid software. ↩
Can you fix bugs in GCC, awk, perl and the SATA drivers? Yeah, you're some kind of god. ↩