Commodore Basic V2

Commodore Basic V2 is the BASIC that Commodore built into its two big home computers of the early 1980s, the VIC-20 and the Commodore 64. On the VIC-20 the machine announced it plainly:

1
2
3
4

**** CBM BASIC V2 ****
3583 BYTES FREE

READY.

It is a small language even by the standards of its day. It has no keywords for colour, graphics, sound, joysticks or disk management, no ELSE, and no tools for renumbering or tracing a program. What it did have was size and sameness: the whole interpreter fits in 8 KB of ROM, and the VIC-20 and C64 versions accept exactly the same keywords.

The encyclopedia lists the C64’s ROM separately as Commodore 64 BASIC (V2), and that page covers the C64 in detail. This page treats V2 as a dialect shared between machines: where the name comes from, how it started on the VIC-20, and what actually changed when it moved to the C64. The wider family is covered under CBM BASIC and Commodore 8-bit Basic.

What “V2” refers to

Three different things are called version 2 in Commodore’s BASIC history, and they are easy to confuse.

The first row is the namesake. Commodore’s own version history, kept as a comment at the top of its BASIC source, dates version 2 to August 1978 and says it “fixed many bugs”, among them arrays limited to 255 elements and string garbage collection. The notes that accompany Michael Steil’s cbmsrc source archive say Microsoft built this version itself and called it 1.1. In a 2008 article Steil wrote that Commodore began shipping it as update ROMs for existing PETs in 1979. It never printed “V2” on the screen.

The second and third rows are the subject of this page. They are the only Commodore BASICs that sign on as V2, and they are nearly the same program.

The year

The master list this page was created from gives 1982, which is the year of the Commodore 64. The dialect is older than that. The change notes in the VIC-20 source begin in August 1980, the VIC-20 was sold in the United States during 1981, and its 1981 manual already prints the CBM BASIC V2 banner. This page therefore uses 1980, the year the machine was announced and, according to Commodore’s press release, was due to go on sale in Japan as the VIC 1001. One caution: the VIC-20 source that survives includes a fix dated March 1981, so it is later than the first Japanese units, and none of the sources consulted here shows what those first units displayed at power-up.

History & Origins

A Microsoft core

Every Commodore 8-bit BASIC descends from Microsoft’s BASIC for the MOS 6502, which Commodore licensed for the PET, in October 1976 according to Michael Steil’s history of the interpreter. BYTE’s May 1981 review of the VIC-20 described the result in one sentence: “VIC BASIC is a version of Microsoft BASIC modified by Commodore.” Microsoft is not named in the VIC-20 or C64 BASIC source. The VIC-20 header reads “COPYRIGHT (C) 1981 BY COMMODORE BUSINESS MACHINES”.

Vixen

Commodore announced the VIC 20 in a press release dated 30 September 1980. Among the listed features was “standard PETBASIC”. The release said the machine had been introduced in Tokyo in mid-September as the VIC 1001, would go on sale in Japan in October, and would reach the United States in the first quarter of 1981.

The BASIC source for the VIC-20 (ROM 901486-01) is in the cbmsrc archive. Its comments use the project’s code name: the ROM location is labelled “VIXEN ROM” and the 22-column setting “VIXEN SCREEN SIZE”. The change notes at the end of the files are signed with three initials:

• RSR 8/10/80: “CHANGE SYS COMMAND”
• RSR 8/26/80: “ADD OPEN&CLOSE MEMSIZ DETECT”
• RSR 10/7/80: “CHANGE LOAD (REMOVE RUN WAIT)”
• RSR 3/06/81: “FIX PROGRAM LOAD FOR OFFSET PROGRAMS”

RSR is most likely Robert Russell, who is generally credited with porting the KERNAL and BASIC to the VIC-20, but the listing never spells the name out.

The header of the same source is dated “06 MARCH 1980” while carrying a 1981 copyright and the note dated 6 March 1981. The year in the listing date looks like a slip, although the source does not say so.

Why a small BASIC

By 1980 Commodore already had BASIC 4.0 on its PET and CBM business machines, with disk commands in the language. The VIC-20 did not get it. The machine shipped with about 5 KB of RAM and was meant to be cheap, and V2 fits in a single 8 KB ROM.

BYTE’s reviewer, Gregg Williams, saw the lack of new keywords as a deliberate advantage. Colour, graphics and sound were all reached through control characters and POKE, so “VIC programs are syntactically equivalent to PET programs”, and programs could be moved between the machines “without syntax errors due to unrecognized keywords”. He added that Commodore had probably developed VIC BASIC faster and more cheaply because of its similarity to PET BASIC.

