General Glossary

If you're on this page, I probably used a term you don't understand. This glossary will attempt to explain general terms in an easy-to-understand vocabulary.


If you see a number prefixed with one of these symbols, that means the number is hexadecimal rather than decimal.
This is an addressing mnemonic in 65c816 assembly that means the values at addresses $xx, $xx+1, and $xx+2 form a pointer to a 24-bit address. This is indirect addressing. It's a lot easier to type, read, and understand than explicitly mentioning all 3 bytes.
This is an addressing mnemonic in 65c816 assembly that means the values at addresses $xx and $xx+1 form a pointer to a local 16-bit address. This is indirect addressing. It's a lot easier to type, read, and understand than explicitly mentioning both bytes.

Memory is not always independent; some addresses operate together to form arrays of data, 16- or 24-bit pointers, or some other related collection. When I use brackets after an address $xx, the value in brackets [y] is the size of the block of data in bytes. For example, $0780[2] would mean two bytes at the consecutive addresses $0780 and $0781. If brackets are omitted, then assume only 1 byte is being addresses, unless context implies otherwise.

When addressing large portions of memory, [y] may be in hexadecimal, but I will use decimal numbers when values are smaller.



A bank is a big section of code or data, and it can hold both RAM and/or ROM. There are 256 addressable banks of 65536 bytes each on the Super Nintedo, but with some caveats. If you'd like to know more about those caveats, see this video by Dotsarecool.

If you see me use an address like this $07:8000, then that first byte ($07) is the bank.

As a verb, branching means to check some condition. If that condition is true, then follow branch's pointer to a new part of the code. If that condition is false, then the pointer is ignored, and execution continues.
As a noun, I may use branch to mean one of those segments of code that is followed after a branch instruction is looked at.
Sometimes you want to set up data to work with later. To do that, you can place it in a buffer, which is just a place in memory that you know will be stable until you're ready to use that data.


Characters are what most people would (technically incorrectly) call a sprite. When discussing SNES graphics, the distinct squares of shared graphics are called characters. If you'd like to know more about characters, see this video by Dotsarecool.

I don't need to, nor will I, explain what a CPU is, but I will explain what the Super Nintendo's CPU is.

The SNES uses the Ricoh 5A22, a 16-bit chip based on the Wester Design Center's 65c816. It has the same instruction set and address space as the 65c816, but it also includes proprietary functions as the 60hz interrupt for V-blank/NMI and direct memory access.


Direct Memory Access
This is just a really fast way to move data from 1 location in memory to another. If you'd like to know more, I recommend watching this video by Dotsarecool.



If I told you to write down a six digit number, say one-hundred-twenty-three-thousand-four-hundred-fifty-six, you would probably write down 123456. This isn't really how the SNES works with large numbers in memory, whether they be data, addresses, or pointers.

The CPU prefers numbers to be in little endian, which means the bytes are written from low to high. For example, the value $123456 would be in memory as $56 in the first byte, $34 in the second, and $12 in the third.

All numbers I write will be in big endian, which means the bytes are written from high to low, as you'd expect for human-readable posts. Just don't be confused if I have to reference the memory byte-by-byte and you see numbers reversed.


Think of indexing as finding your place in a row of seats. Indexing is done with one of the index registers, X or Y. If we're indexing an address, we take the value of the register we're using and count that many bytes from the address.
An interrupt is exactly what it sounds like. Something tells the CPU to stop what it's doing and work on something else. That something else is determined by a vector specific to that interrupt. Many crashes are actually the CPU being given an interrupt it wasn't meant to handle. The vector will be a filler value like $FFFF, which results in garbage code being run.


Masking is just another way of saying "logically AND with a value". It's a mask because it exposes relevant active bits and hides everything else.
Being able to access certain types of memory in more than one place is useful. A mirror is just one of those duplicate places that makes working with that memory doable. If you'd like to learn more, see this video by Dotsarecool.
The game mode or game module is just the topmost level of the execution hierarchy, and it usually defines the broad class of behavior to be expected of its submodules. Submodules being the next step down. For example, A Link to the Past has a module for the both the overworld and the underworld. Within each of those modules, it also has submodules for default player control and transitioning, along with many other module-specific submodules.


NMI stands for Non-Maskable Interrupt. That means that when the interrupt happens, you cannot ignore it. On the Super Nintendo, NMI is handled by the hardware and is intended for the V-blank routine. It's fired roughly 60 times every second, being directly what is responsible for the console's frame rate. While the NMI on the SNES cannot be ignored, it can be halted by telling the CPU to not make the request.


Registers are really just extra special places in memory that we use a lot. Because we use them a lot, they're easy to access. The Super Nintendo CPU has a few that are worth explaining. If there's a register it has that I haven't mentioned here, I probably haven't used it in a post. Yet.
The A register (sometimes C when it's in 16-bit mode) is just the general use register that holds data we are actively working with. If I say something is loaded or stored without qualification, it probably was with the accumulator. The accumulator is the most manipulable register, and the only one that arithmetic or bitwise operations can be performed on. So if I say some number was added to another, it was done with the accumulator.
Index register
The X and Y registers are each an index register. They're used to find offsets into lists or to help control loops. They can and are used for general loading and storing like the accumulator, but they are not as manipulable as it. The only mathematical operations you can perform on the index registers are incrementation and decrementation.
Stack pointer
While the stack itself is just a place in RAM, the stack pointer (S) is a special register that says where the next empty slot is.
A routine is a block of code that does something. I'll usually refer to them as something being called. Calling a routine means the routine was pointed to in the middle of another section of code. The routine gets executed and then execution returns to after the location that called it.


Save RAM
Exactly what it sounds like. This is the game's save data. More general computer-related posts use SRAM to mean Static RAM; I will only ever use it to mean Save RAM.
Scrach space, scratch memory, or whatever I end up calling it just means memory that is used for temporary calculation or storage. The memory is extremely volatile over the course of a frame. I'll try to only explicitly give the address of scratch space if it will be relevant to some part of the explication. Otherwise, just consider it something that doesn't matter in end.
When discussing SNES graphics specifically, a sprite or object is a very specific entity of graphics with the following properties: X-position, Y-position, palette, character, priority, V-flip, H-flip. Contrast this with the colloquial use of sprite as either a self-acting entity or a specific graphic. I will use sprite to mean the former, just because even I find it intuitive, but never the latter. If you'd like to know more about sprites, see this video by Dotsarecool.
When you want to work with a lot of data at once, or remember your place while you perform a side task, you need a way to remember what you were using or doing. That's where the stack comes in. It's a special place in memory that has special operations specific to it which allow you to store and recall data, pointers, or registers. If you'd like a more in-depth explanation of the stack, see this video by Dotsarecool.


When an interrupt it occurs, it has to know where to go. A small portion of ROM contains pointers for each vector, and that's where the CPU will look when it's told to take a break from its normal operation.
Video RAM
This is memory specifically allotted for controlling the ile maps and graphics characters that constitute the image shown on your screen. VRAM is on its own chip, separate from other memory.


Work RAM
This is the main memory the CPU works with to handle temporary data. It contains everything from sprite data and player coordinates to a spare copy of save data in many games.