redox

Pros of Linux

• Massive ecosystem with extensive hardware support and driver availability
• Highly mature and battle-tested in production environments
• Large community and corporate backing, ensuring continuous development

Cons of Linux

• Complex codebase with a long history, making it challenging to maintain
• Monolithic kernel architecture, potentially impacting security and stability
• Slower to adopt modern programming practices due to legacy considerations

Code Comparison

Linux (C):

static inline void __list_add(struct list_head *new,
                              struct list_head *prev,
                              struct list_head *next)
{
    next->prev = new;
    new->next = next;
    new->prev = prev;
    prev->next = new;
}

Redox (Rust):

pub fn insert(&mut self, index: usize, element: T) {
    assert!(index <= self.len, "Index out of bounds");
    self.inner.insert(index, element);
}

The Linux code snippet shows low-level list manipulation in C, while the Redox example demonstrates a higher-level array insertion in Rust. This highlights the difference in language choices and abstraction levels between the two projects.

Redox, being written in Rust, benefits from memory safety and modern language features, potentially reducing certain classes of bugs. However, Linux's C codebase allows for fine-grained control and optimization, which can be crucial for kernel-level operations.

Pros of Serenity

• More active development with frequent updates and contributions
• Richer graphical user interface and desktop environment
• Broader compatibility with existing Unix/POSIX applications

Cons of Serenity

• Larger codebase, potentially more complex to understand and maintain
• Less focus on microkernel architecture, which may impact security and modularity
• Higher system requirements due to more feature-rich environment

Code Comparison

Serenity (C++):

int main(int argc, char** argv)
{
    Core::EventLoop event_loop;
    auto app = GUI::Application::construct(argc, argv);
    auto window = GUI::Window::construct();
    window->set_title("Hello World");
    window->show();
    return app->exec();
}

Redox (Rust):

fn main() {
    println!("Hello World");
}

The code comparison highlights Serenity's focus on GUI applications, while Redox demonstrates a simpler, more minimal approach. Serenity's example showcases its event-driven architecture and windowing system, whereas Redox's example is a basic console output, reflecting its emphasis on simplicity and core functionality.

Pros of Haiku

• More mature project with a longer development history
• Larger community and contributor base
• Better hardware support and compatibility with existing software

Cons of Haiku

• Less modern architecture compared to Redox
• Slower development pace
• More complex codebase due to legacy support

Code Comparison

Haiku (C++):

status_t
BApplication::_InitApplication_(const char* signature, status_t* _error)
{
    BAutolock lock(sAppLock);
    if (be_app != NULL) {
        if (_error)
            *_error = B_ALREADY_RUNNING;
        return B_ERROR;
    }
    // ...
}

Redox (Rust):

pub fn syscall(mut a: usize, mut b: usize, mut c: usize, mut d: usize, mut e: usize, mut f: usize) -> Result<usize> {
    unsafe {
        asm!("int 0x80"
             : "+{rax}"(a), "+{rbx}"(b), "+{rcx}"(c), "+{rdx}"(d), "+{rsi}"(e), "+{rdi}"(f)
             : : "memory", "cc");
    }
    Error::demux(a)
}

The code snippets showcase the different programming languages used (C++ for Haiku, Rust for Redox) and highlight the contrasting approaches to system-level programming between the two projects.

Pros of ReactOS

• More mature project with a longer development history
• Aims for Windows compatibility, potentially easier adoption for Windows users
• Larger community and contributor base

Cons of ReactOS

• More complex codebase due to Windows compatibility goals
• Slower development pace compared to Redox
• Potentially more security vulnerabilities due to mimicking Windows architecture

Code Comparison

ReactOS (C):

NTSTATUS NTAPI NtCreateFile(
    PHANDLE FileHandle,
    ACCESS_MASK DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes,
    PIO_STATUS_BLOCK IoStatusBlock,
    PLARGE_INTEGER AllocationSize,
    ULONG FileAttributes,
    ULONG ShareAccess,
    ULONG CreateDisposition,
    ULONG CreateOptions,
    PVOID EaBuffer,
    ULONG EaLength)

Redox (Rust):

pub fn open<P: AsRef<Path>>(path: P, flags: usize) -> Result<File> {
    let fd = syscall::open(path.as_ref().to_str().unwrap(), flags)?;
    Ok(File { fd })
}

The code snippets demonstrate the difference in language and approach. ReactOS uses C and closely mimics Windows API structures, while Redox uses Rust with a more modern and safe systems programming approach.

Pros of Harvey

• Written in C, which may be more familiar to many developers
• Based on Plan 9, offering a unique and innovative approach to OS design
• Supports multiple architectures, including x86, amd64, and arm64

Cons of Harvey

• Less active development compared to Redox
• Smaller community and fewer contributors
• Limited documentation and resources for newcomers

Code Comparison

Harvey (C):

void
main(int argc, char *argv[])
{
	rfork(RFNAMEG|RFENVG|RFFDG|RFREND);
	if(argc != 2)
		usage();
	mountnet(argv[1]);
	exits(0);
}

Redox (Rust):

fn main() {
    let mut socket = File::create(":0").expect("failed to create socket");
    let mut event_queue = EventQueue::<()>::new().expect("failed to create event queue");
    event_queue.add(socket.fd(), EVENT_READ, ()).expect("failed to watch socket");
    loop {
        let events = event_queue.run().expect("failed to run event queue");
        for event in events.iter() {
            if event.flags.contains(EVENT_READ) {
                let mut packet = [0; 65536];
                let count = socket.read(&mut packet).expect("failed to read packet");
                println!("Packet: {:?}", &packet[..count]);
            }
        }
    }
}

Both Harvey and Redox are open-source operating systems with unique approaches. Harvey is based on Plan 9 and written in C, while Redox is a microkernel OS written in Rust. Redox has a more active community and development, but Harvey offers support for multiple architectures. The code examples showcase the different languages and programming styles used in each project.