Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
The Intel 8087 made floating-point arithmetic dramatically faster than software emulation on the 5 MHz 8086 systems Intel used for its 1980 comparison. Intel measured a single-precision multiply at approximately 19 microseconds on the 8087 versus 1,600 microseconds for optimized 8086 software, while square root took about 36 microseconds versus 19,600 microseconds. Those are instruction-level, historical measurements—not a universal application speed ratio.
Speed was only part of the difference. The 8087 was a coprocessor that worked alongside an 8086 or 8088, used eight 80-bit internal registers, and converted values when loading from or storing to memory. Software could reproduce the instruction set without the chip through Intel’s E8087 emulator, trading hardware availability for much longer execution times and making precision, rounding, and toolchain behavior part of any fair comparison.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Microprocessors: The 8086/8088, 80186/ 80286, 80386/80486 and the Pentium Family | $8.50 | Buy on Amazon |
As an Amazon Associate I earn from qualifying purchases.
What was the Intel 8087?
The 8087 was a numeric coprocessor for Intel’s 8086 and 8088 processors. It was not a replacement CPU and could not run a computer by itself. The host processor fetched the shared instruction stream and coordinated the system, while the 8087 recognized numeric instructions and performed the corresponding arithmetic or transcendental operation.
Intel’s design divided the coprocessor into a control unit and a numeric execution unit. That separation allowed the 8086/8088 and 8087 to work independently when the instruction stream and program dependencies permitted it. The result was more than a faster arithmetic routine: the host CPU could continue useful integer or control work while the coprocessor handled a numeric instruction.
#1 Best Overall
Internally, the 8087 provided an eight-entry register stack. Each register was 80 bits wide and used Intel’s temporary-real format for calculations. Memory operands could instead be integer, single-precision, double-precision, or packed-decimal values; loads converted those representations into the internal format, and stores converted them back.
This architecture explains why “hardware versus software” is not simply a question of running the same formula twice. The number of conversions, intermediate rounding points, exception handling, and the implementation of each operation can change both elapsed time and numerical results.
How much faster was the 8087 than software floating point?
Intel’s July 1980 8086 Family User’s Manual: Numerics Supplement compared the 8087 with highly optimized software equivalents running on a 5 MHz 8086. The figures below are approximate execution times for individual operations, not measurements of complete applications.
| Operation | 8087 hardware | Optimized 8086 emulation | What the comparison represents |
|---|---|---|---|
| Single-precision multiply | 19 µs | 1,600 µs | Intel’s approximate 5 MHz timing |
| Double-precision multiply | 27 µs | 2,100 µs | Intel’s approximate 5 MHz timing |
| Add | 17 µs | 1,600 µs | Intel’s approximate 5 MHz timing |
| Single-precision divide | 39 µs | 3,200 µs | Intel’s approximate 5 MHz timing |
| Compare | 9 µs | 1,300 µs | Intel’s approximate 5 MHz timing |
| Square root | 36 µs | 19,600 µs | Intel’s approximate 5 MHz timing |
| Tangent | 90 µs | 13,000 µs | Intel’s approximate 5 MHz timing |
| Exponentiation | 100 µs | 17,100 µs | Intel’s approximate 5 MHz timing |
The table shows why the coprocessor was valuable for engineering, scientific, graphics, and other workloads dominated by numeric instructions. The largest gaps occur in operations that require substantial algorithms in software, such as square root, tangent, and exponentiation. Even basic arithmetic and comparison were far quicker in the hardware measurements.
These numbers should not be turned into a claim that every application ran a fixed number of times faster. A real program also spends time fetching operands, storing results, branching, handling input and output, and performing integer work. The 8087 and host CPU could overlap activity in some circumstances, changing total throughput. Intel explicitly cautioned that actual performance depended on application-specific factors.
Why should the 5 MHz test conditions be stated?
Clock speed and processor pairing affect both sides of a historical comparison. Intel’s table describes a 5 MHz 8086 with optimized emulation code and an 8087 attached to the same class of system. A separate Intel datasheet gives a different timing table for an 8 MHz 8086/8087 configuration. Values from those tables should not be mixed, because they describe different test conditions.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The word “optimized” also matters. Intel identified the software figures as highly optimized assembly-language procedures from its 8087 emulator. They are therefore a strong historical comparison with the hardware, not a measurement of a slow, naïve floating-point routine written by an inexperienced programmer.
How did software floating-point emulation work?
Intel’s E8087 package implemented the floating-point instruction behavior in software on an 8086 or 8088. It served two practical purposes: a program could run on a machine without an installed coprocessor, and developers could write and test numeric code before 8087 prototype hardware was available.
The package included an assembler and emulator support. Historical descriptions of the toolchain explain that translators produced code suitable for emulation, while link-time libraries could select either real 8087 execution or software support. That arrangement let a source program follow a shared development path while the target machine determined whether calculations used hardware or software.
Emulation did not make the 8087 unnecessary for performance-sensitive work. The timings above show the cost of executing the same class of operations through 8086 instructions. Its value was compatibility and availability: a program could remain functional when the optional coprocessor was absent, and a development team could continue without waiting for hardware.
This historical mechanism should not be confused with how modern compilers implement floating point. Later x86 processors, instruction sets, operating systems, runtimes, and compiler options changed the execution model. E8087 describes one 1980s compatibility strategy, not a template for every software floating-point implementation.
Did the 8087 and software produce the same numerical results?
They could produce matching results when the emulator followed the 8087’s defined behavior, but a software implementation that rounded at different points could produce different intermediate or final values. The 8087 performed calculations in its 80-bit temporary-real registers, even when the original data in memory was single or double precision.
For example, a sequence that keeps a value in an 8087 register can retain more bits than a sequence that stores the value to single- or double-precision memory after every operation. The store converts the 80-bit temporary value to the destination format, potentially rounding it. A software routine that performs that conversion earlier—or keeps an equivalent extended value longer—can follow a different numerical path.
Rounding mode, conversion points, exception behavior, and compiler or runtime choices therefore belong in a serious comparison. Intel presented the 8087 as intended to provide stable, accurate results for straightforward algorithms and documented its supported operations and control behavior. That is a statement about the 8087 design; it is not proof that every possible software library makes the same choices.
Free tools Windows power users keep installed
One-click scans. No signup required.
The 8087 was designed around the proposed IEEE binary floating-point standard of its period. A historical overview from SIAM notes that the extended format recommended by the standard was based on the 8087 design. The broader history of IEEE 754 standardization is more complicated than a simple claim that the final standard and every 8087 detail were identical, so compatibility should be discussed in terms of particular formats, rounding rules, and operations.
What operations did the 8087 accelerate?
The coprocessor handled ordinary arithmetic, comparisons, and built-in transcendental operations. Intel’s sample list includes addition, multiplication, division, comparison, square root, tangent, and exponentiation. This coverage mattered because software implementations of transcendental functions require long sequences of integer instructions and carefully designed approximation algorithms.
Its feature set also included conversions among integer, floating-point, and packed-decimal memory representations. Those conversions were part of the numeric programming model, not merely an afterthought, because applications often read integer measurements, calculate in floating point, and write results in a different format.
An emulator had to reproduce the behavior of those instructions in software. Whether it matched every edge case depended on the implementation and its libraries; the relevant question for a particular program is which operations, formats, rounding modes, and exceptions the selected toolchain supported.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11What did a system need in order to use an 8087?
A usable installation required a compatible 8086- or 8088-based system with the appropriate coprocessor interface and software support. The 8087 was an optional component, so a machine designed without that interface could not gain its benefits merely by installing a generic floating-point library.
- Compatible host: an 8086 or 8088 system designed to coordinate with the numeric coprocessor.
- Matching software: code assembled and linked for 8087 instructions, or an E8087-compatible software path when no chip was present.
- Correct execution mode: the program had to use the intended hardware or emulator library rather than assuming that a coprocessor was always installed.
- Format awareness: programs needed to account for the memory format and precision used when values entered or left the 8087’s internal registers.
For a vintage-system restoration, the physical chip is therefore only one part of the question. The motherboard, socket or interface logic, BIOS or operating environment, assembler, linker libraries, and application binary all determine whether an 8087 can be used successfully.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Which comparison is useful for a vintage computer project?
Choose the comparison that matches the project’s goal rather than treating “hardware” and “software” as interchangeable products.
When performance is the goal
Use matched operations, precision, clock rate, and software versions. The 5 MHz Intel figures provide a historical baseline, but they do not predict the speed of a modern emulator, a different 8086 clock, or a complete application.
Recommended Free Tools
When compatibility is the goal
Software emulation is the practical fallback because it allows numeric code to run without an installed 8087. It is especially useful for development, testing, and systems where the coprocessor is unavailable or the hardware is being reserved for another machine.
When numerical reproducibility is the goal
Document the internal precision, rounding mode, conversion points, and exception behavior. Two builds can use the same source formula yet differ if one spills intermediate values to memory more often than the other.
When historical authenticity is the goal
An actual 8087 preserves the original coprocessor execution model and its interaction with the 8086/8088. Record the host clock and software configuration so that later timing comparisons remain meaningful.
What are the common mistakes when comparing the two?
- Calling the 8087 a standalone processor: it was a coprocessor that depended on an 8086 or 8088 host.
- Presenting one ratio as universal: Intel’s timings apply to selected instructions under stated historical conditions, not every workload.
- Mixing clock tables: the 5 MHz supplement and the separate 8 MHz datasheet describe different setups.
- Ignoring intermediate precision: 80-bit temporary-real registers can change results when software rounds at different stages.
- Assuming all software floats are E8087: later processors and toolchains use different implementations.
- Comparing unoptimized code with optimized hardware: Intel’s software figures came from highly optimized emulator procedures.
A sound test identifies the exact operation, operand format, host clock, implementation, and whether the measurement includes memory traffic or only execution time. It then reports the result as a characteristic of that setup, not as a timeless property of every hardware or software floating-point system.
Why does the 8087 still matter?
The 8087 established a practical pattern for attaching specialized numeric hardware to a general-purpose processor. Its register-stack design, extended internal format, conversion rules, and control behavior influenced how programmers thought about floating-point execution on the x86 family.
Historically, its biggest contribution was making floating-point performance usable on an 8086/8088 computer. Software emulation preserved access and compatibility, but Intel’s own measurements show why applications that could justify the optional chip benefited from it. The lasting lesson is that speed, precision, instruction coverage, and deployment requirements must be evaluated together; a faster arithmetic unit is not automatically a drop-in substitute for a software implementation with different rounding and compatibility choices.
Frequently Asked Questions
Can an 8087 be added to any 8086 computer?
No. The host system must provide the appropriate coprocessor interface and supporting hardware, and the software must be built to use the device. A machine lacking that design cannot gain 8087 operation simply by adding a floating-point library.
Did every program need an 8087 to use floating point?
No. Programs could be linked with software emulation so they ran on an 8086 or 8088 without the optional chip. The trade-off was substantially longer execution time for the numeric instructions measured by Intel.
Why are 80-bit registers important if a program uses single precision?
Single-precision values can remain in the 8087’s wider temporary-real format between a load and a store. If software rounds to single precision after every operation instead, accumulated intermediate values and sometimes the final result can differ.
Can Intel’s 1980 timings predict performance on a modern PC?
No. They describe a 5 MHz 8086 with an 8087 and highly optimized emulator procedures. Modern processors, compilers, runtimes, and instruction sets use different execution mechanisms, so the figures are historical context rather than current benchmarks.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
