DONKEY.BAS

DONKEY.BAS is a video game written in 1981 by Microsoft co-founder Bill Gates and developer Neil Konzen for the IBM Personal Computer.^[1]^[2] It is a rudimentary driving simulation in which the player controls a sports car on a two-lane road, pressing the spacebar to swerve and avoid donkeys that appear as low-resolution brown blobs, with the game ending upon collision.^[3] The program, saved as a BASIC source file, was bundled as a demonstration with early versions of PC DOS, including versions 1.00 and 1.10, to showcase the capabilities of Microsoft BASIC on the new hardware.^[4]^[5] The game's development occurred in late 1980 or early 1981 during Microsoft's collaboration with IBM on the Personal Computer project, which launched in August 1981.^[6] Gates and Konzen, then a teenage programmer who later led Microsoft's Macintosh software efforts, worked overnight in a locked, overheated closet containing a prototype IBM PC to create the application under strict nondisclosure requirements.^[1] As Gates later recounted in a 2001 keynote, "it was myself and Neil Konzen at four in the morning with this prototype IBM PC sitting in this small room... we wrote late at night a little application to show what the BASIC built into the IBM PC could do."^[1] This effort was part of Microsoft's broader contract to supply BASIC interpreters and sample programs, helping to secure the partnership that propelled the company into the PC era.^[6] Despite its simplistic graphics—generated using BASIC's DRAW statements—and repetitive gameplay limited by the IBM PC's 4.77 MHz Intel 8088 processor and CGA display, DONKEY.BAS holds historical significance as one of the first games distributed with a personal computer and a rare credited programming credit for Gates.^[3] It exemplified early PC software's focus on functionality over polish and has been preserved in emulators and archives, inspiring modern recreations such as browser-based versions and ports to other platforms.^[4] The game's code, approximately 200 lines long, remains publicly available and serves as an artifact of computing's formative years.^[7]

Overview

Description

DONKEY.BAS is a single-player driving game in which the player maneuvers a car along a vertically scrolling road divided into two lanes, avoiding donkeys that appear randomly at the top of the screen by pressing the spacebar to switch lanes.^[2] The game was developed specifically for the IBM PC, utilizing the Microsoft BASIC Interpreter on systems running PC DOS versions 1.0 and 1.10.^[5] Released in August 1981, DONKEY.BAS was bundled with early IBM PC systems as a demonstration program to highlight the hardware's graphics capabilities and the interactivity possible with BASIC programming.^[8] The game's visuals employ low-resolution graphics in CGA mode, using BASIC's DRAW commands to render a simple road with a dashed center line, a pixelated car at the bottom, and donkeys moving downward; the road scrolls continuously to simulate motion.^[9] The scoring system tracks points for both the player and the donkeys, with a collision awarding a point to the donkeys accompanied by an explosion animation and "BOOM!" message, after which the player restarts from the bottom of the road; successful avoidance grants the player a point, and the game runs indefinitely until manually quit via the Esc key.^[7]

Historical Context

DONKEY.BAS emerged in 1981 during the launch of the IBM Personal Computer (model 5150), which was unveiled on August 12 of that year and represented a major shift in the computing industry from centralized mainframe systems to accessible personal machines.^[10]^[11] IBM's entry into the personal computer market, powered by an Intel 8088 microprocessor and PC DOS (based on Microsoft's 86-DOS), legitimized PCs for business use and spurred widespread adoption by making computing more affordable and user-friendly for individuals and organizations.^[10]^[11] This transition accelerated the democratization of technology, moving away from expensive, room-sized mainframes controlled by specialists toward compact devices that could run on desktops.^[11] Developed specifically to demonstrate the potential of the new hardware, DONKEY.BAS was written by Microsoft co-founder Bill Gates and programmer Neil Konzen in 1981, prior to the IBM PC's launch.^[9] The game was created as a simple demo application to illustrate the interactive graphics and programming capabilities of Microsoft BASIC, the interpreter licensed to IBM and integrated into the PC's BASIC variant (BASICA).^[9] As Gates later recounted, "It was myself and Neil Konzen at four in the morning with this prototype IBM PC... we wrote late at night a little application to show what the Basic built into the IBM PC could do," emphasizing its role in impressing IBM executives and early users with the platform's versatility.^[9] Bundled with PC-DOS 1.00 and early versions of the operating system, it served as an engaging example of how BASIC enabled rapid development of entertainment software on the 5150.^[4] In the broader context of early personal computing, DONKEY.BAS highlighted the accessibility of programming and gaming on consumer hardware, contrasting with the specialized environments of prior eras.^[11] Recognized as the first video game developed for the IBM PC, it exemplified bundled software entertainment that came pre-installed to showcase the system's multimedia potential without requiring additional purchases.^[2]^[8] By providing a straightforward interactive experience, it underscored Microsoft's strategic partnership with IBM and contributed to the platform's appeal during a time when personal computers were establishing their place in homes and offices.^[10]

