Two dates, one year apart

September 3, 2025. Microsoft put the source of its 6502 BASIC, version 1.1, on GitHub under the MIT licence. That is the interpreter that greeted you when you switched on a PET, a VIC-20 or a C64, and the one that reached the Apple II as Applesoft. September 3, 2026. d/BASIC opens its doors: a new BASIC whose core vocabulary, RND sequence and operator precedence are copied from that release, whose structure comes from QuickBASIC, and whose target is every machine at once. Read the lineage ↓

89 / 96of the listings from David Ahl's 1978 BASIC Computer Games compile in this browser without a single edit

1compiled program file, .dbc, that means the same thing on every machine that runs it

121intents, named requests such as "fill this rectangle", that the browser runtime knows how to carry out

0PEEKs, POKEs, magic memory addresses, or one-machine dialects

Three doors, one language

I learned on a C64, an Atari, an Apple II Paste in a magazine listing. Line numbers, GOSUB, DATA and INPUT are not old-fashioned here; they are how the language greets you. Ninety-six games from 1978, exactly as typed, every one compiled by the real compiler, most of them playable in the console. Bring a listing forward → I am learning to program, or teaching it PRINT prints. IF chooses. FOR repeats. Your first useful program is one line, and the same language grows into procedures, records, classes and windows without ever switching to a different dialect. Start the tutorial → I build applications Windows that know when they open, draw and close, a widget library written in d/BASIC itself, a safe vocabulary for storing data, drag and drop, a library for 2D games, and one compiled file you ship everywhere. d/Works, the office suite, is being written in this language. Open a window →

The idea in one screen

10 PRINT "HELLO FROM THE SAME OLD FUTURE"

DIM Names$(1 TO 3)
ARRAYFILL Names$(), "READY"

FOR I% = LBOUND(Names$) TO UBOUND(Names$)
  PRINT I%; Names$(I%)
NEXT I%

That is recognizably BASIC. A numbered line and a structured loop in the same file, a $ suffix beside a modern whole-array command. The unusual part happens after the source leaves your editor:

.bas source → parse + type → optimize + lower → validate → .dbc bytecode → browser · macOS · Windows · Linux · d/OS

There is one language and one compiled program file, .dbc, with one set of promises behind it. Each machine chooses how to supply graphics, sound, storage and the rest; it does not get to invent a private dialect. That is the property the whole design exists for: write the program once, and the same bytes mean the same thing on a WebGL canvas and in a desktop window today, and the 6502 with a cartridge that carries a modern processor into the 8-bit machine is the target those promises were designed around (what has and has not run). d/OS, at the end of that pipeline, is the operating system that brings modern software to 8-bit home computers such as the Atari 800, the Commodore 64 and the Apple II.

Why d/BASIC exists

BASIC should still feel immediate

Your first useful program is still one line. Line numbers are still legal. GOTO is still spelled GOTO. Bring your old habits with you, then add named labels, procedures, records and classes when a program grows enough to want them.

10 PRINT "HELLO"

Portability should be architectural, not hopeful

Classic programs hid the shape of one particular machine inside PEEK, POKE and each vendor's graphics commands. d/BASIC replaces those escape hatches with Intents and Services. An intent is a named request such as "fill this rectangle" or "set my window title"; the machine carries it out however it can, with a GPU, a compositor, or a tiny route on a small device.

INTENT GFX.FILL_RECT(0, 0, 320, 192, 2081)

Small computers deserve modern structure

TYPE is the QuickBASIC record, bit for bit. CLASS adds identity, inheritance, virtual methods, properties and a predictable lifetime: objects are reference counted, so there are no garbage-collector pauses. CLASS is a developer preview. It runs here and in the desktop runtime, but whether it is ready for shipping products is still an open question. The d/Works widget library is itself written in d/BASIC.

DIM Save AS WorksButton
Save = NEW WorksButton("save", "Save")

Optimization should preserve meaning

The compiler stores each constant once, batches floating-point arithmetic, and turns whole-array work into single instructions. The optimized .dbc still describes one program; the runtime, the program that runs your compiled code, picks the fastest local route without changing the answer.

ARRAYSWAP Front%(), Back%()   ' O(1), nothing copied

Failure should tell the truth

Ask for something the machine cannot do and d/BASIC stops and tells you exactly what is missing, at the line, with an error code. It never fakes success and never quietly runs something slightly different. Learning to read one of these messages is part of learning the language.

