rcore-os/rcore

Analysis updated 2026-07-03

★ 3,683RustAudience · researcherComplexity · 5/5LicenseSetup · hard

Mindmap

mindmap
  root((rCore))
    What It Does
      OS kernel in Rust
      Linux syscall support
      Multi-architecture
    Tech Stack
      Rust
      QEMU
      GCC musl
      Docker
    Architectures
      x86-64
      RISC-V
      AArch64
      MIPS32
    Use Cases
      OS education
      Kernel internals
      Architecture emulation

mindmap root((rCore)) What It Does OS kernel in Rust Linux syscall support Multi-architecture Tech Stack Rust QEMU GCC musl Docker Architectures x86-64 RISC-V AArch64 MIPS32 Use Cases OS education Kernel internals Architecture emulation

Click or tap to explore — scroll the page freely

What do people build with it?

USE CASE 1

Study OS internals by reading and running a real kernel implementation written in modern Rust.

USE CASE 2

Boot rCore on x86-64, RISC-V, ARM, or MIPS hardware using QEMU without needing physical machines.

USE CASE 3

Run Linux-compatible programs on rCore to understand how system calls work at the OS level.

USE CASE 4

Use the Docker setup to build and test rCore without manually installing the full Rust and QEMU toolchain.

What is it built with?

RustQEMUDockerGCC

How does it compare?

	rcore-os/rcore	google/tarpc	grvydev/project-lightspeed
Stars	3,683	3,696	3,670
Language	Rust	Rust	Rust
Setup difficulty	hard	moderate	hard
Complexity	5/5	3/5	4/5
Audience	researcher	developer	ops devops

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1h+

Requires Rust toolchain plus QEMU 4.1 or newer. A musl GCC is needed for user programs. Docker image available.

Use freely for any purpose including commercial as long as you keep the copyright notice, available under MIT or Apache 2.0.

In plain English

rCore is an operating system kernel written in Rust, created as a teaching project at Tsinghua University in China. An operating system kernel is the core software that manages a computer's hardware and lets programs run. This project rewrites an earlier teaching OS called uCore in Rust, a programming language known for its memory safety properties. The repository is no longer actively maintained, and the README points to newer successor projects for anyone interested in current development. The kernel is compatible with Linux system calls, which means it can run programs originally written for Linux without those programs needing to be changed. Beyond that basic compatibility layer, rCore includes a network stack for internet communication, a simple file system for reading and writing files, a signal system for inter-process communication, asynchronous input/output operations, and support for loadable kernel modules. It runs on four different processor architectures: x86_64 (the standard PC chip type), RISC-V (a newer open instruction set used in embedded hardware), AArch64 (the architecture used in ARM chips, including the Raspberry Pi), and MIPS32 (used in some embedded and academic hardware). All of these can be tested using QEMU, which is a software tool that simulates hardware so you can run an OS without needing physical machines. Building rCore requires the Rust toolchain, QEMU version 4.1 or newer, and optionally a musl-based GCC compiler for building user programs. The README provides a Docker option for developers who prefer not to install dependencies manually. This project grew out of a series of undergraduate operating systems courses from 2018 through 2020 and was itself based on a well-known tutorial called Writing an OS in Rust. The source code is available under the MIT or Apache 2.0 license.

Copy-paste prompts

Prompt 1

Help me build the rCore kernel for the RISC-V architecture using the Rust toolchain and QEMU 4.1.

Prompt 2

I'm studying how Linux system calls work, help me trace how a write() call flows through the rCore kernel source.

Prompt 3

Help me understand how rCore handles process scheduling and memory management using Rust's ownership model.

Prompt 4

Walk me through using the rCore Docker environment to build and boot the kernel without installing QEMU locally.

Prompt 5

Help me write a simple user-space program in C that runs on rCore using basic Linux system calls.

Frequently asked questions

What is rcore?

An educational operating system kernel written in Rust for university OS courses, compatible with Linux system calls and runnable on four CPU architectures via QEMU emulation.

What language is rcore written in?

Mainly Rust. The stack also includes Rust, QEMU, Docker.

What license does rcore use?

Use freely for any purpose including commercial as long as you keep the copyright notice, available under MIT or Apache 2.0.

How hard is rcore to set up?

Setup difficulty is rated hard, with roughly 1h+ to a first successful run.

Who is rcore for?

Mainly researcher.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Scan in gitsafehub Deploy in gitdeployhub rcore-os on gitmyhub

Verify against the repo before relying on details.