A new operating system kernel with Linux binary compatibility written in Rust.

Overview

Kerla

CI

screenshot

Kerla is a monolithic operating system kernel from scratch in Rust which aims to be compatible with the Linux ABI, that is, runs Linux binaries without any modifications.

  • Implements *NIX process concepts: context switching, signals, fork(2), execve(2), wait4(2), etc.
  • Supports commonly used system calls like write(2), stat(2), mmap(2), pipe(2), poll(2), ...
  • No disk support for now: initramfs is mounted as the root file system.
  • Pseudo file systems: tmpfs and devfs.
  • smoltcp-based TCP/IP support.
  • Implements tty and pseudo terminal (pty).
  • Supports QEMU and Firecracker (with virtio-net device driver).
  • Supports x86_64.
  • Docker-based initramfs build system.

Check out my blog post for motivation and my thoughts on writing an OS kernel in Rust.

Demo: SSH into Kerla!

You can play with Kerla over ssh. Your login is not visible from others (except me): we automatically launch a dedicated microVM on Firecracker for each TCP connection.

If you found bugs or missing features, let me know on GitHub issues :)

Running a Docker Image (experimental)

You can run a Docker image as a root file system (not as a container!) on Kerla Kenrel instead of our initramfs built from initramfs directory.

For example, to run nuta/helloworld image (Dockerfile), try the following command:

$ make IMAGE=nuta/helloworld run
...
[   0.029] syscall: execve(439398, 4393b8, 4393c8, 8, 2f2f2f2f2f2f2f2f, 8080808080808080)
[   0.030] syscall: arch_prctl(1002, 4055d8, 0, 20000, 0, ff)
[   0.031] syscall: set_tid_address(4057f0, 4055d8, 0, 20000, 0, ff)
[   0.033] syscall: ioctl(1, 5413, 9ffffeed0, 1, 405040, 9ffffeef7)

 _          _ _                            _     _ _
