SoftFloatPy is a Python binding of Berkeley SoftFloat.

Berkeley SoftFloat is a software implementation of binary floating-point functionalities that conforms to the IEEE Standard for Floating-Point Arithmetic (IEEE 754 and the succeeding standards).

As of December 2025, the latest release is Berkeley SoftFloat 3e, and SoftFloatPy supports the following features in it.

• four binary floating-point formats:
  • 16-bit half-precision format (the binary16 format),
  • 32-bit single-precision format (the binary32 format),
  • 64-bit double-precision format (the binary64 format),
  • 128-bit quadruple-precision format (the binary128 format).
• addition, subtraction, multiplication, division, remainder, fused multiply-add, and square root.
• round to an integer value.
• comparisons.
• conversions between the supported floating-point formats.
• conversions between the 32-bit single-precision format and the 16-bit brain floating-point format (bfloat16).

The following features that are not in the IEEE 754 standard are excluded from SoftFloatPy support.

• 80-bit extended format (known as x86 extended-precision format).
• odd-rounding mode (known as jamming).

SoftFloatPy requires Python 3.11 or later. The build configuration provided in the SoftFloatPy repository assumes platforms with 64-bit integer arithmetic support.

The GitHub page is https://github.com/arithy/softfloatpy.

Links related to Berkeley SoftFloat:

• https://www.jhauser.us/arithmetic/SoftFloat.html
• https://github.com/ucb-bar/berkeley-softfloat-3

You can install the release version by the following command.

$ python -m pip install softfloatpy

You can install the development version by the following commands.

$ git clone --recursive https://github.com/arithy/softfloatpy.git  # NOTICE: `--recursive` option is required
$ cd softfloatpy  # the repository root directory
$ make req
$ make clean
$ make dist
$ python -m pip install --no-index --find-links=./dist softfloatpy

To use SoftFloatPy in a Python script, import softfloatpy module. An example is shown below.

import softfloatpy as sf

To use the SoftFloatPy functions, you need to create objects of the classes shown below.

• Floating-Point Classes:
  • Float16
  • Float32
  • Float64
  • Float128
  • BFloat16
• Fixed-Bit Integer Classes:
  • UInt32
  • UInt64
  • Int32
  • Int64

For the floating-point classes, there are two options to create its object.

• Creation from bytes. Below is an example of Float16 with the value 1.0.

  f = sf.Float16.from_bytes(b'\x3c\x00')  # The byte order is big-endian.

• Creation from float. Below is an example of Float16 with the value 1.0.

  f = sf.Float16.from_float(1.0)

For the fixed-bit integer classes, there are two options to create its object.

• Creation from bytes. Below is an example of Int32 with the value 1.

  i = sf.Int32.from_bytes(b'\x00\x00\x00\x01')  # The byte order is big-endian.

• Creation from int. Below is an example of Int32 with the value 1.

  i = sf.Int32.from_int(1)

Once creating the objects, you can use the functions described in the SoftFloat documentation.

a = sf.Float16.from_float(2.0)
b = sf.Float16.from_float(-3.0)
c = sf.f16_mul(a, b)

In addition, you can use Python operators for arithmetic operations such as +, -, *, //, and %. For more details, see the SoftFloatPy API documentation.

a = sf.Float16.from_float(2.0)
b = sf.Float16.from_float(-3.0)
c = a * b

You can retrieve the value retained in an object as a Python built-in type.

For the floating-point classes, there are two built-in types to retrieve the value.

• Retrieve the value as bytes. Below is an example of Float16.

  print(f.to_bytes())
  # -> b'\x3c\x00'  (The byte order is big-endian.)

• Retrieve the value as float. Below is an example of Float16.

  print(f.to_float())
  # -> 1.0

For the fixed-bit integer classes, there are two built-in types to retrieve the value.

• Retrieve the value as bytes. Below is an example of Int32.

  print(i.to_bytes())
  # -> b'\x00\x00\x00\x01'  (The byte order is big-endian.)

• Retrieve the value as int. Below is an example of Int32.

  print(i.to_int())
  # -> 1

The other option is to create a string representation of the object value using str() or formatted strings.

print(f'value: {f}')
# -> value: 1.0

You can set and get the default rounding mode using the functions below.

• set_rounding_mode()
• get_rounding_mode()

The rounding mode is a thread-local property.

You can set, get, and test the floating point exceptions using the functions below.

• set_exception_flags()
• get_exception_flags()
• test_exception_flags()

The floating-point exceptions are thread-local properties.