Frequently asked questions

This page answers the questions people ask first about d/BASIC: what it is, whether an old listing will run, where it runs today, what is not finished yet, and who is behind it. Read it top to bottom in ten minutes, or jump to the question you came with.

What is d/BASIC, in one sentence?

d/BASIC is the BASIC that QuickBASIC grew up into: QuickBASIC's structure, Visual Basic-style classes, the same answers on every machine, all compiled to one portable program file, .dbc, that means the same thing wherever it runs. It 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 it runs, today, in your browser.

Is it QuickBASIC?

At its core, deliberately yes. Names ignore case, and the suffix ($, %) is part of the name's type. A number with no declared type is SINGLE. Parameters are passed BYREF by default, so a procedure can change the caller's variable, and CALL F((X)) passes a copy instead. -2 ^ 2 is -4. True is -1. TYPE is a value record, bit for bit. Those are the rules a transferred program depends on, so they are kept on purpose and checked by a test suite that really runs every case. What d/BASIC adds, CLASS, WINDOW SUB for window programs, INTENT and SERVICE, ARRAYCOPY/ARRAYFILL/ARRAYSWAP, ON REFUSAL, lives in the same grammar. There is no "classic mode" and no "modern mode". See Compatibility, Migration & Refusals.

Will my 1980s listing run?

