Sega Saturn Demo Discs

Edit on Github | Updated: 9th August 2026

Sega Saturn demo discs are useful for reverse engineering because they often ship earlier or alternate builds of retail games, and they can expose different SDK library versions than the final release. Official samplers and magazine covermounts also pack multiple playable demos onto one disc, which makes them a good starting point when hunting for symbols, leftover debug strings, or unreleased content.

The tables below catalogue 184 Saturn demo and magazine disc dumps across Europe, USA, and Japan. Demo names omit region and redundant (Demo) tags already covered by other columns. Notes capture useful extras such as magazine covermount links and alternate dump labels where known.

Product codes, versions, and dates come from each disc’s IP.BIN header when a dump is available. Printed product codes are used when a covermount is documented without a local dump.

For multi-game samplers and magazine discs, the Games column lists titles recovered from per-game *_IP.BIN files on the ISO when present. If those headers are missing or reused, the column falls back to distinctive ISO directory names from the disc.

Europe and USA samplers / covermounts

These discs package multiple demos or trailers onto one CD. They are grouped below into official Sega samplers, the European Sega Flash series, and publisher-produced sampler discs.

Official samplers

The table below lists 5 official sampler discs:

Sega Flash

Sega Flash was Sega Europe’s official Saturn demo-disc series. Discs were console pack-ins and covermounts for the UK magazine Sega Saturn Magazine. Sega Retro lists 7 volumes from 1996 to 1998 ¹. Do not confuse it with the Japanese Flash SegaSaturn club series.

The table below lists 7 disc dumps:

Publisher samplers

The table below lists 3 publisher sampler discs:

Saturn Power

UK magazine Saturn Power shipped covermount discs with several issues. Known covermounts in this set are:

• Saturn Power 1 - Core Demo Disc
• Saturn Power 2 - Gremlin Demo Disc
• Saturn Power 3 - Block Rocking Beats (audio disc artwork only in this set, no game dump)
• Saturn Power 5 - WipEout 2097 demo

Single-game demos (Europe and USA)

The table below lists 13 disc dumps from this group:

Japan demos and magazine discs

The subsections below group 156 Japan disc dumps. Some series were official Sega club/partner discs rather than newsstand magazines. Others were print magazines that shipped Saturn covermount CDs.

Flash SegaSaturn

Flash SegaSaturn (フラッシュ・セガサターン) was an official Sega Japan demo-disc series for Sega Club members, not a print magazine. Sega Retro documents 32 numbered volumes from 1996 to 1998, plus the hardware-bundled special disc Ochikazuki-hen (おちかづき編) ³. Do not confuse it with the unrelated European Sega Flash series.

The table below lists 33 disc dumps:

Mogitate SegaSaturn

Mogitate SegaSaturn (モギタテセガサターン, “freshly picked” Saturn) was a Sega Partners / club information-disc series rather than a newsstand magazine. Known discs include the November 1997 inaugural Soukangou issue, Vol. 2 through Vol. 6 (1998-1999), and a Special Movie disc (Deep Fear and Shadows of the Tusk trailers) that Redump notes was bundled with Vol. 3 ^{4 5}. This set has Vol. 2-6 plus Special Movie, and does not include the 1997 first issue.

The table below lists 6 disc dumps:

Tech Saturn

Tech Saturn (テックサターン) was an ASCII magazine focused on the Sega Saturn. It began as Tech Saturn Tsuushin (TECH サターン通信) and later shortened the title to Tech Saturn when it moved to a denser monthly schedule ⁶. Covermount discs tracked by Sega Retro include Tsuushin Vol. 1-5, two 1996 volumes, and monthly discs for January through October 1997.

The table below lists 17 disc dumps:

Saturn Super

Saturn Super (サターンスーパー) was a Japanese Saturn magazine that shipped its own demo discs. Sega Retro lists it as bimonthly from mid-1995 to early 1997 with 11 numbered issues, plus extras such as Saturn CG Selection and Taikenban Saturn Soft Taizen (体験版サターンソフト大全) ⁷. Later volumes are often labeled as furoku (付録) CD-ROMs.

The table below lists 13 disc dumps:

Develo Magazine

Develo Magazine (デベロマガジン) was a Tokuma Shoten Intermedia print magazine. The Saturn disc below is its known appendix CD-ROM covermount, a compilation of mostly non-interactive demos for upcoming titles ⁹.

The table below lists 1 disc dump:

Publisher samplers

Publisher line-up discs were used to show multiple upcoming titles from one company on a single Saturn CD.

The table below lists 1 disc dump:

Other demo discs

Miscellaneous Japan demo or promotional discs that do not belong to the magazine or club series above.

The table below lists 1 disc dump:

Single-game demos

The table below lists 84 disc dumps:

Reading IP.BIN metadata

Each Saturn disc stores identity fields in the first sectors of the data track as IP.BIN. The useful contribution fields for this catalogue are:

