Rust is a systems-level programming language designed for scenarios ranging from operating system kernel development to high-level application logic. It utilizes static compilation and explicitly avoids garbage collection (GC). By combining modern syntax with C-like performance, Rust ensures memory safety, concurrency safety, and control flow safety directly at compile time.

Unlike languages such as Java or Python, which focus primarily on user-space applications, Rust must support both kernel-space and user-space programming models. Instead of splitting these into entirely separate libraries, Rust organizes its capabilities into three distinct tiers: the CORE library, the ALLOC library, and the STD library.

1. The CORE Library (Language Primitives)

The CORE library is the foundation of the language. Its platform-agnostic and suitable for both kernel and user-space development. It contains no heap allocation and relies solely on stack allocation.

• Compiler Intrinsics: Low-level functions for memory operations, bit manipulation, and atomic operations. These often map directly to CPU instructions via assembly.
• Core Traits: Definitions for operators (ops), markers, iterators, and type conversions.
• Option and Result: Essential types for handling presence and error states, serving as the backbone of Rust's error handling and null-safety.
• Primitive Types: Implementations for integers, floats, booleans, and characters, including specific logic like Unicode handling for chars.
• Unsafe Memory Modules: Contains mem, ptr, and allocation primitives where the majority of unsafe Rust code resides.
• Interior Mutability: Types like UnsafeCell, Cell, and RefCell which allow mutation through a shared reference.

2. The ALLOC Library (Smart Pointers and Collections)

Building on top of CORE, the ALLOC library introduces heap allocation. It is still suitable for kernel development provided the system has a heap allocator implemented.

• Allocator Trait: The interface for memory allocation and deallocation.
• Smart Pointers: Includes Box<T> for heap allocation and Rc<T> for reference counting.
• Dynamic Arrays: The Vec<T> type and its underlying raw vector implementation.
• String Type: The heap-allocated String.
• Thread-Safe Pointers: Arc<T> for atomic reference counting across threads.
• Collections: Data structures such as LinkedList, VecDeque, BTreeMap, and BTreeSet.

3. The STD Library (User-Space Interface)

The STD library is built on top of operating system system calls (syscalls). It is strictly for user-space applications and provides the abstractions necessary to interact with the OS.

• Re-exports: It makes the contents of CORE and ALLOC available in the standard namespace.
• Process Management: Handling of processes and Inter-Process Communication (IPC).
• Threading: High-level thread management, mutexes, and message passing channels.
• File System & Environment: Interactions with files, directories, and environment variables.
• I/O: Standard input, output, and error streams.
• Networking: TCP, UDP, and other network communication primitives.

This layered architecture allows Rust to maintain compatibility across diverse CPU architectures and platforms, from bare-metal kernels to complex networked applications.