Not a port of PET BASIC 2

The obvious reading of the name is that Commodore took the PET’s version 2 and moved it to the VIC-20. Michael Steil, who reconstructed the early Microsoft 6502 BASICs from a common source tree, argued otherwise in 2008: “the BASIC V2 used on the VIC-20 and the C64 is actually a stripped-down version of PET BASIC 4.0 and not a ported version of PET BASIC V2”. In a follow-up article he described it as the 4.0 source “with all post-2.0 features stripped out again for space reasons”, and pointed to two inherited details: it ends lines with a carriage return alone, and it asks the KERNAL for the memory size instead of testing memory itself.

Commodore’s source supports the first of those details directly. The routine that ends a printed line sends a carriage return and then a line feed in the PET version 2 code. In the VIC-20 code it sends the carriage return and then checks the output channel, as the BASIC 4 listing of July 1979 does.

What was stripped out included BASIC 4’s rewritten string garbage collector. The collector in the VIC-20 source matches the older PET version 2 routine, while the BASIC 4 listing keeps its newer collector in a separate file. This is the origin of the long pauses that V2 programs suffer when they create many strings.

From the VIC-20 to the Commodore 64

The Commodore 64 was developed under the code name VIC-40, and its BASIC (ROM 901226-01) is the VIC-20’s with a short list of changes. Comparing the two sets of source files, nine of the 33 differ, most by a few lines:

The C64 code also no longer fits in one ROM: its tail continues at $E000, in the chip that holds the KERNAL. The keyword and token tables are identical in the two versions.

The header of the C64 source lists the machines the code was meant for: the PETs, an unexplained “TOY”, the “VIC-20/VIC-40”, the “COMMODORE 10/16/64” and the MAX.

Design Philosophy

V2 was adapted for its machines, not designed around them:

• Small first. The interpreter was cut to fit 8 KB. Features Commodore already had in BASIC 4.0 were left out.
• One language, several machines. The same keywords work on the PET, the VIC-20 and the C64. What differs between machines is the memory map, not the language.
• BASIC is the user interface. There is no separate command line. Loading, saving and running programs are BASIC statements typed at the READY. prompt.
• Input and output go through the KERNAL. BASIC calls the operating system’s jump table for the screen, keyboard, tape, serial bus and RS-232, which probably helped when it was moved to a new machine: the source lists only a handful of changes for the C64.
• Hardware is reached through memory. PEEK, POKE, SYS, USR and WAIT are the only route to the video and sound chips.

Key Features

Keywords

The token table defines 76 one-byte tokens, from END to GO.

The reserved variables ST, TI and TI$ give the I/O status and the jiffy clock. Keywords can be abbreviated when typing; the VIC-20 manual explains that ? stands for PRINT and that most others are the first letter or two followed by a shifted letter. LIST always shows the full keyword.

Data types

• Floating-point numbers. The VIC 20 Programmer’s Reference Guide says numbers are stored “to over ten digits of accuracy” and printed with nine.
• Integers, written with a % suffix.
• Strings, written with a $ suffix.
• Only the first two characters of a variable name are significant.

The same language in different memory

A V2 program that uses only BASIC statements usually runs on either machine. The differences are in the numbers around it:

On the VIC-20 even the start of a BASIC program depends on the hardware. According to the Programmer’s Reference Guide, an unexpanded machine starts BASIC at 4096 with the screen at 7680. Adding 3 KB moves the start of BASIC down to 1024. Adding 8 KB or more moves it to 4608 and moves the screen to 4096. Programs that POKE characters to the screen had to work out where the screen was first.

Colour and sound by POKE

Because the language has no hardware keywords, the same idea is written with different addresses on each machine. On the VIC-20, one register at 36879 sets both the screen and border colours, and the sound registers follow just below it:

1
2
3
4
5

10 POKE 36879,8:REM BLACK SCREEN AND BORDER
20 POKE 36878,15:REM VOLUME, 0 TO 15
30 POKE 36876,225:REM START A TONE ON THE HIGHEST VOICE
40 FOR T=1 TO 300:NEXT
50 POKE 36876,0:REM SILENCE

On the Commodore 64 the border and background are separate registers, and sound goes through the SID chip at 54272:

1

10 POKE 53280,0:POKE 53281,0:REM BLACK BORDER AND BACKGROUND

Colours for text are simpler. Both machines accept colour and cursor-control characters inside PRINT strings, which is why BYTE could say the VIC needed no new keywords for them.

