sysinfo is a crate used to get a system's information.
It currently supports the following OSes (alphabetically sorted):
- Raspberry Pi
You can still use
sysinfo on non-supported OSes, it'll simply do nothing and always return
empty values. You can check in your program directly if an OS is supported by checking the
The minimum-supported version of
rustc is 1.59.
⚠️ Before any attempt to read the different structs' information, you need to update them to get up-to-date information because for most of them, it works on diff between the current value and the old one.
Which is why, it's much better to keep the same instance of [
System] around instead of
recreating it multiple times.
You have an example into the
examples folder. You can run it with
cargo run --example simple.
Otherwise, here is a little code sample:
use ; // Please note that we use "new_all" to ensure that all list of // components, network interfaces, disks and users are already // filled! let mut sys = new_all; // First we update all information of our `System` struct. sys.refresh_all; // We display all disks' information: println!; for disk in sys.disks // Network interfaces name, data received and data transmitted: println!; for in sys.networks // Components temperature: println!; for component in sys.components println!; // RAM and swap information: println!; println!; println!; println!; // Display system information: println!; println!; println!; println!; // Number of CPUs: println!; // Display processes ID, name na disk usage: for in sys.processes
Please remember that to have some up-to-date information, you need to call the equivalent
refresh method. For example, for the CPU usage:
use ; let mut sys = new; loop
sysinfo uses multiple threads. However, this can increase the memory usage on some
platforms (macOS for example). The behavior can be disabled by setting
default-features = false
Cargo.toml (which disables the
multithread cargo feature).
Good practice / Performance tips
Most of the time, you don't want all information provided by
sysinfo but just a subset of it.
In this case, it's recommended to use
refresh_specifics(...) methods with only what you need
to have much better performance.
Another issues frequently encountered: unless you know what you're doing, it's almost all the
time better to instantiate the
System struct once and use this one instance through your
program. The reason is because a lot of information needs a previous measure to be computed
(the CPU usage for example). Another example why it's much better: in case you want to list
all running processes,
sysinfo needs to allocate all memory for the
Process struct list,
which takes quite some time on the first run.
If your program needs to use a lot of file descriptors, you'd better use:
sysinfo keeps a number of file descriptors open to have better performance on some
targets when refreshing processes.
Running on Raspberry Pi
It'll be difficult to build on Raspberry Pi. A good way-around is to cross-build, then send the executable to your Raspberry Pi.
First install the arm toolchain, for example on Ubuntu:
Then configure cargo to use the corresponding toolchain:
Finally, cross compile:
Linux on Docker & Windows Subsystem for Linux (WSL)
Virtual Linux systems, such as those run through Docker and Windows Subsystem for Linux (WSL), do
not receive host hardware information via
/sys/class/thermal. As such,
querying for components may return no results (or unexpected results) when using this library on
Use in binaries running inside the macOS or iOS Sandbox/stores
Apple has restrictions as to which APIs can be linked into binaries that are distributed through the app store.
sysinfo is not compatible with these restrictions. You can use the
feature flag to disable the Apple prohibited features. This also enables the
In the case of applications using the sandbox outside of the app store, the
can be used alone to avoid causing policy violations at runtime.
How it works
I wrote a blog post you can find here which explains how
sysinfo extracts information
on the different systems.
It's possible to use this crate directly from C. Take a look at the
Makefile and at the
To build the C example, just run:
> make > ./simple # If needed: > LD_LIBRARY_PATH=target/release/
You can run the benchmarks locally with rust nightly by doing:
If you appreciate my work and want to support me, you can do it with github sponsors or with patreon.