Fahrenheit (graphics API)

Fahrenheit was an effort to create a unified high-level API for 3D computer graphics to unify Direct3D and OpenGL. It was designed primarily by Microsoft and SGI and also included work from an HP-Microsoft joint effort.

Direct3D and OpenGL are low-level APIs that concentrate primarily on the rendering steps of the 3D rendering pipeline. Programs that use these APIs have to supply a considerable amount of code to handle the rest of the pipeline. Fahrenheit hoped to provide a single API that would do most of this work, and then call either Direct3D or OpenGL for the last steps.

Much of the original Fahrenheit project was abandoned, and Microsoft and SGI eventually gave up on attempts to work together. In the end, only the scene graph portion of the Fahrenheit system, known as XSG, saw a release and was discontinued shortly afterwards.

Background
In the 1990s SGI's OpenGL was the de facto standard for 3D computer graphics. Prior to the mid-90s different platforms had used various custom solutions, but SGI's power in the graphics market, combined with the efforts of the OpenGL Architecture Review Board (ARB), led to the rapid standardization of OpenGL across the majority of the graphics workstation market. In the mid-1990s, Microsoft licensed OpenGL for their Windows NT operating system as its primary 3D system; Microsoft was positioning NT as a workstation-class system, and OpenGL was required in order to be a real competitor in this space. Initial support was released in Windows NT Workstation version 3.5 in 1994.

Confusing matters was Microsoft's February 1995 purchase of RenderMorphics. Their Reality Lab product was a 3D library written specifically for gaming purposes, aimed primarily at the "low end" market. After renaming it to Direct3D 3.0, Microsoft released it as the primary 3D API for Windows 95 and game programming. This sparked off a massive debate, both within Microsoft and outside, about the merits of the two APIs and whether or not Direct3D should be promoted.

Through the mid-90s SGI had been working on a series of efforts to provide a higher level API on top of OpenGL to make programming easier. By 1997 this had evolved into their OpenGL++ system, a retained-mode C++ API on top of OpenGL. They proposed that a modified version be used as a single API on top of either OpenGL or a new high-performance low-level API that Microsoft was known to be working on (not based on Reality Lab). This would not only hide the implementation details and make the OpenGL/DirectX war superfluous, but at the same time offer considerably better high-level interfaces for a more robust object oriented development environment.

The OpenGL++ effort dragged on in the ARB through 1997. Although SGI committed resources to the project in order to provide a sample implementation, it appears they were unhappy with progress overall and complained "There's been lots of work, but relatively little communication." Microsoft in particular had stated in no uncertain terms that they would not be supporting the effort, and SGI felt that their support would be essential for any efforts moving forward.

Announcement
A joint press release in December 1997, followed by an announcement at an ARB meeting in early 1998 by SGI, announced that work on OpenGL++ had been abandoned and SGI had partnered with Microsoft to produce a new system code-named "Fahrenheit". SGI was to provide the primary "mid-sized" API used in most applications, Fahrenheit Scene Graph, as well as a modified version for handling very large models from CAD applications, Fahrenheit Large Model. Microsoft would provide a new low-level rendering engine for Windows known as Fahrenheit Low Level, essentially a replacement for the Reality Lab-based version of Direct3D. The project was officially announced at SIGGRAPH 1998 for release in late 1999 or early 2000.

Fahrenheit became the primary focus of development at SGI. Their MIPS-based workstations were quickly losing the performance lead they had in the early 1990s, and the company was in serious trouble as the average PC slowly but surely encroached on the high-end graphics market. SGI saw Fahrenheit as an exit strategy; once complete they would be able to move to a PC-based lineup while still offering the best development tools for a now universal API. Although no porting work began, toolkits like Open Inventor and OpenGL Performer were intended in future to be layered on Fahrenheit, meaning that they could deliver a single fully functional development system for Fahrenheit when it shipped, supporting both their existing customers as well as new ones.

Cancellation
By 1999 it was clear that Microsoft had no intention of delivering Low Level; although officially working on it, almost no resources were dedicated to actually producing code. At the same time Microsoft was in the process of massively investing in DirectX 7.0 (similar to 3.0 largely in name only). Without Low Level, Fahrenheit couldn't be delivered on Windows, and the project stalled. Eventually SGI abandoned work on Fahrenheit and started planning other Scene Graph products which became the last in a series of such projects.

By 2000 DirectX 7.0 was in the marketplace, and proving quite popular. DirectX had become the primary API during the rise of 3D gaming in the late 1990s. Microsoft did release Fahrenheit Scene Graph as XSG the same year, but did so with a note saying it would not be supported. No new versions of XSG were ever released, and all of the pages related to either Fahrenheit or XSG on both the Microsoft and SGI web pages have since disappeared. Hardware accelerated OpenGL support was dropped from the included video drivers in Windows XP, although most video card manufacturers deliver their own implementations.

Description
As compared to Open Inventor or Iris Performer, the design of the XSG included some novel ideas. The composition primitives and traversal methods allowed applications to construct scenes in a manner best suited to the structure of the data being visualized, but then to apply a scene graph optimizer to restructure the scene for more efficient rendering without changing the scene's appearance. The developer simply did whatever seemed natural, and the system made it work quickly.

Pipelined rendering allowed a multithreaded application to construct the scene, cull its primitives, and render it in different threads (borrowing from the Performer app-cull-draw pipeline). The representation of primitive scene data was optimized to minimize the amount of data stored so as to avoid completely duplicating it on a thread-by-thread basis.

One of the unique features of XSG was the ability to replace most of the built-in methods for walking the graph with your own versions. Developers could write new functions for quickly traversing their known methods of storing data inside XSG, and then chain them into existing rendering paths.

David Blythe, the primary architect of Fahrenheit at SGI, worked at Microsoft on DirectX until 2010. He was also Chief Graphics Software Architect at Intel.