From e44d7e2b12d25e5928670f976fd085bcb1888c8b Mon Sep 17 00:00:00 2001
From: "Tate, Hongliang Tian" <tate.thl@antgroup.com>
Date: Sat, 24 Jan 2026 09:42:07 +0800
Subject: [PATCH] Update the intro section of README

---
 README.md | 84 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 55 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index 98ecb25ed..5dba8748d 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 <p align="center">
     <img src="book/src/images/logo_en.svg" alt="asterinas-logo" width="620"><br>
-    A secure, fast, and general-purpose OS kernel written in Rust and compatible with Linux<br/>
+    Toward a production-grade Linux alternative—memory safe, high-performance, and more<br/>
 </p>
 
 <!-- Asterinas NixOS 0.17.0 demo. It is uploaded as a Github attachment
@@ -34,37 +34,63 @@ Congratulations to the Asterinas community🎉🎉🎉
 
 ## Introducing Asterinas
 
-Asterinas is a _secure_, _fast_, and _general-purpose_ OS kernel
-that provides _Linux-compatible_ ABI.
-It can serve as a seamless replacement for Linux
-while enhancing _memory safety_ and _developer friendliness_.
+The future of operating systems (OSes) belongs to Rust—a modern systems programming language (PL)
+that delivers safety, efficiency, and productivity at once.
+The open question is not _whether_ OS kernels should transition from C to Rust,
+but _how_ we get there.
 
-* Asterinas prioritizes memory safety
-by employing Rust as its sole programming language
-and limiting the use of _unsafe Rust_
-to a clearly defined and minimal Trusted Computing Base (TCB).
-This innovative approach,
-known as [the framekernel architecture](https://asterinas.github.io/book/kernel/the-framekernel-architecture.html),
-establishes Asterinas as a more secure and dependable kernel option.
+Linux follows an _incremental_ path.
+While the Rust for Linux project has successfully integrated Rust as an official second PL,
+this approach faces _inherent friction_.
+As a newcomer within a massive C codebase,
+Rust must often compromise on safety, efficiency, clarity, and ergonomics
+to maintain compatibility with legacy structures.
+And while new Rust code can improve what it touches,
+it cannot retroactively eliminate _vulnerabilities_ in decades of existing C code.
 
-* Asterinas surpasses Linux in terms of developer friendliness.
-It empowers kernel developers to
-(1) utilize the more productive Rust programming language,
-(2) leverage a purpose-built toolkit called [OSDK](https://asterinas.github.io/book/osdk/guide/index.html) to streamline their workflows,
-and (3) choose between releasing their kernel modules as open source
-or keeping them proprietary,
-thanks to the flexibility offered by [MPL](#License).
+Asterinas takes a _clean-slate_ approach.
+By building a Linux-compatible, general-purpose OS kernel from the ground up in Rust,
+we are liberated from the constraints of a legacy C codebase—its interfaces, designs, and assumptions—and from the need to preserve historical compatibility for outdated platforms.
+**Languages—including PLs—shape our way of thinking**.
+Through the lens of a modern PL, Asterinas rethinks and modernizes the construction of OS kernels:
 
-While the journey towards a production-grade OS kernel is challenging,
-we are steadfastly progressing towards this goal.
-Over the course of 2024,
-we significantly enhanced Asterinas's maturity,
-as detailed in [our end-year report](https://asterinas.github.io/2025/01/20/asterinas-in-2024.html).
-In December 2025,
-we launched [Asterinas NixOS](https://asterinas.github.io/book/distro/index.html),
-an Asterinas distribution based on [NixOS](https://nixos.org/).
-This release marks Asterinas reaching the Minimum Viable Product (MVP) milestone.
-In 2026, we aim to make Asterinas production-ready on x86-64 virtual machines and attract real users.
+* **Modern architecture.**
+  Asterinas pioneers the [_framekernel_](https://asterinas.github.io/book/kernel/the-framekernel-architecture.html) architecture,
+  combining monolithic-kernel performance with microkernel-inspired separation.
+  Unsafe Rust is confined to a small, auditable framework called [OSTD](https://asterinas.github.io/api-docs-nightly/ostd/),
+  while the rest of the kernel is written in safe Rust,
+  keeping the memory-safety TCB intentionally minimal.
+
+* **Modern design.**
+  Asterinas learns from Linux's hard-won engineering lessons,
+  but it is not afraid to deviate when the design warrants it.
+  For example, Asterinas improves the CPU scalability of its memory management subsystem
+  with a novel scheme called [CortenMM](https://dl.acm.org/doi/10.1145/3731569.3764836).
+
+* **Modern code.**
+  Asterinas's codebase prioritizes safety, clarity, and maintainability.
+  Performance is pursued aggressively, but never by compromising safety guarantees.
+  Readability is treated as a feature, not a luxury,
+  and the codebase is structured to avoid hidden, cross-module coupling.
+
+* **Modern tooling.**
+  Asterinas ships a purpose-built toolkit, [OSDK](https://asterinas.github.io/book/osdk/guide/index.html),
+  to facilitate building, running, and testing Rust kernels or kernel components.
+  Powered by OSTD,
+  OSDK makes kernel development as easy and fluid as writing a standard Rust application, eliminating the traditional friction of OS engineering.
+
+Asterinas aims to become **a production-grade, memory-safe Linux alternative**,
+with performance that matches Linux—and in some scenarios, exceeds it.
+The project has been under active development for four years,
+supports 230+ Linux system calls,
+and has launched an experimental distribution,
+[Asterinas NixOS](https://asterinas.github.io/book/distro/index.html).
+
+In 2026, our priority is to advance project maturity toward production readiness,
+specifically targeting standard and confidential virtual machines on x86-64.
+Looking ahead, we will continue to expand functionality and 
+harden the system for **mission-critical deployments**
+in data centers, autonomous vehicles, and embodied AI.
 
 ## Getting Started