Rust for beginners: Getting started with Rust

Are you tired of dealing with memory errors, null pointers, and data races in your code? Have you heard about Rust, the systems programming language that promises "safe, concurrent, and fast" code? If you're a beginner looking to learn Rust, you've come to the right place!

In this article, we'll cover the basics of Rust, including its syntax, types, ownership and borrowing system, and some advanced features like traits and enums. We'll also show you how to install Rust and set up your development environment, and introduce you to some of the most popular Rust tools and libraries.

Why Rust?

Before we dive into Rust's features and syntax, let's first understand why you might want to use Rust in the first place.


Rust is a compiled language that generates machine code, just like C or C++. This means that Rust programs can be as fast and efficient as the best native code. However, unlike C++, Rust provides memory safety guarantees at compile time, without the overhead of a garbage collector, making it a much safer and more reliable option.


Rust's ownership and borrowing system ensures that your code never has dangling pointers, null pointers, buffer overflows, or data races. This means that your code is much less likely to have security vulnerabilities or crash unexpectedly. Rust also has a strong type system that catches most errors at compile time, rather than runtime, saving you valuable debugging time.


Despite being a low-level language, Rust has a modern syntax and expressive features that make it easy to write efficient and readable code. Rust also has an active and supportive community, with plenty of resources, tutorials, and libraries available online.

Now that you're convinced of Rust's benefits, let's get started with the basics!

Installing Rust

Before we can start writing Rust code, we need to install the Rust toolchain. The easiest way to do this is by downloading the official Rustup installer from Rustup is a command-line tool that manages Rust installations and updates, and allows you to switch between Rust channels (stable, beta, and nightly).

Once you've downloaded and run the installer, you should have access to the Rust compiler (rustc) and the Rust package manager (cargo). You can check the version of Rust and cargo using the following commands:

$ rustc --version
rustc 1.55.0 (c8dfcfe04 2021-09-06)
$ cargo --version
cargo 1.55.0 (32da73ab1 2021-08-23)

Congratulations, you've installed Rust!

Your first Rust program

Let's create our first Rust program, the traditional "Hello, world!" program. Create a new file called and add the following code:

fn main() {
    println!("Hello, world!");

To compile and run the program, use the following command:

$ rustc
$ ./hello
Hello, world!

Congratulations, you've written and run your first Rust program!

Rust syntax

Let's dive deeper into Rust's syntax and features. Rust has a C-like syntax, with curly braces, semicolons, and variable declarations. However, Rust also has some unique features, such as its ownership and borrowing system, that make it different from other languages.

Basic types

In Rust, everything is a variable. Rust has built-in support for several basic types, such as integers, floating-point numbers, Booleans, and characters. Rust also has two compound types, arrays, and tuples.

let x = 42;          // integer
let y = 3.14;        // floating-point number
let z = true;        // Boolean
let c = 'a';         // character
let a = [1, 2, 3];   // array
let t = (1, 2, 'a'); // tuple


Functions are declared using the fn keyword, followed by the function name, arguments, and return type (if any).

fn add(x: i32, y: i32) -> i32 {
    x + y

Ownership and borrowing

Rust's ownership and borrowing system is its most unique feature. In Rust, every value has an owner, which is responsible for freeing its memory when it goes out of scope. You can transfer ownership using the move keyword, or pass ownership by reference using the & symbol.

let s1 = String::from("hello"); // s1 owns the String
let s2 = s1;                   // transfer s1's ownership to s2
println!("{}", s2);            // prints "hello"
println!("{}", s1);            // error: s1 no longer owns the String

If you want to pass a value by reference but not transfer ownership, you can use borrowing, which is done using the & symbol.

let s1 = String::from("hello");
let len = calculate_length(&s1); // pass a reference to s1
println!("The length of '{}' is {}.", s1, len); // s1 still owns the String

fn calculate_length(s: &String) -> usize {

Ownership and structs

Structs, Rust's equivalent of classes, also have ownership semantics. You can define a struct using the struct keyword, and declare fields using the name: type syntax. You can then create an instance of the struct using the Struct { field: value } syntax.

struct Rectangle {
    width: u32,
    height: u32,

let rect1 = Rectangle { width: 30, height: 50 };
let area = calculate_area(&rect1);
println!("The area of the rectangle is {} square pixels.", area);

fn calculate_area(rect: &Rectangle) -> u32 {
    rect.width * rect.height


Traits are Rust's way of defining interfaces or protocols for types. Traits define a set of methods that a type must implement, and can be used to enforce a shared behavior across different types.

trait Draw {
    fn draw(&self);

struct Circle {
    x: f64,
    y: f64,
    radius: f64,

impl Draw for Circle {
    fn draw(&self) {
        println!("Drawing a circle at ({}, {}) with radius {}.", self.x, self.y, self.radius);

let c = Circle { x: 1.0, y: 2.0, radius: 3.0 };
c.draw(); // prints "Drawing a circle at (1, 2) with radius 3."


Enums, short for enumerations, allow you to define a type that can take one of several variants. Enums can be used to represent a finite set of values, like the days of the week or the states of a game.

enum IpAddr {
    V4(u8, u8, u8, u8),

let home = IpAddr::V4(192, 168, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));

Rust tools and libraries

Rust has a vibrant ecosystem of tools and libraries that make it easy to develop Rust projects. Here are some of the most popular tools and libraries:


Congratulations, you've made it to the end of this Rust for beginners guide! We hope you've learned enough about Rust's syntax, features, and tools to get started with your own Rust projects. Rust is a powerful and expressive language that offers performance, safety, and productivity benefits that other languages can't match. Happy coding!

Editor Recommended Sites

AI and Tech News
Best Online AI Courses
Classic Writing Analysis
Tears of the Kingdom Roleplay
Control Tower - GCP Cloud Resource management & Centralize multicloud resource management: Manage all cloud resources across accounts from a centralized control plane
Kids Books: Reading books for kids. Learn programming for kids: Scratch, Python. Learn AI for kids
Learn Go: Learn programming in Go programming language by Google. A complete course. Tutorials on packages
Hands On Lab: Hands on Cloud and Software engineering labs
Cloud Architect Certification - AWS Cloud Architect & GCP Cloud Architect: Prepare for the AWS, Azure, GCI Architect Cert & Courses for Cloud Architects