Getting Started

RME ships the kernel and architecture ports; the microcontroller project generation lives in RVM. This page explains which entry point to use and what each one actually delivers.

Microcontrollers: use RVM

On an MCU, RME is a user-level library under RVM. RVM generates the project for the chip, toolchain and IDE, and provides the hypervisor layer that lets RME run alongside other bare-metal applications or RTOSes.

Requirements

• an MPU-equipped microcontroller;
• at least 64 KB ROM / 20 KB RAM (128 KB / 64 KB recommended);
• a supported toolchain: GCC or Keil uVision;
• the RVM repository and its project generator.

Typical flow:

1. clone RVM and the RME repository as siblings;
2. select the target chip and toolchain in RVM's project configuration;
3. generate the project (Makefile or Keil);
4. build, flash and open the console.

The RME repository deliberately does not contain one project per MCU. That knowledge lives in RVM so that a new board is a configuration change rather than another copy of the kernel.

Application processors

The repository has project trees for a few MPU targets. They are useful for bring-up and research, but they are not a production distribution:

Project	Target	Caveat
Project/MFGCC-XC7Z020	Zynq-7020 (Cortex-A9)	Single-core port; LGPL v3+
Project/GCC-RV64V	QEMU-VIRT RV64	Needs a sibling M7M03_Anomalocaris init image
Project/VSCODE-GCC-X64	x86-64	Scaffolding; image is not currently bootable
Project/Immature/*	DSP / Eclipse / AURIX	Experimental

If your goal is a working system today, start on an MPU microcontroller with RVM. The MPU side is where the measured, reproducible path is.

Repository layout

M7M01_Eukaron/
├─ Include/
│  ├─ rme.h                 public API and system-call numbers
│  ├─ Kernel/rme_kernel.h   kernel object and API definitions
│  └─ Platform/             A6M, A7M, A7A, RV32P, RV64V, X64, Immature/C66X
├─ Source/
│  ├─ Kernel/rme_kernel.c   the architecture-independent kernel (~8k lines)
│  ├─ Platform/             HAL and context-switch code per architecture
│  └─ Benchmark/            thread-switch benchmark
├─ Project/                 x64, RV64V, Zynq and immature project trees
└─ Document/                R4T1 manuals and LaTeX sources

Toolchains

• GCC / Clang-LLVM — the primary toolchain for the open ports;
• Keil uVision (ARMCC/ARMCLANG) — supported for the ARM microcontroller ports and used for the best measured MCU numbers.

Other toolchains are not supported at this point. On MCUs, use RVM's generator rather than assembling include paths by hand.

Manuals

The R4T1 technical reference manual is the authoritative description of the API, capability model, kernel-call implementation and porting procedure.

• English manual (PDF, 271 pages)
• 中文手册（PDF，205 页）

The manuals are not embedded in this site yet; they open directly from GitHub. The API reference in the PDF should be cross-checked against Include/rme.h when a port and the manual disagree.

Where next

• Kernel design — capabilities, scheduling, IPC, virtualization.
• Platforms — exactly what is delivered and what is roadmap.
• Performance — measured MCU numbers and their caveats.
• Community — source, chat and license.