Extending it: the Super Expander

Commodore’s answer to the missing commands on the VIC-20 was a cartridge. The Super Expander manual lists what it adds: GRAPHIC, COLOR, REGION, POINT, DRAW, CIRCLE, PAINT, CHAR and SCNCLR for graphics, SOUND and a music mode entered from PRINT strings, the read functions RGR, RCOLR, RDOT, RSND, RPOT, RPEN and RJOY, and KEY for the function keys. It also supplies 3 KB of extra RAM. A Super Expander 64 and Simons’ BASIC did the same job for the C64. Several of these keyword names came back later inside the ROM in BASIC 3.5.

Known Weaknesses

Garbage collection. V2 has the older string garbage collector, not BASIC 4’s. Programs that build and discard many strings can stop for long periods while it runs. No timing is given here because the delay depends entirely on how many strings a program holds.

The multiplication bug. In December 2013, members of the Denial VIC-20 forum found an arithmetic fault in the V2 ROM, in a thread that began on 8 December. A shortcut in the floating-point multiply routine mishandles a carry, so that for some operands the result depends on the order of multiplication:

1
2

A=.75+59E-9
PRINT A*1E9-7.5E8, 1E9*A-7.5E8

Both columns should show 59. The forum reported 59 and 29.5 on an unpatched VIC-20. The forum member Mike traced it on 31 December 2013 and posted a patched VIC-20 ROM the next day. The same code is in the C64, and a C64 patch followed on 19 January 2014. The fault is not peculiar to V2: according to the same thread, the Commodore 16, Plus/4 and the BASIC 4 PETs give the same wrong answer.

Bugs inherited from Microsoft. Steil’s comparison of Microsoft 6502 BASIC versions notes faults that were never fixed in any of them, such as a faulty check on very large line numbers. He also notes one that Commodore did fix “at least as early as for the VIC-20 in 1980”: a pair of random-number constants that were a byte too short.

Evolution

V2 itself barely changed. The work on it ran from August 1980 to July 1982, and after that the C64’s BASIC ROM was never revised.

• MAX Machine (1982). The source archive contains reconstructions of two BASIC cartridges for this Japanese cousin of the C64. One is a slightly patched C64 BASIC. The other, MINI BASIC, is described there as a stripped-down version with no arrays and no trigonometry. Both reconstructions sign on as **** CBM BASIC V2 ****.
• BASIC 3.5 (1984) and 7.0 (1985). The Commodore 16, Plus/4 and Commodore 128 kept the V2 keywords with the same token values and added graphics, sound, disk and structured-loop commands after them. The C128 also kept V2 itself for its C64 mode, reached with GO64.
• Late copies. The 1990 Commodore 64 Games System still carries BASIC V2; the archive’s notes say its binary differs from the ordinary C64 BASIC only in one entry of BASIC’s vector table, which sends the main loop to the console’s power-on message, and the checksum byte. The sources for the unreleased Commodore 65 include a C64-mode BASIC V2 whose changes are tagged 31 May 1990, under a header that carries a 1991 copyright.

Current Relevance

Neither machine has been made for decades. The VIC-20 was reportedly discontinued in January 1985 and C64 production reportedly ended in April 1994. V2 is still easy to run and to study:

• Emulation. VICE emulates both the VIC-20 and the C64 and runs the original ROM images, so each machine still starts at its own V2 banner.
• Source code. Commodore’s original source for both versions is public in the mist64/cbmsrc archive, including the RSR change notes quoted above. In September 2025 Microsoft published its own 6502 BASIC source, the ancestor of the whole Commodore line, under the MIT License.
• cbmbasic. Steil’s 2008 recompilation of the C64 ROM runs V2 programs from a modern command line.
• Hobbyist use. The VIC-20 and C64 both keep hobbyist communities. The 2013 multiplication bug was found on one of them, the Denial VIC-20 forum, more than thirty years after the ROM was written.

Why It Matters

V2 is a study in what a deliberately small language does to its users. Commodore chose an old, compact BASIC for a cheap machine, then reused it on a much more capable one because it was known, it fitted, and existing programs would run. The first choice made sense for a computer with 5 KB of RAM. The second left the Commodore 64 with sprites and a synthesiser chip that its own BASIC could not name. Owners of both machines learned memory addresses, and many of them went from POKE to machine code.

It also shows how little separated two famous computers at the software level. The BASIC that greeted VIC-20 owners in 1981 and the one that greeted C64 owners for the next twelve years differ by a ROM address, a screen width, a banner and two patches.