The , often abbreviated as N64, was Nintendo’s third home video game console for the international market. Named for its 32/64-bit processor, it was released on June 23, 1996 in Japan, September 29, 1996 in North America, March 1, 1997 in Europe and Australia, and September 1, 1997 in France (the system also saw a release in South America, in partnership with Gradiente Eletrônica S/A).
It was released with two launch games (Super Mario 64 and Pilotwings 64) plus one in Japan (Saikyō Habu Shōgi). The N64’s suggested retail price was US$199 at its launch and it was marketed with the slogan: “Get N, or get Out!”
Development and introduction
Nintendo 64 was the culmination of work by Nintendo, Silicon Graphics, and MIPS Technologies. The SGI-based system design that ended up in the Nintendo 64 was originally offered to Tom Kalinske, then CEO of Sega of America by James H. Clark, founder of Silicon Graphics. SGI had recently bought out MIPS Technologies and the two companies had worked together to create a low-cost CPU/3D GPU combo that they thought would be ideal for the console market. A hardware team from Sega of Japan was sent to evaluate the chip’s capabilities and they found some faults which MIPS subsequently solved. However, Sega of Japan ultimately decided against SGI’s design, apparently in part due to internal problems between Sega of Japan and Sega of America.<ref></ref>
In the early stages of development the Nintendo 64 was referred to by the code name “Project Reality”.<ref>Preview pictures from the Nintendo “Project Reality” console had been published in American magazines as early as June 1993</ref> This moniker came from the speculation within Nintendo that the console could produce CGI on par with then-current supercomputers. In 1994 the console was given the name Nintendo Ultra 64 in the West. It was originally to be released in 1994 or 1995 but “Ultra” in the name having to be removed caused a delay. The console design was shown for the first time in late Spring 1994. The first picture of the console ever shown featured the Nintendo Ultra 64 logo and showed a game cartridge, but no controller. The final console was identical to this, but with a different logo. When the system together with the controller was fully unveiled in a playable form to the public on November 24, 1995, the console was introduced as the Nintendo 64 in Japan, contrary to speculation of it being called Ultra Famicom,<ref name=NintendoLandN64>The N64´s Long Way to completion, Nintendoland.com, 1998, accessed December 27, 2006.</ref> at the 7th Annual Shoshinkai Software Exhibition in Japan. Photos of the event were disseminated on the web by Game Zero magazine two days later.<ref>”Coverage of the Nintendo Ultra 64 Debut from Game Zero”, Game Zero. Retrieved May 20, 2006.</ref> Official coverage by Nintendo followed a few weeks later via the Nintendo Power website and print magazine. In February 1995 Nintendo of America announced a delay of Nintendo Ultra 64 until September 1996 in North America. Simultaneously it announced that Nintendo had adopted a new global branding strategy, calling the console everywhere Nintendo 64. Subsequently the PAL introduction was further delayed, finally being released in Europe on March 1, 1997.
During this stage of development two companies, Rareware (UK) and Midway (USA), created the arcade games Killer Instinct and Cruis’n USA which claimed to use the Ultra 64 hardware. In fact, the hardware had very little in common with what was finally released; the arcade games used hard drives and TMS processors, although they were based on the MIPS R4600 CPU. Killer Instinct was the most advanced game of its time graphically, featuring pre-rendered movie backgrounds that were streamed off the hard drive and animated as the characters moved horizontally. Nintendo dropped “Ultra” from the name on May 1, 1996, just months before its Japanese debut, because the word “Ultra” was trademarked by another company, Konami, for its Ultra Games division. The console was finally released on June 23, 1996.
Hardware
The CPU powering Nintendo 64 is a MIPS R4300i-based NEC VR4300.<ref name=”NECVR4300″></ref> The CPU is clocked at 93.75 MHz and connects to the rest of the system through a 32-bit data bus. VR43045 is a RISC 5-stage scalar in-order execution processor with an integrated floating point unit. It is a 64-bit processor, in that it has 64-bit registers, a 64-bit instruction set, and 64-bit internal data paths. However, the cost-reduced NEC VR4300 CPU utilized in the console only has 32-bit buses whereas more powerful MIPS CPUs are equipped with 64-bit buses.<ref name=”NECVR4300″ /> (In this respect the N64 CPU is like the 32-bit Motorola 68000 which is considered a 16-bit architecture, due to its bus limitation.) Many games took advantage of the chip’s 32-bit processing mode as the greater data precision available with 64-bit data types is not typically required by 3D games. Also 64-bit data uses twice as much RAM, cache, and bandwidth thereby reducing the overall system performance.<ref></ref> This was later taken advantage of by emulators such as the UltraHLE and Project64 that had to run on 32-bit Intel systems. These emulators performed most calculations at 32-bit precision, and trapped the few OS subroutines that actually made use of 64-bit instructions.
The CPU has an internal 32 KiB L1 cache but no L2 cache. It was built by NEC on a 0.35 µm process and consisted of 4.6 million transistors. The CPU is cooled passively by an aluminum heatspreader that makes contact with a steel heat sink above.
Nintendo 64’s graphics and audio duties are performed by the 64-bit SGI co-processor, named the “Reality Co-Processor”. The RCP is a 62.5 MHz chip split internally into two major components, the “Reality Drawing Processor” (RDP) and the “Reality Signal Processor” (RSP). Each area communicates with the other by way of a 128-bit internal data bus that provides 1.0 GB/s bandwidth. The RSP is a MIPS R4000-based 8-bit integer vector processor. It is programmable through microcode, allowing the chip’s functions to be significantly altered if necessary, to allow for different types of work, precision, and workloads.<ref name=B3DRCPChat></ref> The RSP performs transform, clipping and lighting calculations, and triangle setup.
The RSP, as said, also frequently performs audio functions (although the CPU can be tasked with this as well). It can playback virtually any type of audio (dependent on software codecs) including uncompressed PCM, MP3, MIDI, and tracker music. The RSP is capable of a maximum of 100 channels of PCM at a time, but this is with 100% system utilization for audio. It has a maximum sampling rate of 48 kHz with 16-bit audio. However, storage limitations caused by the cartridge format limited audio size (and thus quality).
The RDP is the machine’s rasterizer and performs the bulk of actual image creation before output to the display. Nintendo 64 has a maximum color depth of 16.8 million colors (32,768 on-screen) and can display resolutions of 256 × 224, 320 × 240, and 640 × 480 pixels.
RCP 3D features:
- Z-buffering
- Anti-aliasing
- Texture mapping
- Bilinear filtering
- Mip-mapping
- Trilinear mip-map interpolation (filters mip-maps and textures smoothly without blockiness). Nintendo 64’s filtering is not entirely accurate. Precision was reduced to lower mathematical demands.<ref name=B3DRCPFiltering></ref>
- Perspective-correct texture mapping (keeps textures from “warping” when viewed at different angles).<ref>”Perspective Corrected Texture Mapping”, GameDev.net, July 16, 1999. Retrieved May 20, 2006.</ref>
- Environment mapping
- Gouraud shading, Level of Detail (LOD)
The RCP also provides the CPU’s access to main system memory via a 250 MB/s bus. Unfortunately, this link does not allow direct memory access for the CPU. The RCP is cooled passively by an aluminum heatspreader that makes contact with a steel heat sink above.
The final major component in the system is the RAM. Nintendo 64 was the first console to implement a unified memory subsystem, instead of having separate banks of memory for CPU, audio, and video, for example. The memory itself consists of 4 MiB of RAMBUS RDRAM (expandable to 8 MiB) with a 9-bit data bus at 500 MHz providing the system with 562.5 MB/s peak bandwidth. RAMBUS was quite new at the time and offered Nintendo a way to provide a large amount of bandwidth for a relatively low cost. The narrow bus makes board design easier and cheaper than the higher width data buses required for high bandwidth out of slower-clocked RAM types (such as VRAM or EDO DRAM). However RDRAM, at the time, came with a very high access latency, and this did cause some grief for the game developers and limited hardware performance.
Nintendo 64 games were cartridge-based. Cartridge size varied from a tiny 4 MiB (32 Mbit) (i.e., Automobili Lamborghini) to 64 MiB (512 Mbit) for Resident Evil 2. The cartridge dimensions were 10.23 × 7.48 × 2.87 inches (260 × 190 × 73 mm) W×D×H. Some of the cartridges included internal EEPROM or battery-backed-up RAM for saved game storage. Otherwise game saves were put onto separate memory cards.
The new controller included with Nintendo 64 consisted of 1 analog stick, 2 shoulder buttons, 1 digital cross pad, 6 face buttons, a ’start’ button, and one digital trigger (Z). It beat the Sega Saturn’s analog controller to market by approximately one month.
Architecture and software development
The central processing unit (CPU) was primarily used for game logic, such as input management, some audio, and AI, while the “reality co-processor” (RCP) did everything else. The RCP was a customized processor that performed the majority of audio and visual tasks within the Nintendo 64. The chip is split into two main units, the “reality drawing processor” (RDP) and the “reality signal processor” (RSP). It also provides the system’s interface with the RDRAM. The RDP component basically just read a FIFO buffer and rasterized polygons. The RSP was a DSP, based around a MIPS R4000 core, designed to work with 8-bit integer vector operations.<ref name=B3DRCPChat />
In a typical N64 game, the RSP would do transforms, lighting, clipping, triangle setup, and some of the audio decoding.<ref name=B3DRCPChat /> Nintendo 64 was one of the few consoles without a dedicated audio chip so these tasks fell on the RSP and/or CPU. It was relatively common to do audio on the main CPU to increase the graphics performance.<ref name=B3DRCPChat /> Workload on the Nintendo 64 could be arranged almost in any way the programmer saw fit. This created a system that was quite flexible and malleable to the game’s needs, but it also assumed the programmer would be able to properly profile the code to optimize usage of each part of the machine.
The RSP was completely programmable, through microcode (µcode). By altering the microcode run on the device, it could perform different operations, create new effects, and be better tuned for speed or quality. However, Nintendo was unwilling to share the microcode tools with developers until the end of the Nintendo 64’s life-cycle. Programming RSP microcode was said to be quite difficult because the Nintendo 64 µcode tools were very basic, with no debugger, and poor documentation. As a result, it was very easy to make mistakes that would be hard to track down; mistakes that could cause seemingly random bugs or glitches. Some developers noted that the default SGI microcode (”Fast3D”) was actually quite poorly profiled for use in games (it was too accurate), and performance suffered as a result. Several companies were able to create custom microcode programs that ran their software far better than SGI’s generic software (e.g., Factor 5, Boss Game Studios, and Rare).
Two of the SGI microcodes<ref name=B3DRCPChat /><ref name=B3DN64Thread2></ref>
- Fast3D microcode: < ~100,000 polygons per second
- Turbo3D microcode: 500,000–600,000 polygons per second with lower quality. Nintendo never allowed this code to be used in shipping games.
The Nintendo 64 had some weaknesses that were caused by a combination of oversight on the part of the hardware designers, limitations on 3D technology of the time, and manufacturing capabilities. One major flaw was the limited texture cache of 4 KiB.<ref name=B3DN64Thread2 /> This made it extremely difficult to load anything but small textures into the rendering engine, especially textures with high color depth, and was the primary cause of blurry graphics. The small texture limitation caused blurring because developers would stretch these small textures to cover a surface and then the console’s bilinear filtering would blur them even more. To make matters worse, because of how the renderer was designed, if mipmapping was used the texture cache was effectively halved to 2 KiB. To put this in perspective, this cache could be quickly filled with even small textures (a 64×64 4-bit/pixel (bpp) texture is 2 KiB and a 128×64 4 bpp texture is 4 KiB). Modern video cards and consoles (2006) frequently deal with 1024 x 1024 8 bpp and larger textures, and have a more flexible texture cache (not always larger). To