CHIP-8

Last updated May 30, 2024

CHIP-8 is an interpreted programming language, developed by Joseph Weisbecker on his 1802 microprocessor. It was initially used on the COSMAC VIP and Telmac 1800, which were 8-bit microcomputers made in the mid-1970s.

Community

CHIP-8 has been used on a wide range of devices over time, the first community to use CHIP-8 started in the 1970s on microcomputers. They shared extensions and programs in newsletters such as ARESCO's VIPER for COSMAC VIP users or DREAMER for DREAM 6800 users^[4]. In the VIPER newsletter, the first three issues detailed the machine code for the CHIP-8 interpreter for the VIP. ^[5]

In the 1990s, CHIP-8 interpreters started to be created for graphing calculators. Notable examples include CHIP-48 and SCHIP for the HP-48. ^[6]

CHIP-8 applications include original games, demos, as well as recreations of popular games from other systems. ^[7] With some CHIP-8 applications being in the public domain, using licenses like the Creative commons Zero license. ^[8]^[9]

CHIP-8 extensions and variations

During the 1970s and 1980s, CHIP-8 users shared CHIP-8 programs, but also changes and extensions to the CHIP-8 interpreter, like in the VIPER magazine for COSMAC VIP. These extensions included CHIP-10 and Hi-Res CHIP-8, which introduced a higher resolution than the standard 64x32, and CHIP-8C and CHIP-8X, which extended the monochrome display capabilities to support limited color, among other features. ^[10] These extensions were mostly backwards compatible, as they were based on the original interpreter, although some repurposed rarely used opcodes for new instructions. ^[11]

In 1979, Electronics Australia ran a series of articles on building a kit computer similar to the COSMAC VIP, based on the Motorola 6800 architecture. ^[12] This computer, the DREAM 6800, came with its own version of CHIP-8. A newsletter similar to VIPER, called DREAMER^[13], was used to share CHIP-8 games for this interpreter. In 1981, Electronics Today International (ETI) ran a series of articles on building a computer, the ETI-660, which was also very similar to the VIP (and used the same microprocessor). ETI ran regular ETI-660 and general CHIP-8 columns^[14] until 1985.

In 1990, a CHIP-8 interpreter called CHIP-48 was made by Andreas Gustafsson ^[15] for HP-48 graphing calculators. Erik Bryntse later created another interpreter based on CHIP-48,^[16] titled "SUPER-CHIP", often shortened to SCHIP or S-CHIP. SCHIP extended the CHIP-8 language with a larger resolution and several additional opcodes meant to make programming easier. ^[17]

David Winter's interpreter, disassembler, and extended technical documentation popularized CHIP-8/SCHIP on other platforms. It laid out a complete list of undocumented opcodes and features^[18] and was distributed across hobbyist forums. Many interpreters used these works as a starting point.^{[ citation needed ]}

However, CHIP-48 subtly changed the semantics of a few of the opcodes, and SCHIP continued to use those new semantics in addition to changing other opcodes. Many online resources about CHIP-8 propagate these new semantics, so many modern CHIP-8 games are not backwards compatible with the original CHIP-8 interpreter for the COSMAC VIP, even if they do not specifically use the new SCHIP extensions. ^[19]

Some extensions take opcodes or behavior from multiple extensions, like XO-CHIP which takes some from behavior from SCHIP and CHIP-8E. ^[20]

Virtual machine description

Memory

CHIP-8 was most commonly implemented on 4K systems, such as the Cosmac VIP and the Telmac 1800. These machines had 4096 (0x1000) memory locations, all of which are 8 bits (a byte) which is where the term CHIP-8 originated. However, the CHIP-8 interpreter itself occupies the first 512 bytes of the memory space on these machines. For this reason, most programs written for the original system begin at memory location 512 (0x200) and do not access any of the memory below the location 512 (0x200). The uppermost 256 bytes (0xF00-0xFFF) are reserved for display refresh, and the 96 bytes below that (0xEA0-0xEFF) were reserved for the call stack, internal use, and other variables.

In modern CHIP-8 implementations, where the interpreter is running natively outside the 4K memory space, there is no need to avoid the lower 512 bytes of memory (0x000-0x1FF), and it is common to store font data there.

Registers

CHIP-8 has 16 8-bit data registers named V0 to VF. The VF register doubles as a flag for some instructions; thus, it should be avoided. In an addition operation, VF is the carry flag, while in subtraction, it is the "no borrow" flag. In the draw instruction VF is set upon pixel collision.

The address register, which is named I, is 12 bits wide and is used with several opcodes that involve memory operations.

The stack

The stack is only used to store return addresses when subroutines are called. The original RCA 1802 version allocated 48 bytes for up to 12 levels of nesting;^[21] modern implementations usually have more.^[22]^[23]

Timers

CHIP-8 has two timers. They both count down at 60 hertz, until they reach 0.

Delay timer: This timer is intended to be used for timing the events of games. Its value can be set and read.
Sound timer: This timer is used for sound effects. When its value is nonzero, a beeping sound is made. Its value can only be set.

Input

Input is done with a hex keyboard that has 16 keys ranging 0 to F. The '8', '4', '6', and '2' keys are typically used for directional input. Three opcodes are used to detect input. One skips an instruction if a specific key is pressed, while another does the same if a specific key is not pressed. The third waits for a key press, and then stores it in one of the data registers.

Graphics and sound

Original CHIP-8 Display resolution is 64×32 pixels, and color is monochrome. Graphics are drawn to the screen solely by drawing sprites, which are 8 pixels wide and may be from 1 to 15 pixels in height. Sprite pixels are XOR'd with corresponding screen pixels. In other words, sprite pixels that are set flip the color of the corresponding screen pixel, while unset sprite pixels do nothing. The carry flag (VF) is set to 1 if any screen pixels are flipped from set to unset when a sprite is drawn and set to 0 otherwise. This is used for collision detection.

As previously described, a beeping sound is played when the value of the sound timer is nonzero.

Opcode table

CHIP-8 has 35 opcodes, which are all two bytes long and stored big-endian. The opcodes are listed below, in hexadecimal and with the following symbols:

NNN: address
NN: 8-bit constant
N: 4-bit constant
X and Y: 4-bit register identifier
PC : Program Counter
I : 12bit register (For memory address) (Similar to void pointer);
VN: One of the 16 available variables. N may be 0 to F (hexadecimal);

There have been many implementations of the CHIP-8 instruction set since 1978. The following specification is based on the SUPER-CHIP specification from 1991 (but without the additional opcodes that provide extended functionality), as that is the most commonly encountered extension set today. Footnotes denote incompatibilities with the original CHIP-8 instruction set from 1978.

Opcode	Type	C Pseudo	Explanation
0NNN	Call		Calls machine code routine (RCA 1802 for COSMAC VIP) at address NNN. Not necessary for most ROMs.^[22]
00E0	Display	`disp_clear()`	Clears the screen.^[22]
00EE	Flow	`return;`	Returns from a subroutine.^[22]
1NNN	Flow	`gotoNNN;`	Jumps to address NNN.^[22]
2NNN	Flow	`*(0xNNN)()`	Calls subroutine at NNN.^[22]
3XNN	Cond	`if(Vx==NN)`	Skips the next instruction if VX equals NN (usually the next instruction is a jump to skip a code block).^[22]
4XNN	Cond	`if(Vx!=NN)`	Skips the next instruction if VX does not equal NN (usually the next instruction is a jump to skip a code block).^[22]
5XY0	Cond	`if(Vx==Vy)`	Skips the next instruction if VX equals VY (usually the next instruction is a jump to skip a code block).^[22]
6XNN	Const	`Vx=NN`	Sets VX to NN.^[22]
7XNN	Const	`Vx+=NN`	Adds NN to VX (carry flag is not changed).^[22]
8XY0	Assig	`Vx=Vy`	Sets VX to the value of VY.^[22]
8XY1	BitOp	`Vx\|=Vy`	Sets VX to VX or VY. (bitwise OR operation).^[22]
8XY2	BitOp	`Vx&=Vy`	Sets VX to VX and VY. (bitwise AND operation).^[22]
8XY3^{[lower-alpha 1]}	BitOp	`Vx^=Vy`	Sets VX to VX xor VY.^[22]
8XY4	Math	`Vx+=Vy`	Adds VY to VX. VF is set to 1 when there's an overflow, and to 0 when there is not.^[22]
8XY5	Math	`Vx-=Vy`	VY is subtracted from VX. VF is set to 0 when there's an underflow, and 1 when there is not. (i.e. VF set to 1 if VX >= VY and 0 if not).^[22]
8XY6^{[lower-alpha 1]}	BitOp	`Vx>>=1`	Shifts VX to the right by 1, then stores the least significant bit of VX prior to the shift into VF.^{[lower-alpha 2]}^[22]
8XY7^{[lower-alpha 1]}	Math	`Vx=Vy-Vx`	Sets VX to VY minus VX. VF is set to 0 when there's an underflow, and 1 when there is not. (i.e. VF set to 1 if VY >= VX).^[22]
8XYE^{[lower-alpha 1]}	BitOp	`Vx<<=1`	Shifts VX to the left by 1, then sets VF to 1 if the most significant bit of VX prior to that shift was set, or to 0 if it was unset.^{[lower-alpha 2]}^[22]
9XY0	Cond	`if(Vx!=Vy)`	Skips the next instruction if VX does not equal VY. (Usually the next instruction is a jump to skip a code block).^[22]
ANNN	MEM	`I=NNN`	Sets I to the address NNN.^[22]
BNNN	Flow	`PC=V0+NNN`	Jumps to the address NNN plus V0.^[22]
CXNN	Rand	`Vx=rand()&NN`	Sets VX to the result of a bitwise and operation on a random number (Typically: 0 to 255) and NN.^[22]
DXYN	Display	`draw(Vx,Vy,N)`	Draws a sprite at coordinate (VX, VY) that has a width of 8 pixels and a height of N pixels. Each row of 8 pixels is read as bit-coded starting from memory location I; I value does not change after the execution of this instruction. As described above, VF is set to 1 if any screen pixels are flipped from set to unset when the sprite is drawn, and to 0 if that does not happen.^[22]
EX9E	KeyOp	`if(key()==Vx)`	Skips the next instruction if the key stored in VX is pressed (usually the next instruction is a jump to skip a code block).^[22]
EXA1	KeyOp	`if(key()!=Vx)`	Skips the next instruction if the key stored in VX is not pressed (usually the next instruction is a jump to skip a code block).^[22]
FX07	Timer	`Vx=get_delay()`	Sets VX to the value of the delay timer.^[22]
FX0A	KeyOp	`Vx=get_key()`	A key press is awaited, and then stored in VX (blocking operation, all instruction halted until next key event).^[22]
FX15	Timer	`delay_timer(Vx)`	Sets the delay timer to VX.^[22]
FX18	Sound	`sound_timer(Vx)`	Sets the sound timer to VX.^[22]
FX1E	MEM	`I+=Vx`	Adds VX to I. VF is not affected.^{[lower-alpha 3]}^[22]
FX29	MEM	`I=sprite_addr[Vx]`	Sets I to the location of the sprite for the character in VX. Characters 0-F (in hexadecimal) are represented by a 4x5 font.^[22]
FX33	BCD	set_BCD(Vx)(I+0)=BCD(3);(I+1)=BCD(2);*(I+2)=BCD(1);	Stores the binary-coded decimal representation of VX, with the hundreds digit in memory at location in I, the tens digit at location I+1, and the ones digit at location I+2.^[22]
FX55	MEM	`reg_dump(Vx,&I)`	Stores from V0 to VX (including VX) in memory, starting at address I. The offset from I is increased by 1 for each value written, but I itself is left unmodified.^{[lower-alpha 4]}^[22]
FX65	MEM	`reg_load(Vx,&I)`	Fills from V0 to VX (including VX) with values from memory, starting at address I. The offset from I is increased by 1 for each value read, but I itself is left unmodified.^{[lower-alpha 4]}^[22]

Notes

1 2 3 4 The logical opcodes 8XY3, 8XY6, 8XY7 and 8XYE were not documented in the original CHIP-8 specification, as all the 8000 opcodes were dispatched to instructions in the 1802's ALU, and not located in the interpreter itself; these four additional opcodes were therefore presumably unintentional functionality.
1 2 CHIP-8's opcodes 8XY6 and 8XYE (the bit shift instructions), which were in fact undocumented opcodes in the original interpreter, shifted the value in the register VY and stored the result in VX. The CHIP-48 and SCHIP implementations instead ignored VY, and simply shifted VX.^[19]
↑ Most CHIP-8 interpreters' FX1E instructions do not affect VF, with one exception: the CHIP-8 interpreter for the Commodore Amiga sets VF to 1 when there is a range overflow (I+VX>0xFFF), and to 0 when there is not.^[24] The only known game that depends on this behavior is Spacefight 2091!, while at least one game, Animal Race, depends on VF not being affected.
1 2 In the original CHIP-8 implementation, and also in CHIP-48, I is left incremented after this instruction had been executed. In SCHIP, I is left unmodified.

Related Research Articles

The MOS Technology 6502 is an 8-bit microprocessor that was designed by a small team led by Chuck Peddle for MOS Technology. The design team had formerly worked at Motorola on the Motorola 6800 project; the 6502 is essentially a simplified, less expensive and faster version of that design.

The 6800 is an 8-bit microprocessor designed and first manufactured by Motorola in 1974. The MC6800 microprocessor was part of the M6800 Microcomputer System that also included serial and parallel interface ICs, RAM, ROM and other support chips. A significant design feature was that the M6800 family of ICs required only a single five-volt power supply at a time when most other microprocessors required three voltages. The M6800 Microcomputer System was announced in March 1974 and was in full production by the end of that year.

The Intel MCS-51 is a single chip microcontroller (MCU) series developed by Intel in 1980 for use in embedded systems. The architect of the Intel MCS-51 instruction set was John H. Wharton. Intel's original versions were popular in the 1980s and early 1990s, and enhanced binary compatible derivatives remain popular today. It is a complex instruction set computer, but also has some of the features of RISC architectures, such as a large register set and register windows, and has separate memory spaces for program instructions and data.

x86 assembly language is the name for the family of assembly languages which provide some level of backward compatibility with CPUs back to the Intel 8008 microprocessor, which was launched in April 1972. It is used to produce object code for the x86 class of processors.

The MSP430 is a mixed-signal microcontroller family from Texas Instruments, first introduced on 14 February 1992. Built around a 16-bit CPU, the MSP430 was designed for low power consumption embedded applications and low cost.

In computer engineering, Halt and Catch Fire, known by the assembly language mnemonic HCF, is an idiom referring to a computer machine code instruction that causes the computer's central processing unit (CPU) to cease meaningful operation, typically requiring a restart of the computer. It originally referred to a fictitious instruction in IBM System/360 computers, making a joke about its numerous non-obvious instruction mnemonics.

Fetching the instruction opcodes from program memory well in advance is known as prefetching and it is served by using a prefetch input queue (PIQ). The pre-fetched instructions are stored in a queue. The fetching of opcodes well in advance, prior to their need for execution, increases the overall efficiency of the processor boosting its speed. The processor no longer has to wait for the memory access operations for the subsequent instruction opcode to complete. This architecture was prominently used in the Intel 8086 microprocessor.

The COSMAC is an 8-bit microprocessor family introduced by RCA. It is historically notable as the first CMOS microprocessor. The first production model was the two-chip CDP1801R and CDP1801U, which were later combined into the single-chip CDP1802. The 1802 represented the majority of COSMAC production, and today the entire line is known simply as the RCA 1802.

The COSMAC VIP (1977) was an early microcomputer that was aimed at video games. Essentially, it was a COSMAC ELF with a supplementary CDP1861/CDP1864 video display chip. For a price of US$275, it could be purchased from RCA by mail order. It came in kit form, and had to be assembled. Its dimensions were 22 × 28 cm, and it had an RCA 1802 processor; along with a crystal clock operating at 1.76 MHz. It had 2 KB of RAM, which could be expanded to 4 KB on board, and 32 KB via an expansion slot. Its 5V DC CDP18S023 power supply had an output of 600 mA. I/O ports could be added to connect to sensors, interface relays, an ASCII keyboard, or a printer.

The COSMAC Elf was an RCA 1802 microprocessor-based computer described in a series of construction articles in Popular Electronics magazine in 1976 and 1977. Through the back pages of electronics magazines, both Netronics and Quest Electronics offered low-priced, enhanced kits that were based on this design. The system was a very early single-board personal computer. It was operated without built-in ROMs and programs were entered directly with help of the CPU integrated DMA using 8 toggle switches and an Input push button.

The Fairchild F8 is an 8-bit microprocessor system from Fairchild Semiconductor, announced in 1974 and shipped in 1975. The original processor family included four main 40-pin integrated circuits (ICs); the 3850 CPU which was the arithmetic logic unit, the 3851 Program Storage Unit (PSU) which contained 1 KB of program ROM and handled instruction decoding, and the optional 3852 Dynamic Memory Interface (DMI) or 3853 Static Memory Interface (SMI) to control additional RAM or ROM holding the user programs or data. The 3854 DMA was another optional system that added direct memory access into the RAM controlled by the 3852.

The Zilog Z8 is a microcontroller architecture, originally introduced in 1979, which today also includes the Z8 Encore!, eZ8 Encore!, eZ8 Encore! XP, and eZ8 Encore! MC families.

The Saturn family of 4-bit (datapath) microprocessors was developed by Hewlett-Packard in the 1980s first for the HP-71B handheld computer and then later for various HP calculators. It succeeded the Nut family of processors used in earlier calculators. The original Saturn chip was first used in the HP-71B hand-held BASIC-programmable computer, introduced in 1984. Later models of the family powered the popular HP 48 series of calculators. The HP48SX and HP48S were the last models to use genuine Saturn processors manufactured by HP. Later calculator models used Saturn processors manufactured by NEC. The HP 49 series initially used the Saturn CPU as well, until the NEC fab could no longer manufacture the processor for technical reasons in 2003. Therefore, starting with the HP 49g+ model in 2003, the calculators switched to a Samsung S3C2410 processor with an ARM920T core which ran an emulator of the Saturn hardware in software. In 2000, the HP 39G and HP 40G were the last calculators introduced based on the actual NEC fabricated Saturn hardware. The last calculators based on the Saturn emulator were the HP 39gs, HP 40gs and HP 50g in 2006, as well as the 2007 revision of the hp 48gII. The HP 50g, the last calculator utilizing this emulator, was discontinued in 2015 when Samsung stopped producing the ARM processor on which it was based.

TLCS is a prefix applied to microcontrollers made by Toshiba. The product line includes multiple families of CISC and RISC architectures. Individual components generally have a part number beginning with "TMP". E.g. the TMP8048AP is a member of the TLCS-48 family.

The Intersil 6100 is a single-chip microprocessor implementation of the 12-bit PDP-8 instruction set, along with a range of peripheral support and memory ICs developed by Intersil in the mid-1970s. It was sometimes referred to as the CMOS-PDP8. Since it was also produced by Harris Corporation, it was also known as the Harris HM-6100. The Intersil 6100 was introduced in the second quarter of 1975, and the Harris version in 1976.

Each time Intel launched a new microprocessor, they simultaneously provided a system development kit (SDK) allowing engineers, university students, and others to familiarise themselves with the new processor's concepts and features. The SDK single-board computers allowed the user to enter object code from a keyboard or upload it through a communication port, and then test run the code. The SDK boards provided a system monitor ROM to operate the keyboard and other interfaces. Kits varied in their specific features but generally offered optional memory and interface configurations, a serial terminal link, audio cassette storage, and EPROM program memory. Intel's Intellec development system could download code to the SDK boards.

RL78 Family is a 16-bit CPU core for embedded microcontrollers of Renesas Electronics introduced in 2010.

The STM8 is an 8-bit microcontroller family by STMicroelectronics. The STM8 microcontrollers use an extended variant of the ST7 microcontroller architecture. STM8 microcontrollers are particularly low cost for a full-featured 8-bit microcontroller.

Joseph A. Weisbecker was an early microprocessor and microcomputer designer and researcher, as well and designer of toys and games. He was a recipient of the David Sarnoff award for outstanding technical achievement, recipient of IEEE Computer magazine's "Best Paper" award, as well as several RCA lab awards for his work.

<span class="mw-page-title-main">COP400</span> 4-bit microcontroller family

The COP400 or COP II is a 4-bit microcontroller family introduced in 1977 by National Semiconductor as a follow-on product to their original PMOS COP microcontroller. COP400 family members are complete microcomputers containing internal timing, logic, ROM, RAM, and I/O necessary to implement dedicated controllers. Some COP400 devices were second-sourced by Western Digital as the WD4200 family. In the Soviet Union several COP400 microcontrollers were manufactured as the 1820 series.

References

↑ "An Easy Programming System". BYTE . Vol. 3, no. 12. December 1978. p. 108.
↑ "The CHIP-8 Emulator HomePage".
↑ "Nintendo Game & Watch hacking scene brings Pokémon, CHIP-8 and more to the $50 handheld". 8 December 2020.
↑ https://archive.org/details/dreamer_newsletter_01/mode/2up
↑ "VIPER for RCA VIP owner". Intelligent Machines Journal (InfoWorld). InfoWorld Media Group. 1978-12-11. p. 9. Retrieved 2010-01-30.
↑ "[What I Learned About] Python and Emulators [by] Making a Chip-8 Emulator". 15 December 2019.
↑ "The CHIP-8 Emulator HomePage".
↑ "Chip-8 Public Domain ROMs - Zophar's Domain".
↑ https://johnearnest.github.io/chip8Archive/
↑ https://github.com/mattmikolay/chip-8/wiki/CHIP%E2%80%908-Extensions-Reference
↑ https://github.com/trapexit/chip-8_documentation
↑ https://archive.org/stream/EA1979/EA%201979-05%20May#page/n85/mode/2up
↑ https://archive.org/details/dreamer_newsletter_01/mode/2up
↑ https://archive.org/stream/ETIA1981/ETI%201981-11%20November#page/n113/mode/2up
↑ "HP48-Superchip/Binaries/Source/C48_source.TXT at master · Chromatophore/HP48-Superchip". GitHub .
↑ http://devernay.free.fr/hacks/chip8/schip.txt
↑ https://github.com/Chromatophore/HP48-Superchip
↑ https://web.archive.org/web/20140825173007/http://vanbeveren.byethost13.com/stuff/CHIP8.pdf
1 2 https://github.com/JohnEarnest/Octo/blob/gh-pages/docs/SuperChip.md#compatibility
↑ "Octo/Docs/XO-ChipSpecification.md at gh-pages · JohnEarnest/Octo". GitHub .
↑ RCA COSMAC VIP CDP18S711 Instruction Manual. Somerville: RCA Solid State Division. 1978. p. 36.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 Greene, Thomas P. (1997-08-30). "Cowgod's Chip-8 Technical Reference". devernay.free.fr. Archived from the original on 2024-01-03. Retrieved 2020-02-03.
↑ Mikolay, Matthew. "Mastering CHIP-8 : Subroutines". mattmik.com. Retrieved 2020-02-03.
↑ "FX1E and VF · Issue #2 · Chromatophore/HP48-Superchip · GitHub". GitHub .

External links

FPGA SuperChip A Verilog implementation of the SCHIP specification.
Octo is an Online CHIP-8 IDE, Development System, Compiler/Assembler and Emulator, with a proprietary scripting language
Cadmium is a CHIP-8 interpreter for computers, with a GUI which allows for selecting accurate emulation of different extensions and implementations of CHIP-8
Silicon8 A CHIP-8 emulator for web browsers.