Gates, Allen, and the Microsoft BASIC dynasty (1975–1991)

The previous section in this chapter, The birth of BASIC, and the decade before Microsoft, covers the language's invention at Dartmouth in 1964 and the eleven years of commercial spread on minicomputers and time-sharing services that followed. By 1975, by one Dartmouth participant's later estimate, five million people in the world already knew how to write BASIC, on roughly 80 time-sharing systems in the United States plus dozens more abroad.

This section picks up where that one stops. Microsoft did not invent BASIC. What Microsoft did was port an existing commercial dialect down to a $400 microcomputer, fight publicly to be paid for it, and build the licensing machinery that turned BASIC into the on-ramp to programming for the next two decades.

That fight, and the dynasty it produced, is what made "Microsoft BASIC" a non-negotiable brand by the time Visual Basic shipped sixteen years later. Visual Basic 1.0 launched on May 20, 1991, and the "Basic" half of the name was already worth more than the "Visual" because of what's covered below.

Gates, Allen, and the Altair (1975)

In January 1975, Bill Gates and Paul Allen saw the MITS Altair 8800 on the cover of the January issue of Popular Electronics and decided to write a BASIC interpreter for it before they had access to the hardware. They contacted MITS founder Ed Roberts in Albuquerque offering an interpreter that did not yet exist, on a machine they had never touched, for a processor (the Intel 8080) that neither of them had previously written code for. Roberts said he had been getting roughly one such call a day; the answer to all of them was the same: show up with something that works.

What followed was eight weeks of contract-fishing on a borrowed mainframe. The work was done at Harvard, on the PDP-10 in the Aiken Computation Lab, on time the university would later object to on the basis that Gates was using academic resources to develop a commercial product.

Allen had previously written an Intel 8008 emulator that ran on a PDP-10 (work that originated at Traf-O-Data, the earlier Gates and Allen traffic-counter venture). He adapted that emulator to emulate the 8080 based on the printed Altair programmer's guide alone. Neither of them had access to an Altair while the emulator and the interpreter were being written. The interpreter was developed and tested entirely against Allen's emulated 8080. The first time the code ever ran on real hardware was the demo trip to Albuquerque.

Gates wrote the bulk of the interpreter (parser, runtime, command dispatch) by hand in 8080 assembly. Fellow Harvard student Monte Davidoff overheard the two of them debating whether they could fit a floating-point package in the memory budget, told them he had already written one, and was hired to write the Altair BASIC math package. Davidoff's floating-point routines occupied roughly one-third of the 4 KB image on the smallest configuration. A non-trivial budget concession, made because Gates and Allen had decided the language could not credibly ship without floating-point if it wanted to compete with DEC's BASIC dialects.

The dialect they wrote was patterned closely on DEC BASIC-PLUS, DEC's PDP-11 commercial BASIC, shipped in 1971 as part of the RSTS/E time-sharing system. Microsoft Altair BASIC was, in language-design terms, a minicomputer dialect ported down to a microprocessor. That is what gave it instant credibility with anyone who had already used DEC machines, and it is also why Microsoft's BASIC felt familiar to schools and businesses. The dialect was already known. Microsoft's contribution was the interpreter, not the language.

The Altair shipped in standard configurations of 4 KB, 8 KB, and 12 KB of RAM, and Microsoft's BASIC was offered in three matching builds. The 4 KB version was tight enough that integer-only variables were the practical default; the 8 KB version exposed the full floating-point package and string handling; the 12 KB "Extended" version added disk I/O hooks and the longer set of statements that made it feel like a real minicomputer BASIC. The discipline of fitting a credible BASIC into 4 KB (a number that included the interpreter, the user's program, and the variable storage) is the single most-cited piece of engineering work in the early Microsoft story, and it is genuine. The version that shipped on the Altair's paper tape was hand-tuned to the byte.

