Rust (ngôn ngữ lập trình)

Năm 2006, Rust khởi đầu là dự án cá nhân của Graydon Hoare, một nhân viên Mozilla. Theo MIT Technology Review, ông bắt đầu dự án vì bực bội với chiếc thang máy hỏng trong tòa chung cư của mình do phần mềm điều khiển bị lỗi,^[21] và đặt tên ngôn ngữ theo loài nấm gỉ sắt (rust fungi) – loài sinh vật mà ông cho là "được thiết kế quá mức để sinh tồn".^[21] Trong giai đoạn 2006–2009, Rust không được công bố với những người khác ở Mozilla và được Hoare viết trong thời gian rảnh.^[22](7:50) Hoare bắt đầu giới thiệu về ngôn ngữ này vào khoảng năm 2009, sau khi một nhóm nhỏ tại Mozilla tỏ ra quan tâm.^[23]

Những người đóng góp ban đầu đều đồng ý rằng ngôn ngữ chủ yếu dựa trên các ý tưởng đã có từ trước. Hoare nêu các ngôn ngữ từ thập niên 1970, 1980 và 1990 là nguồn ảnh hưởng – bao gồm CLU, BETA, Mesa, NIL,^{[note 4]} Erlang, Newsqueak, Napier, Hermes, Sather, Alef và Limbo.^[23] Ông mô tả ngôn ngữ này là "công nghệ từ quá khứ đến để cứu tương lai khỏi chính nó".^{[22](8:17)[23]} Manish Goregaokar, một người đóng góp ban đầu, cũng mô tả Rust dựa trên "phần lớn là những nghiên cứu đã có từ hàng chục năm trước".^[21]

Trình biên dịch đầu tiên được viết bằng khoảng 38.000 dòng OCaml.^{[22](15:34)[24]} Nó hỗ trợ một số tính năng ngày nay không còn, bao gồm lập trình hướng đối tượng tường minh thông qua từ khóa obj^[22](10:08) và một hệ thống phân tích typestate theo dõi trạng thái của biến, chẳng hạn chuyển từ chưa khởi tạo sang đã khởi tạo.^[22](13:12)

Năm 2009, Mozilla chính thức tài trợ cho dự án.^[21] Brendan Eich cùng các lãnh đạo khác, bị thu hút bởi khả năng dùng Rust để xây dựng một bộ máy trình duyệt web an toàn, đã đưa các kỹ sư vào dự án, trong đó có Patrick Walton, Niko Matsakis, Felix Klock và Manish Goregaokar.^[21] Một phòng họp mà các nhà phát triển dự án chiếm dụng được gọi là "hang ổ mọt sách" (the nerd cave), với một tấm biển treo ngoài cửa.^[21]

Công việc chuyển từ trình biên dịch OCaml sang một trình biên dịch tự lưu trữ (self-hosting, tức là được viết bằng chính Rust) nhắm tới LLVM.^{[25][note 5]} Hệ thống sở hữu (ownership) đã có từ năm 2010.^[21] Biểu trưng Rust được thiết kế năm 2011, lấy cảm hứng từ đĩa xích xe đạp.^[27] Đầu thập niên 2010 chứng kiến sự tham gia ngày càng nhiều của các kỹ sư toàn thời gian tại Mozilla và những người đóng góp mã nguồn mở.^[21]

Ngày 20 tháng 1 năm 2012, Rust 0.1 trở thành bản phát hành công khai đầu tiên^[1] cho Windows, Linux và MacOS.^[28]

Những năm tiếp theo đánh dấu nhiều thay đổi lớn trong hệ thống kiểu của Rust.^{[22](18:36)[21]} Việc quản lý bộ nhớ thông qua hệ thống sở hữu dần được củng cố và mở rộng; đến năm 2013, bộ thu gom rác hiếm khi được dùng và đã bị loại bỏ.^[21] Cũng bị loại bỏ còn có typestate, từ khóa pure,^[29] nhiều loại con trỏ chuyên biệt, và cú pháp hỗ trợ kênh (channel).^[22](22:32)

Theo Steve Klabnik, trong giai đoạn này ngôn ngữ chịu ảnh hưởng từ các nhà phát triển đến từ C++ (ví dụ: hiệu năng cấp thấp của các tính năng), các ngôn ngữ kịch lệnh (ví dụ: Cargo và quản lý gói) và lập trình hàm (ví dụ: hệ thống kiểu).^[22](30:50)

Năm 2013, Graydon Hoare rời khỏi Rust.^[21] Sau khi Hoare ra đi, ngôn ngữ phát triển một cách tự nhiên theo cơ cấu quản trị liên kết, với một "nhóm nòng cốt" (core team) ban đầu gồm sáu người,^[22](21:45) và tổng cộng khoảng 30–40 nhà phát triển trong các nhóm khác.^[22](22:22) Tháng 3 năm 2014, quy trình Request for Comments (RFC) cho các tính năng ngôn ngữ mới được đưa vào.^[22](33:47) Đến năm 2016, nhóm nòng cốt tăng lên chín người^[22](21:45) với hơn 1.600 RFC.^[22](34:08)

Việc phát triển tập trung hoàn thiện các tính năng cho phiên bản 1.0 (phiên bản bắt đầu bảo đảm khả năng tương thích ngược).^[22](41:26) Theo Andrew Binstock viết trên Dr. Dobb's Journal vào tháng 1 năm 2014, dù Rust "được nhìn nhận rộng rãi là một ngôn ngữ thanh lịch đáng kể", việc áp dụng diễn ra chậm vì ngôn ngữ thay đổi triệt để qua từng phiên bản.^[30]

Ngày 15 tháng 5 năm 2015, Rust 1.0 trở thành bản phát hành ổn định đầu tiên.^[21] Một năm sau, trình biên dịch đã có ít nhất 1.400 người đóng góp, và có ít nhất 5.000 thư viện bên thứ ba được đăng trên trang quản lý gói Crates.io.^[22](43:15)

Việc phát triển bộ máy trình duyệt Servo diễn ra song song với Rust, được tài trợ bởi Mozilla và Samsung.^[31] Các tính năng mới của Rust được nhóm Servo thử nghiệm, và các tính năng mới trong Servo được dùng để phản hồi lại cho nhóm Rust.^[22](5:41) Phiên bản đầu tiên của Servo ra mắt năm 2016.^[21] Trình duyệt Firefox bắt đầu đi kèm mã Rust từ năm 2016 (phiên bản 45),^{[22](53:30)[32]} nhưng các thành phần của Servo chỉ xuất hiện trong Firefox từ tháng 9 năm 2017 (phiên bản 57) như một phần của các dự án Gecko và Quantum.^[33]

Trong những năm sau bản 1.0, hệ sinh thái công cụ được cải thiện, bao gồm Rustfmt, hỗ trợ môi trường phát triển tích hợp (IDE),^[22](44:56) và chu kỳ kiểm thử, phát hành trình biên dịch định kỳ.^[22](46:48) Cộng đồng Rust có thêm một bộ quy tắc ứng xử và một kênh trò chuyện IRC để thảo luận.^[22](50:36)

Những trường hợp áp dụng sớm nhất được biết đến bên ngoài Mozilla là các dự án riêng lẻ tại Samsung, Facebook (nay là Meta Platforms), Dropbox và Tilde, Inc. – công ty đứng sau Ember.js.^{[22](55:44)[21]} Amazon Web Services tiếp bước vào năm 2020.^[21] Các kỹ sư nêu hiệu năng, việc không có bộ thu gom rác, tính an toàn và trải nghiệm nhà phát triển là những lý do lựa chọn. Các nhà phát triển của Amazon dẫn một nghiên cứu năm 2017 cho thấy mã Rust tiết kiệm năng lượng hơn so với mã Java tương đương.^[21][34]

Tháng 8 năm 2020, Mozilla sa thải 250 trong tổng số 1.000 nhân viên trong đợt tái cơ cấu doanh nghiệp giữa đại dịch COVID-19.^[35][36] Nhóm Servo bị giải tán. Sự kiện này làm dấy lên lo ngại về tương lai của Rust.^[37] Nhóm nòng cốt Rust thừa nhận tác động của đợt cắt giảm và công bố kế hoạch thành lập một quỹ độc lập. Mục tiêu đầu tiên của quỹ là sở hữu và chịu trách nhiệm tài chính đối với các thương hiệu và tên miền.^[38]

Ngày 8 tháng 2 năm 2021, Quỹ Rust được thành lập bởi các công ty sáng lập Amazon Web Services, Google, Huawei, Microsoft và Mozilla.^[39][40] Quỹ hỗ trợ tài chính cho các nhà phát triển thông qua các khoản tài trợ và kinh phí máy chủ.^[21] Trong một bài blog ngày 6 tháng 4 năm 2021, Google công bố hỗ trợ Rust trong Dự án mã nguồn mở Android (AOSP).^[41] Facebook (Meta Platforms) gia nhập quỹ vào tháng 4 năm 2021,^[42] tiếp theo là ARM (Arm Holdings) vào tháng 11.^[43]

Ngày 22 tháng 11 năm 2021, Nhóm Kiểm duyệt (Moderation Team) – nhóm chịu trách nhiệm thực thi bộ quy tắc ứng xử của cộng đồng – đồng loạt từ chức "để phản đối việc Nhóm nòng cốt tự đặt mình ngoài sự giám sát của bất kỳ ai ngoài chính họ".^[44] Tháng 5 năm 2022, ban lãnh đạo Rust công bố phản hồi về sự việc.^[45]

Ngày 6 tháng 4 năm 2023, Quỹ Rust đăng bản dự thảo chính sách thương hiệu mới, vấp phải phản ứng tiêu cực rộng rãi.^[46] Chính sách này bao gồm các quy định về cách sử dụng biểu trưng và tên gọi Rust.^[46]

Tháng 6 năm 2026, OpenAI gia nhập Quỹ Rust.^[47]