Gameplay

Mechanics

In DONKEY.BAS, the primary objective is to control a car traveling along a two-lane road and avoid collisions with donkeys that appear randomly ahead, with the goal of surviving as long as possible to maximize the distance traveled. The game simulates forward motion through a continuously scrolling road, where donkeys are generated at the top of the screen in one of the two lanes and move downward toward the player's car at a constant speed, creating the illusion of approaching obstacles at varying distances. Success depends on timely lane changes to dodge each donkey, as only one donkey appears on the screen at a time, and failure to avoid it results in a collision that awards a point to the donkey and resets the road segment.^[12]^[4] Player controls are limited to a single input mechanism: pressing the spacebar toggles the car's position between the left lane (positioned at x=110) and the right lane (x=142), with no options for acceleration, braking, or fine steering adjustments. The car remains fixed at the bottom of the screen (y=105), and the road's procedural generation ensures unpredictable donkey placements, requiring quick reactions to maintain progress. The ESC key serves as the only means to quit the game prematurely.^[12]^[13] Scoring emphasizes survival and avoidance, with the player's score (displayed as "YOU") incrementing by one each time a donkey passes the bottom of the screen without a collision, effectively measuring the number of successful dodges or units of distance covered. Conversely, the donkey's score (displayed as "DONKEY") increases by one upon each collision, accompanied by an on-screen message such as "DONKEY 1, YOU 0" to reflect the updated tally, followed by a brief animation of the crash and a road reset. These scores accumulate within the play session, providing a competitive metric against the donkeys.^[12]^[7] There is no definitive win condition, as the game operates in an endless loop designed for high-score chasing through prolonged avoidance sequences. Collisions do not terminate play but penalize the player by advancing the donkey's score and restarting the current road segment, allowing continued attempts to outperform the cumulative donkey points; the session only concludes when the player presses ESC. High scores are thus determined by the ratio of avoided donkeys to collisions, rewarding skillful lane toggling over extended play.^[12]^[4]

Audio and Visuals

DONKEY.BAS employs rudimentary graphics rendered in CGA mode at 320x200 resolution with four colors, utilizing Microsoft BASIC's DRAW statements to create vector-based shapes for the car and donkeys rather than text characters. The car is depicted as a simple 29x45 pixel outline positioned at the bottom of the screen, while donkeys appear as 32x25 pixel figures that spawn at the top and move downward. The road consists of two lanes defined by straight white lines for the edges and a dashed center divider, with upcoming obstacles visible in a fixed viewport to convey forward motion through periodic redrawing.^[4] The screen layout adopts a top-down perspective, centering the road within the display while allocating space on the left and right sides for score indicators: the number of donkeys hit by the player and the number missed, updated in real-time using text overlays. This design accommodates the IBM PC's hardware limitations, operating without sprites or hardware acceleration and relying on software-based line drawing for all visual elements. The game supports both monochrome and color CGA displays, though color enhances the distinction between road elements and obstacles.^[4] Audio in DONKEY.BAS is minimalistic, generated exclusively through the PC speaker via the SOUND command, producing short beeps to provide feedback: continuous short high-frequency tones (approximately 20000 Hz) simulate engine noise during gameplay, a low-frequency beep (200 Hz) accompanies lane switches, while variable low pitches (37 to 237 Hz) signal collisions. No background music or multi-channel effects are present, reflecting the era's constraints on the single-channel speaker hardware.^[4] Upon detecting a collision, visual feedback includes an animated sequence where the car and donkey graphics are bisected and scattered across the screen using XOR drawing operations for erasure and repositioning over six frames, accompanied by centered "BOOM!" text in large font. The road and elements then regenerate continuously during gameplay by clearing and redrawing the scene at each update cycle, ensuring smooth scrolling without persistent artifacts. This approach highlights the game's adaptation to the 80-column text mode for initial setup and low-overhead graphics mode for runtime, prioritizing performance on the original 4.77 MHz IBM PC.^[4]

