I have just finished making decimal library in Rust, fastnum.

It provides signed and unsigned exact precision decimal numbers suitable for financial calculations that require significant integral and fractional digits with no round-off errors (such as 0.1 + 0.2 ≠ 0.3).

Additionally, the crate can be used in no_std environments.

Why fastnum?

• Strictly exact precision: no round-off errors.
• Special values: fastnum support ±0, ±Infinity and NaN special values with IEEE 754 semantic.
• Blazing fast: fastnum numerics are as fast as native types, well almost :).
• Trivially copyable types: all fastnum numerics are trivially copyable and can be stored on the stack, as they're fixed size.
• No dynamic allocation: no heap allocations are made when creating or performing operations on an integer, no expensive sys-call's, no indirect addressing, cache-friendly.
• Compile-time integer and decimal parsing: all the from_* methods are const, which allows parsing numerics from string slices and floats at compile time. Additionally, the string to be parsed does not have to be a literal: it could, for example, be obtained via include_str!, or env!.
• Const-evaluated in compile time macro-helpers: any type has its own macro helper which can be used for definitions of constants or variables whose value is known in advance. This allows you to perform all the necessary checks at the compile time.
• no-std compatible: fastnum can be used in no_std environments.
• const evaluation: nearly all methods defined on fastnum decimals are const, which allows complex compile-time calculations and checks.

Other functionality (such as serialization and deserialization via the serde, diesel and sqlx ORM's support) can be enabled via crate features.

Feedback on this here or on GitHub is welcome! Thanks!