#bytes #size #units #formatting #prettysize

no-std size

A crate for expressing, formatting, and interacting with file sizes

9 unstable releases (3 breaking)

0.4.1 Oct 13, 2022
0.4.0 Jun 23, 2022
0.3.1 Jun 22, 2022
0.2.1 Jun 21, 2022
0.1.1 Aug 16, 2018

#69 in Rust patterns

Download history 2595/week @ 2022-11-28 2316/week @ 2022-12-05 2166/week @ 2022-12-12 1679/week @ 2022-12-19 1743/week @ 2022-12-26 1332/week @ 2023-01-02 1966/week @ 2023-01-09 1817/week @ 2023-01-16 2929/week @ 2023-01-23 3404/week @ 2023-01-30 3316/week @ 2023-02-06 3078/week @ 2023-02-13 3433/week @ 2023-02-20 2513/week @ 2023-02-27 3496/week @ 2023-03-06 4127/week @ 2023-03-13

13,771 downloads per month
Used in 20 crates (14 directly)

MIT license


PrettySize, rust edition

crates.io docs.rs

A comprehensive file size crate for rust applications, meant to be light and effective. Includes utilities for human-readable formatting of file sizes as well as converting between different base-two and base-ten size units and performing both mathematical and logical operations on strongly-typed file sizes.

See the crate documentation for a more complete summary of what this crate can do and how to use it.


PrettySize provides

  • a Size type that can be used to hold a strongly-typed size (e.g. let size = Size::from_gigabytes(4)) and perform operations on it,
  • definitions for the base-two and base-ten file size units defined as pub const in the size::consts namespace, available both in abbreviated and unabridged forms (i.e. consts::KiB and consts::KIBIBYTE or consts::GB and consts::GIGABYTE),
  • an std::Display impl for Size to automatically display sizes in a human-readable format, automatically choosing the best size unit and numeric precision to give the nicest results (you can also use Size::to_string() instead).
  • a Size.format() method that gives you more control over how sizes are converted to a textual representation, letting you to specify the base of the human-readable units and their style (smart, abbreviated, or full; plus their lowercase variants).
  • mathematical and logical operations on strongly-typed Size values,
  • full support for expressing negative sizes (e.g. the difference between two sizes, or the amount of space reclaimed on a disk)

This crate can also be used in no_std mode (by compiling with default features disabled). This disables string conversion/formatting but keeps all the strongly-typed size conversion and mathematical/logical operations available.

This crate is free of any dependencies.



size = "0.4"

and in your code:

use size::consts;
use size::{Base, Size};

fn main() {
  // Create strongly-typed sizes:
  let byte_count = Size::from_kilobytes(42);
  assert_eq!(42_000, byte_count.bytes());

  // Use predefined constants for the various units
  let byte_count = 42 * consts::KiB;
  assert_eq!(43_008, byte_count);

  // `Size` can take any numeric type you throw at it
  let byte_count = Size::from_mib(0.040055);
  assert_eq!(byte_count.bytes(), 42_000);

  // And for those of you that haven't yet drunk the base-two Kool-Aid:
  let file_size = Size::from_kb(42);
  assert_eq!(file_size.bytes(), 42_000);

  println!("{}, I say!", file_size);
  // prints "41 KiB, I say!"

  // Override the default choice of base-2 units
  println!("{}, I meant!", file_size.format().with_base(Base::Base10));
  // prints "42 KB, I meant!"

  // Add and subtract strongly-typed sizes, even with different underlying types
  let sum = Size::from_mb(1.0) + Size::from_kb(200);
  assert_eq!(sum.bytes(), 1_200_000);

  // Multiply and divide strongly-typed sizes by scalar values
  let new_size = Size::from_mib(2) * 2;
  assert_eq!(new_size, Size::from_mib(4));

  // Compare sizes for equality or order
  let size1 = Size::from_gigabytes(2);
  let size2 = Size::from_gibibytes(1.99);
  assert!(size1 < size2);


This project started off as a port of Mahmoud's PrettySize.NET library from C# to Rust. Like the C# edition of this project. Rust's richer enum types and powerful generics made implementing a custom Size generic over the number type without verbosity additionally possible. Its scope has since grown considerably.


PrettySize is written and maintained by Mahmoud Al-Qudsi of NeoSmart Technologies and released to the general public under the terms of the MIT public license.


  • Providing a FromStr impl to parse file sizes (coming soon!)

Pull requests are welcome!

No runtime deps


  • std