78_Sine_Wave.bas:4 DB0031
no SUB or FUNCTION named 'REMARKABLE'

Line 4 is the fourth line of the file, the one numbered 40; the compiler counts lines of source, not line numbers.

The machine should stay honest, too

No raw pointers, no loading of unverified code, no numbers that quietly differ from one machine to the next: PRINT 1/3 matches QuickBASIC everywhere, and RND is Microsoft's own sequence, same seed, same numbers, on every machine.

PRINT RND(1)   ' .1840745 on every machine

From the teletype to the dock

• 1964 · Dartmouth, 4 a.m., May 1. John Kemeny and Thomas Kurtz's BASIC runs its first programs on the college time-sharing system.¹ Fourteen statements, nine functions, and a radical premise: computing should not belong only to specialists.
• 1975 · The Altair. Bill Gates, Paul Allen and Monte Davidoff write a BASIC for a machine they do not own. It becomes Microsoft's first product.² The same year Edsger Dijkstra writes that students with a prior exposure to BASIC are, as potential programmers, "mentally mutilated beyond hope of regeneration."³ We regenerated.
• 1977 · The 6502. Microsoft's 6502 BASIC ships in the Commodore PET and becomes the welcome mat of the home computer. It carries on into the VIC-20 and the Commodore 64, and, licensed by Apple in July 1977 and sold as Applesoft, into the Apple II Plus in place of Wozniak's Integer BASIC.⁴ Turn the machine on and a prompt is waiting before any application has loaded.
• 1978 · The book. David Ahl's BASIC Computer Games collects 101 type-in games; by 1979 it is the first computer book to sell a million copies.⁵ Ninety-six of its programs, as transcribed and dedicated to the public domain by the coding-horror/basic-computer-games project, are on this site exactly as typed, and they are the programs d/BASIC tests itself against.
• 1988 · QuickBASIC 4.5. The last and best-loved release of a line that had by then added named SUB and FUNCTION procedures, SELECT CASE (3.0, 1987) and TYPE records (4.0, 1987), inside an editor that made large programs reasonable.⁶ d/BASIC's structure, precedence, BYREF default and SINGLE default are QuickBASIC's, kept on purpose.
• 1991 · QBasic and Visual Basic. One ships free with MS-DOS 5 and teaches another generation; the other shows that approachable syntax can build real graphical applications, and, by Visual Basic 4 in 1995, object-shaped ones.⁷
• 2004 · 2007 · The keepers of the flame. FreeBASIC and QB64 keep the dialect alive on modern operating systems.⁸ d/BASIC adopts, clean-room, the member syntax FreeBASIC put inside TYPE, CONSTRUCTOR, DESTRUCTOR, PROPERTY, EXTENDS, VIRTUAL, ABSTRACT and OVERRIDE, and places it inside a VB-style CLASS, a keyword FreeBASIC does not have. Wherever d/BASIC differs from them, the difference is written down case by case, with their documentation cited, in d/BASIC's compatibility table; neither compiler is part of the build.
• 2025 · September 3. Microsoft releases the source of Microsoft BASIC for 6502, version 1.1, under the MIT licence.⁹ The core of the home-computer era is, at last, free to build on.
• 2026 · August 27. d/BASIC first light: 10 PRINT "HELLO" runs through the real toolchain, the count we made of the 96 classic listings settles the design, and the language gets its name. The same day the compiler front end, the desktop runtime, a second and smaller runtime for the 6502 and a test suite that really runs are all in the tree; the optimizer follows within days.
• 2026 · September 3. This site. One year, to the day.

The retro roots stay visible; the machine-specific cage does not. d/BASIC is not a museum piece and not a nostalgia skin over JavaScript. It is a new implementation with a specification, a test suite that runs every case, a compiled file format that gives the same answer every time, and a licence-clean family tree.

What runs today, and what does not yet

d/BASIC is in alpha, and this site publishes what runs, not what is planned. Every number above was measured on the compiler and runtime you are about to use.

Built and running	Where
Compiler, optimizer, validator, and the compiled program file, .dbc	this browser, macOS (the dbasic command line)
Console programs with interactive INPUT, window programs, keyboard and pointer events	this browser, a native macOS window
d/Works widgets, GX (the 2D game library), database intents, copy and paste, drag and drop	this browser, macOS
A test suite that runs every case to the end: 129 named tests plus the 96 classic listings	the repository, every build
A second, independent runtime written for the 6502, whose output is compared byte for byte with the first: 219 of 224 test cases identical, zero disagreements	desktop builds, checked on every change

