Rust began in 2006 as a personal side project of Graydon Hoare, an employee at Mozilla. It is a systems programming language meant to supersede languages like C++. Rust's initial focus was memory safety but later targeted performance as well adopting the C++ approach of zero cost abstraction. Rust's ecosystem consist of crates (Rust libraries) which can be installed using the Cargo tool.
Rust is the first industry-supported computer programming language to overcome the longstanding trade-off between the control over resource management provided by lower-level languages for systems programming, and the safety guarantees of higher-level languages.
SafetyThe safety of a programming language comes down to its ability to prevent or detect errors like buffer overreads. Rust ensures this primarily through the ownership system which put simply is that memory is allocated when a variable is declared and deallocated once the variable is no longer in scope as the variable's scope is the owner of the memory. (Note: It is possible to associate memory with a lifetime that allows it to outlive its variable's scope.)
The other aspect of the ownership system - counterintuitively called the borrowing system solves the problem with having only 1 owner at a time i.e. the problem of sharing values between functions, structs, and threads. This is solved using a borrowing system with its own rules for shared references. The rules of the borrowing system are fairly simple: there can either be one mutable reference to memory or multiple immutable references, meaning that there will only ever be, at most, one thread modifying the memory with no others reading. The combination of these systems and their rules completely prevent data races from occurring, making Rust an amazing choice for highly concurrent software systems.
Rust also does automatic bounds checking for buffer accesses preventing both buffer overreads and overflows.
Zero cost abstraction and lack of a garbage collector is what drives Rust's performance.
PerformanceA good way to think of zero cost abstraction is monomorphization, which allows one to create generic functions that are converted into the needed concrete type functions at compile time, so no runtime costs are incurred. Garbage collection adds overhead at runtime as the garbage collector must track the memory in some way (usually through reference counting) in order to determine when memory can be freed. This increases both memory usage (very important for embedded devices with limited memory) and CPU usage (important for performance critical software). Another considerable problem with garbage collection is that it is more difficult to control, leading to unexpected pauses in execution when it is running and/or freeing unused resources. So lack of one does aid in performance improvement.
SecurityThere is a lot of overlap between the safety of a language and the security of software written in that language. The Microsoft Security Response Center estimates that 70% of bugs they assign a common vulnerabilities and exposure (CVE) tag to are caused by memory exploits (i.e., buffer overflows or other memory misuses); this, obviously, means that ensuring memory safety can eliminate up to approximately 70% of security bugs.
Besides Cargo, other noteworthy tools are Clippy, which is a linter that provides extra warnings and can enforce extra compile time constraints, making code even safer and faster and rustfmt, which is a code formatter for Rust that offers extensive configuration options. Rust should be a good bet for highly performant, safe and highly concurrent systems.