| |__   ___| | | ___   __      _____  _ __| | __| | |
| '_ \ / _ \ | |/ _ \  \ \ /\ / / _ \| '__| |/ _` | |
| | | |  __/ | | (_) |  \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___/    \_/\_/ \___/|_|  |_|\__,_(_)

This feature is in the very early stage and I guess almost all images out there won't work because:

  • They tend to be too large to be embedded into the kernel image.
  • They might use unimplemented features (e.g. position-independent executables used in Alpine Linux).

Building and Running the OS

See HACKING.md for instructions on building from source, running on emulators, etc.

Compatibility

See COMPATIBILITY.md for the current status.

Contributing

Send me bug reports, feature requests, and patches on GitHub for example:

  • Implementing missing features: majority of existing Linux applications won't work due to the lack of features.
  • Writing documentation: I think Kerla could be good material to learn how operating system kernel works.
  • Trying experimenting with Rust-y ideas: for example currently I'm interested in GhostCell.

License

See LICENSE.md.

Related Work

Emulating Linux ABI is not a novel work. Some UNIX-like kernels like FreeBSD and NetBSD already have their own Linux emulation layers. Windows has a well-known feature called Windows Subsystem for Linux (WSL) which enables running Linux binaries seamlessly. WSL 1 implements the feature by the ABI emulation. WSL 2 runs the real Linux kernel using the hardware-accelerated virtualization (Hyper-V) by the way.

Aside from general-purpose operating systems, there're some attractive projects related to the Linux ABI emualtion. OSv is a unikernel which runs unmodified Linux binaries. rCore is a teaching operating system which implements the Linux ABI in Rust. Noah suggests an intriguing approach to run unmodified Linux binaries on macOS.

Comments
  • Maybe change the license is good choice (such as GPLv3)

    Maybe change the license is good choice (such as GPLv3)

    The big problem of MIT license is that the companies love take the project and close it or not colaborate in the main or parent project. Because MIT license has not the "Freedom 3: The freedom to improve the program, and release your improvements (and modified versions in general) to the public, so that the whole community benefits." .

    There are a lot of links about this:

    • https://www.lesinskis.com/MIT-licence-community-hostile.html
    • https://www.gnu.org/philosophy/open-source-misses-the-point.en.html
    • https://www.quora.com/What-are-the-key-differences-between-the-GNU-General-Public-license-and-the-MIT-License

    IMHO: GPLv3 is better.

    opened by mdtrooper 108
  • #70 implement ext2

    #70 implement ext2

    Summary

    it's better to merge this ext2 library once it got a MVP feature like

    tasklist

    • [ ] defined struct
    • [ ] try to read super block ... to be continue🤔
    opened by dust1 46
  • Implement Virtio Block Driver

    Implement Virtio Block Driver

    This PR works towards resolving #74.

    Checklist Towards Completion

    • [x] Complete function to handle interrupts
    • [x] Handle PCI and MMIO
    • [x] Enable block device from qemu side
    • [x] Register Device
      • [x] Resolve kernel panic upon block driver initialization
    • [ ] Ensure Driver works
    opened by bayedieng 30
  • Suggestion: Kerla Chatroom

    Suggestion: Kerla Chatroom

    Github is nice and all for posting issues, but perhaps this project would benefit from a community chatroom somewhere?

    I know I'd like to dive in and hack at a system call or two, but the real-time collaboration a chatroom could provide would help immensely.

    I'd prefer a Discord server myself, but I'm amicable to anything really. Whatever it is, I think it's something @nuta should start to avoid any conflicts of interest :-)

    opened by yamamushi 11
  • exec `make` have a rpc receive error

    exec `make` have a rpc receive error

    It looks like I have encountered the limitation of grpc transfer file size, But I can't find where I can set this value.

         BUILD  testing
    [+] Building 3.6s (17/42)
     => [internal] load build definition from Dockerfile                                                               0.0s
     => => transferring dockerfile: 32B                                                                                0.0s
     => [internal] load .dockerignore                                                                                  0.0s
     => => transferring context: 2B                                                                                    0.0s
     => [internal] load metadata for docker.io/library/ubuntu:20.04                                                    0.0s
     => [internal] load build context                                                                                  0.0s
     => => transferring context: 536B                                                                                  0.0s
     => [curl 1/8] FROM docker.io/library/ubuntu:20.04                                                                 0.0s
     => CACHED [curl 2/8] RUN apt-get update && apt-get install -qy build-essential curl sed                           0.0s
     => CACHED [curl 3/8] RUN apt-get install -qy musl-tools                                                           0.0s
     => CACHED [dropbear 4/11] RUN curl -fsSL --output tarball.tar.bz2 "https://matt.ucc.asn.au/dropbear/releases/dro  0.0s
     => CACHED [dropbear 5/11] RUN mkdir /build && tar xf tarball.tar.bz2 --strip-components=1 -C /build               0.0s
     => CACHED [dropbear 6/11] ADD dropbear/accept-empty-password-root-login.patch /build/accept-empty-password-root-  0.0s
     => CACHED [dropbear 7/11] ADD dropbear/localoptions.h /build/localoptions.h                                       0.0s
     => CACHED [dropbear 8/11] WORKDIR /build                                                                          0.0s
     => CACHED [dropbear 9/11] RUN sh -c 'patch --ignore-whitespace -p1 < accept-empty-password-root-login.patch'      0.0s
     => [dropbear 10/11] RUN ./configure CC=musl-gcc --enable-static --disable-largefile --disable-zlib --disable-sys  3.5s
     => => # checking for endutent... yes
     => => # checking for getutent... yes
     => => # checking for getutid... yes
     => => # checking for getutline... yes
     => => # checking for pututline... yes
     => => # checking for setutent... yes
     => CACHED [busybox 4/8] RUN curl -fsSL --output tarball.tar.bz2 "https://busybox.net/downloads/busybox-1.31.1.ta  0.0s
     => CACHED [busybox 5/8] RUN mkdir /build && tar xf tarball.tar.bz2 --strip-components=1 -C /build                 0.0s
     => CACHED [busybox 6/8] WORKDIR /build                                                                            0.0s
     => CACHED [busybox 7/8] ADD busybox/config /build/.config                                                         0.0s
     => [busybox 8/8] RUN yes n | make oldconfig     && ln -s /usr/bin/ar /usr/bin/musl-ar     && ln -s /usr/bin/stri  3.5s
     => => # ) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6]
     => => # (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW)
     => => # Minimum password length (PASSWORD_MINLEN) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW) Minimu
     => => # m password length (PASSWORD_MINLEN) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW) Minimum pass
     => => # word length (PASSWORD_MINLEN) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW) Minimum password l
     => => # ength (PASSWORD_MINLEN) [6] (NEW) Minimum password length (PASSWORD_MINLEN) [6] (NEW)
    failed to receive status: rpc error: code = ResourceExhausted desc = grpc: received message larger than max (5417870 vs. 4194304)
    make[2]: *** [Makefile:193: build/kerla.initramfs] Error 1
    make[1]: *** [Makefile:92: build-crate] Error 2
    make: *** [Makefile:78: build] Error 2
    
    Type: Build Error 
    opened by dust1 9
  • make run error: panicked at 'called `Result::unwrap()` on an `Err` value: TooShort'

    make run error: panicked at 'called `Result::unwrap()` on an `Err` value: TooShort'

    I followed the steps of quickstart.md to try to compile and run from the source code. When I executed make run, I got an error: image

    sorry, I personally don’t know how to solve it, so I created this issues.

    Vesion python 3.9.7 rustc 1.58.0-nightly

    OS Version: image

    opened by OnePieceJoker 9
  • For Issue No. 99

    For Issue No. 99

    To deal with discussions of Contracts/Documentations for rights of other people who fork the code in https://github.com/nuta/kerla/issues/5 & proposed changes in https://github.com/nuta/kerla/issues/99

    Closes #99 & #5

    opened by Daasin 8
  • Panic on irq_handler overwrite

    Panic on irq_handler overwrite

    Fixes #50

    In this PR we introduce struct IrqHandler.

    struct IrqHandler {
        callback: Box<dyn FnMut() + Send + Sync>,
        attached: bool,
    }
    

    Right now there is only one ancillary field - attached, which allows an "overwrite" check. But potentially opens the way to build something like /proc/interrupts.

    opened by Lurk 8
  • rt_sigprocmask syscall implementation

    rt_sigprocmask syscall implementation

    This pull request adds rt_sigprocmask syscall handler (https://man7.org/linux/man-pages/man2/sigprocmask.2.html).

    Before adding signal filtering, I want to discuss the general approach.

    Things that bother me:

    I feel like the how argument should be an enum, but how to handle EINVAL in that case?

    And the length argument doesn't make any sense to me. According to the manual, it is sizeof(kernel_sigset_t), and according to kernel sources, kernel_sigset_t is 1024 bits. So it always, according to POSIX, should be 128 bytes, unless we will run on something exotic like PDP-6/10 or DSP. If you can point me to some document or discussion to make sense of it, I would be grateful.

    Also set and oldset are 1024 bits in length. I am using a slightly modified BitMap from kerla_utils, but it is suboptimal. It is [u8;128], which means we have 128 iterations on SIG_BLOCK and SIG_UNBLOCK. The solution can be generic over the type BitMap. Or create a new LongBitMap, which will use u128 under the hood. Or, maybe we can use or take inspiration from something like https://docs.rs/bitmaps/latest/bitmaps/. But I have a feeling that this is a task by itself, and should be discussed in a separate issue/PR.

    opened by Lurk 7
  • building error

    building error

    hey @nuta team so I am facing this issue

         CARGO  kernel
    error: no such subcommand: `+nightly`
    make[1]: *** [build-crate] Error 101
    make: *** [build] Error 2
    

    any ideas on fixing this issue?? pls help me

    opened by NukeWilliams 6
  • make: rust-strip: No such file or directory

    make: rust-strip: No such file or directory

    I'm using archlinux and I installed the cargo and rustup dependencies , and docker,qemu,python3,gdb

    and I'm getting this error

    warning: kerla (bin "kerla") generated 9 warnings (1 duplicate) Finished dev [unoptimized + debuginfo] target(s) in 2.11s make[1]: Leaving directory '/home/coolpp/github/kerla' NM kerla.x64.symbols /bin/sh: line 1: rust-nm: command not found /bin/sh: line 1: rustfilt: command not found SYMBOLS kerla.x64.elf STRIP kerla.x64.stripped.elf make: rust-strip: No such file or directory make: *** [Makefile:67: build] Error 127

    opened by prajwalprabhu 6
  • [Resolves #142] Add lifetimes to VAddr & PAddr

    [Resolves #142] Add lifetimes to VAddr & PAddr

    Description

    An unfinished attempt to add lifetimes to VAddr & PAddr (as per #142).

    @nuta I stuck with:

    error[E0308]: mismatched types
       --> runtime/backtrace.rs:113:56
        |
    113 |         Backtrace::current_frame().traverse(|_, vaddr: VAddr<'memory>| {
        |                                                        ^^^^^^^^^^^^^^ lifetime mismatch
        |
        = note: expected struct `address::VAddr<'_>`
                   found struct `address::VAddr<'memory>`
    note: the anonymous lifetime #1 defined here...
       --> runtime/backtrace.rs:113:45
        |
    113 |           Backtrace::current_frame().traverse(|_, vaddr: VAddr<'memory>| {
        |  _____________________________________________^
    114 | |             if let Some(symbol) = resolve_symbol(vaddr) {
    115 | |                 let _ = trace.try_push(CapturedBacktraceFrame::<'memory> {
    116 | |                     vaddr,
    ...   |
    120 | |             }
    121 | |         });
        | |_________^
    note: ...does not necessarily outlive the lifetime `'memory` as defined here
       --> runtime/backtrace.rs:111:43
        |
    111 |     pub fn capture() -> CapturedBacktrace<'memory> {
        |                                           ^^^^^^^
    

    I'm not the expert of lifetimes, but I read this a problem with the lifetime of the closure as argument of traverse(). Any suggestions welcome.

    Pre-Submission Checklist

    When you submit a PR, please make sure your PR satisfies the following checklist:

    • [X] I assert this contribution was authored by me.
    • [X] I license this contribution under the license of this project.
    • [X] The PR title describes your changes briefly and uses the present tense, without a trailing full stop.
    • [X] The PR description describes the reason why we need the change.
    • [X] This is an isolated change. No multiple changes and no unrelated changes are included.
    • [ ] Fixed all cargo clippy warnings.
    • [ ] Applied rustfmt.
    opened by michalfita 1
  • Add lifetime to `PAddr` and `VAddr`

    Add lifetime to `PAddr` and `VAddr`

    In #141, I noticed that we need to track the lifetime of a PAddr object which references to OwnedPages. It's problematic because it lead to memory leaks or nasty use-after-free bugs. In this issue, I'll replace PAddr and VAddr as:

    #[repr(transparent)]
    pub struct PAddr<'a> {
        value: usize,
        _pd: PhantomData<&'a ()>,
    }
    
    Type: Enhancement 
    opened by nuta 0
  • [#88] Draft of foundations for `clone3()` syscall & friends

    [#88] Draft of foundations for `clone3()` syscall & friends

    This is draft for bringing in resolution for #88. The whole work is pretty complex, so probably would need to be split into pieces. I already defined a few things to fix first for get this any further.

    I don't have much time to work on it, but I'll tray to add bits into it as time allows. Till then please look and comment.

    Any input appreciated.

    opened by michalfita 1
  • Compress symbol table

    Compress symbol table

    Currently, a symbol table reserves 2MiB space to store symbols (e.g. function names) of the kernel. Because symbols in Rust tend to be lengthy, they are truncated to 55 characters.

    This issue aims to implement a simple symbol table compression to:

    • Decrease the kernel image size.
    • Print the whole symbol name (avoid truncating).
    Type: Enhancement 
    opened by nuta 3
  • `RootFs` need to be cloneable, so the whole state can be copies instead of inherit a reference on `fork()`/`clone()`

    `RootFs` need to be cloneable, so the whole state can be copies instead of inherit a reference on `fork()`/`clone()`

    At the moment Process::fork() seem to clone the Arc<RootFs> instead of content of the RootFs itself, what leads to shared RootFs between processes, not independent file system states.

    Found during work on #88 and belongs to Multithreading milestone (I can't add myself).

    More details in the flags mask of clone(2), scroll down to CLONE_FS. I haven't checked yet how it's implemented in Linux Kernel.

    Linux Compatibility 
    opened by michalfita 3
Releases(v0.1.0)
  • v0.1.0(Dec 24, 2021)

    Run the following command to try Kerla on QEMU:

    qemu-system-x86_64 -m 512 -cpu Icelake-Server -serial mon:stdio \
        -netdev user,id=net0                                        \
        -device virtio-net,netdev=net0,disable-legacy=on            \
        -kernel kerla.x64.elf
    

    Notable Changes

    • The first cloud support for DigitalOcean: for example, my website is now powered by Kerla on DigitalOcean!
    • boot2dump support: if an ext4 disk is attached over virtio-blk, kernel panic log will automatically saved into /kerla.dump.

    All Changes

    Baye Dieng (2):

    • Remove redundant files already defined in virtio crate (#84)
    • Make driver trait available globally for other drivers and typo fix (#89)

    Seiya Nuta (42):

    • Isolate arch-specific and memory allocators into a separate library (kerla_runtime) (#77)
    • Use Rust 2021 edition (#78)
    • Turn device drivers into libraries (#80)
    • build: Use Docker image cross compiling for M1 Mac (#81)
    • Update author fields
    • Implement deferred job (#82)
    • Add some README.md
    • Rename initramfs to testing (#83)
    • Release IRQ_HANDLERS' lock before running deferred jobs (#85)
    • Generate the kernel extensions loader (#86)
    • Implement log filtering (#92)
    • build: Add $(QEMU_ARGS) option (#93)
    • Support the secondary serial port for kernel messages (#94)
    • x64: Make SyscallFrame compatible with Linux's struct pt_regs (#95)
    • Remove kexts_loader (#97)
    • initramfs: Implement file size (#122)
    • Implement shutdown(2) (#118)
    • Implement exit_group(2) syscall (#119)
    • Re-disable interrupts after handling an interrupt (#124)
    • Kill a process immediately if its parent ignores SIGCHLD (#121)
    • Make network parameters and allowed PCI devices configurable via cmdline (#123)
    • Support freeing pages (#120)
    • Use yapf for formatting python scripts (#125)
    • Implement /proc/metrics (#126)
    • Add rust-toolchain.toml (#129)
    • build: Allow specifying extra kernel parameters through $(CMDLINE) (#127)
    • downcast: Take a reference instead of the ownership (#130)
    • virtio: Fix a bug in used descriptors GC (#131)
    • net: Fix a memory leak (#132)
    • virtio: Support legacy virtio devices (#133)
    • /proc/metrics: Expose the monotonic clock (#134)
    • x64: Fill an XSAVE area with zeroes (#136)
    • net: Fix for dhcp=off (#135)
    • x64: Dump some important registers on an unsupported exception (#138)
    • allocator: Fill allocated pages with zeroes by default (#137)
    • Support saving kernel crash logs using boot2dump (#139)
    • x64: Fix memory leaks in a process internal buffers (#140)
    • Add docs
    • Fix some docs
    • Allow specifying multiple interrupt handlers for the same IRQ number (#143)
    • testing: Refactor Dockerfile (#128)
    • Add tools/create-release.py

    Serhiy Barhamon (4):

    • Panic on irq_handler overwrite (#53)
    • Single thread gettid syscall implementation (#75)
    • rt_sigprocmask syscall implementation (#112)
    • #112 followup (bugfix and fix build) (#114)

    dependabot[bot] (1):

    • build(deps): bump memoffset from 0.6.4 to 0.6.5 (#113)
    Source code(tar.gz)
    Source code(zip)
    kerla.x64.elf(7.52 MB)
  • v0.0.4(Nov 8, 2021)

    Run the following command to try Kerla on QEMU:

    qemu-system-x86_64 -m 512 -cpu Icelake-Server -serial mon:stdio \
        -device isa-debug-exit,iobase=0x501,iosize=2                \
        -netdev user,id=net0                                        \
        -device virtio-net,netdev=net0,disable-legacy=on            \
        -cdrom kerla.iso
    

    Seiya Nuta (3): Fix a syntax error in .github/workflows/release.yml ci: Fix the release workflow v0.0.4

    Source code(tar.gz)
    Source code(zip)
    kerla.iso(13.51 MB)
  • v0.0.3(Nov 8, 2021)

    Andrés Correa Casablanca (1): docs: mark few syscalls as implemented (#14)

    Dasein (1): Compromise license patch 1 (#13)

    Michał Fita (3): [ISSUE-29] IRQ handlers with no conditional branching (#37) [ISSUE-42] Reduce indirection of parent field in Process (#43) [#41] process: Implementation of getppid syscall (#46)

    Proloy Mishra (1): remove unnecesary loop in lang_items.rs (#32)

    Seiya Nuta (85): Fix a broken link virtio: Fix an out-of-bounds error virtio_net: Warn an invalid receive buffer uname: Update the version field initramfs/busybox: Update the build config vscode: Update the program filename boot_kernel: Print "Booting Kerla..." net: Ignore DHCP errors in the release build README: Add a screenshot and a CI status badge ring_buffer: make RingBuffer::new() const ring_buffer: Fix a bug occurred when trying to push an empty slice Implement syslog(2) panic: Update PANICKED before calling a print macro x64: Print '(empty)' if the cmdline is empty rt_sigaction: Support SIG_DFL Update screenshot.png Implement readlink(2) mm: Specify the order of buddy_system_allocator::LockedHeap Run Busybox shell on startup by default Update HACKING.md version 0.0.2 Move docs into Documentation Update a link in README Update README Address compiler warnings Add PR Guidelines Update PR guidelines README: Add the Discord badge Fix compiler warnings. NFC busybox: Enable some features in shell Introduce integration tests Include process's argv in a system call trace message ci: Try fixing integration tests ci: Fix the workflow definition ci: Fix the workflow definition again ci: Try fixing integration tests ci: Run sudo apt-get update before installing packages ci: Try fixing integration tests x64: Exit QEMU if $SEMIHOSTING_HALT_ON_PANIC is set x64: Disable auto \r printing in the serial port output ci: Exit QEMU on panic (or all tests are done) ci: Remove redundant newline characters from the GitHub's console Fix compiler warnings ci: Fix the multiline string indentation in ci.yml ci: Run unit tests README: Replace kerla-demo.seiya.me with demo.kerla.dev FIx compiler warnings on #[cfg(test)] Replace the initramfs build system with a single Dockerfile Implement reboot(2) syscall: Print argv0 instead of cmndline in a trace messsage Fix a compile error ci: Power off once integration tests are done initramfs: Add /usr/bin and /usr/sbin Embed a backtrace into Error in debug build Add a workaround for Docker's /etc/resolv.conf overriding process: Fine-grained locking (closes #49) process: Make all Process fields private. NFC Replace current_process_arc() with current_process(). NFC Address clippy warnings. NFC Add a debug assertion to ensure dead locks won't occur in the page fault handler Clean up "use" declarations. NFC Move utils to libs/kerla_utils. NFC Add make docs and make docsw command result: Fix a compile error in release build ci: Don't tolerate compiler warnings README: Update a link ci: Install clippy Fix a clippy warning. NFCI ci: Run clippy after building docs: Add architecture.md Add Code of Conduct (#38) Close opened files on exit (#55) process: Cleanup fields in Process (#56) Implement fmt::Debug for inode objects (#57) Fix opened file locking (#58) spinlock: Improve the debug message on a dead lock (#59) ci: Run tests in the debug build (#60) Refactor context switching. NFCI (#61) Call arch::print_str() directly on double panic (#64) backtrace: Don't access unmapped addresses (#68) Implement VGA console (#65) Implement boot time profiling (#67) ci: Automate releases (#66) Remove changelog.md v0.0.3

    Sergey Shepelev (1): typo (#4)

    Serhiy Barhamon (3): ISSUE-29: Switch IRQ handler's map from BTreeMap to array (#35) panic if handler for specific IRQ is already attached (#36) move net::process_packets() call from interrupt::handle_irq to handle (#47)

    Shlomi Fish (1): Correct some broken grammar in README.md. (#18)

    VocalFan (1): Dependency updates! (#11)

    Yoke (1): ISSUE-25:Add chmod implememt (#30)

    dependabot[bot] (1): build(deps): bump arrayvec from 0.7.1 to 0.7.2 (#31)

    Source code(tar.gz)
    Source code(zip)
Owner
Seiya Nuta
Seiya Nuta
Xrs is a POSIX-subset operating system kernel written in Rust.

XRS-OS ( ?? WIP) Xrs is a POSIX-subset operating system kernel written in Rust. Current project team members 0x5459 core developer (he/him) 0x5457 cor

null 7 Nov 16, 2022
Rux - An x86_64 toy operating system kernel written in Rust

Rux - An x86_64 toy operating system kernel written in Rust. Rux is a port of the Hux kernel, my x86 32-bit single-CPU toy kernel written in C, following the OSTEP book structure and terminology.

Guanzhou Jose Hu 6 Feb 26, 2022
The official kernel for Popcorn OS, and operating system designed for handheld devices.

About Popkern is the kernel for Popcorn OS, an operating system designed for handheld devices. As such, the kernel is (to be) optimised at all levels

Team Scena 3 Sep 19, 2021
Aero is a new modern, unix based operating system. It is being developed for educational purposes.

Areo Aero is a new modern, unix based operating system written in Rust and is being developed for educational purposes. Aero follows the monolithic ke

Anhad Singh 623 Dec 24, 2022
Writing an OS in Rust, To Study Operating System and Computer System

Hun Os Writing an OS in Rust, To Study Operating System and Computer System Reference Os Written In Rust https://github.com/seonghun-dev/blog_os https

Jung Seonghun 2 Dec 15, 2022
Linux kernel modules written in Rust

Linux kernel modules written in Rust A collection of in-progress experimental Linux kernel modules written for the Rust for Linux project To run the o

Milan 10 Nov 13, 2022
Linux ABI-compatible kernel written in Rust

Linux ABI-compatible kernel written in Rust ??️ Screenshot (v0.1.0-alpha.1) ?? Build dependencies To compile GalaxyOS kernel and create basic OS ISO i

Krzysztof Stefańczyk 3 Dec 5, 2022
Library for loading Linux kernel modules.

liblmod - Library for loading Linux kernel modules Features: modprobe rmmod Example code: extern crate liblmod; fn main() -> std::io::Result<()> {

Zapomnij 2 Aug 2, 2022
Operating system written in Rust for NumWorks calculator (model n0110)

RustWorks An OS (eventually) for the Numworks calculator (model n0110). Setup First install Rust by following these instuctions then: rustup target ad

null 30 Nov 10, 2022
SteinsOS is an operating system written in Rust

SteinsOS is an operating system featuring non-preemptive kernel targeting on single-core armv8 architecture.

Sheng 84 Dec 15, 2022
An attempt at an operating system written in Rust

Rust Operating System An attempt at a simple operating system in Rust and a semester project for the Operating Systems course at CS@UCU. Documentation

Andriy Sultanov 10 Jan 15, 2022
A Rust Operating System, written from the ground up

ThornOS A Rust Operating System, written from the ground up Build Dependencies Bootimage TODO: Document build process in more detail Acknowledgements

Stuart Reid 1 Mar 31, 2022
🌃 Shade is an operating system written for the communication.

?? Shade Shade is an operating system written for the communication. ?? Experiencing Building Requirements System: Windows, Linux or macOS. Memory: 1G

EnabledFish 2 Dec 22, 2022
A hobby operating system written in Zig & C that reimagines classic UNIX ideas for modern technology

zorroOS is a hobby operating system written in Zig, currently targeting x86_64 PCs. Building Building zorroOS is simple. First, ensure that you have t

TalonFox 34 Jul 5, 2023
A hobby operating system, in Rust

intermezzOS: kernel intermezzOS is a hobby operating system. This repository is for its kernel. See the website for more. License This project is dual

intermezzOS 1.3k Jan 1, 2023
A simples rust operating system that prints hello world.

rust-os-helloworld A simples rust operating system that prints hello world. Just run: cargo install bootimage and: cargo bootimage Install QEMU and: q

null 3 Nov 24, 2021
A Real Time Operating System in Rust for Cortex M3 embedded systems

A Real Time Operating System in Rust for Cortex M3 embedded systems

Manuel Forcén Muñoz 5 Jun 1, 2022
A secure embedded operating system for microcontrollers

Tock is an embedded operating system designed for running multiple concurrent, mutually distrustful applications on Cortex-M and RISC-V based embedded

Tock Embedded OS 4.1k Jan 5, 2023
A secure embedded operating system for microcontrollers

Tock is an embedded operating system designed for running multiple concurrent, mutually distrustful applications on Cortex-M and RISC-V based embedded

Tock Embedded OS 4k Jan 2, 2023