High performance 128-bit fixed-point decimal numbers in go.

• High performance
• Zero dependencies
• Minimal or zero memory allocation
• Scale up to 19 decimal places
• Fixed size memory layout (128 bits)
• No panic or error arithmetics (use NaN instead)
• Immutability (methods return new instances)
• Basic arithmetic operations required for financial calculations (specifically for banking and accounting)
• Additional arithmetic operations for scientific calculations
• Easy to use
• Easy to integrate with external systems (e.g. databases, accounting systems, JSON, etc.)
• Financially correct rounding
• Correct comparison of numbers encoded in different scales (e.g. 1.0 == 1.00)
• Correct handling of NaN values (e.g. NaN + 1 = NaN)
• Conversion to canonical representation (e.g. 1.0000 -> 1)
• Conversion to fixed string representation (e.g. 1.0000 -> "1.0000")
• Conversion to human-readable string representation (e.g. 1.0000 -> "1")

Run go get github.com/jokruger/dec128

This library requires Go version >=1.23

http://godoc.org/github.com/jokruger/dec128

package main

import (
    "fmt"
    "github.com/jokruger/dec128"
)

func main() {
    principal := dec128.FromString("1000.00")
    annualRate := dec128.FromString("5.0")
    days := 30

    dailyRate := annualRate.Div(dec128.FromInt64(365))
    dailyRate = dailyRate.Div(dec128.FromInt64(100))

    accruedInterest := principal.Mul(dailyRate).Mul(dec128.FromInt64(days)).RoundBank(2)

    fmt.Printf("Principal: %v\n", principal.StringFixed())
    fmt.Printf("Annual Interest Rate: %v\n", annualRate.String())
    fmt.Printf("Days: %v\n", days)
    fmt.Printf("Accrued Interest: %v\n", accruedInterest.String())

    total := principal.Add(accruedInterest).RoundBank(2)
    fmt.Printf("Total after %v days: %v\n", days, total.StringFixed())
}

There are several other libraries that provide decimal arithmetic in Go. However, most of them are either too slow, too memory-intensive, or lack the integration features required for financial applications. This library aims to provide a high-performance, low-memory, and easy-to-use alternative to existing libraries.

The following benchmarks were run on a MacBook Pro (2019) with a 2.6 GHz 6-Core Intel Core i7 processor and 16 GB of RAM (https://github.com/jokruger/go-decimal-benchmark).

                                 parse (ns/op)  string (ns/op)     add (ns/op)     mul (ns/op)     div (ns/op)

dec128.Dec128                           14.024          33.683           9.975           6.569          35.116
udecimal.Decimal                        23.302          41.854          12.226          11.346          40.877
alpacadecimal.Decimal                   89.528          78.884         206.393          60.364         451.828
shopspring.Decimal                     152.263         169.300         218.909          65.241         428.002

• Scale: Number of digits after the decimal point. For example, 1.00 has scale of 2 and 1.0000 has scale of 4.
• Exponent: Same as scale, but in the context of low-level implementation details or Dec128 encoding.
• Canonical: The representation of a number with the minimum number of decimal places required to represent the number.
• Quantum*: The smallest step at a given scale. For example, scale 2 has quantum 0.01

This project is licensed under the MIT License. See the LICENSE file for details.

This project includes code derived from:

• A project licensed under the BSD 3-Clause License (Copyright © 2025 Quang).
• A project licensed under the MIT License (Copyright © 2019 Luke Champine).

See the LICENSE file for full license texts.