Ask a room of Commodore owners what the C128 actually was for, and the honest ones will eventually say: typing in programs. The C64’s BASIC 2.0 was already a period piece in 1982 — a fine interpreter with almost no commands for the machine’s own hardware, so that using sprites, sound or the disk drive meant a catechism of PEEKs and POKEs memorised from magazines. The Commodore 128 answered with BASIC 7.0, and the answer was total. Well over a hundred new keywords, structured programming, graphics and sound as first-class citizens, a proper disk dialect, a built-in machine-language monitor — even a sprite editor, living in ROM. It is, command for command and idea for idea, the best BASIC Commodore ever shipped, and it is not close.
The lineage explains the generosity. BASIC 7.0 descends from the Plus/4’s BASIC 3.5, which had already added graphics and sound commands to the family, crossbred with the business machines’ BASIC 4.0 disk dialect, and then extended by Fred Bowen and Terry Ryan’s system team with everything the new hardware implied. The result is a language that reads like a checklist of every complaint ever filed against BASIC 2.0, each one crossed out in ROM.
Graphics and sound without a single POKE
Start with the showpiece commands. DRAW, BOX, CIRCLE, PAINT and CHAR put the VIC-II’s bitmap and text screens under plain English; SSHAPE and GSHAPE capture regions of the screen as data and stamp them back; SPRITE, MOVSPR and COLLISION manage the hardware sprites that on a C64 required a page of register arithmetic; SCALE and WIDTH handle the geometry. Sound is a parallel revelation: SOUND for raw voices, ENVELOPE to shape them, PLAY to perform actual musical strings — notes, octaves, tempo under TEMPO, volume under VOL — so that a type-in listing could carry a recognisable tune in a dozen lines. FILTER reaches the SID’s signature circuitry by name. A generation of C64 programmers had done all of this through 53248 and prayer; the 128 simply named things.
Then there is the structure. BASIC 7.0 has DO…LOOP with WHILE and UNTIL conditions, WHILE…WEND, IF…THEN…ELSE, and BEGIN…BEND blocks — real control flow that let listings be written, and taught, as structured programs rather than GOTO spaghetti. Add PRINT USING for formatted output, INSTR for string searching, a proper HELP command that flags the line where an error occurred, RENUMBER and DELETE for program maintenance, TRON and TROFF for tracing execution, and the built-in MONITOR — entered by typing MONITOR — which gives you a machine-code assembler, disassembler and debugger in ROM. The 128 didn’t just ship with a better language; it shipped with a development environment.
The disk drive, civilised
Nowhere is the generational jump clearer than at the disk drive. On the C64, reading a directory overwrote your program; saving meant LOAD”*”,8,1 liturgy and device-number arithmetic for every operation. BASIC 7.0 speaks disk natively: DLOAD and DSAVE with defaults, DIRECTORY to list a disk to the screen without touching memory, COLLECT to clean up splat files, BACKUP and COPY for whole disks and files, CONCAT, RENAME, SCRATCH, HEADER to format, and a DS$ variable that tells you what the drive is unhappy about in words. The 128 also auto-boots from disk — put a boot disk in the drive and switch on — a feature so basic on other platforms that its absence on earlier Commodores had become a joke, and its arrival here is BASIC 7.0’s philosophy in miniature: the machine should meet the user halfway.
On the C64 you programmed the hardware despite BASIC. On the 128, BASIC 7.0 was the hardware’s user interface — sprites, SID, disk and all.
Honesty requires the footnote every C128 programmer knows: BASIC 7.0 could be slow. The interpreter is more than twice the size of BASIC 2.0 — some 28K of ROM — and it must bank-switch to reach program text and variables stored in separate memory, so a plain interpreted program often runs slower than its C64 equivalent. The remedy is in the language too: the FAST command doubles the 8502’s clock to 2 MHz (with the 40-column screen blanked or the 80-column VDC display used, since the VIC-II cannot run at that speed), and SLOW returns it. With FAST engaged, 7.0’s structured programs pull away from anything the 64 could interpret. The easter egg buried in the ROM — SYS 32800,123,45,6, which displays the development team’s credits under the motto “Link arms, don’t make them” — feels earned: this was software made by people who loved the form.
The sprite editor in the attic
The most delightful corner of BASIC 7.0 is the one manuals mention last: SPRDEF, the built-in sprite designer. Type it and the ROM swaps the programming screen for a character-grid workshop where you draw a sprite pixel by pixel with the keyboard, watch it animate, and save the result directly into your program’s data. Nothing like it shipped in the C64’s ROM — sprite design there meant graph paper, arithmetic, and magazines full of DATA statements to copy by eye. On the 128 it is a utility the machine simply has, like the MONITOR and the HELP key. Add the function keys, user-definable and waiting on the keyboard’s top row; the WINDOW command for carving text regions out of the screen; STASH and FETCH for moving data between the computer and its expansion memory; and the sound of all these small mercies accumulates into a philosophy: the computer should arrive complete. The 128’s ROM is the fullest expression of that philosophy Commodore ever funded, a machine that walked out of the shop with its toolbox already inside.
It is worth noting who that toolbox served. The type-in culture of COMPUTE! and Run magazine peaked alongside the 128, and BASIC 7.0 listings filled their pages — programs that used DRAW and PLAY and DLOAD as naturally as breathing, unreadable on a 64, effortless on their intended machine. The dialect had a literature. It just had a shorter newsstand life than it deserved.
The teaching machine
There is an educational legacy here that deserves the emphasis. For the cohort who learned programming on a 128 — and they were numerous, because the machine was marketed to families as the serious step up — BASIC 7.0 was not merely a nicer dialect. It was the difference between learning programming and learning incantations. A ten-year-old could draw a circle, give it a colour, make the machine sing a scale, save the result with DLOAD’s plain English, and — crucially — reach the interesting parts before the POKE tables defeated them. The structured commands then taught the habits that transferred: loops with conditions, branching with ELSE, programs as architecture rather than as a treasure map of line numbers. Many of those children became the programmers who built the demo scene, the utilities and eventually this era’s retro tools. The dialect’s fingerprints are on the culture long after the listings stopped. Commodore built many machines that entertained people. With BASIC 7.0, it built one that taught them.
Why it still matters
BASIC 7.0 arrived at the end of the type-in era, as the magazines that would have taught it were turning to games coverage and the 16-bit machines were redrawing expectations. It never got the decade of listings culture that made BASIC 2.0 a shared language of millions. But as a piece of design it stands: a complete, coherent, hardware-fluent dialect that treated beginners as future programmers and gave them the whole machine. The MEGA65’s BASIC 65 descends from its unfinished successor, BASIC 10 — the line runs 2.0, 3.5, 7.0, and into the present. Type RUN on a 128 today and you are using the best tool Commodore ever gave its users. They knew it, too. They signed it in the ROM.