Development

Background

In late 1980, IBM approached Microsoft to supply programming languages, including BASIC, for its forthcoming personal computer, marking a pivotal partnership that positioned Microsoft as a key software provider for the IBM PC launched in August 1981.^[14] The agreement, finalized in November 1980 for $430,000 total (including $385,000 for BASIC and other languages, and $45,000 for the OS), required Microsoft to deliver not only BASIC but also demonstration programs to illustrate the viability of the hardware and software ecosystem, as IBM sought to establish the PC as a credible business tool amid skepticism from corporate buyers.^[14]^[10] Bill Gates, Microsoft's co-founder, emphasized the need for engaging sample applications to highlight BASIC's capabilities and differentiate the IBM PC from competitors like Apple, whose computers featured recreational software such as Pinball to appeal to broader users.^[6] Gates advocated for fun, interactive demos to demonstrate that BASIC could support more than just utilitarian tasks, addressing the early personal computing landscape where entertainment options were scarce and machines were primarily viewed as productivity devices.^[6]^[10] To meet this demand, Microsoft recruited Neil Konzen, a young programmer renowned for his expertise in BASIC from Apple II development, as one of its earliest employees to contribute to rapid prototype creation.^[6]^[9] Konzen's involvement stemmed directly from the urgency to produce simple yet compelling examples that showcased BASIC's potential for graphics and user interaction, fulfilling IBM's requirements for bundled software that went beyond basic utilities.^[6]^[15]

Programming and Release

DONKEY.BAS was developed in early 1981 by Microsoft co-founder Bill Gates and employee Neil Konzen during an intense overnight coding session on a prototype IBM PC, motivated by the need to create a simple demonstration application for an upcoming IBM presentation. According to Gates, the pair worked until around 4 a.m. in a small, locked closet room that exceeded 100°F (38°C), under significant time constraints to showcase the capabilities of the Microsoft BASIC interpreter integrated into the IBM PC. This rushed environment contributed to the game's minimalist design, with no advanced debugging tools available in the early BASIC environment, leading to straightforward implementations like direct coordinate comparisons for key features.^[1] The game was written entirely in the Microsoft BASIC interpreter for the IBM PC, comprising approximately 200 lines of code. Road scrolling was achieved through loops that incrementally updated and redrew vertical elements, such as the center line animated every third frame using pixel overlays. Donkey placement relied on the RND function for random lane selection at the top of the screen, introducing unpredictability with one donkey appearing at a time. Collision detection employed basic position checks, comparing the car's coordinates (CX, CY) against the donkey's (DX, DY) to trigger an explosion sequence and "BOOM!" message upon overlap.^[16] DONKEY.BAS was released as part of PC DOS 1.0 in August 1981, coinciding with the IBM PC's launch, and carried over to version 1.10 in 1982. The full source code was included openly on the boot disks, allowing users to view, modify, and learn from it directly within the BASIC environment. Distribution occurred via pre-installed floppy disks bundled with IBM PCs, where users could launch the game by loading the BASIC interpreter and executing the DONKEY.BAS file, typically via a simple RUN command. This approach encouraged experimentation and served as an educational tool for early PC owners.^[17]^[8]