Dưới đây là một chương trình "Hello, World!" viết bằng Rust. Từ khóa fn khai báo một hàm, còn macro println! (xem mục Macro) in thông điệp ra đầu ra chuẩn.^[51] Các câu lệnh trong Rust được phân tách bằng dấu chấm phẩy.

fn main() {
    println!("Hello, World!");
}

Biến trong Rust được khai báo bằng từ khóa let.^[52] Ví dụ dưới đây gán một giá trị cho biến tên foo có kiểu i32 và in giá trị đó ra; chú thích kiểu : i32 có thể được lược bỏ.

fn main() {
    let foo: i32 = 10;
    println!("The value of foo is {foo}");
}

Theo mặc định, biến là bất biến (immutable), trừ khi thêm từ khóa mut.^[53] Ví dụ sau dùng //, ký hiệu bắt đầu một chú thích.^[54]

fn main() {
    // Đoạn mã này sẽ không biên dịch được nếu thiếu "mut".
    let mut foo = 10;
    println!("The value of foo is {foo}");
    foo = 20;
    println!("The value of foo is {foo}");
}

Nhiều biểu thức let có thể khai báo nhiều biến cùng tên, gọi là che khuất biến (variable shadowing). Che khuất biến cho phép biến đổi giá trị mà không phải đặt tên biến khác.^[55] Ví dụ dưới đây khai báo một biến mới cùng tên, có giá trị gấp đôi giá trị ban đầu:

fn main() {
    let foo = 10;
    // Dòng này sẽ in ra "The value of foo is 10"
    println!("The value of foo is {foo}");
    let foo = foo * 2;
    // Dòng này sẽ in ra "The value of foo is 20"
    println!("The value of foo is {foo}");
}

Che khuất biến cũng áp dụng được cho các giá trị khác kiểu. Ví dụ, chuyển từ một chuỗi sang độ dài của nó:

fn main() {
    let letters = "abc";
    let letters = letters.len();
}

Một biểu thức khối (block expression) được giới hạn bởi cặp dấu ngoặc nhọn. Khi biểu thức cuối cùng trong khối không kết thúc bằng dấu chấm phẩy, khối sẽ nhận giá trị của biểu thức cuối đó:^[56]

fn main() {
    let x = {
        println!("this is inside the block");
        1 + 2
    };
    println!("1 + 2 = {x}");
}

Biểu thức cuối trong thân hàm được dùng làm giá trị trả về:^[57]

fn add_two(x: i32) -> i32 {
    x + 2
}

fn main() {
    let x = 10;
    if x > 5 {
        println!("value is greater than five");
    }

    if x % 7 == 0 {
        println!("value is divisible by 7");
    } else if x % 5 == 0 {
        println!("value is divisible by 5");
    } else {
        println!("value is not divisible by 7 or 5");
    }
}

fn main() {
    let x = 10;
    let new_x = if x % 2 == 0 { x / 2 } else { 3 * x + 1 };
    println!("{new_x}");
}

fn main() {
    // Duyệt qua mọi số nguyên từ 4 đến 10
    let mut value = 4;
    while value <= 10 {
         println!("value = {value}");
         value += 1;
    }
}

fn main() {
    // Dùng `for` với cú pháp khoảng để có chức năng giống ví dụ trên
    // Cú pháp 4..=10 nghĩa là khoảng từ 4 đến 10, bao gồm cả 10.
    for value in 4..=10 {
        println!("value = {value}");
    }
}

(1..=100).filter(|x| x % 3 == 0).sum()

fn main() {
    let value = 456;
    let mut x = 1;
    let y = loop {
        x *= 10;
        if x > value {
            break x / 10;
        }
    };
    println!("largest power of ten that is smaller than or equal to value: {y}");

    let mut up = 1;
    'outer: loop {
        let mut down = 120;
        loop {
            if up > 100 {
                break 'outer;
            }

            if down < 4 {
                break;
            }

            down /= 2;
            up += 1;
            println!("up: {up}, down: {down}");
        }
        up *= 2;
    }
}

Các biểu thức match và if let cung cấp tính năng khớp mẫu (pattern matching). Ví dụ, match có thể nhân đôi một giá trị số nguyên tùy chọn nếu có, và trả về 0 nếu không có:^[62]

fn double(x: Option<u64>) -> u64 {
    match x {
        Some(value) => value * 2,
        None => 0,
    }
}

Một cách tương đương, đoạn mã trên có thể viết bằng if let và else:

fn double(x: Option<u64>) -> u64 {
    if let Some(value) = x {
        value * 2
    } else {
        0
    }
}

Rust là ngôn ngữ định kiểu mạnh và định kiểu tĩnh, nghĩa là kiểu của mọi biến phải được xác định tại thời điểm biên dịch. Gán một giá trị thuộc một kiểu cho biến có kiểu khác sẽ gây lỗi biên dịch. Suy luận kiểu xác định kiểu của biến nếu không được chỉ rõ.^[63]

Kiểu đơn vị (unit type), ký hiệu () trong Rust, là một kiểu cụ thể có đúng một giá trị. Nó không chiếm bộ nhớ (vì biểu thị sự vắng mặt của giá trị). Mọi hàm không khai báo kiểu trả về đều ngầm trả về (). Kiểu này tương tự void trong các ngôn ngữ kiểu C khác; tuy nhiên, void biểu thị sự vắng mặt của kiểu và không thể có giá trị nào.

Kiểu số nguyên mặc định là i32, và kiểu số thực dấu phẩy động mặc định là f64. Nếu kiểu của một số literal không được chỉ rõ, nó sẽ được suy ra từ ngữ cảnh hoặc dùng kiểu mặc định.^[64]

let tuple: (u32, bool) = (3, true);
let array: [i8; 5] = [1, 2, 3, 4, 5];
let value = tuple.1; // true
let value = array[2]; // 3

let array2: [char; 10] = [' '; 10];

Hệ thống sở hữu (ownership) của Rust gồm các quy tắc bảo đảm an toàn bộ nhớ mà không cần bộ thu gom rác. Tại thời điểm biên dịch, mỗi giá trị phải gắn với một biến gọi là chủ sở hữu (owner) của giá trị đó, và mỗi giá trị phải có đúng một chủ sở hữu.^[74] Giá trị được chuyển (move) giữa các chủ sở hữu thông qua phép gán hoặc khi truyền làm tham số hàm. Giá trị cũng có thể được mượn (borrow) – tạm thời truyền cho một hàm khác trước khi trả lại cho chủ sở hữu.^[75] Với các quy tắc này, Rust ngăn việc tạo và sử dụng con trỏ treo (dangling pointer):^[75][76]

fn print_string(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello, World");
    print_string(s); // s bị print_string tiêu thụ
    // s đã bị chuyển đi nên không thể dùng được nữa
    // gọi print_string(s); thêm lần nữa sẽ gây lỗi biên dịch
}

Hàm print_string nhận quyền sở hữu giá trị String được truyền vào. Ngoài ra, & có thể được dùng để biểu thị một kiểu tham chiếu (trong &String) và để tạo một tham chiếu (trong &s):^[77]

fn print_string(s: &String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello, World");
    print_string(&s); // s được print_string mượn
    print_string(&s); // s chưa bị tiêu thụ; có thể gọi hàm nhiều lần
}

Do các quy tắc sở hữu này, các kiểu trong Rust được gọi là kiểu affine (affine type), nghĩa là mỗi giá trị chỉ được dùng tối đa một lần. Điều này thực thi một dạng cô lập lỗi phần mềm (software fault isolation), vì chủ sở hữu của một giá trị chịu trách nhiệm duy nhất về tính đúng đắn và việc giải phóng giá trị đó.^[78]

Khi một giá trị ra khỏi phạm vi, nó bị hủy (drop) bằng cách chạy hàm hủy của nó. Hàm hủy có thể được định nghĩa bằng cách cài đặt trait Drop. Điều này giúp quản lý các tài nguyên như file handle, socket mạng và khóa (lock), vì khi đối tượng bị hủy, các tài nguyên gắn với chúng sẽ tự động được đóng hoặc giải phóng.^[79]

fn main() {
    let mut x = 5;            // ------------------+- Vòng đời 'a
                              //                   |
    let r = &x;               // -+-- Vòng đời 'b  |
                              //  |                |
    println!("r: {}", r);     // -+                |
    // Vì r không còn được dùng,                   |
    // vòng đời của nó kết thúc                    |
    let r2 = &mut x;          // -+-- Vòng đời 'c  |
}                             // ------------------+

fn main() {
    let r;                    // ------------------+- Vòng đời 'a
                              //                   |
    {                         //                   |
        let x = 5;            // -+-- Vòng đời 'b  |
        r = &x; // LỖI: x không   |                |
    }           // sống đủ lâu -|                |
                //                                 |
    println!("r: {}", r);     //                   |
}                             // ------------------+

fn remove_prefix<'a>(mut original: &'a str, prefix: &str) -> &'a str {
    if original.starts_with(prefix) {
        original = original[prefix.len()..];
    }
    original
}

Kiểu do người dùng định nghĩa được tạo bằng từ khóa struct hoặc enum. Từ khóa struct khai báo một kiểu bản ghi gom nhiều giá trị liên quan lại với nhau.^[89] Các enum có thể nhận các biến thể (variant) khác nhau khi chạy, với khả năng tương tự kiểu dữ liệu đại số trong các ngôn ngữ lập trình hàm.^[90] Cả bản ghi lẫn biến thể enum đều có thể chứa các trường thuộc các kiểu khác nhau.^[91] Tên thay thế, hay bí danh (alias), cho cùng một kiểu có thể được định nghĩa bằng từ khóa type.^[92]

Từ khóa impl dùng để định nghĩa phương thức cho một kiểu do người dùng định nghĩa. Dữ liệu và hàm được định nghĩa tách biệt. Các khối cài đặt (implementation) đóng vai trò tương tự lớp trong các ngôn ngữ khác.^[93]

