SMC File Documentation
Summary
An SMC file is a Super Nintendo (SNES) game ROM: a byte-for-byte dump of a cartridge's read-only memory that you play in an SNES emulator. Its MIME type is application/octet-stream. The .smc extension is interchangeable with .sfc; the difference is historical, as .smc files often carry a 512-byte copier header that emulators skip. Play one with Snes9x, RetroArch or OpenEmu — only with ROMs of games you own.
Technical details
| Feature | Value |
|---|---|
| Full name | Super Nintendo (SNES) ROM image |
| File extension | .smc |
| MIME type | application/octet-stream |
| Format type | Raw cartridge ROM dump |
| Console | Super Nintendo Entertainment System / Super Famicom |
| Origin of name | Super Magicom cartridge copier |
| Introduced | Early-mid 1990s (copier era) |
| Open standard | No — community convention, no formal spec |
| Magic number | None — identified by size and internal header |
| Copier header | Optional 512 bytes at the start (file size = multiple of 32 KB + 512) |
| Internal header location | 0x7FC0 (LoROM) or 0xFFC0 (HiROM) |
| Internal header holds | Game title (ASCII), map mode, ROM/RAM size, checksum |
| Memory maps | LoROM, HiROM (and variants) |
| Interchangeable with | .sfc (often headerless) |
| Save data | Separate .srm file (not inside the ROM) |
| Enhancement chips | May target SA-1, Super FX, DSP, etc. (in ROM data) |
| Patches applied to it | IPS / BPS ROM hacks and translations |
| Related extensions | .sfc, .fig, .swc, .srm, .zip |
| Category | Game / ROM image |
| Reference | snes.nesdev.org/wiki/ROM_file_formats |
What is an SMC file?
An .smc file is a ROM image of a Super Nintendo Entertainment System (SNES / Super Famicom) game cartridge: a byte-for-byte copy of the cartridge's read-only memory. Run inside an emulator, it reproduces the original game, because the ROM holds the game's program code, graphics and audio data exactly as the cartridge's mask-ROM chip stored them. The extension dates to the cartridge-copier era of the early-to-mid 1990s. "SMC" is named after the Super Magicom, a floppy-based device that backed up cartridges; copiers like it prepended a 512-byte header to the dump, which is why many .smc files are exactly 512 bytes larger than a clean dump.
There is no vendor specification for the format because it is a community convention rather than a designed file type. What structure it has comes from two places: the optional copier header at the front, and the SNES internal header that the console itself expects to find in the cartridge's address space. The sections below cover both, the LoROM/HiROM memory maps that decide where the internal header sits, the near-identical .sfc extension, and how patches are applied on top of a base ROM. Byte offsets follow the SNESdev Wiki.
The 512-byte copier header
Many .smc files open with a 512-byte block that is not part of the cartridge data at all. Old copiers wrote it to record how the dump was split across floppy disks and how the ROM should be mapped. On a modern system this header is dead weight, and it is the single most common reason an SMC ROM "won't load" cleanly: if a tool assumes a headerless ROM but the file has the extra 512 bytes, every offset is off by 512.
Detecting it is arithmetic. A clean SNES dump is always a whole number of 32 KB banks, so its size is a multiple of 32768. The copier header adds exactly 512 bytes, so a headered file's size leaves a remainder of 512 when divided by 1024. Emulators run this check automatically and skip the header when present, which is why the same ROM plays whether or not the header is there. Tools such as NSRT can strip or add the header explicitly when a program needs one form or the other.
headered .smc = [ 512-byte copier header ] + [ ROM data ]
headerless = [ ROM data ]
is_headered = (filesize mod 1024) == 512The SNES internal header
Separate from any copier header, the console expects a small internal header inside the cartridge address space. It is not at the start of the file; it sits near the top of the first ROM bank, at file offset 0x7FC0 for a LoROM cartridge or 0xFFC0 for a HiROM cartridge (add 512 to each if a copier header is present). This 64-byte region is how the SNES, and an emulator, learn what the cartridge is.
offset (LoROM) size field
0x7FC0 21 Game title (ASCII, space-padded)
0x7FD5 1 Map mode / speed (LoROM vs HiROM, FastROM bit)
0x7FD6 1 Cartridge type (ROM, ROM+RAM, coprocessor)
0x7FD7 1 ROM size (log2, in KB)
0x7FD8 1 RAM size (log2, in KB)
0x7FD9 1 Destination / region code
0x7FDB 1 ROM version
0x7FDC 2 Checksum complement
0x7FDE 2 ChecksumThe game title is 21 bytes of ASCII, space-padded, which is why a hex viewer often shows a readable game name near 0x7FC0. The map mode byte tells the reader whether this is a LoROM or HiROM layout and whether FastROM timing is used. The cartridge type byte flags whether the game carries battery-backed RAM or an enhancement coprocessor. The last four bytes are a 16-bit checksum and its bitwise complement; the two must sum to 0xFFFF, giving a quick integrity test. Emulators use the map mode and checksum here, together with the file size, to decide how to map the ROM, precisely because the file has no signature at offset 0 to rely on.
LoROM and HiROM
SNES cartridges map their ROM into the CPU's address space in one of two main ways, and this is what fixes the internal header's location. In LoROM, 32 KB banks are mapped into the upper half of each memory bank, placing the internal header at 0x7FC0. In HiROM, 64 KB banks are mapped whole, moving the header to 0xFFC0. Bigger or special games use variants (ExHiROM, or bank layouts required by chips like the SA-1). An emulator that can't tell from the map-mode byte will try both header positions and pick the one whose checksum validates.
SMC versus SFC
In practice .smc and .sfc are the same thing: both are raw SNES ROMs. The convention is that .sfc (from "Super Famicom") is a headerless, clean dump, while .smc often carries the 512-byte copier header, but the extensions are used interchangeably and modern emulators auto-detect and skip the header either way. Renaming .smc to .sfc (or the reverse) generally just works, because the emulator judges the ROM by its size and internal header, not by the extension. If a stubborn tool insists on a headerless ROM, strip the copier header first with NSRT or an emulator's built-in handling.
ROM hacks and IPS/BPS patches
Fan translations and ROM hacks are not distributed as whole ROMs (that would be sharing the copyrighted game). Instead they ship as a patch that a user applies to a base .smc they already have. The two common patch formats are IPS and BPS. An IPS patch is a list of "at offset X, write these bytes" records — simple, but it works blind, with no check that you patched the right ROM. A BPS patch is a binary delta that records CRC checksums of the source ROM, the patch and the result, so a patcher refuses to apply it to the wrong or already-headered ROM and can verify the output byte-for-byte. Because IPS applies by raw offset, a copier header will misalign every edit, another reason header handling matters. Battery saves, incidentally, are never inside the ROM: they live in a separate .srm file, and emulator save states in their own files.
Playing an SMC, and the legal line
An .smc is inert game code; it only runs inside an emulator. Snes9x is the long-standing, actively maintained choice on Windows, macOS and Linux; RetroArch runs SNES cores (Snes9x or the accuracy-focused bsnes) across desktop and mobile; OpenEmu is the native macOS front-end; and Delta covers iOS. All of them auto-handle the copier header, so you generally just load the file. Avoid ZSNES: development ended around 2007, it is inaccurate, and it has known parsing vulnerabilities with malformed ROMs.
The legal position is worth stating plainly. Downloading ROMs of games you do not own is copyright infringement in most countries. The lawful uses are dumping cartridges you own (with a hardware dumper) and playing homebrew or freeware. The emulators themselves are legal; the ROMs are the issue. "ROM sites" are also a practical hazard, laden with fake download buttons and bundled malware, so a current, accurate emulator plus your own dumps is both the safest and the lawful path.
Frequently asked questions
What is the difference between .smc and .sfc?
They are the same SNES ROM format. By convention .sfc is a clean, headerless dump and .smc often carries a 512-byte copier header, but the extensions are interchangeable and modern emulators read either. You can usually just rename one to the other.
Why won't my SMC ROM load?
Most often a copier-header mismatch (the 512-byte block) or a corrupt download. Use a current emulator that auto-detects headers, such as Snes9x or RetroArch, re-download from a clean source, or strip the header with a tool like NSRT. You can confirm a header by checking that the file size leaves a remainder of 512 when divided by 1024.
Where are my saved games stored?
Not in the ROM. Battery saves are written to a separate .srm file, and emulator save states are kept in their own files. The .smc itself is read-only game data and never changes as you play.
References
- SNESdev Wiki — ROM file formats (headers, .smc/.sfc)
- Snes9x — official site
- RetroArch — official site
Feedback
Was this page helpful?
Glad to hear it! Please tell us how we can improve.
Sorry to hear that. Please tell us how we can improve.