Rust a safe, concurrent, practical language

Rust is a curly-brace, block-structured expression language. It visually resembles the C language family, but differs significantly in syntactic and semantic details. Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency.

It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

A short summary of features

Type system	static, nominal, linear, algebraic, locally inferred
Memory safety	no null or dangling pointers, no buffer overflows
Concurrency	lightweight tasks with message passing, no shared memory
Generics	type parameterization with type classes
Exception handling	unrecoverable unwinding with task isolation
Memory model	optional task-local GC, safe pointer types with region analysis
Compilation model	ahead-of-time, C/C++ compatible
License	dual MIT / Apache 2

A very small taste of what it looks like

use core::rand::RngUtil;

fn main() {
    for ["Alice", "Bob", "Carol"].each |&name| {
        do spawn {
            let v = rand::Rng().shuffle([1, 2, 3]);
            for v.each |&num| {
                print(fmt!("%s says: '%d'\n", name, num))
            }
        }
    }
}