• Product - 10-byte product number at offset 0x20
• Version - 6-byte version string at offset 0x2A
• Date - 8-byte release date at offset 0x30 (usually YYYYMMDD)
• Title - game/disc title at offset 0x60

Multi-game samplers and magazine discs often also ship per-game headers such as G1_IP.BIN or BB_IP.BIN in the ISO root. The script below reads the disc IP.BIN, then scans the ISO9660 root for those files and prints each game title.

If you have a .cue / .bin dump, run it against Track 1 (the MODE1 data track). Paste the printed values into the tables on this page.

#!/usr/bin/env python3
"""Read Sega Saturn disc IP.BIN fields and list games on multi-game discs."""

from __future__ import annotations

import argparse
import re
import struct
from pathlib import Path

HW_MAGIC = b"SEGA SEGASATURN "
SECTOR = 2352
USER = 2048
USER_OFF = 16


def format_date(raw: str) -> str:
    raw = raw.strip()
    if len(raw) == 8 and raw.isdigit():
        yyyy, mm, dd = raw[0:4], raw[4:6], raw[6:8]
        if yyyy.startswith(("19", "20")) and 1 <= int(mm) <= 12 and 1 <= int(dd) <= 31:
            return f"{yyyy}-{mm}-{dd}"
        mm, dd, yyyy = raw[0:2], raw[2:4], raw[4:8]
        if yyyy.startswith(("19", "20")) and 1 <= int(mm) <= 12 and 1 <= int(dd) <= 31:
            return f"{yyyy}-{mm}-{dd}"
    return raw


