cargo install installs a rust binary to your user space.

cargo add adds the dep to your project by editing your Cargo.toml.

The file is named Cargo.toml. Whatever dependencies you add to there are automatically downloaded by Cargo. You can manage them with cargo add and cargo remove.

cargo install is not the same thing. That installs binaries. I last installed cargo-release to automate the annoying part of managing git tags and crate version number.

Cargo is heavily used.

Your tutorial is the odd one.

cargo add <dep> is a relatively new command. For a long time you had to edit the Cargo.toml file to add a new dependency. So a lot of tutorials still use that as a way of adding a dependency. And other guides often copy from the older ones. They also can describe it this way as a way to introduce the Cargo.toml structure since it is not hard to hand edit. cargo add is just a convenience after all and it is still worth understanding the Cargo.toml structure.

But yes, many people do use cargo add for simply adding deps rather than editing the toml file. Though it is not uncommon to edit it by hand either.

Almost everyone uses Cargo. I think the only people that don’t are Google and Facebook who will probably be using Bazel or Buck2. I think you’re a bit confused about what Cargo is.

Presumably you’re using an IDE or smart text editor to run your code. Otherwise you’d be running e.g. cargo build and cargo test from the command-line quite often.

The difference to Pip is that Cargo detects changes in the Cargo.toml and will automatically install all the necessary dependencies, when you run cargo build or cargo test (or other similar commands). And since your IDE / editor runs these for you, it looks to you like you’re just editing a text file.

It should also be said that Pip has a somewhat unusual workflow in that you pip install everything, which would normally install it globally into your operating system. And then with venv, you kind intercept that to install it into the .venv/ folder in your repo instead.
This workflow doesn’t make a ton of sense, if you always have a repo folder where the dependencies can be installed into, so Rust just doesn’t do it that way.
(In particular, installing dependencies globally quickly causes issues when different projects have different version requirements for the same library.)

There is a cargo install command, but it’s only for installing applications, not libraries.

• cargo install is for installing rust programs for your user, not for adding dependencies to your Rust project. Many cargo subcommands can be installed this way, for instance cargo bloat.
• The file you are talking about is called Cargo.toml, because it is the file you need to write in order to configure cargo for your Rust project. TOML is the name of the file format. For details, please see the introductory chapter to Cargo in the Rust book.
• Cargo recently got a new subcommand called cargo add, which allows to add dependencies directly on the command line. However, all it does is to add/edit/remove the respective lines in Cargo.toml. (Personal opinion: I have found it way easier to just edit the file directly than to learn yet another command…)

That said: You still need to edit the Cargo.toml file, even if you solely use cargo add to manage your dependencies. That’s because that file contains a lot more information about your project than just the dependencies. For instance the current version, the feature-flags, your name, a link to the public repo,…

Maybe I am wrong or my understanding is oversimplified. But the way I understand it is that when you add a dependency to your cargo.toml file, when you run the build rust is going to cargo and downloading those dependencies you added for you and stores the dependencies with project files.

Then when you rebuild it is checking cargo to see if there is a later version and will update according to how you specified the version in the cargo.toml file.

So you are using cargo. it’s basically just automated, so you don’t have to manually interact with cargo the same way you do with pip.

That TOML is cargo.toml. when you add dependencies to cargo.toml you are using cargo. There is a command called cargo add, which adds a dependency, and they way it adds this dependency is by putting it in cargo.toml. it’s cargo all the way down.

If you want to not use cargo, you would use rustc, which is rust’s compiler. Almost noone uses rustc directly, I would say more than 95% of rust devs use cargo.

Manually editing the toml file and using cargo add accomplish the same thing, they both add the dependency to the toml file. Cargo add just tries to grab the latest version of a dependency it can and install it. If you manually add the dependency you still need to run cargo to actually install the dependency.

Often package maintainers will tell you to add a thing to the Cargo.toml file so that they can specify the features for a particular use case

Cargo is Rust’s build tool. It manages your project, invokes rustc to compile your code, and does a whole bunch of other stuff. When you add a dependency to Cargo.toml, cargo will download and build it the next time you run cargo build.

You can use cargo add to add the dependency to Cargo.toml if you wish, but the result is the same as if you just edited the file yourself.

The nice thing about it is that you can see all the direct dependencies for your project by inspecting the Cargo.toml file, and you can edit that file to add or remove dependencies as needed. (check out the cargo-tree command if you want to see all of your dependencies)

To answer your question, yes, most people use Cargo. 😁

There is a command now to add a dependency “cargo add”

But it does the same thing as adding it in Cargo.toml.

In contrary to python, cargo dependencies can have supplementary parameters in addition to the version number, such as features. That’s why we didn’t have “cargo add” at first.

But other than that, cargo is used for everything else: compiling, building doc, compile-time checks, formatting, code optimizations…