Editing CHIP-8

{{Short description|Interpreted programming language}}
[[Image:PONG CHIP8.png|framed|Screenshot of ''[[Pong]]'' implemented in CHIP-8]]
[[File:Space intercept.png|thumb|[[Telmac 1800]] running CHIP-8 game Space Intercept (Joseph Weisbecker, 1978)]]

'''CHIP-8''' is an [[interpreter (computing)|interpreted]] [[programming language]], developed by [[Joseph Weisbecker]] on his [[RCA 1802|1802]] microprocessor. It was initially used on the [[COSMAC VIP]] and [[Telmac 1800]], which were [[8-bit]] [[microcomputer]]s made in the mid-1970s.

CHIP-8 was designed to be easy to program for and to use less memory than other programming languages like [[BASIC]]. <ref>{{cite magazine|title=An Easy Programming System |magazine=[[Byte_(magazine)|BYTE]] |volume=3 |issue=12 |publisher= |date=December 1978 |page=108}}</ref>

Interpreters have been made for many devices, such as [[home computer]]s, [[microcomputer]]s, [[graphing calculator]]s, [[mobile phone]]s, and [[video game console]]s. <ref>{{cite web | url=https://pong-story.com/chip8/ | title=The CHIP-8 Emulator HomePage }}</ref> <ref>{{cite web | url=https://liliputing.com/nintendo-games-watch-hacking-scene-brings-pokemon-chip-8-and-more-to-the-50-handheld/ | title=Nintendo Game & Watch hacking scene brings Pokémon, CHIP-8 and more to the $50 handheld | date=8 December 2020 }}</ref>

==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 [[microcomputer]]s. They shared extensions and programs in newsletters such as ARESCO's VIPER for COSMAC VIP users or DREAMER for DREAM 6800 users{{refn|https://archive.org/details/dreamer_newsletter_01/mode/2up}}. In the VIPER newsletter, the first three issues detailed the machine code for the CHIP-8 interpreter for the VIP. <ref>{{Cite news|date=1978-12-11|title=''VIPER'' for RCA VIP owner|pages=9|newspaper=Intelligent Machines Journal ([[InfoWorld]])|publisher=InfoWorld Media Group|url=https://books.google.com/books?id=IT4EAAAAMBAJ&q=aresco+viper&pg=PA9|accessdate=2010-01-30}}</ref>

In the 1990s, CHIP-8 interpreters started to be created for [[graphing calculator]]s. Notable examples include CHIP-48 and SCHIP for the [[HP-48]]. <ref>{{cite web | url=https://medium.com/@tobywhughes/what-i-learned-about-python-and-emulators-by-making-a-chip-8-emulator-f6ac7f25e095 | title=&#91;What I Learned About&#93; Python and Emulators &#91;by&#93; Making a Chip-8 Emulator | date=15 December 2019 }}</ref>

CHIP-8 applications include original games, [[Demoscene|demos]], as well as recreations of popular games from other systems. <ref>{{cite web | url=https://pong-story.com/chip8/ | title=The CHIP-8 Emulator HomePage }}</ref> With some CHIP-8 applications being in the [[public domain]], using licenses like the [[Creative_Commons_license#Zero,_public_domain|Creative Commons Zero]] license. <ref>{{cite web | url=https://www.zophar.net/pdroms/chip8.html | title=Chip-8 Public Domain ROMs - Zophar's Domain }}</ref> <ref>[https://johnearnest.github.io/chip8Archive/ CHIP-8 Archive]</ref>

==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. {{refn|[https://github.com/mattmikolay/chip-8/wiki/CHIP%E2%80%908-Extensions-Reference CHIP‐8 Extensions Reference] by Matthew Mikolay}} These extensions were mostly backwards compatible, as they were based on the original interpreter, although some repurposed rarely used opcodes for new instructions. {{refn|https://github.com/trapexit/chip-8_documentation}}

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. {{refn|https://archive.org/stream/EA1979/EA%201979-05%20May#page/n85/mode/2up}} This computer, the DREAM 6800, came with its own version of CHIP-8. A newsletter similar to VIPER, called DREAMER{{refn|https://archive.org/details/dreamer_newsletter_01/mode/2up}}, 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{{refn|https://archive.org/stream/ETIA1981/ETI%201981-11%20November#page/n113/mode/2up}} until 1985.

In 1990, a CHIP-8 interpreter called CHIP-48 was made by Andreas Gustafsson <ref>{{cite web | url=https://github.com/Chromatophore/HP48-Superchip/blob/master/binaries/source/c48_source.txt | title=CHIP-48 source code | website=[[GitHub]] }}</ref> for [[HP-48]] [[graphing calculator]]s. Erik Bryntse later created another interpreter based on CHIP-48,<ref>[http://devernay.free.fr/hacks/chip8/schip.txt SCHIP 1.1 documentation]</ref> 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. {{refn|[https://github.com/Chromatophore/HP48-Superchip HP48-Superchip] Repository on [[GitHub]]}}

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{{refn|[https://web.archive.org/web/20140825173007/http://vanbeveren.byethost13.com/stuff/CHIP8.pdf CHIP8.pdf] by David WINTER (HPMANIAC)}} and was distributed across hobbyist forums. Many interpreters used these works as a starting point.{{Citation needed|date=May 2024|reason=What interpreters?}}

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 [[Backward compatibility|backwards compatible]] with the original CHIP-8 interpreter for the COSMAC VIP, even if they do not specifically use the new SCHIP extensions. {{refn|name=compatibility|[https://github.com/JohnEarnest/Octo/blob/gh-pages/docs/SuperChip.md#compatibility Mastering SuperChip] Compatibility section}}

Some extensions take opcodes or behavior from multiple extensions, like XO-CHIP which takes some from behavior from SCHIP and CHIP-8E. <ref>{{cite web | url=https://github.com/JohnEarnest/Octo/blob/gh-pages/docs/XO-ChipSpecification.md | title=XO-CHIP Specification by John Earnest | website=[[GitHub]] }}</ref>

==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 [[processor register|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 [[Status register|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 [[opcode]]s that involve memory operations.

===The stack===

The [[call stack|stack]] is only used to store return addresses when [[subroutine]]s are called. The original [[RCA 1802]] version allocated 48 bytes for up to 12 levels of nesting;<ref>{{Cite book|url=https://archive.org/details/bitsavers_rcacosmacCManual1978_6956559/page/n36/mode/2up|title=RCA COSMAC VIP CDP18S711 Instruction Manual|publisher=RCA Solid State Division|year=1978|location=Somerville|pages=36}}</ref> modern implementations usually have more.<ref>{{Cite web |last=Greene |first=Thomas P. |date=1997-08-30 |title=Cowgod's Chip-8 Technical Reference |url=http://devernay.free.fr/hacks/chip8/C8TECH10.HTM |url-status=live |archive-url=https://web.archive.org/web/20240103155311/http://devernay.free.fr/hacks/chip8/C8TECH10.HTM |archive-date=2024-01-03 |access-date=2020-02-03 |website=devernay.free.fr }}</ref><ref>{{Cite web|url=http://mattmik.com/files/chip8/mastering/chip8.html|title=Mastering CHIP-8 : Subroutines|last=Mikolay|first=Matthew|website=mattmik.com|access-date=2020-02-03}}</ref>

===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 [[hexadecimal|hex]] [[computer keyboard|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 [[pixel]]s, and color is [[monochrome]]. Graphics are drawn to the screen solely by drawing [[sprite (computer science)|sprite]]s, 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 [[opcode]]s, which are all two bytes long and stored [[Endianness|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.

{| class="wikitable sortable"
!Opcode
!Type
!C Pseudocode
!Explanation
|-
| {{mono|0NNN}}
| {{mono|Call}}
|
|Calls machine code routine ([[RCA 1802]] for COSMAC VIP) at address NNN.  Not necessary for most ROMs.<ref name=":0" />
|-
| {{mono|00E0}}
| {{mono|Display}}
| {{code|1=disp_clear()|2=c}}
|Clears the screen.<ref name=":0">{{Cite web |last=Schümann |first=Steffen "Gulrak" |title=CHIP-8 Variant Opcode Table |url=https://chip8.gulrak.net/ |website=chip8.gulrak.net}}</ref>
|-
| {{mono|00EE}}
| {{mono|Flow}}
| {{code|1=return;|2=c}}
|Returns from a subroutine.<ref name=":0" />
|-
| {{mono|1NNN}}
| {{mono|Flow}}
| {{code|1=goto NNN;|2=c}}
|Jumps to address NNN.<ref name=":0" />
|-
| {{mono|2NNN}}
| {{mono|Flow}}
| {{code|1=*(0xNNN)()|2=c}}
|Calls subroutine at NNN.<ref name=":0" />
|-
| {{mono|3XNN}}
| {{mono|Cond}}
| {{code|1=if (Vx == NN)|2=c}}
|Skips the next instruction if VX equals NN (usually the next instruction is a jump to skip a code block).<ref name=":0" />
|-
| {{mono|4XNN}}
| {{mono|Cond}}
| {{code|1=if (Vx != NN)|2=c}}
|Skips the next instruction if VX does not equal NN (usually the next instruction is a jump to skip a code block).<ref name=":0" />
|-
| {{mono|5XY0}}
| {{mono|Cond}}
| {{code|1=if (Vx == Vy)|2=c}}
|Skips the next instruction if VX equals VY (usually the next instruction is a jump to skip a code block).<ref name=":0" />
|-
| {{mono|6XNN}}
| {{mono|Const}}
| {{code|1=Vx = NN|2=c}}
|Sets VX to NN.<ref name=":0" />
|-
| {{mono|7XNN}}
| {{mono|Const}}
| {{code|1=Vx += NN|2=c}}
|Adds NN to VX (carry flag is not changed).<ref name=":0" />
|-
| {{mono|8XY0}}
| {{mono|Assig}}
| {{code|1=Vx = Vy|2=c}}
|Sets VX to the value of VY.<ref name=":0" />
|-
| {{mono|8XY1}}
| {{mono|BitOp}}
| <syntaxhighlight lang="c" inline>Vx |= Vy</syntaxhighlight>
|Sets VX to VX [[Logical disjunction|or]] VY. (bitwise OR operation).<ref name=":0" />
|-
| {{mono|8XY2}}
| {{mono|BitOp}}
| {{code|1=Vx &= Vy|2=c}}
|Sets VX to VX [[Logical conjunction|and]] VY. (bitwise AND operation).<ref name=":0" />
|-
| {{mono|8XY3}}{{efn|name=rcaops|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 [[Arithmetic logic unit|ALU]], and not located in the interpreter itself; these four additional opcodes were therefore presumably unintentional functionality.}}
| {{mono|BitOp}}
| {{code|1=Vx ^= Vy|2=c}}
|Sets VX to VX [[xor]] VY.<ref name=":0" />
|-
| {{mono|8XY4}}
| {{mono|Math}}
| {{code|1=Vx += Vy|2=c}}
|Adds VY to VX. VF is set to 1 when there's an overflow, and to 0 when there is not.<ref name=":0" />
|-
| {{mono|8XY5}}
| {{mono|Math}}
| {{code|1=Vx -= Vy|2=c}}
|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).<ref name=":0" />
|-
| {{mono|8XY6}}{{efn|name=rcaops}}
| {{mono|BitOp}}
| {{code|1=Vx >>= 1|2=c}}
|Shifts VX to the right by 1, then stores the least significant bit of VX prior to the shift into VF.{{efn|name=bitshift|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.{{refn|name=compatibility}}}}<ref name=":0" />
|-
| {{mono|8XY7}}{{efn|name=rcaops}}
| {{mono|Math}}
| {{code|1=Vx = Vy - Vx|2=c}}
|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).<ref name=":0" />
|-
| {{mono|8XYE}}{{efn|name=rcaops}}
| {{mono|BitOp}}
| {{code|1=Vx <<= 1|2=c}}
|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.{{efn|name=bitshift}}<ref name=":0" />
|-
| {{mono|9XY0}}
| {{mono|Cond}}
| {{code|1=if (Vx != Vy)|2=c}}
|Skips the next instruction if VX does not equal VY. (Usually the next instruction is a jump to skip a code block).<ref name=":0" />
|-
| {{mono|ANNN}}
| {{mono|MEM}}
| {{code|1=I = NNN|2=c}}
|Sets I to the address NNN.<ref name=":0" />
|-
| {{mono|BNNN}}
| {{mono|Flow}}
| {{code|1=PC = V0 + NNN|2=c}}
|Jumps to the address NNN plus V0.<ref name=":0" />
|-
| {{mono|CXNN}}
| {{mono|Rand}}
| {{code|1=Vx = rand() & NN|2=c}}
|Sets VX to the result of a bitwise and operation on a random number (Typically: 0 to 255) and NN.<ref name=":0" />
|-
| {{mono|DXYN}}
| {{mono|Display}}
| {{code|1=draw(Vx, Vy, N)|2=c}}
|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.<ref name=":0" />
|-
| {{mono|EX9E}}
| {{mono|KeyOp}}
| {{code|1=if (key() == Vx)|2=c}}
|Skips the next instruction if the key stored in VX(only consider the lowest nibble) is pressed (usually the next instruction is a jump to skip a code block).<ref name=":0" />
|-
| {{mono|EXA1}}
| {{mono|KeyOp}}
| {{code|1=if (key() != Vx)|2=c}}
|Skips the next instruction if the key stored in VX(only consider the lowest nibble) is not pressed (usually the next instruction is a jump to skip a code block).<ref name=":0" />
|-
| {{mono|FX07}}
| {{mono|Timer}}
| {{code|1=Vx = get_delay()|2=c}}
|Sets VX to the value of the delay timer.<ref name=":0" />
|-
| {{mono|FX0A}}
| {{mono|KeyOp}}
| {{code|1=Vx = get_key()|2=c}}
|A key press is awaited, and then stored in VX (blocking operation, all instruction halted until next key event, delay and sound timers should continue processing).<ref name=":0" />
|-
| {{mono|FX15}}
| {{mono|Timer}}
| {{code|1=delay_timer(Vx)|2=c}}
|Sets the delay timer to VX.<ref name=":0" />
|-
| {{mono|FX18}}
| {{mono|Sound}}
| {{code|1=sound_timer(Vx)|2=c}}
|Sets the sound timer to VX.<ref name=":0" />
|-
| {{mono|FX1E}}
| {{mono|MEM}}
| {{code|1=I += Vx|2=c}}
|Adds VX to I. VF is not affected.{{efn|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.<ref>{{cite web |url=https://github.com/Chromatophore/HP48-Superchip/issues/2 |title = FX1E and VF · Issue #2 · Chromatophore/HP48-Superchip · GitHub| website=[[GitHub]] }}</ref> 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.}}<ref name=":0" />
|-
| {{mono|FX29}}
| {{mono|MEM}}
| {{code|1=I = sprite_addr[Vx]|2=c}}
|Sets I to the location of the sprite for the character in VX(only consider the lowest nibble). Characters 0-F (in hexadecimal) are represented by a 4x5 font.<ref name=":0" />
|-
| {{mono|FX33}}
| {{mono|BCD}}
| <syntaxhighlight lang="c" style="font-size: 90%">set_BCD(Vx)
*(I+0) = BCD(3);
*(I+1) = BCD(2);
*(I+2) = BCD(1);</syntaxhighlight>
|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.<ref name=":0" />
|-
| {{mono|FX55}}
| {{mono|MEM}}
| {{code|1=reg_dump(Vx, &I)|2=c}}
|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.{{efn|name=increment|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.}}<ref name=":0" />
|-
| {{mono|FX65}}
| {{mono|MEM}}
| {{nowrap|{{code|1=reg_load(Vx, &I)|2=c}}}}
|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.{{efn|name=increment}}<ref name=":0" />
|}

==See also==
*[[Fantasy video game console]]

===Notes===
{{Notelist}}
==References==

{{Reflist}}

==Further reading==
*[https://chip8.gulrak.net/ CHIP-8 Variant Opcode Table] an accurate reference to the opcodes for CHIP-8 and several extensions, including CHIP-48, SCHIP 1.0, 1.1, XO-CHIP.
*[http://mattmik.com/files/chip8/mastering/chip8.html Mastering CHIP-8], an accurate reference to the original CHIP-8 instruction set.
*[http://devernay.free.fr/hacks/chip8/C8TECH10.HTM Cowgod's Chip-8 Technical Reference] contains inaccuracies and omissions in several instructions.
*[http://www.mattmik.com/files/chip8/extensions/CHIP8ExtensionsReference.pdf Matt Mikolay ''CHIP-8 Extensions Reference'']
*[https://archive.today/20130412050150/http://dir.groups.yahoo.com/group/rcacosmac/ RCA COSMAC group on Yahoo], with authorized scans of the VIPER magazine.
*[https://storage.googleapis.com/wzukusers/user-34724694/documents/5c83d6a5aec8eZ0cT194/CHIP-8%20Classic%20Manual%20Rev%201.3.pdf ''CHIP-8.com''] CHIP-8 Classic Computer Manual
*Archive of [https://web.archive.org/web/20131030034311/http://www.chip8.com/ Chip8.com] Website dedicated to CHIP-8 and related systems. Maintained a large collection of CHIP-8 programs on the net.
* "RCA COSMAC VIP CDP18S711 Instruction Manual," RCA Solid State Division, Somerville, NJ 08776, February 1978. Part VIP-311. pp.&nbsp;13–18, 35–37.
* [[BYTE magazine]], [https://archive.org/details/byte-magazine-1978-12 December 1978], pp.&nbsp;108–122. "An Easy Programming System," by [[Joseph Weisbecker]].  Describes CHIP-8 with specific example of a rocketship and UFO shooting-gallery game.

==External links==
*[https://bitbucket.org/csoren/fpga-chip8 FPGA SuperChip] A Verilog implementation of the SCHIP specification.
*[https://johnearnest.github.io/Octo/ Octo] is an Online CHIP-8 IDE, Development System, Compiler/Assembler and Emulator, with a proprietary scripting language
*[https://github.com/gulrak/cadmium Cadmium] is a CHIP-8 interpreter for computers, with a [[Graphical user interface|GUI]] which allows for selecting accurate emulation of different extensions and implementations of CHIP-8
*[https://timendus.github.io/silicon8/ Silicon8] A CHIP-8 emulator for web browsers.

[[Category:Virtual machines]]
[[Category:Virtualization software]]
[[Category:Microcomputer software|CHIP-8]]
[[Category:Graphing calculator software]]