Frequently asked questions

What is d/BASIC, in one sentence?

d/BASIC is the BASIC that QuickBASIC grew up into: QuickBASIC structure, VB-style classes, modern determinism, compiled to one portable bytecode (.dbc) that means the same thing on every runner. It is the house language of d/OS and it runs, today, in your browser.

Is it QuickBASIC?

At its core, deliberately yes. Names are case-insensitive and the suffix is part of the type; an untyped numeric is SINGLE; parameters are BYREF by default and CALL F((X)) passes a value; -2 ^ 2 is -4; truth 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 proven by an executing conformance suite. What d/BASIC adds, CLASS, WINDOW SUB faces, 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, unmodified. 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, and the seven that do not are refused at a named line with a rule id. Three of those are the listing's own history: a REMARKABLE that 1970s interpreters silently crunched into REM, a GOTO to a line that does not exist, 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 rule id.

What will not run is machine access: PEEK, POKE, WAIT, USR, SYS, address-form CALL, VARPTR, DEF SEG. Those are refused by name, permanently, because a program that writes to $D400 means something on one machine and nothing on the next. The census that settled the design found that 96 of 96 of those listings need none of them.

Why refuse instead of emulating?

Because one bytecode has to mean one thing on machines that share no address map. Emulating a C64's 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 the exits with named Intents ("fill this rectangle", "present this frame", "open this file") and lets each host implement them honestly. 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 parks: 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 with the conformance suite's reviewed answer script. A parked program retires no instructions and records the question once in its trace, so an interactive run and a scripted run produce the same trace.

Where do I download the compiler?

There is no packaged developer kit to download yet. The browser playground is the official way to use d/BASIC today, and it is not a toy: it runs the real compiler and the real shared runtime compiled to WebAssembly, locally, with nothing uploaded. A macOS command-line kit (dbasic build, run, exec, trace) exists in the d/OS tree and is what the Getting Started chapter describes; a packaged download follows the alpha.

What is a .dbc?

d/BASIC Compiled: a validated, versioned bytecode image with u32 lengths (no 64 KiB wall), a face table for console and window programs, a requirements list the loader checks before the first instruction runs, and exact identities for any shared libraries it depends on. The same image 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, independently written floor runtime already exists: on every build its traces are byte-compared with the host runtime's (see What Runs Today for the current count). Its first 6502 image has been measured and refused by size, 183,662 bytes of code against a 65,008-byte address space, so the next rung is a hand-written 6502 interpreter, with the cartridge as the math coprocessor. Nothing has executed on a 6502 yet. When it does, it will be on this site with a receipt. 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 coprocessor, and small boards with their own display heads. Every screen is one composed picture, every application is a first-class window with a catalog entry, and d/BASIC is its house language. The d/Works 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 bytecode across every machine, with a specification and an executing conformance suite behind it.

What about Windows and Linux?

The toolchain is portable Rust with no macOS-only dependency in the compiler or the console runner, but macOS is the only host it has been built and measured on. Windows and Linux builds, and the native presentation kits, are next; the browser is already 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 deterministic lifetime with reference counting instead of a garbage collector, so there are no pauses. The object model is a developer preview: it runs in the playground and the host runtime, and its production admission on shipping products is still open. 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 URL fragment (#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 site-hosted listings use #src=/listings/NAME.bas. Use the download button to save a .bas.

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, deterministic bytecode and ships an executing conformance suite that holds every runner to the same trace; it refuses machine access by name rather than emulating any one machine; and it adds a semantic capability layer (Intents, Services, DATA, widgets, GX) so one program can be a real application on very different hosts. 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 receipt is public: 89 of the 96 listings compile with no edit, and the 7 that do not are named with line and rule id. 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 numeric literal, but an identifier 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 conformance cases are checked against, divergence by named divergence.

What licences are involved?

d/BASIC's lineage is licence-clean by construction. Its core vocabulary, RND algorithm and operator precedence are transcribed 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 nominatively. FreeBASIC's member syntax is adopted clean-room from its published documentation; no FreeBASIC or QB64 binary is executed in d/BASIC's build, and nothing is transcribed from either. d/BASIC's gx library is house code: a clean-room d/BASIC porting rung inspired by boxgaming's MIT-licensed GX project (Copyright (c) 2021 boxgaming), with no vendored upstream source or assets; 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. A browser-resident agent 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 diagnostic with its rule id, line and column. An agent gets exactly the refusals 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 moves only when a receipt moves.

Who makes it?

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