Line numbers, GOTO, GOSUB, DATA/READ/RESTORE, ON … GOTO, DEF FN and TAB( all work, unchanged. The proof is on the Classic Listings page: 89 of the 96 games in the public-domain transcription of David Ahl's BASIC Computer Games compile without a single edit, Super Star Trek included. The seven that do not each stop at a named line with an error code. Three of those are the listing's own history: a REMARKABLE that 1970s interpreters quietly read as REM, a GOTO to a line that does not exist, and a PRINT list that relied on the interpreter guessing. Four are d/BASIC being stricter than the interpreter they were typed for: a FOR whose NEXT is reached by GOTO, a NEXT inside a single-line IF … THEN, and a listing that uses THIS as a variable name. Each one is named on the Classic Listings page with its line and error code.

What will not run is direct access to the machine: PEEK, POKE, WAIT, USR, SYS, CALL with an address, VARPTR, DEF SEG. d/BASIC won't run those and says why, permanently, because a program that writes to $D400 means something on one machine and nothing on the next. The count we made of the 96 classic listings, which settled the design, found that 96 of 96 of them need none of those commands.

Why stop instead of emulating?

Because one compiled file has to mean one thing on machines that share no memory map. Emulating a C64's hardware registers inside a program that also has to run on an Apple II, in a browser and on a desktop would turn the language into a museum of machines rather than a language. d/BASIC replaces those escape hatches with intents, named requests such as "fill this rectangle", "show this frame" or "open this file", and lets each machine carry them out honestly in its own way. Read Intents & Services.

Can I play the classic games, or is it just PRINT?

You can play them. When a program reaches INPUT or LINE INPUT, it pauses: the playground shows an answer row under the question, you type a reply and press Enter, and the program continues exactly where it stopped. 84 of the 89 listings that compile are conversations, and the Classic Listings page says, for each one, whether it plays to its natural end using the test suite's reviewed script of answers. A paused program runs no instructions and records the question once in its output log, so a game you play by hand and a game answered by script produce the same log.

Where do I download the compiler?

From the releases page: a universal macOS kit (Apple silicon and Intel), Linux x86-64 and Windows x86-64 kits, and the browser bundle (the compiler and runtime as WebAssembly with the playground page, for embedding in your own site). Each kit is a folder you can move anywhere, with the dbasic compiler and runtime, the d/Works widget library and the GX game library as source you can IMPORT, and the examples. Console programs and window programs run on all three desktops (the window layer is cross-platform Rust: winit and wgpu). Drag and drop and the pasteboard between d/BASIC and other applications are macOS-only for now, and INPUT from the terminal is still to come on Windows. The browser playground remains the quickest way to try d/BASIC. The kits are pre-release.

What is a .dbc?

d/BASIC Compiled: the compiled program file. It is a checked, versioned bytecode image with 32-bit lengths (so no 64 KiB wall), a table saying whether the program is a console program or a window program, a list of what the program requires that is checked before its first instruction runs, and the exact identity of any shared library it depends on. The same file runs on the browser runtime, the desktop runtime, and the runtime designed for d/OS. See Bytecode & Cross-Platform Delivery.

Does it run on a real Atari, C64 or Apple II today?

Not yet, and this site will not tell you otherwise. The 6502 runtime is designed and specified, and a second, smaller runtime written for the 6502, the processor in the Atari 800, the Commodore 64 and the Apple II, already exists: on every build its output is compared byte for byte with the desktop runtime's (see What Runs Today for the current count). Its first 6502 build has been measured and is too big to fit, 183,662 bytes of code against a 65,008-byte address space, so the next step is a hand-written 6502 interpreter, with the cartridge that carries a modern processor into the machine doing the maths. Nothing has run on a 6502 yet. When it does, it will be on this site with the measurements. See What Runs Today.

What is d/OS?

d/OS ("dock OS") is an operating system for the machines people already love: 8-bit computers with a cartridge carrying a modern processor, and small boards with their own displays. Every screen is one composed picture, every application is a proper window with an entry in the catalog, and d/BASIC is its house language. d/Works, the office suite (d/Write, d/Calc, d/Present), is being written in d/BASIC. d/OS will have its own site; until then this one is the front door.

Is this FastBasic?

No. FastBasic is Daniel Serpell's excellent BASIC for the Atari 8-bit line and remains its own project. d/BASIC is a separate, new implementation with a different lineage and a different goal: one compiled file across every machine, with a specification and a test suite that really runs behind it.

What about Windows and Linux?

They are first-class desktops. The compiler, the runtime and the native window host are portable Rust, and the window layer is the cross-platform winit and wgpu, so console programs and window programs both run on Linux and Windows with a display. The Linux and Windows kits are on the releases page beside the macOS one. What is still macOS-only is narrower than a platform: copy/paste and drag and drop with other applications, and, on Windows only, INPUT from the terminal. The browser version is the same on all three.

How do objects work, and are they finished?

TYPE stays the QuickBASIC value record forever. CLASS is the reference type: constructors, destructors, properties, single inheritance with EXTENDS, VIRTUAL/ABSTRACT/OVERRIDE, THIS, and a predictable lifetime, because objects are reference counted instead of garbage collected, so there are no pauses. The object model is a developer preview: it runs in the playground and the desktop runtime, but whether it is ready for shipping products is still an open question. Records & Objects has the details.

How do I share a program?

Press Copy share link in the playground. The link carries your whole program in the part of the URL after the # (#code=<base64url>), which never leaves the browser, and &run=1 runs it on arrival. Every code block on this site carries the same kind of link, and the listings hosted on the site use #src=/listings/NAME.bas. Use the download button to save a .bas file.

How is this different from QB64, QBJS or FreeBASIC?

They are native compilers or JavaScript translators for the QBasic dialect, and they are good at that. d/BASIC compiles to a portable program file that gives the same answer everywhere, and ships a test suite that holds every runtime to the same output. It won't run machine tricks and says why, rather than emulating any one machine. And it adds a layer of named capabilities (intents, services, database, widgets, GX, the 2D game library) so one program can be a real application on very different machines. One concrete difference you will feel in the first minute: QBJS, the best-known QBasic in a browser, documents that it does not support GOTO or GOSUB, a reasonable choice for a JavaScript translator. In d/BASIC, line numbers, GOTO and GOSUB are permanent language features, not a compatibility mode, and the test results are public: 89 of the 96 listings compile with no edit, and the 7 that do not are named with line and error code. One deliberate line: a keyword glued to the end of a number (1TO3, 1ANDX) is read the 1978 way, because a name can never begin inside a number, but a name is never split (COUNTER is a name, not COUNT and ER). Credit where it is due: FreeBASIC's and QB64's documented behaviour is what d/BASIC's object and QuickBASIC tests are checked against, one named difference at a time.

What licences are involved?

d/BASIC's lineage is licence-clean by construction. Its core vocabulary, RND algorithm and operator precedence are copied from Microsoft BASIC for 6502, version 1.1, released by Microsoft under the MIT licence on 3 September 2025 (microsoft/BASIC-M6502). QuickBASIC's behaviour is followed by name, not by code. FreeBASIC's member syntax is adopted clean-room from its published documentation; no FreeBASIC or QB64 binary runs in d/BASIC's build, and nothing is copied from either. d/BASIC's gx library is house code: a clean-room d/BASIC port inspired by boxgaming's MIT-licensed GX project (Copyright (c) 2021 boxgaming), with no upstream source or assets bundled; the notice ships with the library. The 96 classic listings are public domain under the Unlicense, with attribution. The d/BASIC toolchain and runtimes are written to ship under the MIT licence.

Can a program or an agent drive the playground?

Yes. The playground registers a WebMCP tool, run_dbasic_source, on document.modelContext. An agent running in the browser can hand it complete d/BASIC source, and the playground compiles and runs it with the shipping compiler and returns the status, the console transcript, and every error with its code, line and column. An agent gets exactly the same messages a person gets.

How do I follow this, or ask a question?

d/BASIC is alpha, and the fastest way to change it is to tell us what broke. Write to support@kallinnovations.com. What lands next is published on What Runs Today, which is dated and changes only when the measurements change.

Who makes it?

Kall Innovations, the makers of d/OS. d/BASIC was designed in an adversarial panel on 27 August 2026 and ran its first program the same day; this site opened on 3 September 2026.