Malleum Knowledge Base

Reducing the size

3 min read

Reducing the size of a binary when developing with Rust can be challenging, especially when compared to languages traditionally used in malware development like C or C++, which can produce very small binaries. Rust’s rich standard library and safety features come with a trade-off in terms of binary size. However, there are several strategies you can employ to minimize the size of your Rust binaries:

1. Optimize Build Configuration

In your Cargo.toml, you can adjust the release profile to optimize for size:

[profile.release]
opt-level = 'z'  # Optimize for size
lto = true       # Enable Link Time Optimization
codegen-units = 1  # Reduce parallel code generation units
panic = 'abort'   # Abort on panic, no unwinding
strip = 'symbols' # Strip symbols from the binary
  • opt-level = 'z': Tells the compiler to optimize for size rather than speed.
  • lto = true: Enables Link Time Optimization, which can significantly reduce binary size by eliminating unused code and data at the link stage.
  • codegen-units = 1: This can increase compilation time but may reduce code size because it allows more aggressive optimizations across the entire crate.
  • panic = 'abort': Reduces binary size by not including code for unwinding the stack on panic.
  • strip = 'symbols': This removes symbols from the final binary, which is useful for reducing size when debugging information is not needed.

2. Minimize Dependencies

Every external crate you include in your project potentially adds to the binary size. Review your dependencies and remove any that are not absolutely necessary. For crates that are necessary, check if they can be configured to reduce their footprint (e.g., disabling default features that are not needed).

Example:

[dependencies]
serde = { version = "1.0", default-features = false }

3. Use s Instead of z for opt-level If Needed

While opt-level = 'z' is typically best for size, opt-level = 's' might produce better results in some scenarios. It optimizes for size but also considers performance, which might result in better inlining decisions.

4. Avoid or Minimize Use of Std Library

Using #![no_std] in your crate attribute can exclude the Rust standard library, relying only on the core library, which is much smaller. This is often used in embedded development but might be too restrictive for some applications.

Example:

#![no_std]

5. Compression Tools

You can use tools like upx to compress the executable. This can reduce the binary size dramatically, although it may increase the time it takes for your program to start as it needs to decompress in memory.

upx --best --lzma your_binary

6. Review Code for Size Efficiency

Sometimes the way you’ve structured your code or specific features of Rust can lead to larger binaries. For instance, using generics extensively can increase binary size because each instantiation of a generic function or type for different types results in additional code.

Conclusion

While Rust provides many benefits, its default setup is not geared towards minimal binary sizes, especially compared to languages like C. Applying the above tips should help reduce the size of your Rust binaries significantly. Each application is unique, so some trial and error with these settings may be necessary to find the best balance between size, performance, and functionality for your specific use case.

Graph View