Reception and Legacy

Contemporary Response

Upon its inclusion with the IBM PC in 1981, DONKEY.BAS received mixed initial reactions, primarily serving as a demonstration tool rather than a standalone entertainment product. Users and early adopters appreciated its simplicity as an accessible introduction to the PC's graphics and input capabilities, often using it as an immediate "icebreaker" to engage with the new hardware without complex setup.^[15] This bundled demo helped foster excitement around personal computing by providing a quick, interactive experience for novice owners, aligning with IBM and Microsoft's goal of showcasing BASIC's potential for graphical applications.^[18] From the Microsoft perspective, the game was regarded as a pragmatic success in demonstrating the platform's features during late-night development sessions with prototype hardware. Bill Gates, who co-authored the code with Neil Konzen, later reflected on it fondly in a 2001 keynote address, recounting the effort as a creative, if rudimentary, push to highlight the IBM PC's graphics at four in the morning, despite acknowledging the game's poor quality.^[6] IBM similarly valued it as an effective sample program to illustrate the versatility of their new machine, contributing to the overall appeal of the PC ecosystem.^[15] Criticism emerged prominently from the rival Apple Macintosh development team, underscoring the early PC-Mac competition. In August 1981, Andy Hertzfeld described the bundled BASIC games, including DONKEY.BAS, as "especially embarrassing," singling it out as the worst due to its low-resolution graphics and simplistic design.^[9] This view highlighted perceived shortcomings in the IBM PC's entertainment software compared to Apple's more polished offerings. Media coverage in the early 1980s treated DONKEY.BAS as a quirky example of bundled software rather than subjecting it to formal reviews, given its demo status. It appeared in publications like the June 1984 issue of PC Magazine, noted alongside other entertainment programs such as ART.BAS as part of the PC DOS distribution.^[19] Hobbyists frequently modified its open BASIC source code to experiment with graphics and mechanics, reflecting its role in encouraging programming tinkering among early PC enthusiasts.^[5]

Modern Interpretations

In the early 2000s, Microsoft created Donkey .NET, a three-dimensional reinterpretation of the original game released as a demonstration for Visual Basic .NET developers during the framework's beta phase in 2002. Unlike the avoidance mechanics of DONKEY.BAS, this version inverted the gameplay by tasking players with colliding with donkeys using a 3D car model, showcasing advanced graphics and programming features available in the new language. The sample highlighted Microsoft's evolution in software development tools while paying homage to Gates' early work.^[5] Subsequent remakes expanded accessibility to modern platforms. In 2012, developer XVision released DONKEY.BAS for iOS devices, faithfully recreating the top-down driving experience with touch controls, increased donkey speeds for added challenge, and compatibility with Game Center for leaderboards; an Apple TV version followed in 2020. A Windows Phone 7 port also emerged around the same period, adapting the game for mobile hardware while preserving its retro simplicity. These efforts brought the 1981 title to contemporary audiences, emphasizing its historical novelty as the first IBM PC game co-authored by Bill Gates.^[20]^[21] Enthusiast recreations further demonstrated the game's enduring appeal in retro computing communities. In 2016, programmer VileR developed "Sorry Ass," a 512-byte boot sector executable that emulates DONKEY.BAS mechanics in assembly language, runnable directly from a floppy disk image to celebrate the IBM PC's 35th anniversary. Online emulators like PCjs have enabled browser-based play of the authentic 1981 source code since the 2010s, allowing users to experience it on original hardware simulations without physical vintage equipment.^[22]^[4] Beyond gameplay revivals, DONKEY.BAS holds educational value in computing history curricula, illustrating early personal computer programming in BASIC and Microsoft's foundational role in the industry. It serves as a case study in introductory texts on software evolution, highlighting how simple demos like this bundled with DOS 1.0 helped popularize interactive computing for non-experts in the 1980s. Modern analyses, such as those extracting its rudimentary graphics code, underscore its technical ingenuity within hardware constraints, informing discussions on game design origins.^[23]