Udemy

Free Rust Foundations Course: Start with Cargo, Types and Variables

Before building a larger Rust application, it helps to understand the small steps between a source file and a running program. This free English course by Ellie Sleightholm introduces that workflow, then connects it to printing values, choosing data types and working with variables. It is a focused starting point for someone who wants to become comfortable with the language’s basic tools and notation.

Free learning access

Listed as Free on Udemy when checked on 6 November 2026. No coupon or subscription trial is required for the listed lessons. Enrollment needs a Udemy account; availability can change.

About this course

Before building a larger Rust application, it helps to understand the small steps between a source file and a running program. This free English course by Ellie Sleightholm introduces that workflow, then connects it to printing values, choosing data types and working with variables. It is a focused starting point for someone who wants to become comfortable with the language’s basic tools and notation.

This is Part One of a three-part series. Its seven videos span three sections and total one hour, fifty-seven minutes and twenty-three seconds. The actual sequence covers an introduction, installation, files and execution, Cargo, printing and formatting, variables and data types. The broader series description also mentions functions, control flow, vectors, structs and enums; those should not be treated as additional lessons within this seven-video course.

Official course Rust Programming Crash Course for Beginners (Part 1/3)
Created by Ellie Sleightholm
Platform Udemy
Language English
Level Beginner
Listed duration 117 minutes; 7 lectures across 3 sections
Completion terms Not included with a new free enrollment

What you’ll learn

Follow the path from a Rust source file to a compiled program. Recognize the different purposes of Cargo’s project, build, run and check commands. Explore formatted output, immutable and mutable bindings, constants, shadowing, and the scalar and compound types introduced in the final lesson.

Skills you’ll gain

  • Rust toolchain concepts
  • Cargo project workflow
  • Formatted console output
  • Variable mutability
  • Constants and shadowing
  • Scalar and compound types

Build a clear picture of the toolchain

The opening lesson introduces Rust as a compiled, statically typed language. The setup section then considers installation on Windows and macOS, using an editor such as Sublime Text or Visual Studio Code. An editor gives you a place to write code; the compiler and related tools perform different work. Keeping those roles separate makes it easier to understand which part of your setup needs attention when a command cannot be found.

The recording was updated in April 2023, so follow current official installation guidance for your operating system. Rustup manages Rust toolchains, while the Windows MSVC setup may also require Microsoft build tools. Check the relevant prerequisites and licensing for your environment. Watching the lessons is free; that does not make every optional editor, extension or third-party development service free, or establish that an old installation screen still matches your machine.

Use Cargo with a purpose

The files lesson introduces a main function, printed output and compilation with rustc. Cargo then adds a project-oriented workflow. A useful distinction is between creating a project, building it and running the resulting program. Rather than memorizing a sequence as a single action, describe what each command is supposed to produce. That habit helps when you later return to a project after changing its source.

Cargo check examines code without producing the final executable in the same way as cargo build. It can provide a quicker development check, but a successful check does not prove that every possible build diagnostic or runtime problem has been addressed. Likewise, successfully building a program is different from showing that it calculates the result you intended. Read diagnostics, then test behavior deliberately as your examples grow.

Make values visible

The printing lesson combines console output with placeholders, named arguments and different representations of values. Use a short, descriptive label alongside a result so that the output is understandable when several values appear together. Formatting a number for display changes how a reader sees it; it should not be confused with changing the underlying role of that value in your calculation.

The same lesson introduces rustfmt. Consistent source formatting can make examples easier to scan and compare, particularly when you are looking for the statement you just changed. It does not decide whether your algorithm is correct. Keep the distinction between formatting source code, formatting printed output and checking the program’s behavior: all three matter, but they answer different questions.

Reason about names and types

The variables lesson develops mutability, constants, explicit and inferred types, and shadowing. A variable binding is immutable by default. Adding mut allows reassignment within the rules of its type; creating a new binding with let can instead shadow an earlier name. Shadowing is not simply another spelling of mutation, and it can introduce a value of a different type. Constants have their own declaration requirements rather than being interchangeable with every immutable variable.

The final lesson surveys integers, floating-point values, Booleans and characters, followed by tuples and arrays. Think about the information each value represents before choosing its type. A count, a decimal measurement and a true-or-false result have different uses. Type inference reduces some annotation, but it does not remove types from Rust or make every combination of values valid.

Try a small reading exercise

For an editorial practice exercise, sketch a program that prints a labeled item count, changes a mutable count, and then introduces a shadowed binding with a clearly explained purpose. Predict the output at each step before trying it. This exercise is proposed here, not supplied or executed as part of this review. General programming familiarity is helpful but not required by the course. Use these lessons as a foundation for further practice, without expecting a complete Rust curriculum, professional readiness or a completion certificate from this free enrollment.

Enroll Now ↗

Related courses for your next step

  • Add a related skillBash Scripting

    Focus: Script setup · Interpreter selection

    Beginner

Compare course focus, level and study time
Compare the published course outlines. A lower level is a preparation option, not a required prerequisite.
Course Level Focus Study time
This course — Free Rust Foundations Course: Start with Cargo, Types and Variables Beginner Rust toolchain concepts · Cargo project workflow · Formatted console output 117 minutes (Udemy listing)
Free Bash Scripting Course: Write Your First Linux Script Beginner Script setup · Interpreter selection · Shell builtins 44 minutes (Udemy listing)

Frequently asked questions

Does this include all three parts of the Rust series?

No. This listing is Part One, with seven videos about setup, Cargo, formatting, variables and data types. The other parts are separate courses.

Do I need previous programming experience?

The course is marked Beginner. Familiarity with general programming concepts is helpful, but it is not an essential prerequisite.

Does cargo check run my program?

No. It checks code without producing the final executable as a normal build would. Building, running and testing behavior are separate activities.

Share this course

Questions & discussion

Share a useful question or correction. Comments appear after moderation. Please avoid personal or sensitive information.

Add to the discussion

Your email address will not be published. Required fields are marked *