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.
Related courses for your next step
- Add a related skillBash Scripting
Focus: Script setup · Interpreter selection
Beginner
Compare course focus, level and study time
| 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.
Questions & discussion
Share a useful question or correction. Comments appear after moderation. Please avoid personal or sensitive information.