# Rustlings ships exercises and solutions in one crate, behind a Rust 1.88 floor

> Rustlings is rust-lang's set of small Rust exercises, recommended in parallel to the official Rust book. Its manifest carries more usable detail than its 41 word README: exercises and solutions are packaged together, the compiler floor is Rust 1.88 on edition 2024, and the newest release is v6.5.0 from 2025-08-21.

**rust-lang/rustlings** — Rustlings offers small hands-on exercises that teach you to read and write Rust code, designed to be worked through alongside the official Rust book.

- Repository: https://github.com/rust-lang/rustlings
- Website: https://rustlings.rust-lang.org
- Stars: 64,249 · Forks: 11,255
- Language: Rust
- License: MIT
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/rust-lang-rustlings

## The README has no install command and points at rustlings.rust-lang.org

Everything a newcomer needs lives on a page the repository does not contain. At 41 words, the README names itself, links rust-lang.org for Rust, and sends you to rustlings.rust-lang.org for a demo and setup details. No command appears anywhere in that text. Reach the site from a clone without a browser and the source tree offers no install line, no flag list and no configuration key. One other name appears: the official Rust book at doc.rust-lang.org/book, offered as something to read alongside. What this project costs a beginner first is a manual it does not ship.

## Rust 1.88 is the floor and the edition comment names three edits

Three lines in the workspace package section decide what compiler you need and who has to touch what when the language moves.

```toml
license = "MIT"
edition = "2024" # On Update: Update the edition of `rustfmt` in `dev check` and `CARGO_TOML` in `dev new`.
rust-version = "1.88"
```

rust-version = "1.88" is the compiler floor, and the root listing has no toolchain file that would pin it for you, so an older stable compiler surfaces as build errors rather than as a clear message. For a first run, that floor is the thing to check, and Cargo.toml is where you find it. The trailing comment deserves a second reading. An edition bump is not a single edit: the rustfmt edition used by dev check and the CARGO_TOML template written by dev new both have to change in the same commit. Move the package edition alone and the scaffolding those two helpers produce stops matching what the formatter expects, and nobody finds out until both tools run.

## Exercises and solutions are packed into the same crate

Anyone can read the answers before writing the exercises, because the published package carries both halves. The include list is short and it names them side by side.

```toml
include = [
  "/src/",
  "/exercises/",
  "/solutions/",
  # A symlink to be able to include `dev/Cargo.toml` although `dev` is excluded.
  "/dev-Cargo.toml",
  "/README.md",
  "/LICENSE",
]
```

Packing solutions/ next to exercises/ has one clear consequence. Self-discipline is the only gate between a learner and a finished file, so rustlings cannot serve as a closed exercise set, and a course that assigns it has no way to stop a student opening solutions/ on the first afternoon. Nothing in the crate records whether an exercise was attempted first. The tool has no way to tell you that, and it has no way to stop you.

## dev and tests/test_exercises sit outside the workspace

The root manifest begins by removing two directories from the workspace.

```toml
[workspace]
exclude = [
  "tests/test_exercises",
  "dev",
]
```

That exclusion is why include needs the extra dev-Cargo.toml entry, described in the manifest as a symlink for including dev/Cargo.toml although dev is excluded. Without it, the include list could not name the dev manifest at all. For a reader, the effect is that the tools the project uses on itself are not reachable from a root build. Exercise crates under tests/test_exercises and the helper crate in dev/ have to be entered directly, and the root listing names neither. Using the project's own tooling means changing into dev/ and reading its manifest first. Root level clippy.toml, .rumdl.toml and .typos.toml are versioned alongside, so configuration for the project's own checks exists in the tree, though nothing says which command consumes it.

## crossterm, rustix and a read bounded by a deadline

The dependency list describes the program from the outside. A keyboard driven terminal comes from crossterm, declared with default features switched off and only two features kept, and wait-timeout closes out the same list.

```toml
[dependencies]
anyhow = "1"
clap = { version = "4", features = ["derive"] }
crossterm = { version = "0.29", default-features = false, features = ["windows", "events"] }
notify = "8"
rustlings-macros = { path = "rustlings-macros", version = "=6.5.0" }
serde_json = "1"
serde.workspace = true
shlex = "2"
toml.workspace = true
wait-timeout = "0.2"
```