Thư viện chuẩn

[sửa | sửa mã nguồn]

Thư viện chuẩn của Rust định nghĩa và cài đặt nhiều kiểu dữ liệu tùy biến thông dụng, bao gồm các cấu trúc dữ liệu cốt lõi như Vec, Option và HashMap, cũng như các kiểu con trỏ thông minh (smart pointer). Rust cung cấp cách loại bỏ phần lớn thư viện chuẩn bằng thuộc tính #![no_std], dành cho các ứng dụng như thiết bị nhúng. Bên trong, thư viện chuẩn được chia thành ba phần: core, alloc và std, trong đó std và alloc bị loại bỏ khi dùng #![no_std].^[94]

Rust dùng kiểu tùy chọn (option type) Option<T> để định nghĩa các giá trị có thể vắng mặt; giá trị này có thể được khớp bằng if let hoặc match để truy cập giá trị bên trong:^[95]

fn main() {
    let name1: Option<&str> = None;
    // Trong trường hợp này, không có gì được in ra
    if let Some(name) = name1 {
        println!("{name}");
    }

    let name2: Option<&str> = Some("Matthew");
    // Trong trường hợp này, từ "Matthew" sẽ được in ra
    if let Some(name) = name2 {
        println!("{name}");
    }
}

Tương tự, kiểu kết quả (result type) Result<T, E> của Rust chứa hoặc một giá trị được tính thành công (biến thể Ok) hoặc một lỗi (biến thể Err).^[96] Giống Option, việc dùng Result có nghĩa là không thể dùng trực tiếp giá trị bên trong; lập trình viên phải dùng biểu thức match, cú pháp rút gọn như ? (toán tử "try"), hoặc lời khẳng định unwrap tường minh để truy cập. Cả Option và Result đều được dùng khắp thư viện chuẩn và là một phần nền tảng trong cách tiếp cận tường minh của Rust đối với việc xử lý lỗi và dữ liệu vắng mặt.

Các kiểu tham chiếu & và &mut được bảo đảm không rỗng và trỏ tới vùng nhớ hợp lệ.^[97] Các kiểu con trỏ thô *const và *mut không có các bảo đảm an toàn này, nên chúng có thể rỗng hoặc không hợp lệ; tuy nhiên, không thể giải tham chiếu chúng trừ khi đoạn mã được khai báo rõ là không an toàn thông qua khối unsafe.^[98] Khác với việc giải tham chiếu, việc tạo con trỏ thô được phép trong mã Rust an toàn.^[99]

Rust không hỗ trợ chuyển đổi kiểu ngầm định (ép kiểu tự động) giữa hầu hết các kiểu nguyên thủy. Tuy nhiên, chuyển đổi kiểu tường minh (casting) có thể được thực hiện bằng từ khóa as.^[100]

let x: i32 = 1000;
println!("1000 as a u16 is: {}", x as u16);

Rust hỗ trợ đa hình thông qua trait, hàm tổng quát và đối tượng trait (trait object).^[101]

trait Zero: Sized {
    fn zero() -> Self;
    fn is_zero(&self) -> bool
    where
        Self: PartialEq,
    {
        self == &Zero::zero()
    }
}

impl Zero for u32 {
    fn zero() -> u32 { 0 }
}

impl Zero for f32 {
    fn zero() -> Self { 0.0 }
}

// zero là hàm tổng quát với một tham số kiểu, Num
fn zero<Num: Zero>() -> Num {
    Num::zero()
}

fn main() {
    let a: u32 = zero();
    let b: f32 = zero();
    assert!(a.is_zero() && b.is_zero());
}

use std::fmt::Display;

let v: Vec<Box<dyn Display>> = vec![
    Box::new(3),
    Box::new(5.0),
    Box::new("hi"),
];

for x in v {
    println!("{x}");
}

Rust không dùng thu gom rác. Thay vào đó, bộ nhớ và các tài nguyên khác được quản lý theo quy ước "thu nhận tài nguyên là khởi tạo" (resource acquisition is initialization, RAII),^[110] với cơ chế đếm tham chiếu tùy chọn. Rust quản lý tài nguyên một cách tất định, với phí tổn rất thấp.^[111] Theo mặc định, giá trị được cấp phát trên ngăn xếp (stack), và mọi cấp phát động đều phải được thực hiện tường minh.^[112]

Các kiểu tham chiếu dựng sẵn dùng ký hiệu & không liên quan đến việc đếm tham chiếu khi chạy. Tính an toàn và hợp lệ của các con trỏ bên dưới được kiểm tra tại thời điểm biên dịch, ngăn con trỏ treo và các dạng hành vi không xác định (undefined behavior) khác.^[113] Hệ thống kiểu của Rust tách biệt tham chiếu dùng chung, bất biến dạng &T với tham chiếu duy nhất, khả biến dạng &mut T. Một tham chiếu khả biến có thể được ép thành tham chiếu bất biến, nhưng không có chiều ngược lại.^[114]

Các kiểm tra an toàn bộ nhớ của Rust (xem mục An toàn) có thể được bỏ qua bằng cách dùng khối unsafe. Điều này cho phép lập trình viên giải tham chiếu con trỏ thô tùy ý, gọi mã bên ngoài, hoặc thực hiện các thao tác cấp thấp khác vốn không được phép trong Rust an toàn.^[115] Một số chức năng cấp thấp được mở ra theo cách này gồm truy cập bộ nhớ volatile, các hàm nội tại (intrinsic) đặc thù kiến trúc, type punning và hợp ngữ nội tuyến (inline assembly).^[116]

Mã không an toàn là cần thiết, chẳng hạn trong việc cài đặt các cấu trúc dữ liệu.^[117] Một ví dụ thường được nhắc tới là rất khó hoặc không thể cài đặt danh sách liên kết đôi trong Rust an toàn.^{[118][119][120][121]}

Lập trình viên dùng Rust không an toàn được xem là chịu trách nhiệm duy trì các yêu cầu về an toàn bộ nhớ và an toàn kiểu của Rust, ví dụ không được có hai tham chiếu khả biến cùng trỏ tới một vị trí.^[122] Nếu lập trình viên viết mã vi phạm các yêu cầu này, kết quả sẽ là hành vi không xác định.^[122] Tài liệu Rust có danh sách các hành vi được coi là không xác định, bao gồm truy cập con trỏ treo hoặc con trỏ không căn chỉnh, hay vi phạm quy tắc bí danh (aliasing) đối với tham chiếu.^[123]

Macro cho phép sinh và biến đổi mã Rust nhằm giảm lặp lại. Macro có hai dạng: macro khai báo (declarative macro) được định nghĩa bằng macro_rules!, và macro thủ tục (procedural macro) được định nghĩa trong các crate riêng.^[124][125]

macro_rules! sum {
    ( $initial:expr $(, $expr:expr )* $(,)? ) => {
        $initial $(+ $expr)*
    }
}

fn main() {
    let x = sum!(1, 2, 3);
    println!("{x}"); // in ra 6
}

Rust hỗ trợ tạo giao diện hàm ngoại (foreign function interface, FFI) thông qua từ khóa extern. Một hàm dùng quy ước gọi hàm của C có thể được viết bằng extern "C" fn. Các ký hiệu có thể được xuất từ Rust sang ngôn ngữ khác thông qua thuộc tính #[unsafe(no_mangle)], và được nhập vào Rust thông qua các khối extern:^{[note 6][131]}

#[unsafe(no_mangle)]
pub extern "C" fn exported_from_rust(x: i32) -> i32 { x + 1 }
unsafe extern "C" {
    fn imported_into_rust(x: i32) -> i32;
}

Thuộc tính #[repr(C)] cho phép bố cục bộ nhớ tất định cho các struct và enum để dùng qua ranh giới FFI.^[131] Các thư viện bên ngoài như bindgen và cxx có thể sinh mã liên kết (binding) Rust cho C/C++.^[131][132]

Trình biên dịch Rust, rustc, biên dịch mã Rust thành tệp thực thi. Mã nguồn được phân tích thành một cây cú pháp trừu tượng (AST) rồi được hạ cấp qua nhiều biểu diễn trung gian (IR). Tiếp theo, một backend trình biên dịch được gọi để áp dụng các tối ưu hóa và tạo ra mã đối tượng, và một trình liên kết (linker) kết hợp các tệp đối tượng thành một tệp thực thi nhị phân duy nhất.^[140]

Trình biên dịch dùng LLVM làm backend mặc định, và hỗ trợ các backend thay thế như GCC và Cranelift.^[141] Mục đích của các backend thay thế này là mở rộng số nền tảng hỗ trợ Rust hoặc cải thiện thời gian biên dịch.^[142][143]

Cargo là hệ thống dựng (build system) và trình quản lý gói của Rust. Nó tải về, biên dịch, phân phối và tải lên các gói – gọi là crate – được lưu trữ trong một kho đăng ký chính thức. Cargo cũng đóng vai trò giao diện cho Clippy và các thành phần Rust khác.^[144]

Theo mặc định, Cargo lấy các thành phần phụ thuộc từ kho đăng ký crates.io do người dùng đóng góp. Kho Git, thư mục trên hệ thống tệp cục bộ và các nguồn bên ngoài khác cũng có thể được chỉ định làm thành phần phụ thuộc.^[145]

Cargo hỗ trợ dựng tái lập (reproducible build) thông qua hai tệp siêu dữ liệu: Cargo.toml và Cargo.lock.^[146] Cargo.toml khai báo từng gói được dùng và yêu cầu về phiên bản của nó. Cargo.lock được tạo tự động trong quá trình phân giải phụ thuộc và ghi lại chính xác phiên bản của mọi thành phần phụ thuộc, kể cả các phụ thuộc bắc cầu.^[147]

Rustfmt là công cụ định dạng mã cho Rust. Nó định dạng khoảng trắng và thụt lề để mã tuân theo một phong cách lập trình chung. Rustfmt có thể được gọi như một chương trình độc lập hoặc thông qua Cargo.^[148]

