Herbie aims to make floating point problems easier to find and fix.

The Herbie project provides Herbie and HerbGrind, complementary tools for finding and fixing floating point problems:

- Herbie
- rewrites floating point expressions to make them more accurate. Herbie supports all commonly-used floating point functions, and uses a cutting-edge search to identify more-accurate rearrangements of a floating point computation.
- HerbGrind
- analyzes binaries to catch floating point inaccuracies as they occur and extract them for analysis. HerbGrind analyzes binaries directly, detecting problems on realistic workloads and extracting them in a standard format.

The Herbie tools have been used on large numerical computations, mathematical libraries, graphics programs, and embedded systems. It regularly finds subtle floating point issues and produces fixes.

- In preparation for the Version 1.0 release, we've renamed the
`pi`

and`e`

constants to upper case. This matches`libm`

and should make it a little harder to cause bugs. Herbie will now optimize expressions like`(exp 1)`

to`E`

. - We're proud to announce that we've been collaborating with Prof. Martel and his students to build a common benchmark suite and format for floating point tools. Version 1.0 of Herbie will support only the FPBench format.
- Pavel is giving a talk at Google on how Herbie works and what our plans for the future are.
- Pavel is giving a talk at MIT on how Herbie works internally.
- In preparation for the Version 1.0 release, we've renamed several functions in Herbie to match the
`libm`

names. In particular, look out for`abs`

, which is now`fabs`

, and`expt`

, which is now`pow`

. - Pavel is giving a talk at MathWorks on how Herbie works answered questions on how it could be extended.
- The Herbie Rust Linter plugs into the Rust compiler to add warnings for numerically unstable expressions, and suggests Herbie's more accurate output as a hint.
- The Herbie GHC Plugin by Mike Izbicki automatically runs Herbie on applicable expressions in a Haskell program. He's also scanned all of Stackage LTS-3.5 for numerical inaccuracies with Herbie.
- Pavel is giving a Distinguished Paper talk at PLDI’15 on the scientific advances that underpin Herbie.
- Zach is giving a talk at Berkeley on how we plan to improve floating point accuracy with Herbie.
- Pavel is giving a talk at OPLSS on whether floating point accuracy can be improved, and our plans for finding out.
- Pavel is giving a lightning talk on a new project to improve the accuracy of floating point expressions.
- Pavel is giving a talk on at Dropbox on a new project to improve the accuracy of floating point expressions. (video)

- Installing Herbie: installing Racket and Herbie.
- Installing HerbGrind: installing HerbGrind.
- Installing with Docker: an alternate installation method for Docker users.
- Tutorial: how to prepare inputs to Herbie and run the tool.
- Using Herbie: a guide to running Herbie.
- Input format: how to write expressions for Herbie to improve.
- Command-line flags: modifying Herbie's behavior.
- Using HerbGrind: a guide to running HerbGrind.

- Let Herbie Make Your Floating Point Better: why programmers who deal with floating point should use Herbie.
- Improving Accuracy: a Look at Sums: why floating point summation is hard, and how compensated summation works.
- Measuring the Error of Floating Point Programs: how Herbie measures the error of a floating point program, and how we're working to extend that to programs with loops.
- Logarithms of Taylor Expansions: how Herbie takes Taylor expansions of logarithms.
- Hyperbolic sines in math.js: how Herbie fixed an accuracy bug in math.js using series expansion.
- Taylor Expansions of Taylor Expansions: how Herbie takes Taylor expansions of exponential and trigonometric functions.
- Arbitrary Precision, not Arbitrary Accuracy: why arbitrary-precision libraries aren’t an answer to rounding error.
- Complex Square Roots in math.js: how Herbie automatically fixed an accuracy bug in math.js, an open source mathematics library.
- Floating Point Guarantees: how floating point rounding and primitive operators work.

Herbie is chiefly developed by the University of Washington Programming Languages and Software Engineering group, with contributions from a supportive community. The main contributors are: