Commodore VIC-20

The Commodore VIC-20 was announced in 1980, three years after the first personal computer that Commodore made, the PET. The VIC-20 was hugely successful, it was the first computer to sell more than a million units.

In Germany the comptuer was introduced as the VC-20, since the word VIC sounds like a German expletive, and was marketed as the VolksComputer (People's Computer). In Japan the computer was marketed as the VIC-1001.

The aim of the VIC-20 was to be more affordable than the PET. The computer was equipped with only 5K of RAM, but used the same MOS 6502 CPU as the PET. The Video chip was a general-purpose color video chip designed by Al Charpentier in 1977 and intended for use in terminals and game consoles, but Commodore could not find a market for it. The chip was rebranded as the MOS Technology VIC and used in the VIC-20.

The VIC-20 really opened up the market to low-price computers selling at retail stores to the general public, rather than professionals or people with an electronics background. In that way, the VIC-20 really was the "People's Computer".

There was a sizable library of software for the VIC-20. The VIC-20 BASIC is compatible with the PET, and the Datasette format for tape is the same. Commodore actively promoted third-party development of software and also created a fan-base that produced a lot of public domain and freeware distributed through online services such as CompuServe, BBSs, as well as through clubs and user groups. Magazines published listings that people could type-in, another way to distribute and share software.

Commodore BASIC

Commodore BASIC was a dialect of Microsoft BASIC, licensed by Commodore in 1977 for use in the PET 2001. It ran from ROM, freeing all RAM for user programs, and provided an immediate programming environment upon power-up. The interpreter was built on the 6502 processor, with tightly coded routines for tokenization, line storage, and execution. This structure allowed BASIC statements to be entered interactively, stored in memory as linked line records, and executed sequentially or via branching constructs. Commodore kept this design across its entire 8-bit product line, from the PET and VIC-20 to the Commodore 64 and beyond, creating a sense of continuity between machines.

Historically, Commodore BASIC differed from many other implementations in its limited feature set relative to machine capabilities. For example, the original PET BASIC lacked dedicated graphics or sound commands, requiring programmers to manipulate memory directly through PEEK and POKE. Even later versions, such as BASIC V2 on the C64, still omitted high-level graphics and sound statements, in contrast with Atari BASIC or BBC BASIC, which provided structured access to system hardware. Only with extended versions such as BASIC 3.5, 4.0, and 7.0 did Commodore add disk commands, string handling improvements, and more advanced features.

When compared to contemporaries, Commodore BASIC was often criticized as being underpowered, but its simplicity made it approachable. BBC BASIC, for example, incorporated structured programming constructs and inline assembler, whereas Commodore’s offering retained the line-numbered, unstructured style of early Microsoft BASIC. Atari BASIC, developed separately, emphasized graphics and sound integration through dedicated keywords. Commodore’s approach forced users to learn the underlying memory map, making them more technically literate about hardware but also raising the entry barrier for certain types of applications.

Despite its limitations, Commodore BASIC achieved massive popularity due to sheer reach. Millions of units shipped with it as the only built-in interface, ensuring every user interacted with it directly. Its ubiquity in schools, homes, and small businesses made it a de facto teaching language for a generation. Moreover, the reliance on PEEK and POKE, while cumbersome, fostered a culture of type-in listings and hardware exploration. This combination of accessibility, wide distribution, and necessity cemented Commodore BASIC’s role as one of the most influential programming environments of the late 1970s and 1980s.

Commodore BASIC Versioning

BASIC 1.0 (PET 2001, 1977)
Computers: Commodore PET 2001
Features: Essentially a stock Microsoft BASIC interpreter running in ROM, with support for integer and floating-point arithmetic, strings, arrays, and file operations for tape storage.
Limitations: No disk commands, no advanced error trapping, and no machine-specific extensions. Designed as a minimal environment to ship the PET quickly.
BASIC 2.0 (VIC-20, C64, C-MAX, 1981–1982)
Computers: VIC-20, Commodore 64, Commodore MAX Machine
Features: Nearly identical to BASIC 1.0 with minor bug fixes, provided the same core Microsoft BASIC functionality.
Limitations: No disk drive commands, no dedicated graphics or sound statements. Hardware had to be accessed through POKE and PEEK.
BASIC 3.5 (Commodore 16, C116, Plus/4, 1984)
Computers: Commodore 16, Commodore 116, Commodore Plus/4
Features: Added graphics and sound commands (GRAPHIC, CIRCLE, PAINT, SOUND, PLAY), integrated disk commands (DLOAD, DSAVE, DIRECTORY), plus utilities like RENUM and TRON/TROFF.
Limitations: Still line-number oriented and lacked the structured programming richness of competitors like BBC BASIC.
BASIC 4.0 (PET/CBM Business Series, 1979+)
Computers: PET/CBM 4000 and 8000 series
Features: Expanded disk support with DLOAD, DSAVE, DIRECTORY, COPY, and SCRATCH. Improved error handling suitable for commercial environments.
Limitations: Focused on business and disk operations, no graphics or sound capabilities because target hardware lacked them.
BASIC 7.0 (C-128, 1985)
Computers: Commodore 128
Features: Added high-level graphics (DRAW, CIRCLE, PAINT) and sound (PLAY, SOUND) commands, advanced disk operations, structured programming constructs like WHILE...WEND, RENUM, and support for memory banking and multi-mode operation.
Limitations: Despite enhancements, still less sophisticated in structured constructs compared to BBC BASIC or contemporary Pascal-like systems.
BASIC 10.0 (C-65 prototype, 1990–1991)
Computers: Commodore 65 (prototype, unreleased commercially)
Features: Extended support for high-resolution graphics and larger color palettes through VIC-III, up to 8 MB memory addressing, advanced string handling, and structured commands.
Limitations: Never commercially released, so its practical impact was negligible despite advanced features.

Video - The Video Interface Chip (VIC)

The VIC (Video Interface Chip), specifically known as the MOS Technology 6560 (NTSC version) / 6561 (PAL version), is the integrated circuit chip responsible for generating video graphics and sound in the VIC-20 home computer from Commodore.

The VIC chip is not only for video display. It also integrates sound and support for analog devices through its sound circuitry and its AD converters. This allows for light-pens and other peripherals on the VIC-20

Features:

16KByte address space for screen, character and color memory. (In the VIC-20 only 5KByte points to RAM)
16 Colors (Upper 8 can only be used in global background and auxiliary colors)
Two selectable character sizes (8x8 or 8x16, the first for multi-color, the second for "hires" modes)
176x182 resolution (256x280 possible on PAL; 248x232 possible on NTSC)
4 Channel integrated sound circuitry; 3 square waves + a white noise channel.
On-chip DMA
Two 8-bit AD converters
Light pen support

CPU - The Motorola 6502

The 6502 is an 8-bit MicroProcessor designed by MOS Technology. The team was led by Chuck Peddle and had also worked on the Motorola 6800. The 6502 is a simplified, but faster and cheaper design than the 6800.

The 6502 was introduced in 1975 and was the cheapest microprocessor on the market. Together with the Zilog Z80, the 6502 helped start the home computer revolution of the 1980s. The 6502 was used in a wide range of devices: the Atari 2600, the 8-bit Atari home computers, the Apple II, the Nintendo Entertainment System, the Commodore 64, the BBC Micro and many others. All used the 6502 or a variation of it.

The 6502 is a 1MHz design, while the 6502A is designed for 2MHz. The 6502A is 100% compatible with the original 6502.

Commodore soon bought MOS Technology, but conitnued to sell the microprocessor to competitors and licensed the design to other manufacturers.

Source: WikiPedia - MOS Technology 6502

The 650x Instruction Set

Mnemonic	Operation	Description
ADC	Add with Carry	Adds a memory location and the carry bit to the accumulator.
AND	Logical AND	Performs a logical AND between memory and the accumulator.
ASL	Arithmetic Shift Left	Shifts all bits one position to the left (in memory or accumulator).
BCC	Branch on Carry Clear	Branches to a new address if the carry flag is clear (0).
BCS	Branch on Carry Set	Branches to a new address if the carry flag is set (1).
BEQ	Branch on Equal (Zero Set)	Branches to a new address if the zero flag is set (1).
BIT	Bit Test	Tests bits in memory with the accumulator without modifying the accumulator.
BMI	Branch on Minus	Branches to a new address if the negative flag is set (1).
BNE	Branch on Not Equal	Branches to a new address if the zero flag is clear (0).
BPL	Branch on Plus	Branches to a new address if the negative flag is clear (0).
BRK	Force Break	Forces an interrupt request and pushes status and PC to the stack.
BVC	Branch on Overflow Clear	Branches to a new address if the overflow flag is clear (0).
BVS	Branch on Overflow Set	Branches to a new address if the overflow flag is set (1).
CLC	Clear Carry Flag	Clears the processor carry flag.
CLD	Clear Decimal Mode	Clears the processor decimal mode flag.
CLI	Clear Interrupt Disable	Clears the interrupt disable flag, allowing maskable interrupts.
CLV	Clear Overflow Flag	Clears the processor overflow flag.
CMP	Compare Accumulator	Compares the contents of a memory location with the accumulator.
CPX	Compare X Register	Compares the contents of a memory location with the X register.
CPY	Compare Y Register	Compares the contents of a memory location with the Y register.
DEC	Decrement Memory	Subtracts one from the value held at a specified memory location.
DEX	Decrement X Register	Subtracts one from the X register.
DEY	Decrement Y Register	Subtracts one from the Y register.
EOR	Exclusive OR	Performs a logical Exclusive OR between memory and the accumulator.
INC	Increment Memory	Adds one to the value held at a specified memory location.
INX	Increment X Register	Adds one to the X register.
INY	Increment Y Register	Adds one to the Y register.
JMP	Jump	Sets the program counter to a new address.
JSR	Jump to Subroutine	Pushes the return address to the stack and jumps to a new address.
LDA	Load Accumulator	Loads a byte of memory into the accumulator.
LDX	Load X Register	Loads a byte of memory into the X register.
LDY	Load Y Register	Loads a byte of memory into the Y register.
LSR	Logical Shift Right	Shifts all bits one position to the right (in memory or accumulator).
NOP	No Operation	Performs no operation, consuming 2 machine cycles.
ORA	Logical Inclusive OR	Performs a logical OR between memory and the accumulator.
PHA	Push Accumulator	Pushes a copy of the accumulator onto the stack.
PHP	Push Processor Status	Pushes a copy of the status flags onto the stack.
PLA	Pull Accumulator	Pulls a byte from the stack into the accumulator.
PLP	Pull Processor Status	Pulls a byte from the stack into the processor status flags.
ROL	Rotate Left	Rotates all bits one position left through the carry flag.
ROR	Rotate Right	Rotates all bits one position right through the carry flag.
RTI	Return from Interrupt	Pulls the processor flags and program counter from the stack.
RTS	Return from Subroutine	Pulls the program counter from the stack and resumes execution.
SBC	Subtract with Carry	Subtracts memory and the inverse of the carry bit from the accumulator.
SEC	Set Carry Flag	Sets the processor carry flag.
SED	Set Decimal Flag	Sets the processor decimal mode flag.
SEI	Set Interrupt Disable	Sets the interrupt disable flag, preventing maskable interrupts.
STA	Store Accumulator	Stores the contents of the accumulator in memory.
STX	Store X Register	Stores the contents of the X register in memory.
STY	Store Y Register	Stores the contents of the Y register in memory.
TAX	Transfer Accumulator to X	Copies the current value of the accumulator into the X register.
TAY	Transfer Accumulator to Y	Copies the current value of the accumulator into the Y register.
TSX	Transfer Stack Pointer to X	Copies the current value of the stack pointer into the X register.
TXA	Transfer X to Accumulator	Copies the current value of the X register into the accumulator.
TXS	Transfer X to Stack Pointer	Copies the current value of the X register into the stack pointer.
TYA	Transfer Y to Accumulator	Copies the current value of the Y register into the accumulator.