In late February 1975, Allen flew to Albuquerque carrying the punched paper tape that contained the assembled interpreter. The famous detail of the trip is that he wrote the paper-tape loader (the code that would actually pull the BASIC interpreter off the tape into the Altair's memory) on the plane, because they had remembered the interpreter and forgotten the loader. He typed it in by hand on the Altair's front-panel switches when he arrived. When the loader finished and the interpreter started, the Altair's teletype printed MEMORY SIZE?, the first prompt the interpreter asked at startup. Allen typed a number. The teletype printed OK. He typed PRINT 2+2. It printed 4.

That four-character output was the first time their code had ever run on the target hardware. Roberts agreed on the spot to distribute it. Gates took a leave of absence from Harvard and joined Allen in Albuquerque. "Micro-Soft" was established on April 4, 1975, Allen's contraction of "micro-computer software"; the hyphen was dropped by 1976.

Three engineering points worth landing before moving on. One, the 8080 emulator on a PDP-10 was a real piece of work. Allen built a development environment for a processor that he didn't have, on a machine that bore no resemblance to it, and got it close enough that the interpreter ran first time on real hardware. Two, the memory budget was tight enough that the discipline involved was real. Gates' assembly is hand-tuned in places that the 2025 6502 source release (a later port of the same lineage) makes browsable. Three, none of this was invention. The language was DEC's. The processor was Intel's. The hardware was MITS's. What Gates and Allen brought was the willingness to commit to a port before the contract existed and the discipline to land it on the byte budget the hardware actually had. That is engineering. It is also exactly the kind of engineering that makes commercial sense as the founding act of a software company, rather than as a research project.

The fight to be paid, the Open Letter (1976)

The monetisation fight came almost immediately. MITS bundled Altair BASIC with the Altair itself for $500 (machine plus interpreter), and sold it standalone for $150. The standalone price was high enough to be controversial in the hobbyist community and low enough that Microsoft genuinely needed volume to make money on it.

The leak that triggered the Open Letter happened at a Homebrew Computer Club meeting in Menlo Park in June 1975. MITS was on a national promotional tour with the Altair, billed as the "MITS Mobile Caravan," and stopped at Rickeys Hyatt House in Palo Alto. A pre-release paper tape of Altair BASIC was being demonstrated. Dan Sokol, a semiconductor test engineer who attended Homebrew, got hold of one of the tapes (the accounts vary on whether it was lent, lifted from the floor, or pulled from a trash can; Sokol's own later account is that it was given to him to copy). Within weeks Sokol had duplicated dozens of copies on a paper-tape duplicator at his employer's lab, and the tapes were being passed around at Homebrew meetings under the unwritten rule of "bring one back, take one."

Within months copies had spread far beyond Homebrew. By early 1976 Gates estimated, by comparing MITS's reported BASIC sales against the number of Altair owners he knew or suspected were running it, that fewer than one in ten Altair BASIC users had paid for the software. His response was the "An Open Letter to Hobbyists," dated February 3, 1976 and published in Computer Notes (the MITS newsletter), the Homebrew Computer Club newsletter, Dr. Dobb's Journal, and several others over the following weeks.

The argument is short and unhedged. The most-cited section, in Gates' own words:

"As the majority of hobbyists must be aware, most of you steal your software. Hardware must be paid for, but software is something to share. Who cares if the people who worked on it get paid? Is this fair? ... One thing you do is prevent good software from being written. Who can afford to do professional work for nothing? What hobbyist can put 3-man years into programming, finding all bugs, documenting his product, and distribute for free?" Bill Gates, "An Open Letter to Hobbyists," 3 February 1976.

He closed by inviting anyone who wanted to pay, or who had ideas about the economics of hobbyist software, to write to him at the Albuquerque address. The replies came back. By Gates' own later account, 300 to 400 letters, most of them hostile, accusing him of greed, of misunderstanding the hobbyist ethic, of being twenty years old and having no business lecturing the community on what software was worth. Five or six of them contained payment.

The Open Letter is widely cited (particularly in retrospectives produced by Microsoft itself and by trade press writing for software-industry audiences) as the opening shot of the proprietary-software-versus-free-software debate. That framing is a retrospective construction and worth attributing as such. The Tiny BASIC project (Dennis Allison's specification, published in the People's Computer Company newsletter in September 1975) predated the Open Letter by five months and was already a deliberate counter-proposal to commercial microcomputer BASIC. The free-versus-proprietary argument did not start with Gates' letter; the letter was the moment one side of an existing argument was put in print by a commercial vendor under his own name. Whatever it started or didn't start, the Open Letter is the moment Microsoft's institutional posture toward customers crystallised. Pay for the software, or stop using it. That posture shaped how Microsoft licensed BASIC to every subsequent platform vendor: by-the-machine licensing, source-code-protected, royalty-bearing. The licensing model that came out of the Open Letter era is what made the BASIC dynasty profitable enough to fund everything that came after.

The MITS and Pertec arbitration (1977)

A second, less-cited fight unlocked the proliferation that followed. The original Altair BASIC contract between Microsoft and MITS gave MITS distribution rights, and contained a clause requiring MITS to "use its best efforts to license, promote and market" the software. That single phrase became the lever that decided the case.

In May 1977, Pertec Computer Corporation acquired MITS. Pertec was a much larger company (disk and tape peripherals, primarily) and treated the Altair BASIC distribution rights as having transferred wholesale with the acquisition. Pertec asserted exclusive worldwide rights to license Microsoft's BASIC, and indicated it would not be sub-licensing the interpreter to any other microcomputer manufacturer. By 1977 those other manufacturers existed in significant numbers: Commodore was developing the PET, Tandy the TRS-80, Apple was about to add a floating-point BASIC to the Apple II. Each of them was, or was about to become, a customer Microsoft could not legally serve if Pertec's reading of the contract held.

Microsoft argued that the rights were non-exclusive, and that Pertec's announced intention to not sub-license to other manufacturers was a direct violation of the "best efforts" clause. Pertec, by refusing to license to anyone but itself, had stopped making best efforts to license at all. The contract required disputes to be settled by binding arbitration.

Microsoft's lawyer was William H. Gates Sr., Bill Gates' father, a senior partner at the Seattle law firm Shidler McBroom Gates and Lucas (later Preston Gates and Ellis, and eventually K&L Gates). The case was argued through 1977. In September 1977 the arbitrator ruled in Microsoft's favour. The ruling found that MITS, and therefore Pertec, had violated the "best efforts" clause, and described the behaviour in language that became the most-quoted line of the proceeding:

"corporate piracy which is not permitted by the wording or any reasonable interpretation of the contract." Arbitrator's ruling, MITS and Pertec arbitration, September 1977.

The phrase is rhetorically pointed in a way that arbitration rulings rarely are, and it became part of the Microsoft origin-story canon for that reason. The arbitrator had explicitly used the same word ("piracy") that Gates had used in the Open Letter eighteen months earlier, but pointed it at a corporation rather than at hobbyists.

Within weeks of the ruling, Microsoft licensed BASIC to Commodore (October 1977, the deal that produced the PET ROM), Tandy (Level II for the TRS-80, shipped March 1978), and Apple (Applesoft I, on cassette in January 1978). Each of those licences would have been legally impossible if Pertec's reading of the original MITS contract had held. The September 1977 arbitration is one of the most consequential and least-remembered inflection points in Microsoft's history; the entire proliferation era runs through it.

The proliferation era (1976–1981)

In the five years between the September 1977 arbitration ruling and the IBM PC's launch in August 1981, Microsoft BASIC ran on essentially every commercially significant microcomputer that wasn't a Sinclair. The lineup is worth naming individually, because the deals (and Microsoft's pricing decisions on each of them) set the pattern that the company carried forward into MS-DOS licensing five years later.

The 6502 port (1976)

The original Altair BASIC was 8080 assembly. Most of the hardware Microsoft was about to license to ran the MOS 6502: Apple II, Commodore PET, Atari 8-bit, Ohio Scientific, KIM-1, BBC Micro. Bill Gates and Ric Weiland completed a 6502 port over the summer of 1976. The port was largely a translation of the 8 KB version of BASIC-80, with Gates writing the dispatcher and Weiland doing most of the instruction-by-instruction reassembly. John Feagans at Commodore later contributed garbage-collector fixes for the Commodore variant in 1978, a documented case of Microsoft accepting an upstream contribution from a licensee, unusual for the company and the era.

The 6502 port is the source tree Microsoft formally released as open source on September 3, 2025 at microsoft/BASIC-M6502, fifty years and change after the Altair release. The release credits Gates and Allen (interpreter, 1975), Gates and Weiland (6502 port, 1976), and Feagans (garbage collector, 1978). The famous STORD0 Easter egg (a vanity string Gates inserted into the source so he could prove authorship if a licensee tried to claim the code as their own) is in the released source, exactly as Gates confirmed in 2010. The release makes the 6502 BASIC source canonical for any technical claim about what Microsoft actually shipped in this period; preservationist Michael Steil's mist64/msbasic reconstruction predated the official release by years and remains a useful annotated read of the same code.

Commodore PET, the $25,000 mistake (October 1977)

Within weeks of the Pertec arbitration ruling, Commodore licensed Microsoft BASIC for the PET. In the deal that closed, Commodore paid a single one-time fee of $25,000 for an unlimited per-machine licence. No royalties. No per-unit fee. No expiry. Flat rate, paid once.

The 25-grand PET deal is the most-cited business-decision blunder in Microsoft's early history, and the citation is fair. Across the PET, the VIC-20, and the Commodore 64, Commodore shipped roughly 17 million machines with Microsoft BASIC in ROM, and Microsoft saw none of the upside beyond the initial twenty-five thousand dollars. The C64 alone (by some estimates the best-selling single computer model in history) represented many millions of paid Microsoft BASIC installations that returned Microsoft nothing.

There is one detail Commodore's executives did not foresee, which is that the famous READY. prompt of the PET, VIC-20, and C64 startup screen is, byte-for-byte, the output of Microsoft's 6502 BASIC. Tens of millions of users learned to program at a Microsoft prompt for which Microsoft was paid $25,000 once. Gates, by his own later account, never made the same flat-rate mistake again. Every BASIC licence after Commodore was royalty-bearing.

Apple II, Applesoft replaces Integer BASIC (January and May 1978)

The Apple II shipped in 1977 with Wozniak's "Integer BASIC" in ROM, written by hand by Steve Wozniak, tight, fast, and entirely lacking floating-point. Apple's customers immediately began demanding floating-point, particularly for the scientific and educational software the Apple II was being marketed for. Wozniak's own account is that he could have added floating-point but had moved on to the disk controller work; Apple chose to license a finished product rather than wait.

Applesoft I shipped on cassette in January 1978, ported from Microsoft's 6502 BASIC by Marc McDonald and Ric Weiland. It was clunky in a few places (the Microsoft floating-point format differed from Wozniak's) and was superseded within months by Applesoft II, released in May 1978, initially on cassette and disk, then burned into ROM on later Apple II models (the II Plus from June 1979 onward shipped Applesoft II in ROM as the default, with Integer BASIC moved to a disk-loaded module). Applesoft II is the BASIC most Apple II owners actually used; the famous Apple II ] prompt was Applesoft's. Apple paid Microsoft per machine on this deal. Gates had learned from the Commodore mistake within a quarter.

TRS-80, Tiny BASIC out, Microsoft in (March 1978)

The Tandy TRS-80 Model I shipped in August 1977 with Li-Chen Wang's Palo Alto Tiny BASIC in ROM, the freely-distributed Tiny BASIC, ironically the same project that had been positioned as the hobbyist counter-shot to Microsoft's commercial licensing. Tandy called it Level I BASIC. It was 4 KB, integer-only, and almost immediately the limiting factor in what the TRS-80 could run.

Tandy contracted Microsoft to provide a more capable replacement, and Level II BASIC shipped in March 1978, a 12 KB ROM port of Microsoft's BASIC-80, with floating-point and the full statement set. Level II is the BASIC TRS-80 owners spent the next half-decade writing code in. Microsoft was nineteen months old when Tandy made this swap, and it's one of the cleanest examples of the era's economics: a hobbyist-ethic free BASIC was on the hardware, the user base demanded more, and the manufacturer paid Microsoft a per-unit royalty to get it.

The rest of the field

Within the same window, Microsoft BASIC also shipped on the Ohio Scientific Model 500 series (one of the earliest 6502 customers, 1977), the KIM-1 (the original 6502 development board, also 1977), the Atari 8-bit family (Atari BASIC, 1979, initially intended to be a Microsoft licence, eventually built by Shepardson Microsystems instead because of size constraints, but the Microsoft conversation framed the requirement), the TI-99/4 (TI BASIC, with Microsoft involvement in some of the underlying floating-point work), and most of the dozens of 8080, Z80, and 6502 hobbyist machines that came and went in the late seventies.

By 1980, Microsoft BASIC was the de facto standard microcomputer BASIC. Not because Microsoft had invented anything new (the dialect was DEC's, the floating-point was Davidoff's algorithm, the per-machine licensing model was a refinement of the existing minicomputer-software business pattern) but because Microsoft was the one company that had:

1. A working 8080 and 6502 source tree, kept current and ported to each new processor variant as it emerged.
2. The legal posture (post-Pertec) and the willingness (post-Open Letter) to enforce per-machine royalty deals against manufacturers.
3. A relationship with every hardware vendor that mattered, built one licence at a time over five years.

Marc McDonald and the FAT file system

One supporting piece of that period's work is worth singling out. Marc McDonald, Microsoft's first salaried employee (hired 1976; Gates, Allen, and Weiland predated him as founders or early hires), designed a file allocation table for the standalone version of Microsoft BASIC sometime in 1977. That table, the FAT file system, was carried forward into Standalone Disk BASIC, then into 86-DOS (which Microsoft would later acquire and rename MS-DOS), then into MS-DOS proper, then into Windows. The FAT design McDonald did for BASIC in 1977 was still in mainstream Microsoft operating systems forty years later, and is still embedded in essentially every USB stick and SD card sold today. McDonald's name appears on almost no retrospective; the design is one of the most-shipped pieces of software architecture in computing history.

GW-BASIC, the IBM era (1981)

The IBM deal that anchored Microsoft's first decade was, in part, the product of a personal connection that almost no other software company in 1980 could have called on. Mary Maxwell Gates, Bill Gates' mother, sat on the national board of directors of the United Way of America alongside John Opel, then chairman of IBM. The Gates family was professionally well-connected: William H. Gates Sr. was a senior Seattle attorney, Mary Maxwell Gates was a director of First Interstate Bancsystem and the United Way. When IBM's Boca Raton team began looking for a BASIC interpreter and an operating system for the project that would become the IBM PC, the Microsoft name reportedly came up at IBM's executive level partly because Opel knew of Mary Gates' son's company.

That story is sometimes inflated into "Mom got Bill the IBM contract." That overstates it. IBM evaluated Microsoft on technical merit, and the company had genuine BASIC dominance to offer. But it understates it to leave the connection out entirely; the door at IBM that opened to Microsoft would not have opened nearly as quickly to a Microsoft headed by anyone other than a Gates. The garage-genius framing of Microsoft's IBM deal is incomplete without it.

What Microsoft actually shipped to IBM in August 1981 was three related BASIC products, and the difference between them is consistently muddled in retrospectives.

• ROM Cassette BASIC. Burned into the IBM PC's motherboard ROM in 32 KB. Loaded automatically if the machine booted with no disk in the drive. Could load and save programs to cassette tape. Limited; almost nobody used it intentionally, but every IBM PC, XT, and AT had it on the motherboard, and every IBM clone-maker had to ship something equivalent or skip BASIC entirely.
• IBM BASICA ("Advanced BASIC"). Disk-loaded extension that required the ROM Cassette BASIC underneath it. The full statement set, disk I/O, advanced graphics, sound. Shipped on the PC DOS disk by IBM. Could not run on a non-IBM machine because it called into IBM's ROM.
• GW-BASIC. Microsoft's standalone equivalent for the clone market. Same syntax, same semantics, same statement set as BASICA, but contained the BASIC code itself in the executable rather than calling into IBM's ROM. That's what made it work on a Compaq, a Tandy 1000, an AT&T 6300, or any of the other clones that didn't have IBM's ROM to call into.

The functional split mattered commercially. IBM owned BASICA on IBM hardware; Microsoft owned GW-BASIC on every clone. As the clone market grew through the mid-eighties, with Compaq alone shipping hundreds of thousands of PCs by 1984, GW-BASIC became the more economically significant of the two products, even though BASICA was the better-known name to early PC users.

The "GW" name is widely attributed to Gregory "Greg" Whitten, Microsoft's chief BASIC architect for years and the engineer who ported much of the line. The folklore alternative (that "GW" stood for "Gee Whiz") circulated in trade press in the eighties; the Whitten attribution is the canonical one but rests largely on internal Microsoft recollection rather than a written contemporary source. Worth flagging as the standard story without asserting it as audited fact.

GW-BASIC was an interpreter only. It read, edited, and ran source code. It could not produce a standalone .exe. That mattered, because by the mid-eighties hobbyists and small-shop developers were starting to want compiled output, both for speed and for the ability to ship a customer a single binary instead of source code plus a runtime.

BASCOM, QuickBASIC, and the PDS line, the compiled era (1982–1990)

The compiler line started with BASCOM 1.0 in 1982, the first BASIC compiler for the IBM PC. By 1985 BASCOM had been rebranded and repackaged as QuickBASIC 1.0, released August 18, 1985, on a single 5.25" 360 KB floppy. QuickBASIC 1.0 was, in effect, BASCOM with a new label; the compiler executable was still named BASCOM.EXE.

Subsequent versions cleaned up the BASIC dialect, added new instructions, and bolted a fresh interpreter and IDE on top. From version 2.0 (1986) it shipped with an integrated development environment: editor, debugger, and compiler in one screen, blue background, F-key menus, the lot.

The line went:

QuickBASIC 4.5 was the last QuickBASIC.

QBasic (1991)

In MS-DOS 5.0, released June 1991, Microsoft replaced the bundled GW-BASIC with QBasic, the third bundled BASIC in the DOS lineage and the one most people of a certain age first learned to program in. QBasic was, technically, a re-engineering of QuickBASIC 4.5 with the compiler back-end removed. Concretely, the things that came out of QB 4.5 to make QBasic were:

• The compiler. QBasic could not produce a standalone .exe. Programs ran inside the QBasic environment or not at all.
• Separately compiled program modules. QB 4.5 supported multi-module programs with $INCLUDE and separate compilation; QBasic was single-source-file only.
• The link to external libraries. No Declare-ing into compiled .lib or .qlb libraries. The runtime was self-contained.
• The full extended math library. Some of the more specialised numeric and string routines from QB 4.5 were stripped out to reduce footprint.
• The professional-edition extras. ISAM database support and the third-party-library hooks from BASIC PDS 7.x did not make it into the bundled product.

What QBasic kept was the part that mattered for an entry-level user: the integrated environment. Full-screen editor, syntax highlighting, the on-screen help system that included a worked example for every statement and function in the language, the in-place debugger with single-step and watchpoints, the F1-on-any-keyword help. That on-line help system is the part QBasic veterans most often remember; it was, in 1991, an unusually well-built piece of educational tooling.

The most-cited piece of code that shipped in the QBasic era was not Microsoft's. GORILLA.BAS and NIBBLES.BAS, the gorilla-throwing-bananas game and the snake game, both written by Microsoft as sample programs and bundled in the DOS distribution, were the first programs millions of users opened, ran, and then started reading the source of. The two files together did more for BASIC literacy in the 1990s than any deliberate Microsoft education effort.

Microsoft kept shipping QBasic in the box for nearly a decade after MS-DOS 5.0. It appeared in MS-DOS 6.0 (1993), 6.2 (1993), 6.21 (1994), and 6.22 (1994), and continued to ship as part of the bundled MS-DOS subsystem in Windows 95, Windows 98, and Windows ME. The last consumer Windows in which it appeared was Windows ME in September 2000. The reason Microsoft kept shipping it that long is mostly inertia (the DOS subsystem was there anyway and QBasic added almost no install footprint), but partly customer pressure: every removal threat brought letters from teachers, hobbyist programmers, and people who had built small in-house tools in QBasic and did not want to port them. It outlasted GW-BASIC by a decade, outlasted QuickBASIC itself by twelve years, and ended up shipping in the box on perhaps half a billion PCs.

For most of a generation of would-be programmers, QBasic was "BASIC." The Kemeny and Kurtz vision of universal computing access (computing for the masses, as Kurtz put it on tape decades later, the framing covered in the previous section) was, by the early nineties, more or less realised. Every consumer PC sold in the mid-nineties shipped with a working programming environment in the box, free, with a full help system and a working debugger. Microsoft was the channel through which the vision was delivered, twenty-seven years after Dartmouth's first run. The bill, in the end, came back to Microsoft as Windows licence revenue and as the per-machine fees Microsoft collected from every PC vendor that pre-installed DOS or Windows. Computing for the masses turned out to be a profitable business.

Why the dynasty mattered when "Visual Basic" arrived

That family (Altair to GW-BASIC to QuickBASIC to BASIC PDS to QBasic) is the DOS lineage. When Microsoft eventually shipped Visual Basic 1.0 for MS-DOS in September 1992, it descended directly from this branch, not from the Cooper and Tripod work that produced VB/Windows. Two products, same name, different ancestors.

Three things follow from the dynasty's shape, all of which shape what Microsoft did next:

1. By 1990, Microsoft had been the dominant commercial supplier of BASIC interpreters and compilers for fifteen years. Not the inventor, the seller. "Microsoft BASIC" had genuine brand equity nobody at the company was prepared to throw away.
2. The DOS BASIC business had real customers and real revenue. Whatever Microsoft did with the new Windows-based product, abandoning the existing line was not on the table, and the Open Letter–era posture made that decision a financial one as much as a technical one.
3. The "Basic" in "Visual Basic" was therefore non-negotiable. It was the part of the name that already meant something to the customer base. The "Visual" was the new claim.

The pattern that started here

Altair BASIC is also the first instance of a pattern Microsoft would repeat for the next twenty years. The interpreter Gates and Allen wrote was a port of an existing commercial dialect (DEC BASIC-PLUS). What Microsoft contributed was not the language. It was the licensing model, the willingness to fight piracy publicly, and the discipline to scale a single port across every microcomputer the industry shipped between 1975 and 1981.

That same pattern (acquire or license the innovation, refine the commercial machinery, scale through distribution) runs straight through Microsoft's history. MS-DOS in 1980 was 86-DOS, bought from Tim Paterson at Seattle Computer Products for $50,000. Word's WYSIWYG framing came with Charles Simonyi when he was hired from Xerox PARC. The form designer that became the Visual in Visual Basic was Alan Cooper's Tripod, bought by Bill Gates personally in 1988, the subject of the next section.

Gates and Allen had real technical skill. Gates wrote chunks of Altair BASIC by hand to fit the memory. Allen's 8080-emulator-on-PDP-10 was an actual engineering achievement. But their disproportionate contribution to Microsoft's success was business: recognising opportunities, accessing the capital and the contacts the Gates family already had at the level of Seattle law and national-board governance, winning licensing fights (Pertec in 1977) with discipline most engineering shops never built, and refining the per-machine royalty model that made the BASIC dynasty profitable enough to fund everything that followed. They were entrepreneurs first, coders second.

That is not a criticism. Building the commercial machinery for software-as-a-product was a genuine and consequential contribution. It is also not the same thing as inventing what they sold.

The next section picks up the parallel track: what was happening outside Microsoft while all this BASIC iteration was going on, and the California developer whose drag-and-drop shell would become the Visual in Visual Basic.

Sources

• Wikipedia, Altair BASIC
• Wikipedia, Microsoft BASIC
• Wikipedia, QuickBASIC
• Wikipedia, QBasic
• Wikipedia, An Open Letter to Hobbyists
• Wikipedia, Marc McDonald
• Wikipedia, Ric Weiland
• Wikipedia, Micro Instrumentation and Telemetry Systems
• Microsoft Open Source Blog, Microsoft Releases Historic 6502 BASIC
• Microsoft Learn, The History of Microsoft - 1975
• The Register, Bill Gates on the creation of Altair BASIC 50 years ago
• The New Stack, 50 years ago, a young Bill Gates took on the 'software pirates'
• emsps.com, Microsoft BASIC version information