awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
rcore-os avatar

rcore-os/rCore

0
View on GitHub↗
3,688 stars·378 forks·Rust·MIT·14 views

RCore

rCore is a Rust-based operating system kernel and microkernel designed for Linux compatibility. It functions as a self-hosted development kit that implements a system call interface to support the execution of standard Linux userspace applications.

The system is designed for modularity, featuring a mechanism for loading and integrating kernel modules into the active environment without requiring a system reboot.

The kernel provides core operating system capabilities, including virtual memory mapping for process isolation, a disk-based file system for data persistence, and a layered network protocol stack. It also includes an interrupt-driven asynchronous input and output system and a signal coordination mechanism for communication between isolated processes.

Features

  • Linux-Compatible Kernels - Acts as an operating system core that mimics Linux environment behaviors to support standard Linux programs.
  • Linux-Compatible Kernel Development - Develops a Rust-based kernel designed to execute standard Linux userspace applications.
  • File Storage Systems - Implements a basic file system for organizing, writing, and persisting data to a storage medium.
  • Layered Network Stacks - Ships a structured hierarchy of protocol layers to process network traffic.
  • Asynchronous IO Systems - Implements an interrupt-driven asynchronous input and output system to prevent execution thread blocking.
  • Disk-Based File Systems - Provides a disk-based file system to manage the organization and persistence of data.
  • Kernel Memory Implementations - Implements low-level kernel memory management including paging and virtual address mapping.
  • Memory Mapping Interfaces - Provides low-level interfaces for mapping physical and virtual memory regions to ensure process isolation.
  • System Call Interfaces - Implements a system call interface that mimics Linux to provide core kernel services to userspace applications.
  • Operating System Kernels - Implements a core operating system kernel written in Rust with a Linux-compatible system call interface.
  • Rust-Based Microkernels - Provides a modular system core using Rust to manage memory allocation, process isolation, and asynchronous IO.
  • System Call Interfaces - Provides a Linux-compatible system call interface that allows userspace applications to request core kernel services.
  • Virtual Memory Mapping - Manages memory allocation and process isolation through a page table-based virtual memory mapping system.
  • Linux Compatibility Layers - Implements a compatibility layer that allows standard Linux userspace applications to run within the kernel environment.
  • Non-blocking IO Architectures - Designs non-blocking input and output mechanisms to maintain system responsiveness during heavy processing.
  • Network Stacks - Implements a structured, layered network protocol stack for managing data communication within the kernel.
  • Interrupt-Driven Async IO - Ships an interrupt-driven asynchronous IO system to prevent the main execution thread from blocking during data operations.
  • Kernel Extension Frameworks - Implements a system that allows new features and drivers to be loaded into a running kernel.
  • Dynamic Kernel Module Loading - Allows new kernel functions to be integrated into the active environment without requiring a system reboot.
  • Operating System Development - Functions as a self-hosted development kit for building and extending a complete operating system stack.
  • Asynchronous Process Signaling - Implements a signaling mechanism for asynchronous coordination and event notifications between isolated processes.
  • Dynamic Kernel Modules - Provides a mechanism to load and integrate kernel modules into the active environment without a restart.
  • Process Coordinators - Provides a signal coordination mechanism to manage communication and events between isolated processes.

Star history

Star history chart for rcore-os/rcoreStar history chart for rcore-os/rcore

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with RCore

These projects share indexed features with RCore. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • mit-pdos/xv6-publicmit-pdos avatar

    mit-pdos/xv6-public

    9,466View on GitHub↗

    xv6 is a Unix-like educational operating system designed for teaching kernel concepts. It is implemented as an instructional kernel for x86 and RISC-V architectures, featuring a virtual memory manager and support for symmetric multiprocessing. The system is designed to demonstrate core OS principles through a simplified re-implementation of Unix Version 6. It provides a controlled environment for studying system calls, trap handling, and process lifecycles. Its capability surface covers process management, including scheduling and context switching, and memory management via page tables for

    C
    View on GitHub↗9,466
  • chyyuu/os_kernel_labchyyuu avatar

    chyyuu/os_kernel_lab

    4,045View on GitHub↗

    This project is an educational framework and toolkit designed for developing and testing operating system kernels. It provides a structured environment for implementing fundamental system primitives, including virtual memory management, preemptive process scheduling, and filesystem organization, using Rust and C. The framework is specifically oriented toward RISC-V and x86 architectures, serving as a laboratory for learning how to build core system software from the ground up. The project distinguishes itself by supporting both bare-metal deployment and hardware emulation, allowing developers

    Rustkernellabos
    View on GitHub↗4,045
  • klange/toaruosklange avatar

    klange/toaruos

    6,783View on GitHub↗

    ToaruOS is an independent operating system built from the ground up without external dependencies. It features a custom x86-64 kernel that supports symmetric multiprocessing and paging, paired with a graphical windowing system and a dedicated bytecode interpreter for application logic. The system distinguishes itself by integrating an embedded Python environment for system-level development and a custom graphical interface that handles its own window composition and text rendering. It includes a compatibility layer for third-party application support and a system package manager for handling

    Caarch64armv8baremetal
    View on GitHub↗6,783
  • redox-os/redoxredox-os avatar

    redox-os/redox

    16,054View on GitHub↗

    Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe language for the kernel and all system components, the project eliminates common vulnerabilities such as buffer overflows and use-after-free errors. Its architecture relies on a minimal kernel that manages only essential hardware and process isolation, delegating all other system services to unprivileged user-space processes. The system distinguishes itself through a modular design where hardware drivers and system services run as independent user-space daemons, allowing them to

    Rustbsdfreebsdgnu
    View on GitHub↗16,054
Compare all 30 related projects→

Frequently asked questions

What does rcore-os/rcore do?

rCore is a Rust-based operating system kernel and microkernel designed for Linux compatibility. It functions as a self-hosted development kit that implements a system call interface to support the execution of standard Linux userspace applications.

What are the main features of rcore-os/rcore?

The main features of rcore-os/rcore are: Linux-Compatible Kernels, Linux-Compatible Kernel Development, File Storage Systems, Layered Network Stacks, Asynchronous IO Systems, Disk-Based File Systems, Kernel Memory Implementations, Memory Mapping Interfaces.

Which projects share features with rcore-os/rcore?

Projects with overlapping indexed features include: chyyuu/os_kernel_lab — This project is an educational framework and toolkit designed for developing and testing operating system kernels. It… mit-pdos/xv6-public — xv6 is a Unix-like educational operating system designed for teaching kernel concepts. It is implemented as an… klange/toaruos — ToaruOS is an independent operating system built from the ground up without external dependencies. It features a… redox-os/redox — Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe… maxogden/art-of-node — This project is a structured Node.js programming course and educational guide designed to teach JavaScript backend… asterinas/asterinas — Asterinas is a memory-safe operating system kernel designed to prevent data races and memory corruption. It functions…