Clippy là công cụ phân tích mã tĩnh (linter) tích hợp của Rust, giúp cải thiện tính đúng đắn, hiệu năng và tính dễ đọc của mã Rust. Tính đến năm 2026, công cụ này có hơn 800 quy tắc.^[149][150]

Sau Rust 1.0, các tính năng mới được phát triển trong các phiên bản nightly, phát hành hằng ngày. Trong mỗi chu kỳ phát hành sáu tuần, các thay đổi ở phiên bản nightly được đưa lên beta, còn các thay đổi từ phiên bản beta trước được phát hành thành một phiên bản ổn định mới.^[151]

Cứ hai hoặc ba năm, một "phiên bản" (edition) mới lại được phát hành. Các edition được phát hành để cho phép thực hiện một số thay đổi phá vỡ tương thích có giới hạn, chẳng hạn nâng await thành từ khóa để hỗ trợ tính năng async/await. Các crate nhắm tới những edition khác nhau vẫn tương tác được với nhau, nên một crate có thể nâng lên edition mới ngay cả khi các bên gọi hoặc các thành phần phụ thuộc của nó vẫn nhắm tới edition cũ. Việc chuyển sang edition mới có thể được hỗ trợ bằng công cụ tự động.^[152]

rust-analyzer là bộ phần mềm tiện ích cung cấp cho các môi trường phát triển tích hợp (IDE) và trình soạn thảo văn bản thông tin về một dự án Rust thông qua giao thức Language Server Protocol. Trong số các tính năng, công cụ này cung cấp tự động hoàn thành mã và hiển thị lỗi biên dịch ngay trong khi soạn thảo.^[153]

Quỹ Rust
Thành lập	8 tháng 2 năm 2021; 5 năm trước (2021-02-08)
Sáng lập	Amazon Web Services Google Huawei Microsoft Quỹ Mozilla
Vị thế pháp lý	501(c)(6)[215]
Vị trí	Hoa Kỳ
Chủ tịch	Shane Miller
Giám đốc điều hành	Rebecca Rumbul
Website	foundation.rust-lang.org

Quỹ Rust (Rust Foundation) là một tổ chức thành viên phi lợi nhuận được thành lập tại Hoa Kỳ dưới hình thức tổ chức 501(c)(6);^[215] quỹ quản lý thương hiệu, cơ sở hạ tầng và tài sản của Rust.^[216][49]

Quỹ được thành lập ngày 8 tháng 2 năm 2021.^[217] Hội đồng quản trị của quỹ do Shane Miller làm chủ tịch,^[218] với Ashley Williams là giám đốc điều hành lâm thời.^[49] Cuối năm 2021, Rebecca Rumbul trở thành giám đốc điều hành kiêm CEO.^[219]

Trang web của quỹ liệt kê ARM, Amazon, Google, Huawei, Meta, Microsoft và OpenAI là các thành viên bạch kim.^[220] OpenAI là thành viên bạch kim mới nhất, gia nhập vào tháng 6 năm 2026.^[47]

Tính đến tháng 11 năm 2025, dự án Rust được duy trì bởi 8 nhóm cấp cao nhất: hội đồng lãnh đạo, nhóm trình biên dịch, nhóm công cụ phát triển, nhóm hạ tầng, nhóm ngôn ngữ, launching pad, nhóm thư viện và nhóm kiểm duyệt.^[221] Hội đồng lãnh đạo giám sát dự án và gồm đại diện của các nhóm khác.^[222]

