The Path to Wine 1.0

Wine developer John R. Sheets talks about the current status of the Wine project, where it's been, and where it might go in the future.

Wine developer John R. Sheets talks about the current status of the Wine
project, where it's been, and where it might go in the future.

The Path to Wine 1.0

Wine, an open source development effort to reimplement the win32 application
programming interface (API) as a native UNIX library, has been around for over
seven years, almost as long as the Linux kernel. Throughout this time, Wine
has been released as alpha-quality software, not stable or reliable enough for
consumption by end users. The main audience has been UNIX developers capable
of dealing with Wine's idiosyncrasies.

Seven years is a long time for a piece of software to be stuck in alpha release
mode. The problem is by no means a lack of quality developers: The volunteers
who work on Wine are some of the most talented software engineers in the business.
The holdup is more of a technical battle than a manpower issue.

Perhaps the biggest obstacle Wine faces is the sheer size of the win32 API.
Literally hundreds and hundreds of function calls exist, which pass around dozens
and dozens of data structures. Often the behavior of these function calls is
poorly documented, and sometimes not at all. In fact, a number of the core internal
functions called by Windows applications aren't mentioned anywhere in the documentation.
Wine must implement these unnamed functions; otherwise applications that use
them will not run. The Wine developers must investigate the manner in which
applications seem to use them, and refine the implementation as new applications
reveal bugs.

To make matters worse, Microsoft continually adds new APIs and changes the
behavior of the existing APIs in subtle ways for each major release of the Windows
operating system. For example, Windows 95 introduced a different look and feel
for applications, as well as a handful of new controls. Wine developers had
to implement these new controls in order to support all the Win95 applications
that used them, and enhance the internal drawing code to match the new appearances.

A lot of Wine's growth has been fueled by the desire to play Windows games
on Linux machines. As a result, Wine boasts a healthy implementation of the
win32 multimedia API, including sound playback, animation, and even OpenGL.
Many popular modern games work well under Wine, including Starcraft and Ultima
Online. Wine optionally supports the Direct Graphics Architecture (DGA) X11
extension to make full-screen games behave more like native Linux applications.

The lion's share of Wine's functionality is the product of individual developers
fixing bugs and implementing missing APIs in their spare time, for free. It
has only been recently that commercial companies have begun to contribute openly
to Wine. One of the largest corporations to do this is Corel, who threw their
weight behind Wine for their office and drawing suites. While this eventually
lead to a benign forking (i.e., divergence) of the Wine source code, Corel kept
their version of Wine public, and a good portion of their fixes have been merged
back into the main Wine tree.

Another major player in the Wine space is CodeWeavers (my employer). CodeWeavers
has done quite a bit over the past year to flesh out the missing parts of Wine
and debug the existing parts, trying to move Wine toward a rock solid 1.0 release.
Outside of straight C coding, CodeWeavers has also spent time improving the
infrastructure in and around Wine, to make it more accessible to users and developers.
This includes organizing and converting the text-file documentation into DocBook/SGML,
writing a new GUI configuration tool, helping to cement Wine's integration with
the X11 desktop, and improving the compile environment. An offshoot of this
last effort is the winemaker tool, a new script capable of converting an existing
Windows project (including MS Visual C++/MFC projects) into a Wine/UNIX project.

It's hard to predict what the future of Wine might hold, beyond the 1.0 target.
Perhaps someday Wine will acquire a fully native GNOME front end. As Wine support
is cautiously integrated into the Linux kernel and the surrounding operating
system, we might see the day when Wine becomes a transparent loader, allowing
us to run Windows executables on equal footings with other UNIX executable formats.
In that sense, Wine may fade from the limelight, into the background, to become
a fundamental feature of the GNU/Linux operating system, alongside the linkers,
the compilers, and the daemons.

About the Author

John R. Sheets has been following the GNOME project on a day-to-day
basis for more than two years, since GNOME was only six months old. He is a
software developer for CodeWeavers,
Inc., where he works on Wine and GNOME. In his free time, he is helping
the WorldForge Project
to create a free online multiplayer gaming environment. John is the author of
Writing
GNOME Applications (Addison-Wesley,
2001), and the maintainer of the OpenBooks
Web site.