IEEE 754 defines 128-bit floating point, though perhaps in a three-way chicken and egg problem, it's rarely supported by hardware, rarely supported by compilers, and rarely used.

Have there been, historically, any

  • Computers that supported 128-bit floating point

  • Compilers that supported it

  • Workloads that used it?

I'm interested in both references and anecdotes from personal experience, and particularly specific information, not just that a certain computer supported 128-bit FP, but how it was implemented, what it was used for or both.


I never used it, so I can't give any anecdotes. But the 'implementation' section of the wikipedia about this topic cites some hardware and compilers. I quote some parts of the article:

Hardware: "Native support of 128-bit floats is defined in SPARC V8 and V9 architectures, but no SPARC CPU implements quad-precision operations in hardware as of 2004. POWER9 (ISA 3.0) will have 128-bit hardware support."

Compilers: "Quadruple precision is specified in Fortran by the real(real128), or as real(selected_real_kind(33, 4931)), or in a non-standard way as REAL*16. (Quadruple-precision REAL*16 is supported by the Intel Fortran Compiler and by the GNU Fortran compiler on x86, x86-64, and Itanium architectures, for example.) (...) in C/C++ with a few systems and compilers, quadruple precision may be specified by the long double type, but this is not required by the language (which only requires long double to be at least as precise as double), nor is it common (...) some C/C++ compilers provide a nonstandard quadruple-precision type as an extension. For example, gcc provides a quadruple-precision type called __float128 for x86, x86-64 and Itanium CPUs, and on PowerPC as IEEE 128-bit floating-point using the -mfloat128-hardware or -mfloat128 options; and some versions of Intel's C/C++ compiler for x86 and x86-64 supply a nonstandard quadruple-precision type called _Quad"

Libraries and toolboxes: "The Boost multiprecision library Boost.Multiprecision provides unified cross-platform C++ interface for __float128 and _Quad types, and includes a custom implementation of the standard math library. The Multiprecision Computing Toolbox for MATLAB allows quadruple-precision computations in MATLAB. It includes basic arithmetic functionality as well as numerical methods, dense and sparse linear algebra. The DoubleDouble package provides support for double-double computations for the Julia programming language."

  • 3
    Although I hardly believe this is really a "retro" question: A partial implementation of quadruple precision floats has been implemented in AIX compilers for quite a long time. Also, most Common Lisp implementations seem to have support for 128-bit floats. – tofro May 5 '17 at 11:47
  • 3
    On SPARCs, there are quad-precision instructions which trigger traps so that the OS can emulate them (as no existing SPARC supports them natively). FP registers used for simple and double are reused for quad, an hardware implementation would be entirely compatible with existing OSes and software.This "trap-and-emulate" method is slower than using a 128bits software library though, so existing software really needing that precision is unlikely to use these instructions. – TEMLIB May 5 '17 at 20:21
  • 1
    Is this specifically about IEEE 754? Some VAXen had 128-bit float ("H-float") support. – another-dave Dec 4 '18 at 23:02
  • double-double is not the same as float128: not only does it have 2×53=106-bit significand instead of 113-bit found in float128, but it also has 11 bits of exponent instead of 15, limiting to ~10^308 maximum order of magnitude instead of ~10^4932. – Ruslan Apr 27 at 6:52

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.