1. 1 2 Anderson, Brian (ngày 24 tháng 1 năm 2012). "[rust-dev] The Rust compiler 0.1 is unleashed". rust-dev (Danh sách thư). Bản gốc lưu trữ ngày 24 tháng 1 năm 2012. Truy cập ngày 7 tháng 1 năm 2025.
2. ↑ "Announcing Rust 1.99.1" (bằng tiếng Anh). ngày 15 tháng 10 năm 2026. Truy cập ngày 18 tháng 10 năm 2026.
3. 1 2 "Platform Support". The rustc book. Lưu trữ bản gốc ngày 30 tháng 6 năm 2022. Truy cập ngày 27 tháng 6 năm 2022.
4. ↑ "Copyright". GitHub. The Rust Programming Language. ngày 19 tháng 10 năm 2022. Lưu trữ bản gốc ngày 22 tháng 7 năm 2023. Truy cập ngày 19 tháng 10 năm 2022.
5. ↑ "Licenses". The Rust Programming Language. Lưu trữ bản gốc ngày 23 tháng 2 năm 2025. Truy cập ngày 7 tháng 3 năm 2025.
6. ↑ "Uniqueness Types". Rust Blog. Lưu trữ bản gốc ngày 15 tháng 9 năm 2016. Truy cập ngày 8 tháng 10 năm 2016. Those of you familiar with the Elm style may recognize that the updated --explain messages draw heavy inspiration from the Elm approach.
7. ↑ Strom, Robert E. (1983). "Mechanisms for compile-time enforcement of security". Proceedings of the 10th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL '83. tr. 276–284. doi:10.1145/567067.567093. ISBN 0897910907. S2CID 6630704.
8. ↑ Strom, Robert E.; Yemini, Shaula (1986). "Typestate: A programming language concept for enhancing software reliability" (PDF). IEEE Transactions on Software Engineering. 12 (1). IEEE: 157–171. Bibcode:1986ITSEn..12..157S. doi:10.1109/tse.1986.6312929. S2CID 15575346.
9. ↑ "Influences". The Rust Reference. Lưu trữ bản gốc ngày 26 tháng 11 năm 2023. Truy cập ngày 31 tháng 12 năm 2023.
10. ↑ "Uniqueness Types". Idris 1.3.3 documentation. Lưu trữ bản gốc ngày 21 tháng 11 năm 2018. Truy cập ngày 14 tháng 7 năm 2022. They are inspired by ... ownership types and borrowed pointers in the Rust programming language.
11. ↑ Eberlei, Benjamin; Schröder, Martin (ngày 9 tháng 3 năm 2020). "PHP RFC: Attributes v2". wiki.php.net. Truy cập ngày 11 tháng 5 năm 2026.
12. ↑ Tovilo, Ilija (ngày 22 tháng 5 năm 2020). "PHP RFC: Match expression v2". wiki.php.net. Truy cập ngày 29 tháng 11 năm 2020.
13. ↑ Garfield, Larry; Tovilo, Ilija (ngày 4 tháng 12 năm 2020). "PHP RFC: Enumerations". wiki.php.net. Truy cập ngày 11 tháng 5 năm 2026.
14. ↑ Garfield, Larry; Tovilo, Ilija (ngày 11 tháng 11 năm 2020). "PHP RFC: Pattern Matching". wiki.php.net. Truy cập ngày 11 tháng 5 năm 2026.
15. ↑ Tung, Liam. "Microsoft opens up Rust-inspired Project Verona programming language on GitHub". ZDNET. Lưu trữ bản gốc ngày 17 tháng 1 năm 2020. Truy cập ngày 17 tháng 1 năm 2020.
16. ↑ Jaloyan, Georges-Axel (ngày 19 tháng 10 năm 2017). "Safe Pointers in SPARK 2014". arXiv:1710.07047 [cs.PL].
17. ↑ Lattner, Chris. "Chris Lattner's Homepage". Nondot. Lưu trữ bản gốc ngày 25 tháng 12 năm 2018. Truy cập ngày 14 tháng 5 năm 2019.
18. ↑ "V documentation (Introduction)". GitHub (bằng tiếng Anh). The V Programming Language. Truy cập ngày 4 tháng 11 năm 2023.
19. ↑ Yegulalp, Serdar (ngày 29 tháng 8 năm 2016). "New challenger joins Rust to topple C language". InfoWorld (bằng tiếng Anh). Lưu trữ bản gốc ngày 25 tháng 11 năm 2021. Truy cập ngày 19 tháng 10 năm 2022.
20. ↑ "Gleam for Rust users". Lưu trữ bản gốc ngày 27 tháng 1 năm 2026. Truy cập ngày 27 tháng 1 năm 2026.
21. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Thompson, Clive (ngày 14 tháng 2 năm 2023). "How Rust went from a side project to the world's most-loved programming language". MIT Technology Review (bằng tiếng Anh). Lưu trữ bản gốc ngày 19 tháng 9 năm 2024. Truy cập ngày 23 tháng 2 năm 2023.
22. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Klabnik, Steve (ngày 2 tháng 6 năm 2016). "The History of Rust". Applicative 2016. New York, NY, USA: Association for Computing Machinery. tr. 80. doi:10.1145/2959689.2960081. ISBN 978-1-4503-4464-7.
23. 1 2 3 4 Hoare, Graydon (tháng 7 năm 2010). Project Servo: Technology from the past come to save the future from itself (PDF). Mozilla Annual Summit. Bản gốc (PDF) lưu trữ ngày 31 tháng 3 năm 2026. Truy cập ngày 29 tháng 10 năm 2024.
24. ↑ Hoare, Graydon (tháng 11 năm 2016). "Rust Prehistory (Archive of the original Rust OCaml compiler source code)". GitHub. Truy cập ngày 29 tháng 10 năm 2024.
25. ↑ "0.1 first supported public release Milestone · rust-lang/rust". GitHub (bằng tiếng Anh). Truy cập ngày 29 tháng 10 năm 2024.
26. ↑ Nelson, Jynn (ngày 5 tháng 8 năm 2022). RustConf 2022 - Bootstrapping: The once and future compiler. Portland, Oregon: Rust Team. Truy cập ngày 29 tháng 10 năm 2024 – qua YouTube.
27. ↑ "Rust logo". Bugzilla. Lưu trữ bản gốc ngày 2 tháng 2 năm 2024. Truy cập ngày 2 tháng 2 năm 2024.
28. ↑ Anthony, Sebastian (ngày 24 tháng 1 năm 2012). "Mozilla releases Rust 0.1, the language that will eventually usurp Firefox's C++". ExtremeTech (bằng tiếng Anh). Truy cập ngày 7 tháng 1 năm 2025.
29. ↑ "Purity by pcwalton · Pull Request #5412 · rust-lang/rust". GitHub (bằng tiếng Anh). Truy cập ngày 29 tháng 10 năm 2024.
30. ↑ Binstock, Andrew (ngày 7 tháng 1 năm 2014). "The Rise And Fall of Languages in 2013". Dr. Dobb's Journal. Bản gốc lưu trữ ngày 7 tháng 8 năm 2016. Truy cập ngày 20 tháng 11 năm 2022.
31. ↑ Lardinois, Frederic (ngày 3 tháng 4 năm 2015). "Mozilla And Samsung Team Up To Develop Servo, Mozilla's Next-Gen Browser Engine For Multicore Processors". TechCrunch. Lưu trữ bản gốc ngày 10 tháng 9 năm 2016. Truy cập ngày 25 tháng 6 năm 2017.
32. ↑ "Firefox 45.0, See All New Features, Updates and Fixes". Mozilla (bằng tiếng Anh). Lưu trữ bản gốc ngày 17 tháng 3 năm 2016. Truy cập ngày 31 tháng 10 năm 2024.
33. ↑ Lardinois, Frederic (ngày 29 tháng 9 năm 2017). "It's time to give Firefox another chance". TechCrunch (bằng tiếng Anh). Lưu trữ bản gốc ngày 15 tháng 8 năm 2023. Truy cập ngày 15 tháng 8 năm 2023.
34. ↑ Pereira, Rui; Couto, Marco; Ribeiro, Francisco; Rua, Rui; Cunha, Jácome; Fernandes, João Paulo; Saraiva, João (ngày 23 tháng 10 năm 2017). "Energy efficiency across programming languages: How do energy, time, and memory relate?". Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering. SLE 2017. New York, NY, USA: Association for Computing Machinery. tr. 256–267. doi:10.1145/3136014.3136031. hdl:1822/65359. ISBN 978-1-4503-5525-4.
35. ↑ Cimpanu, Catalin (ngày 11 tháng 8 năm 2020). "Mozilla lays off 250 employees while it refocuses on commercial products". ZDNET. Lưu trữ bản gốc ngày 18 tháng 3 năm 2022. Truy cập ngày 2 tháng 12 năm 2020.
36. ↑ Cooper, Daniel (ngày 11 tháng 8 năm 2020). "Mozilla lays off 250 employees due to the pandemic". Engadget. Lưu trữ bản gốc ngày 13 tháng 12 năm 2020. Truy cập ngày 2 tháng 12 năm 2020.
37. ↑ Tung, Liam (ngày 21 tháng 8 năm 2020). "Programming language Rust: Mozilla job cuts have hit us badly but here's how we'll survive". ZDNET (bằng tiếng Anh). Lưu trữ bản gốc ngày 21 tháng 4 năm 2022. Truy cập ngày 21 tháng 4 năm 2022.
38. ↑ "Laying the foundation for Rust's future". Rust Blog. ngày 18 tháng 8 năm 2020. Lưu trữ bản gốc ngày 2 tháng 12 năm 2020. Truy cập ngày 2 tháng 12 năm 2020.
39. ↑ "Hello World!". Rust Foundation (bằng tiếng Anh). ngày 8 tháng 2 năm 2020. Lưu trữ bản gốc ngày 19 tháng 4 năm 2022. Truy cập ngày 4 tháng 6 năm 2022.
40. ↑ "Mozilla Welcomes the Rust Foundation". Mozilla Blog. ngày 9 tháng 2 năm 2021. Lưu trữ bản gốc ngày 8 tháng 2 năm 2021. Truy cập ngày 9 tháng 2 năm 2021.
41. ↑ Amadeo, Ron (ngày 7 tháng 4 năm 2021). "Google is now writing low-level Android code in Rust". Ars Technica (bằng tiếng Anh). Lưu trữ bản gốc ngày 8 tháng 4 năm 2021. Truy cập ngày 8 tháng 4 năm 2021.
42. ↑ Sharma, Mayank (ngày 30 tháng 4 năm 2021). "Facebook joins Rust Foundation". TechRadar (bằng tiếng Anh). Truy cập ngày 19 tháng 8 năm 2026.
43. ↑ Flaherty, Nick (ngày 5 tháng 11 năm 2021). "ARM joins the Rust foundation". eeNews Europe (bằng tiếng Anh). Truy cập ngày 19 tháng 8 năm 2026.
44. ↑ Anderson, Tim (ngày 23 tháng 11 năm 2021). "Entire Rust moderation team resigns". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 4 tháng 8 năm 2022.
45. ↑ Levick, Ryan; Bos, Mara. "Governance Update". Inside Rust Blog (bằng tiếng Anh). Lưu trữ bản gốc ngày 27 tháng 10 năm 2022. Truy cập ngày 27 tháng 10 năm 2022.
46. 1 2 Claburn, Thomas (ngày 17 tháng 4 năm 2023). "Rust Foundation apologizes for trademark policy confusion". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 7 tháng 5 năm 2023. Truy cập ngày 7 tháng 5 năm 2023.
47. 1 2 "Rust Foundation Welcomes OpenAI As Platinum Member, Announces Donation to Rust Project - The Rust Foundation". Rust Foundation (bằng tiếng Anh). Truy cập ngày 6 tháng 8 năm 2026.
48. ↑ Proven, Liam (ngày 27 tháng 11 năm 2019). "Rebecca Rumbul named new CEO of The Rust Foundation". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 14 tháng 7 năm 2022. Both are curly bracket languages, with C-like syntax that makes them unintimidating for C programmers.
49. 1 2 3 Vigliarolo, Brandon (ngày 10 tháng 2 năm 2021). "The Rust programming language now has its own independent foundation". TechRepublic (bằng tiếng Anh). Bản gốc lưu trữ ngày 20 tháng 3 năm 2023. Truy cập ngày 14 tháng 7 năm 2022.
50. ↑ Klabnik & Nichols 2019, tr. 263.
51. ↑ Klabnik & Nichols 2019, tr. 5–6.
52. ↑ Klabnik & Nichols 2023, tr. 32.
53. ↑ Klabnik & Nichols 2023, tr. 32-33.
54. ↑ Klabnik & Nichols 2023, tr. 49-50.
55. ↑ Klabnik & Nichols 2023, tr. 34-36.
56. ↑ Klabnik & Nichols 2023, tr. 6,47,53.
57. ↑ Klabnik & Nichols 2023, tr. 47-48.
58. 1 2 Klabnik & Nichols 2023, tr. 50-53.
59. ↑ Klabnik & Nichols 2023, tr. 56.
60. ↑ Klabnik & Nichols 2023, tr. 57-58.
61. ↑ Klabnik & Nichols 2023, tr. 54-56.
62. ↑ Klabnik & Nichols 2019, tr. 104–109.
63. ↑ Klabnik & Nichols 2019, tr. 24.
64. ↑ Klabnik & Nichols 2019, tr. 36–38.
65. ↑ "isize". doc.rust-lang.org. Truy cập ngày 28 tháng 9 năm 2025.
66. ↑ "usize". doc.rust-lang.org. Truy cập ngày 28 tháng 9 năm 2025.
67. ↑ Klabnik & Nichols 2023, tr. 36-38.
68. ↑ Klabnik & Nichols 2023, tr. 502.
69. ↑ "Primitive Type char". The Rust Standard Library documentation. Truy cập ngày 7 tháng 9 năm 2025.
70. ↑ "Glossary of Unicode Terms". Unicode Consortium. Lưu trữ bản gốc ngày 24 tháng 9 năm 2018. Truy cập ngày 30 tháng 7 năm 2024.
71. ↑ Klabnik & Nichols 2019, tr. 38–40.
72. ↑ Klabnik & Nichols 2023, tr. 40-42.
73. ↑ Klabnik & Nichols 2023, tr. 42.
74. ↑ Klabnik & Nichols 2019, tr. 59–61.
75. 1 2 Klabnik & Nichols 2019, tr. 63–68.
76. ↑ Klabnik & Nichols 2019, tr. 74–75.
77. ↑ Klabnik & Nichols 2023, tr. 71–72.
78. 1 2 Balasubramanian, Abhiram; Baranowski, Marek S.; Burtsev, Anton; Panda, Aurojit; Rakamarić, Zvonimir; Ryzhyk, Leonid (ngày 7 tháng 5 năm 2017). "System Programming in Rust". Proceedings of the 16th Workshop on Hot Topics in Operating Systems. HotOS '17. New York, NY, US: Association for Computing Machinery. tr. 156–161. doi:10.1145/3102980.3103006. ISBN 978-1-4503-5068-6. S2CID 24100599. Lưu trữ bản gốc ngày 11 tháng 6 năm 2022. Truy cập ngày 1 tháng 6 năm 2022.
79. ↑ Klabnik & Nichols 2023, tr. 327-30.
80. ↑ "Lifetimes". Rust by Example. Lưu trữ bản gốc ngày 16 tháng 11 năm 2024. Truy cập ngày 29 tháng 10 năm 2024.
81. ↑ "Explicit annotation". Rust by Example. Truy cập ngày 29 tháng 10 năm 2024.
82. 1 2 Klabnik & Nichols 2019, tr. 194.
83. ↑ Klabnik & Nichols 2019, tr. 75,134.
84. ↑ Shamrell-Harrington, Nell (ngày 15 tháng 4 năm 2022). "The Rust Borrow Checker – a Deep Dive". InfoQ (bằng tiếng Anh). Lưu trữ bản gốc ngày 25 tháng 6 năm 2022. Truy cập ngày 25 tháng 6 năm 2022.
85. ↑ Klabnik & Nichols 2019, tr. 194-195.
86. ↑ Klabnik & Nichols 2023, tr. 208–12.
87. ↑ Klabnik & Nichols 2023, 4.2. References and Borrowing.
88. ↑ Pearce, David (ngày 17 tháng 4 năm 2021). "A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust". ACM Transactions on Programming Languages and Systems. 43: 1–73. doi:10.1145/3443420. Lưu trữ bản gốc ngày 15 tháng 4 năm 2024. Truy cập ngày 11 tháng 12 năm 2024.
89. ↑ Klabnik & Nichols 2019, tr. 83.
90. ↑ Klabnik & Nichols 2019, tr. 97.
91. ↑ Klabnik & Nichols 2019, tr. 98–101.
92. ↑ Klabnik & Nichols 2019, tr. 438–440.
93. ↑ Klabnik & Nichols 2019, tr. 93.
94. ↑ Gjengset 2021, tr. 213-215.
95. ↑ Klabnik & Nichols 2023, tr. 108-110,113-114,116-117.
96. ↑ "Rust error handling is perfect actually". Bitfield Consulting. ngày 27 tháng 5 năm 2024. Lưu trữ bản gốc ngày 7 tháng 8 năm 2025. Truy cập ngày 15 tháng 9 năm 2025.
97. ↑ Gjengset 2021, tr. 155-156.
98. ↑ Klabnik & Nichols 2023, tr. 421-423.
99. ↑ Klabnik & Nichols 2019, tr. 418–427.
100. ↑ "Casting". Rust by Example. Truy cập ngày 1 tháng 4 năm 2025.
101. ↑ Klabnik & Nichols 2023, tr. 378.
102. 1 2 3 Klabnik & Nichols 2023, tr. 192-198.
103. ↑ Klabnik & Nichols 2023, tr. 98.
104. ↑ Klabnik & Nichols 2019, tr. 171–172,205.
105. 1 2 Klabnik & Nichols 2023, tr. 191-192.
106. ↑ Klabnik & Nichols 2019, tr. 441–442.
107. ↑ Gjengset 2021, tr. 25.
108. ↑ Klabnik & Nichols 2023, 18.2. Using Trait Objects That Allow for Values of Different Types.
109. ↑ Klabnik & Nichols 2019, tr. 379–380.
110. ↑ "RAII". Rust by Example. Lưu trữ bản gốc ngày 21 tháng 4 năm 2019. Truy cập ngày 22 tháng 11 năm 2020.
111. ↑ "Abstraction without overhead: traits in Rust". Rust Blog. Lưu trữ bản gốc ngày 23 tháng 9 năm 2021. Truy cập ngày 19 tháng 10 năm 2021.
112. ↑ "Box, stack and heap". Rust by Example. Lưu trữ bản gốc ngày 31 tháng 5 năm 2022. Truy cập ngày 13 tháng 6 năm 2022.
113. ↑ Klabnik & Nichols 2019, tr. 70–75.
114. ↑ Klabnik & Nichols 2019, tr. 323.
115. ↑ Klabnik & Nichols 2023, tr. 420-429.
116. ↑ McNamara 2021, tr. 139, 376–379, 395.
117. 1 2 Astrauskas, Vytautas; Matheja, Christoph; Poli, Federico; Müller, Peter; Summers, Alexander J. (ngày 13 tháng 11 năm 2020). "How do programmers use unsafe rust?". Proceedings of the ACM on Programming Languages (bằng tiếng Anh). 4: 1–27. doi:10.1145/3428204. hdl:20.500.11850/465785. ISSN 2475-1421.
118. ↑ Lattuada, Andrea; Hance, Travis; Cho, Chanhee; Brun, Matthias; Subasinghe, Isitha; Zhou, Yi; Howell, Jon; Parno, Bryan; Hawblitzel, Chris (ngày 6 tháng 4 năm 2023). "Verus: Verifying Rust Programs using Linear Ghost Types". Proceedings of the ACM on Programming Languages. 7: 85:286–85:315. doi:10.1145/3586037. hdl:20.500.11850/610518.
119. ↑ Milano, Mae; Turcotti, Julia; Myers, Andrew C. (ngày 9 tháng 6 năm 2022). "A flexible type system for fearless concurrency". Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. New York, NY, USA: Association for Computing Machinery. tr. 458–473. doi:10.1145/3519939.3523443. ISBN 978-1-4503-9265-5.
120. ↑ "Introduction - Learning Rust With Entirely Too Many Linked Lists". rust-unofficial.github.io. Truy cập ngày 6 tháng 8 năm 2025.
121. ↑ Noble, James; Mackay, Julian; Wrigstad, Tobias (ngày 16 tháng 10 năm 2023). "Rusty Links in Local Chains✱". Proceedings of the 24th ACM International Workshop on Formal Techniques for Java-like Programs. New York, NY, USA: Association for Computing Machinery. tr. 1–3. doi:10.1145/3611096.3611097. ISBN 979-8-4007-0784-1.
122. 1 2 Evans, Ana Nora; Campbell, Bradford; Soffa, Mary Lou (ngày 1 tháng 10 năm 2020). "Is rust used safely by software developers?". Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering. New York, NY, USA: Association for Computing Machinery. tr. 246–257. arXiv:2007.00752. doi:10.1145/3377811.3380413. ISBN 978-1-4503-7121-6.
123. ↑ "Behavior considered undefined". The Rust Reference. Truy cập ngày 6 tháng 8 năm 2025.
124. ↑ Klabnik & Nichols 2023, tr. 449–455.
125. ↑ Gjengset 2021, tr. 101-102.
126. ↑ "Macros By Example". The Rust Reference. Lưu trữ bản gốc ngày 21 tháng 4 năm 2023. Truy cập ngày 21 tháng 4 năm 2023.
127. ↑ Klabnik & Nichols 2019, tr. 446–448.
128. ↑ "Procedural Macros". The Rust Programming Language Reference. Lưu trữ bản gốc ngày 7 tháng 11 năm 2020. Truy cập ngày 23 tháng 3 năm 2021.
129. ↑ Klabnik & Nichols 2019, tr. 449–455.
130. ↑ Baumgartner, Stefan (ngày 23 tháng 5 năm 2025). "Programming language: Rust 2024 is the most comprehensive edition to date". heise online (bằng tiếng Anh). Truy cập ngày 28 tháng 6 năm 2025.
131. 1 2 3 Gjengset 2021, tr. 193-209.
132. ↑ "Safe Interoperability between Rust and C++ with CXX". InfoQ (bằng tiếng Anh). ngày 6 tháng 12 năm 2020. Lưu trữ bản gốc ngày 22 tháng 1 năm 2021. Truy cập ngày 3 tháng 1 năm 2021.
133. ↑ Rosenblatt, Seth (ngày 3 tháng 4 năm 2013). "Samsung joins Mozilla's quest for Rust". CNET. Lưu trữ bản gốc ngày 4 tháng 4 năm 2013. Truy cập ngày 5 tháng 4 năm 2013.
134. ↑ Brown, Neil (ngày 17 tháng 4 năm 2013). "A taste of Rust". LWN.net. Lưu trữ bản gốc ngày 26 tháng 4 năm 2013. Truy cập ngày 25 tháng 4 năm 2013.
135. ↑ "Races". The Rustonomicon. Lưu trữ bản gốc ngày 10 tháng 7 năm 2017. Truy cập ngày 3 tháng 7 năm 2017.
136. ↑ Vandervelden, Thibaut; De Smet, Ruben; Deac, Diana; Steenhaut, Kris; Braeken, An (ngày 7 tháng 9 năm 2024). "Overview of Embedded Rust Operating Systems and Frameworks". Sensors. 24 (17): 5818. Bibcode:2024Senso..24.5818V. doi:10.3390/s24175818. PMC 11398098. PMID 39275729.
137. 1 2 Klabnik & Nichols 2023, tr. 343-346.
138. ↑ Gjengset 2021, tr. 6.
139. ↑ Blandy, Orendorff & Tindall 2021, tr. 6-8.
140. ↑ "Overview of the compiler". Rust Compiler Development Guide. Rust project contributors. Lưu trữ bản gốc ngày 31 tháng 5 năm 2023. Truy cập ngày 7 tháng 11 năm 2024.
141. ↑ "Code Generation". Rust Compiler Development Guide. Rust project contributors. Truy cập ngày 3 tháng 3 năm 2024.
142. ↑ "rust-lang/rustc_codegen_gcc". GitHub. The Rust Programming Language. ngày 2 tháng 3 năm 2024. Truy cập ngày 3 tháng 3 năm 2024.
143. ↑ "rust-lang/rustc_codegen_cranelift". GitHub. The Rust Programming Language. ngày 2 tháng 3 năm 2024. Truy cập ngày 3 tháng 3 năm 2024.
144. 1 2 3 Perkel, Jeffrey M. (ngày 1 tháng 12 năm 2020). "Why scientists are turning to Rust". Nature (bằng tiếng Anh). 588 (7836): 185–186. Bibcode:2020Natur.588..185P. doi:10.1038/d41586-020-03382-2. PMID 33262490. S2CID 227251258. Lưu trữ bản gốc ngày 6 tháng 5 năm 2022. Truy cập ngày 15 tháng 5 năm 2022.
145. ↑ Simone, Sergio De (ngày 18 tháng 4 năm 2019). "Rust 1.34 Introduces Alternative Registries for Non-Public Crates". InfoQ (bằng tiếng Anh). Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 14 tháng 7 năm 2022.
146. ↑ "Why Cargo Exists - The Cargo Book". doc.rust-lang.org. Truy cập ngày 22 tháng 3 năm 2026.
147. ↑ "Cargo.toml vs Cargo.lock - The Cargo Book". doc.rust-lang.org. Truy cập ngày 22 tháng 3 năm 2026.
148. ↑ Klabnik & Nichols 2019, tr. 511–512.
149. ↑ "rust-lang/rust-clippy". The Rust Programming Language. ngày 4 tháng 1 năm 2026. Truy cập ngày 4 tháng 1 năm 2026.
150. ↑ "Clippy Lints". The Rust Programming Language. Truy cập ngày 30 tháng 11 năm 2023.
151. ↑ Klabnik & Nichols 2019, Appendix G – How Rust is Made and "Nightly Rust"
152. ↑ Blandy, Orendorff & Tindall 2021, tr. 176–177.
153. ↑ Klabnik & Nichols 2023, tr. 623.
154. ↑ Anderson, Tim (ngày 30 tháng 11 năm 2021). "Can Rust save the planet? Why, and why not". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 11 tháng 7 năm 2022. Truy cập ngày 11 tháng 7 năm 2022.
155. ↑ Yegulalp, Serdar (ngày 6 tháng 10 năm 2021). "What is the Rust language? Safe, fast, and easy software development". InfoWorld (bằng tiếng Anh). Lưu trữ bản gốc ngày 24 tháng 6 năm 2022. Truy cập ngày 25 tháng 6 năm 2022.
156. ↑ McNamara 2021, tr. 11.
157. 1 2 Popescu, Natalie; Xu, Ziyang; Apostolakis, Sotiris; August, David I.; Levy, Amit (ngày 15 tháng 10 năm 2021). "Safer at any speed: automatic context-aware safety enhancement for Rust". Proceedings of the ACM on Programming Languages. 5 (OOPSLA). Section 2. doi:10.1145/3485480. S2CID 238212612. tr. 5: We observe a large variance in the overheads of checked indexing: 23.6% of benchmarks do report significant performance hits from checked indexing, but 64.5% report little-to-no impact and, surprisingly, 11.8% report improved performance.
158. ↑ McNamara 2021, tr. 19, 27.
159. ↑ Couprie, Geoffroy (2015). "Nom, A Byte oriented, streaming, Zero copy, Parser Combinators Library in Rust". 2015 IEEE Security and Privacy Workshops. tr. 142–148. doi:10.1109/SPW.2015.31. ISBN 978-1-4799-9933-0. S2CID 16608844.
160. ↑ McNamara 2021, tr. 20.
161. ↑ "Code generation". The Rust Reference. Lưu trữ bản gốc ngày 9 tháng 10 năm 2022. Truy cập ngày 9 tháng 10 năm 2022.
162. ↑ Farshin, Alireza; Barbette, Tom; Roozbeh, Amir; Maguire, Gerald Q. Jr; Kostić, Dejan (2021). "PacketMill: Toward per-Core 100-GBPS networking". Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (bằng tiếng Anh). tr. 1–17. doi:10.1145/3445814.3446724. ISBN 9781450383172. S2CID 231949599. Lưu trữ bản gốc ngày 12 tháng 7 năm 2022. Truy cập ngày 12 tháng 7 năm 2022. ... While some compilers (e.g., Rust) support structure reordering [82], C & C++ compilers are forbidden to reorder data structures (e.g., struct or class) [74] ...
163. ↑ Gjengset 2021, tr. 22.
164. ↑ "How Fast Is Rust?". The Rust Programming Language FAQ. Lưu trữ bản gốc ngày 28 tháng 10 năm 2020. Truy cập ngày 11 tháng 4 năm 2019.
165. ↑ Shankland, Stephen (ngày 12 tháng 7 năm 2016). "Firefox will get overhaul in bid to get you interested again" (bằng tiếng Anh). CNET. Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 14 tháng 7 năm 2022.
166. ↑ Cimpanu, Catalin (ngày 15 tháng 10 năm 2019). "AWS to sponsor Rust project". ZDNET (bằng tiếng Anh). Truy cập ngày 17 tháng 7 năm 2024.
167. ↑ Nichols, Shaun (ngày 27 tháng 6 năm 2018). "Microsoft's next trick? Kicking things out of the cloud to Azure IoT Edge". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 27 tháng 9 năm 2019. Truy cập ngày 27 tháng 9 năm 2019.
168. ↑ Tung, Liam (ngày 30 tháng 4 năm 2020). "Microsoft: Why we used programming language Rust over Go for WebAssembly on Kubernetes app". ZDNET (bằng tiếng Anh). Lưu trữ bản gốc ngày 21 tháng 4 năm 2022. Truy cập ngày 21 tháng 4 năm 2022.
169. ↑ Claburn, Thomas (ngày 20 tháng 9 năm 2022). "In Rust We Trust: Microsoft Azure CTO shuns C and C++". The Register. Truy cập ngày 7 tháng 7 năm 2024.
170. ↑ Simone, Sergio De (ngày 10 tháng 3 năm 2019). "NPM Adopted Rust to Remove Performance Bottlenecks". InfoQ (bằng tiếng Anh). Lưu trữ bản gốc ngày 19 tháng 11 năm 2023. Truy cập ngày 20 tháng 11 năm 2023.
171. ↑ Lyu, Shing (2020). "Welcome to the World of Rust". Trong Lyu, Shing (biên tập). Practical Rust Projects: Building Game, Physical Computing, and Machine Learning Applications (bằng tiếng Anh). Berkeley, CA: Apress. tr. 1–8. doi:10.1007/978-1-4842-5599-5_1. ISBN 978-1-4842-5599-5. Truy cập ngày 29 tháng 11 năm 2023.
172. ↑ Lyu, Shing (2021). "Rust in the Web World". Trong Lyu, Shing (biên tập). Practical Rust Web Projects: Building Cloud and Web-Based Applications (bằng tiếng Anh). Berkeley, CA: Apress. tr. 1–7. doi:10.1007/978-1-4842-6589-5_1. ISBN 978-1-4842-6589-5. Truy cập ngày 29 tháng 11 năm 2023.
173. 1 2 Li, Hongyu; Guo, Liwei; Yang, Yexuan; Wang, Shangguang; Xu, Mengwei (ngày 30 tháng 6 năm 2024). "An Empirical Study of Rust-for-Linux: The Success, Dissatisfaction, and Compromise". USENIX (bằng tiếng Anh). Truy cập ngày 28 tháng 11 năm 2024.
174. ↑ Corbet, Jonathan (ngày 13 tháng 10 năm 2022). "A first look at Rust in the 6.1 kernel". LWN.net. Lưu trữ bản gốc ngày 17 tháng 11 năm 2023. Truy cập ngày 11 tháng 11 năm 2023.
175. ↑ Vaughan-Nichols, Steven (ngày 7 tháng 12 năm 2021). "Rust takes a major step forward as Linux's second official language". ZDNET (bằng tiếng Anh). Truy cập ngày 27 tháng 11 năm 2024.
176. ↑ Corbet, Jonathan (ngày 10 tháng 12 năm 2025). "The (successful) end of the kernel Rust experiment". LWN.net (bằng tiếng Anh). Truy cập ngày 10 tháng 12 năm 2025.
177. ↑ Amadeo, Ron (ngày 7 tháng 4 năm 2021). "Google is now writing low-level Android code in Rust". Ars Technica (bằng tiếng Anh). Lưu trữ bản gốc ngày 8 tháng 4 năm 2021. Truy cập ngày 21 tháng 4 năm 2022.
178. ↑ Darkcrizt (ngày 2 tháng 4 năm 2021). "Google Develops New Bluetooth Stack for Android, Written in Rust". Desde Linux. Bản gốc lưu trữ ngày 25 tháng 8 năm 2021. Truy cập ngày 31 tháng 8 năm 2024.
179. 1 2 Newman, Lily Hay (ngày 2 tháng 11 năm 2022). "The 'Viral' Secure Programming Language That's Taking Over Tech". Wired (bằng tiếng Anh). ISSN 1059-1028. Truy cập ngày 3 tháng 11 năm 2026.
180. ↑ Claburn, Thomas (ngày 27 tháng 4 năm 2023). "Microsoft is rewriting core Windows libraries in Rust". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 13 tháng 5 năm 2023. Truy cập ngày 13 tháng 5 năm 2023.
181. ↑ Proven, Liam (ngày 1 tháng 12 năm 2023). "Small but mighty, 9Front's 'Humanbiologics' is here for the truly curious". The Register. Truy cập ngày 7 tháng 3 năm 2024.
182. ↑ Yegulalp, Serdar (ngày 21 tháng 3 năm 2016). "Rust's Redox OS could show Linux a few new tricks". InfoWorld. Bản gốc lưu trữ ngày 21 tháng 3 năm 2016. Truy cập ngày 21 tháng 3 năm 2016.
183. ↑ Anderson, Tim (ngày 14 tháng 1 năm 2021). "Another Rust-y OS: Theseus joins Redox in pursuit of safer, more resilient systems". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 14 tháng 7 năm 2022.
184. ↑ Boos, Kevin; Liyanage, Namitha; Ijaz, Ramla; Zhong, Lin (2020). Theseus: an Experiment in Operating System Structure and State Management (bằng tiếng Anh). tr. 1–19. ISBN 978-1-939133-19-9. Lưu trữ bản gốc ngày 13 tháng 5 năm 2023. Truy cập ngày 13 tháng 5 năm 2023.
185. ↑ Zhang, HanDong (ngày 31 tháng 1 năm 2023). "2022 Review | The adoption of Rust in Business". Rust Magazine (bằng tiếng Anh). Truy cập ngày 7 tháng 2 năm 2023.
186. ↑ Sei, Mark (ngày 10 tháng 10 năm 2018). "Fedora 29 new features: Startis now officially in Fedora". Marksei, Weekly sysadmin pills. Lưu trữ bản gốc ngày 13 tháng 4 năm 2019. Truy cập ngày 13 tháng 5 năm 2019.
187. ↑ Proven, Liam (ngày 12 tháng 7 năm 2022). "Oracle Linux 9 released, with some interesting additions". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 14 tháng 7 năm 2022.
188. ↑ Proven, Liam (ngày 2 tháng 2 năm 2023). "System76 teases features coming in homegrown Rust-based desktop COSMIC". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 17 tháng 7 năm 2024. Truy cập ngày 17 tháng 7 năm 2024.
189. ↑ Hu, Vivian (ngày 12 tháng 6 năm 2020). "Deno Is Ready for Production". InfoQ (bằng tiếng Anh). Lưu trữ bản gốc ngày 1 tháng 7 năm 2020. Truy cập ngày 14 tháng 7 năm 2022.
190. ↑ Abrams, Lawrence (ngày 6 tháng 2 năm 2021). "This Flash Player emulator lets you securely play your old games". Bleeping Computer (bằng tiếng Anh). Lưu trữ bản gốc ngày 25 tháng 12 năm 2021. Truy cập ngày 25 tháng 12 năm 2021.
191. ↑ Kharif, Olga (ngày 17 tháng 10 năm 2020). "Ethereum Blockchain Killer Goes By Unassuming Name of Polkadot". Bloomberg News. Bloomberg L.P. Lưu trữ bản gốc ngày 17 tháng 10 năm 2020. Truy cập ngày 14 tháng 7 năm 2021.
192. ↑ Keizer, Gregg (ngày 31 tháng 10 năm 2016). "Mozilla plans to rejuvenate Firefox in 2017". Computerworld (bằng tiếng Anh). Lưu trữ bản gốc ngày 13 tháng 5 năm 2023. Truy cập ngày 13 tháng 5 năm 2023.
193. ↑ Claburn, Thomas (ngày 12 tháng 1 năm 2023). "Google polishes Chromium code with a layer of Rust". The Register. Truy cập ngày 17 tháng 7 năm 2024.
194. ↑ Jansens, Dana (ngày 12 tháng 1 năm 2023). "Supporting the Use of Rust in the Chromium Project". Google Online Security Blog (bằng tiếng Anh). Lưu trữ bản gốc ngày 13 tháng 1 năm 2023. Truy cập ngày 12 tháng 11 năm 2023.
195. 1 2 Caballar, Rina Diane (ngày 20 tháng 3 năm 2023). "The Move to Memory-Safe Programming". IEEE Spectrum (bằng tiếng Anh). Truy cập ngày 3 tháng 11 năm 2026.
196. 1 2 3 "2025 Stack Overflow Developer Survey – Technology". Stack Overflow. Truy cập ngày 9 tháng 8 năm 2025.
197. ↑ Claburn, Thomas (ngày 23 tháng 6 năm 2022). "Linus Torvalds says Rust is coming to the Linux kernel". The Register (bằng tiếng Anh). Lưu trữ bản gốc ngày 28 tháng 7 năm 2022. Truy cập ngày 15 tháng 7 năm 2022.
198. ↑ Krill, Paul (ngày 6 tháng 7 năm 2026). "Rust language rises to top 10 in Tiobe popularity index". InfoWorld. Truy cập ngày 21 tháng 8 năm 2026.
199. ↑ Gent, Edd (ngày 28 tháng 1 năm 2026). "AI Code Transforms C to Rust for Safer Software". IEEE Spectrum (bằng tiếng Anh). Truy cập ngày 3 tháng 11 năm 2026.
200. ↑ Jung, Ralf; Jourdan, Jacques-Henri; Krebbers, Robbert; Dreyer, Derek (ngày 27 tháng 12 năm 2017). "RustBelt: securing the foundations of the Rust programming language". Proceedings of the ACM on Programming Languages (bằng tiếng Anh). 2 (POPL): 1–34. doi:10.1145/3158154. hdl:21.11116/0000-0003-34C6-3. ISSN 2475-1421.
201. ↑ Popescu, Natalie; Xu, Ziyang; Apostolakis, Sotiris; August, David I.; Levy, Amit (ngày 20 tháng 10 năm 2021). "Safer at any speed: automatic context-aware safety enhancement for Rust". Proceedings of the ACM on Programming Languages (bằng tiếng Anh). 5 (OOPSLA): 1–23. doi:10.1145/3485480. ISSN 2475-1421.
202. ↑ Blanco-Cuaresma, Sergi; Bolmont, Emeline (ngày 30 tháng 5 năm 2017). "What can the programming language Rust do for astrophysics?". Proceedings of the International Astronomical Union (bằng tiếng Anh). 12 (S325): 341–344. arXiv:1702.02951. Bibcode:2017IAUS..325..341B. doi:10.1017/S1743921316013168. ISSN 1743-9213. S2CID 7857871. Lưu trữ bản gốc ngày 25 tháng 6 năm 2022. Truy cập ngày 25 tháng 6 năm 2022.
203. ↑ Ho, Son; Protzenko, Jonathan (ngày 31 tháng 8 năm 2022). "Aeneas: Rust verification by functional translation". Proceedings of the ACM on Programming Languages. 6 (ICFP). New York, NY, USA: Association for Computing Machinery: 116:711–116:741. arXiv:2206.07185. doi:10.1145/3547647.
204. ↑ Denis, Xavier; Jourdan, Jacques-Henri; Marché, Claude (2022). Riesco, Adrian; Zhang, Min (biên tập). "Creusot: A Foundry for the Deductive Verification of Rust Programs". Formal Methods and Software Engineering. Cham: Springer International Publishing: 90–105. doi:10.1007/978-3-031-17244-1_6. ISBN 978-3-031-17244-1.
205. ↑ Lehmann, Nico; Geller, Adam T.; Vazou, Niki; Jhala, Ranjit (ngày 6 tháng 6 năm 2023). "Flux: Liquid Types for Rust". Proceedings of the ACM on Programming Languages. 7 (PLDI). New York, NY, USA: Association for Computing Machinery: 169:1533–169:1557. arXiv:2207.04034. doi:10.1145/3591283.
206. ↑ VanHattum, Alexa; Schwartz-Narbonne, Daniel; Chong, Nathan; Sampson, Adrian (ngày 21 tháng 5 năm 2022). "Verifying dynamic trait objects in rust". Proceedings of the 44th International Conference on Software Engineering: Software Engineering in Practice (bằng tiếng Anh). ACM: 321–330. doi:10.1145/3510457.3513031. ISBN 978-1-4503-9226-6.
207. ↑ Astrauskas, Vytautas; Bílá, Aurea; Fiala, Jonáš; Grannan, Zachary; Matheja, Christoph; Müller, Peter; Poli, Federico; Summers, Alexander J. (2022). Deshmukh, Jyotirmoy V.; Havelund, Klaus; Perez, Ivan (biên tập). "The Prusti Project: Formal Verification for Rust". NASA Formal Methods Symposium. Cham: Springer International Publishing: 88–108. doi:10.1007/978-3-031-06773-0_5. ISBN 978-3-031-06773-0.
208. ↑ Matsushita, Yusuke; Denis, Xavier; Jourdan, Jacques-Henri; Dreyer, Derek (ngày 9 tháng 6 năm 2022), "RustHornBelt: a semantic foundation for functional verification of Rust programs with unsafe code", Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, ACM Conferences, tr. 841–856, doi:10.1145/3519939.3523704, ISBN 978-1-4503-9265-5, truy cập ngày 18 tháng 9 năm 2026
209. ↑ Parno, Bryan (ngày 31 tháng 8 năm 2026). "Developing provably correct Rust code with Verus". Amazon Science (bằng tiếng Anh). Truy cập ngày 17 tháng 9 năm 2026.
210. ↑ "Practical System Verification". Microsoft Research (bằng tiếng Anh). Truy cập ngày 17 tháng 9 năm 2026.
211. ↑ Wallach, Dan. "TRACTOR: Translating All C to Rust". DARPA. Truy cập ngày 3 tháng 8 năm 2025.
212. ↑ Klabnik & Nichols 2019, tr. 4.
213. ↑ "Getting Started". The Rust Programming Language. Lưu trữ bản gốc ngày 1 tháng 11 năm 2020. Truy cập ngày 11 tháng 10 năm 2020.
214. ↑ The Rust Survey Team (ngày 13 tháng 2 năm 2025). "2024 State of Rust Survey Results". The Rust Programming Language. Truy cập ngày 7 tháng 9 năm 2025.
215. 1 2 "Anti-Bribery and Anti-Corruption Policy". Rust Foundation (bằng tiếng Anh). Truy cập ngày 3 tháng 6 năm 2026.
216. ↑ Tung, Liam (ngày 8 tháng 2 năm 2021). "The Rust programming language just took a huge step forwards". ZDNET (bằng tiếng Anh). Lưu trữ bản gốc ngày 14 tháng 7 năm 2022. Truy cập ngày 14 tháng 7 năm 2022.
217. ↑ Krill, Paul (ngày 9 tháng 2 năm 2021). "Rust language moves to independent foundation". InfoWorld. Lưu trữ bản gốc ngày 10 tháng 4 năm 2021. Truy cập ngày 10 tháng 4 năm 2021.
218. ↑ Vaughan-Nichols, Steven J. (ngày 9 tháng 4 năm 2021). "AWS's Shane Miller to head the newly created Rust Foundation". ZDNET. Lưu trữ bản gốc ngày 10 tháng 4 năm 2021. Truy cập ngày 10 tháng 4 năm 2021.
219. ↑ Vaughan-Nichols, Steven J. (ngày 17 tháng 11 năm 2021). "Rust Foundation appoints Rebecca Rumbul as executive director". ZDNET. Lưu trữ bản gốc ngày 18 tháng 11 năm 2021. Truy cập ngày 18 tháng 11 năm 2021.
220. ↑ "Rust Foundation Members | Join Us". Rust Foundation (bằng tiếng Anh). Truy cập ngày 19 tháng 8 năm 2026.
221. ↑ "Governance". The Rust Programming Language (bằng tiếng Anh). Lưu trữ bản gốc ngày 2 tháng 10 năm 2025. Truy cập ngày 19 tháng 11 năm 2025.
222. ↑ "Introducing the Rust Leadership Council". Rust Blog (bằng tiếng Anh). ngày 20 tháng 6 năm 2023. Truy cập ngày 12 tháng 1 năm 2024.