Platform handling splits in the target section, where anything that is not Windows reaches for rustix and its terminal features.

```toml
[target.'cfg(not(windows))'.dependencies]
rustix = { version = "1.0", default-features = false, features = ["std", "stdio", "termios"] }
```

Put together, notify and crossterm say the program watches paths and reads keys, and wait-timeout says a read is bounded by a deadline. The README does not say what happens when standard input is not a terminal, and the root listing holds no document that does. Piped input, a CI job and a detached shell are undocumented territory rather than a known bad state, which is the practical cost of a tool built around an interactive tty.

## panic = abort turns one failure into the end of the run

Both build profiles set the same option.

```toml
[profile.release]
panic = "abort"

[profile.dev]
panic = "abort"
```

Aborting in the development profile is the part that costs a learner something. Unwinding exists in a development profile so that a failing test or a catch_unwind survives one failure; here a panic ends the process, so a mistake in one file takes the run with it rather than a single exercise. That lands hardest on exactly the user this project has, someone holding a compiler error. The single dev-dependency, tempfile = "3", points the other way, at tests that create scratch directories and remove them afterwards, work a panicking process never finishes. shlex = "2" and notify = "8" in the main list point at a tool that parses command words and watches files, and none of that is explained anywhere in the 41 words the project publishes about itself.

## The tree moved on 2026-09-29, the last release is v6.5.0

Nothing here is archived, and the last push landed on 2026-09-29, so the source tree is current. The tags move slower. v6.3.0 shipped on 2024-08-29, v6.4.0 on 2024-11-11, and v6.5.0 on 2025-08-21, which puts the last two releases nine months apart and the newest one more than a year behind the last push. Cargo.toml still reads version = "6.5.0", so about thirteen months of commits sit past the newest tag. Two consequences follow for anyone choosing between the git clone and the released crate. Depending on the release means running code from August 2025 and missing every commit since. And rustlings-macros is pinned with an exact requirement, so the macros in rustlings-macros/ cannot drift ahead of the binary that calls them; a version gap between the two becomes a resolution failure instead of a quiet upgrade. CHANGELOG.md is the place to check which side of that line you are on.

## The book is the parallel text, not the replacement

Rustlings names a companion rather than a competitor. The project describes itself as small exercises to get you used to reading and writing Rust code, and the README adds one clause: recommended in parallel to reading the official Rust book. The two do different jobs. A book chapter sets out a concept in prose and stops where the reader is ready to continue. An exercise file hands over a failing build and no explanation, so retrieval replaces recognition. The tree is arranged for that split, with code in exercises/ and solutions/ and pages in website/, and no chapters of prose at the repository root. Learn Rust by reading and rustlings is the drill that comes after. Want a concept explained instead, and the book is where the explanation lives, which this project will not supply.

## Conclusion

Someone working through the official Rust book who wants files to edit rather than pages to read gets the most out of Rustlings, and the MIT licence removes any cost of trying it. It is the wrong tool for anyone who needs the exercises kept closed, because solutions/ travels inside the same package as exercises/, and it is the wrong choice on a compiler older than 1.88. Check that toolchain floor first, then read the newest entry in CHANGELOG.md to see how far the last release sits behind the 2026-09-29 push.

## FAQ

### What is Rustlings?

A set of small Rust exercises, packaged as an MIT licensed crate at version 6.5.0 and described as recommended in parallel to reading the official Rust book. Its homepage is rustlings.rust-lang.org.

### How do I install Rustlings?

The README gives no install command and points to rustlings.rust-lang.org for setup. The manifest supplies the constraints instead: version 6.5.0, edition 2024 and rust-version 1.88.

### Is Rustlings a replacement for the Rust book?

The README frames Rustlings as recommended in parallel to reading the official Rust book, not instead of it. The repository holds exercise code, not prose chapters.

## Sources

- [Official documentation](https://rustlings.rust-lang.org)
- [Official README](https://github.com/rust-lang/rustlings#readme)
- [Project repository](https://github.com/rust-lang/rustlings)
- [Release notes](https://github.com/rust-lang/rustlings/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rust-lang-rustlings