def raw_to_user(raw: bytes) -> bytes:
    user = bytearray()
    for i in range(len(raw) // SECTOR):
        off = i * SECTOR
        user.extend(raw[off + USER_OFF : off + USER_OFF + USER])
    return bytes(user)


def read_lbas(track_bin: Path, start_lba: int, count: int) -> bytes:
    with track_bin.open("rb") as f:
        f.seek(start_lba * SECTOR)
        raw = f.read(count * SECTOR)
    if len(raw) < SECTOR:
        raise SystemExit(f"Could not read LBA {start_lba} from {track_bin}")
    return raw_to_user(raw)


def parse_ip(ip: bytes) -> dict[str, str] | None:
    if ip[:16] != HW_MAGIC:
        idx = ip.find(HW_MAGIC)
        if idx < 0:
            return None
        ip = ip[idx:]
    if len(ip) < 0xD0:
        return None

    def field(start: int, size: int) -> str:
        return ip[start : start + size].decode("ascii", "replace").replace("\0", "").strip()

    date_raw = field(0x30, 8)
    title = re.sub(r"[^\x20-\x7E]+", " ", field(0x60, 0x70))
    title = re.sub(r"\s+", " ", title).strip()
    if not title:
        return None
    return {
        "maker": field(0x10, 16),
        "product": field(0x20, 10),
        "version": field(0x2A, 6),
        "date_raw": date_raw,
        "date": format_date(date_raw),
        "device": field(0x38, 8),
        "title": title,
    }


def both_endian_u32(buf: bytes, offset: int) -> int:
    return struct.unpack_from("<I", buf, offset)[0]


def list_iso_dir(user: bytes, extent: int, size: int) -> list[tuple[str, bool, int, int]]:
    data = user[extent * USER : extent * USER + size]
    pos = 0
    entries: list[tuple[str, bool, int, int]] = []
    while pos < len(data):
        length = data[pos]
        if length == 0:
            nxt = ((pos // USER) + 1) * USER
            if nxt <= pos or nxt >= len(data):
                break
            pos = nxt
            continue
        if pos + length > len(data):
            break
        flags = data[pos + 25]
        name_len = data[pos + 32]
        name = data[pos + 33 : pos + 33 + name_len]
        extent_lba = both_endian_u32(data, pos + 2)
        file_size = both_endian_u32(data, pos + 10)
        if name not in (b"\x00", b"\x01"):
            decoded = name.decode("ascii", "replace").split(";")[0]
            entries.append((decoded, bool(flags & 0x02), extent_lba, file_size))
        pos += length
    return entries


def root_entries(track_bin: Path) -> list[tuple[str, bool, int, int]]:
    # PVD is logical block 16. Pull enough early LBAs for the root directory.
    head = read_lbas(track_bin, 0, 1024)
    pvd = head[16 * USER : 17 * USER]
    if pvd[1:6] != b"CD001":
        raise SystemExit(f"No ISO9660 PVD found in {track_bin}")
    root = pvd[156 : 156 + 34]
    root_extent = both_endian_u32(root, 2)
    root_size = both_endian_u32(root, 10)
    need = root_extent + (root_size + USER - 1) // USER + 4
    if need > 1024:
        head = read_lbas(track_bin, 0, need)
    return list_iso_dir(head, root_extent, root_size)


def is_game_ip_name(name: str) -> bool:
    return bool(re.search(r"(^|_)IP\.BIN$", name.upper()))


def list_games(track_bin: Path, disc_title: str) -> list[str]:
    games: list[str] = []
    seen: set[str] = set()
    entries = root_entries(track_bin)

    for name, is_dir, extent, size in entries:
        if is_dir or not is_game_ip_name(name):
            continue
        sectors = max(1, (min(size, 32768) + USER - 1) // USER)
        payload = read_lbas(track_bin, extent, sectors)[:size]
        meta = parse_ip(payload)
        if not meta:
            continue
        title = meta["title"]
        if title == disc_title or title in seen:
            continue
        if title.upper() in {"SAMPLE GAME", "SAMPLE IP_BIN", "DEMO DEMO DISK"}:
            continue
        if title.upper().startswith("GAME TITLE"):
            continue
        seen.add(title)
        games.append(title)

    if len(games) >= 2:
        return games

    # Fallback: distinctive root folders when per-game IP headers are missing/reused.
    skip = {
        "SYSTEM", "DATA", "SOUND", "SOUNDS", "TITLE", "FMV", "OTHER", "INTRO",
        "MAINMENU", "DEMOMENU", "VIDPROC", "SOFDEC", "CA_RYUBO",
    }
    dirs = []
    for name, is_dir, _extent, _size in entries:
        if not is_dir:
            continue
        upper = name.upper()
        if upper in skip or re.fullmatch(r"G\d{1,3}", upper):
            continue
        dirs.append(name)
    return dirs


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("track1_bin", type=Path, help="Path to Track 1 MODE1/2352 .bin")
    args = parser.parse_args()

    disc = parse_ip(read_lbas(args.track1_bin, 0, 16))
    if not disc:
        raise SystemExit(f"No Saturn IP header at sector 0: {args.track1_bin}")

    print(f"Title:   {disc['title']}")
    print(f"Maker:   {disc['maker']}")
    print(f"Product: {disc['product']}")
    print(f"Version: {disc['version']}")
    print(f"Date:    {disc['date']} (raw {disc['date_raw']})")
    print(f"Device:  {disc['device']}")

    games = list_games(args.track1_bin, disc["title"])
    if not games:
        print("Games:   (single-game disc, or no per-game IP.BIN / folders found)")
        return

    print(f"Games ({len(games)}):")
    for title in games:
        print(f"  - {title}")


if __name__ == "__main__":
    main()

Example for a single-game demo:

python3 saturn_ip_info.py "Bug! (USA) (Demo) (Track 01).bin"

Example for a multi-game sampler:

python3 saturn_ip_info.py "Bootleg Sampler (Europe) (Track 01).bin"

When contributing a missing disc, send the Demo name, Region, Product, Version, Date, and the playable games list if it is a multi-game disc.

SDK library versions in demo executables

Many Saturn demos still embed Sega SDK library banners inside their game executables (.BIN, .PRG, and similar). The banner format is:

GFS_SGL Version 2.11 1996-03-21

These strings identify which SEGALIB / SGL companion libraries were linked, and roughly when that library build was dated. They are useful for FLIRT-style matching and for dating a build relative to retail.

Method

The scan used the dumps catalogued on this page and worked in two steps:

• Extract likely game executables from each demo Track 1 ISO (scripts/saturn-demo-extract-ip.py --mode exe)
• Search those binaries for known library banners (scripts/saturn-demo-sdk-versions.py)

Across 1190 extracted executables, 418 contained at least one banner. That produced 45 unique library + version pairs (or 51 if identical version numbers with different embedded dates are counted separately).

Hits count how many extracted executables contained that banner. One example executable is listed per version.

Findings

The most common banners in this demo set are:

• CPK Version 1.20 1995-10-05 - 152 hits (Cinepak / FILM playback)
• GFS_SBL Version 2.10 1996-02-01 - 131 hits (file system, SBL-linked)
• GFS_SGL Version 2.11 1996-03-21 - 92 hits (file system, SGL-linked)
• STM_SGL Version 2.11 1996-03-21 - 62 hits (stream system, SGL-linked)
• SYS Version 2.11 1996-02-26 - 49 hits (system / init helpers)

A few patterns stand out:

• SGL titles cluster around GFS_SGL / STM_SGL 2.11; SBL titles cluster around GFS_SBL / STM_SBL 2.10
• Later SYS 2.50 / 2.52 / 2.53 banners appear mainly on 1997-98 demos
• MPG banners show up in SoftBank / Mogitate SFDPLAY MPEG players rather than ordinary game code
• Rare but present: GFS_SBL 2.13, DPSYS 2.10, and a single SYS 3.00 string inside Mogitate Vol. 2’s SFDPLAY.BIN

Not every demo leaves banners behind. Stripped retail-style builds, PSY-Q titles, and assets-only files will not appear below.

Unique library versions

The table below lists each unique library version found in the extracted demo executables, with hit count and one example file:

To reproduce against a local extract folder:

python3 scripts/saturn-demo-sdk-versions.py /path/to/SaturnDemoExes

References