Designed, not yet running on real hardware	Where it stands
The 6502 runtime on a real Atari, C64 or Apple II	specified and built as a second runtime; its 6502 build has been measured and is too big to fit (183,662 bytes of code against a 65,008-byte address space); nothing has run on a 6502 yet
d/OS integration: launching from the dock, packaging and signing	designed; the package format and the launch checks are specified
FILE in the browser	the eight FILE commands are registered and wired into the runtime, but this playground has no file provider (the part of the host that supplies files), so they stop and say exactly that
Networking, audio and named-media intents	described in the guide; not yet in the official list of intents
Windows and Linux	macOS is the only desktop build measured so far; Windows and Linux builds and native window kits are next
Console INPUT on the 6502 runtime	the browser and desktop runtimes pause on a question and wait for you; the 6502 runtime still answers only from a prepared script

When something above is missing, the program stops and says exactly what it needed, the same way on every machine. It does not pretend.

Made for d/OS, useful everywhere

d/BASIC is the house language of d/OS, the operating system that brings modern software to 8-bit home computers such as the Atari 800, the Commodore 64 and the Apple II, and to small boards with a WebGL display. On a 6502 it arrives on a cartridge that carries a modern processor into the machine, and on every machine it treats the screen as one composed picture. A d/BASIC program is a full d/OS application: an entry in the catalog, an icon, a window, menus, and the same .dbc on every product. d/Works, the office suite (d/Write, d/Calc, d/Present), is being written in d/BASIC on shared libraries, because a language that cannot carry an office suite has no business calling itself a systems language.

You do not need d/OS to use d/BASIC. You need a browser.

Learn it in human order

The guide is a course, not a wall of keywords. Twenty-seven short chapters, and every code block is one click from running.

Foundations

1. Make something run
2. Choose a program shape
3. Learn the nouns
4. Own the storage
5. Work with text
6. Calculate meaning
7. Give it a plot
8. Give ideas names
9. Work in collections
10. Model a world
11. Talk to the console
12. Handle trouble honestly

Applications

13. Work with files
14. Store durable meaning
15. Open a window
16. Build an interface
17. Give it sights and sounds
18. Make a little world
19. Reach beyond the machine
20. Ask the world
21. Move real objects

Reuse and delivery

22. Share good code
23. Think like the compiler
24. Outgrow 64 KiB
25. Ship the artifact
26. Bring a listing forward
27. Find the spelling

The whole guide, with summaries →

The five ideas worth remembering

1. Line numbers are welcome, not required. Named labels and structured blocks live in the same source file.
2. A numeric name without a type is SINGLE. Use a suffix, AS, or DEFINT A-Z when you mean an integer.
3. Parameters are BYREF by default. Write BYVAL when the procedure you call should get a copy it cannot use to change your variable.
4. TYPE copies; CLASS shares. Two records are two values; two variables holding one object point at the same thing. This one distinction explains most record and object behavior.
5. Programs say what they want; each machine supplies it however it can. That is how one program crosses very different machines.

Ready?

Run a 1978 listingBUNNY, from Ahl's BASIC Computer Games, unmodified, in the real compiler. Write your first programOne line, then a window, then a widget. Read the FAQLicences, compatibility, d/OS, and what is next.

---

1. Dartmouth College, BASIC at 50: "BASIC at Dartmouth". ↩

2. Altair BASIC; the MITS licence was signed on 22 July 1975. ↩

3. E. W. Dijkstra, EWD498, "How do we tell truths that might hurt?", 18 June 1975. ↩

4. Microsoft Open Source Blog, Microsoft Releases Historic 6502 BASIC; Applesoft BASIC; Integer BASIC. ↩

5. BASIC Computer Games; the transcriptions are coding-horror/basic-computer-games. ↩

6. QuickBASIC; 4.5 shipped 21 October 1988. ↩

7. QBasic, with MS-DOS 5.0 in 1991; Visual Basic (classic), 1.0 in May 1991. ↩

8. FreeBASIC (2004) and QB64 (first release 8 September 2007); FreeBASIC's object model is Type … Extends. ↩

9. microsoft/BASIC-M6502, released under the MIT licence on 3 September 2025. ↩