Live Reloading in Rust with Cargo Watch

in rust •  2 years ago 

Cover Image

Helo everyone 👋🏻
When we are developing a Rust application, sometimes we have the need to reduce the time of the cycle of changes, compilation, and execution. It sounds a bit complicated, but today I am going to show you a tool that does it in a very simple and automatic way. This tool is called cargo watch, and it reduces the time of each cycle of changes in the background.

Cargo Watch

Cargo Watch creates a listener on your project changes and runs Cargo commands when they occur. At the time of writing this article the latest version is 8.1.2.
Cargo Watch doc
Github Project

Disclaimer

For this tutorial I am assuming you are familiar with using Cargo.

Cargo is Rust’s build system and package manager. Most Rustaceans use this tool to manage their Rust projects because Cargo handles a lot of tasks for you, such as building your code, downloading the libraries your code depends on, and building those libraries

You can read more about cargo here

Change Cycle

Change Cycle

We start by creating a new project. For our example we will call it cargo-watch-example

cargo new cargo-watch-example

If the project was created correctly you should see the following message in the terminal
Created binary (application)cargo-watch-examplepackage

Install Cargo Watch

cargo install cargo-watch

Run project and observe changes

Inside the root directory:

cargo watch -x run

If you want to only listen for changes from only the working directory add the -w option to specify a file or directory from which you want to listen for changes.

cargo watch -w src -x run

Demo

Cargo Watch Demo

The previous example was the simplest configuration observing changes on the whole project or on a specific directory, but you can do much more, Here's a copy of the help:

USAGE:
    cargo watch [FLAGS] [OPTIONS]

FLAGS:
    -c, --clear              Clear the screen before each run
    -h, --help               Display this message
        --ignore-nothing     Ignore nothing, not even target/ and .git/
        --debug              Show debug output
        --why                Show paths that changed
    -q, --quiet              Suppress output from cargo-watch itself
        --no-gitignore       Don’t use .gitignore files
        --no-ignore          Don’t use .ignore files
        --no-restart         Don’t restart command while it’s still running
        --poll               Force use of polling for file changes
        --postpone           Postpone first run until a file changes
    -V, --version            Display version information
        --watch-when-idle    Ignore events emitted while the commands run.
                             Will become default behaviour in 8.0.

OPTIONS:
    -x, --exec <cmd>...
            Cargo command(s) to execute on changes [default: check]

    -s, --shell <cmd>...           Shell command(s) to execute on changes

    -d, --delay <delay>
            File updates debounce delay in seconds [default: 0.5]

        --features <features>
            List of features passed to cargo invocations

    -i, --ignore <pattern>...      Ignore a glob/gitignore-style pattern

    -B <rust-backtrace>
            Inject RUST_BACKTRACE=VALUE (generally you want to set it to 1)
            into the environment

        --use-shell <use-shell>
            Use a different shell. E.g. --use-shell=bash. On Windows, try
            --use-shell=powershell, which will become the default in 8.0.

    -w, --watch <watch>...
            Watch specific file(s) or folder(s) [default: .]

    -C, --workdir <workdir>
            Change working directory before running command [default: crate root]

ARGS:
    <cmd:trail>...    Full command to run. -x and -s will be ignored!

Cargo commands (-x) are always executed before shell commands (-s). You can use
the `-- command` style instead, note you'll need to use full commands, it won't
prefix `cargo` for you.

By default, your entire project is watched, except for the target/ and .git/
folders, and your .ignore and .gitignore files are used to filter paths.

On Windows, patterns given to -i have forward slashes (/) automatically
converted to backward ones (\) to ease command portability.

In the next tutorial we will apply this example using Docker Containers 😎

If you like my content and want to support my work, you can give me a cup of coffee ☕️ 🥰


Buy me a coffee

Authors get paid when people like you upvote their post.
If you enjoyed what you read here, create your account today and start earning FREE STEEM!