Skip to content
Supermodel

Supermodel

EMULATOR DATABASE

Supermodel

Supermodel is an open-source emulator that reproduces Sega’s Model 3 arcade hardware, allowing many Model 3 arcade titles to run on PC and other hosts.

6.0 / 10

mame mess

Download Tutorials & guides

Sign in to download. Files are hosted by the emulator project.

mame mess
SYSTEM SPOTLIGHTmame messArtwork from the Retro Replay system database

About Supermodel

Sega’s Model 3 hardware powered a set of influential 3D arcade games in the late 1990s (Virtua Fighter 3, Scud Race, Daytona USA 2, The House of the Dead 2, etc.). Supermodel is one of the few projects focused specifically on recreating that hardware so those original arcade titles can be run and tested on modern systems for preservation, development, and hobbyist play.

- Focused, active Model 3 hardware emulation with ongoing development and cross-platform builds (Windows, Linux, macOS). - Native GUI and command-line usage options; save states and configuration stored in Supermodel.ini. - Integration into frontends via libretro (there is a libretro core) and third-party ports (Android ports exist that are based on Supermodel).

The people behind Supermodel / history

Supermodel traces to efforts to recreate Sega’s Model 3 platform; the source repository maintained by Bart Trzynadlowski (GitHub: trzy/Supermodel) and contributors contains code, documentation, and releases. The project is actively maintained with automated builds and periodic releases. There are community resources (the Supermodel website and forum) with compatibility lists and setup discussion. Third-party ports and wrappers exist (for example Android ports and frontends) that use Supermodel as upstream code. Note: Supermodel’s development builds and release notes are published from the official GitHub repository; community projects sometimes repackage or extend the emulator for specific platforms.

Screenshots

Sega Rally 2 gameplay, shown in its Dreamcast port; the game originated on Sega Model 3
Sega Rally 2 gameplay, shown in its Dreamcast port; the game originated on Sega Model 3. Image from Retro Replay media.

Tutorials & guides

Supermodel setup guide (click to expand)

Setup note: This guide explains verifying downloads, preparing Model 3 ROMs and configuration, and running Supermodel on a desktop host. It focuses on the official trz y/Supermodel project and practical steps referenced from the project's documentation and forum resources.

  1. 1) Obtain Supermodel: Download releases or the source from the official GitHub repository (trzy/Supermodel). For Windows, Linux, and macOS the project provides automated release assets; for other platforms check for well-known downstream ports (for example Android ports) and verify they reference the trz y/Supermodel upstream.
  2. 2) Verify integrity and provenance: Prefer official GitHub release assets. If building from source, clone trz y/Supermodel and follow the repository’s build instructions in Docs. When using third-party builds (community packages, Homebrew formula, or Linux distribution packages), confirm the package references the official repository or a clearly identified fork.
  3. 3) Prepare required game files (ROMs and system files): Supermodel requires original Model 3 ROM image files to run games. The emulator and its releases do not include any commercial ROMs, BIOS, or firmware. Place ROM sets and any required system files in the paths the emulator expects (refer to Docs and the Supermodel.ini configuration). Compatibility information for specific titles is maintained on the Supermodel website and community compatibility lists—consult those lists to confirm required ROM filenames for each title.
  4. 4) Configure folders and Supermodel.ini: On first run Supermodel writes a Supermodel.ini (or you can create one following Docs). The emulator reads configuration (controls, video, audio, paths) from that file. Some frontends place the configuration under a system directory (for example libretro frontends require system files under a frontend-specific system path). Ensure the Config and NVRAM directories are writable by the user account running the emulator.
  5. 5) Select video/audio/input backends and options: Supermodel supports multiple host rendering and audio backends depending on the platform and build. Use the GUI or command-line options to choose rendering resolution, vsync, and audio device. Driving games that expect special steering or drive board hardware may need additional configuration or specific input mappings; refer to the project documentation and community threads for recommended controller mappings and drive-board emulation settings.
  6. 6) Running games, troubleshooting, and save states: Launch a supported ROM set via the GUI or CLI. If a game fails to load, check the log/console output for missing ROM filenames and verify ROM integrity. Use the project’s compatibility list to check known working titles and any game-specific notes. Save states are supported; their files will be created in the configured NVRAM/save-state directory.
  7. 7) Frontend integration (optional): For use inside a frontend, either use the libretro core (if available for your frontend) or configure the emulator as an external emulator with the proper command-line template and system directory. Put required system files where the frontend expects them and test one game before importing a full game list.

Software reminder: Supermodel does not include or distribute commercial game ROMs, firmware, or BIOS files. You must supply legally obtained ROM images and any required system files. Building or running Supermodel from source requires a working toolchain as described in the repository Docs.

Additional information

What Supermodel supports

  • Sega Model 3 arcade hardware (Model 3 Step 1/Step 2/Step 3 titles)
  • Host platforms: Windows (official binaries), Linux, macOS (official builds); third-party Android ports based on Supermodel source
  • Libretro core available for frontends that accept libretro cores (separate libretro integration)
  • Save states, configuration files (Supermodel.ini), and optional peripheral support such as drive/steering board emulation for driving titles

READMEs & documentation

Supermodel official project README
# Supermodel: A Sega Model Series Arcade Emulator
*Copyright 2003-2026 The Supermodel Team*

## Overview

**Supermodel** emulates Sega's Model 3 arcade platform, allowing you to relive state-of-the-art 3D arcade gaming as it existed from 1996 through 1999. It uses OpenGL, [SDL2](https://libsdl.org), and can run on Windows, Linux, and macOS. It also supports network play on low-latency network connections. The source code is freely available under the terms of the [GNU General Public License](http://www.gnu.org/copyleft/gpl.html).

<p align="center">
  <img src="Docs/Images/Daytona2_1.gif" width="375" height="250" /> <img src="Docs/Images/LAMachin.gif" width="375" height="250" />
  <img src="Docs/Images/StarWars.gif" width="375" height="250" /> <img src="Docs/Images/FVipers2.gif" width="375" height="250" />
</p>

<img src="Docs/Images/Real3D_Logo.png" align="right" height="100"> Model 3 first made its debut in 1996 with Virtua Fighter 3 and Scud Race, and for the subsequent three years boasted the most powerful 3D hardware of any gaming platform. Developed by Real3D, then a Lockheed Martin company, and with a heritage rooted in advanced flight simulator technology, Model 3 featured capabilities that would not appear on PCs for several years. Using an on-board scene graph and geometry processor, it could store, transform, light, and rasterize tens of thousands of polygons per frame at a fluid 57.524 frames per second.

The aim of the Supermodel project is to develop an emulator that is both accurate and playable. As with virtually all arcade hardware, no public documentation for the Model 3 platform exists. What is known so far has been painstakingly reverse engineered from scratch.

## How To Get It

Automated builds for Windows, macOS and Linux are now available here on GitHub.  
Check out the releases page [here](https://github.com/trzy/Supermodel/releases).

## Community

<table border="0">
  <tr>
    <td><a href="https://discord.gg/XDd7TMMUMz"><img width="32" src="Docs/Images/Discord.svg"></a></td><td><a href="https://discord.gg/XDd7TMMUMz">Join the Discord server</a>.</td>
  </tr>
</table>

We lost our web hosting and have no backup of the recent forum. For now, please use this GitHub page for official releases and [Discord](https://discord.gg/XDd7TMMUMz) for asking questions.

## Build Instructions

### Windows

The preferred method for building Supermodel is to use GCC and MSYS2. After installing [MSYS2](https://msys2.org), open the MSYS2 shell and install the required dependencies using the pacman package manager:

- GCC (```mingw64/mingw-w64-x86_64-gcc```)
- Make (```mingw64/mingw-w64-x86_64-make```)
- SDL2 (```mingw64/mingw-w64-x86_64-SDL2```, ```mingw64/mingw-w64-x86_64-SDL2_net```)

This can be done using the following commands:

```
pacman -S mingw64/mingw-w64-x86_64-gcc
pacman -S mingw64/mingw-w64-x86_64-make
pacman -S mingw64/mingw-w64-x86_64-SDL2
pacman -S mingw64/mingw-w64-x86_64-SDL2_net
```

At this point, you can continue using either the MSYS2 shell or Windows Command Prompt but ensure that both ```gcc``` and ```mingw32-make``` are in your path. In MSYS2, the location of these binaries will be ```/mingw64/bin``` and for Command Prompt, assuming MSYS2 was installed in the default location, add ```C:\msys64\mingw64\bin``` to your Windows ```PATH``` variable.

To build Supermodel use (Network support built in by default now, no need to specify anymore):

```
mingw32-make -f Makefiles/Makefile.Win32
```

If you wish to build via Visual Studio 2026,
Make sure to run the Get_Libs.cmd files in the libraries directory. It will automatically pull in the required dependencies. Then either build inside the GUI or use the Build.cmd file in the MSVC folder.

### Linux

Ensure SDL2 is installed. Most package managers ought to have this available. For example, on Ubuntu, it should be sufficient to run:

```
sudo apt install libsdl2-dev
sudo apt install libsdl2-net-dev
sudo apt install libglu1-mesa-dev
```

And then build Supermodel:

```
make -f Makefiles/Makefile.UNIX
```

### macOS

Ensure Apple's Xcode Command Line Tools are installed:

From a terminal:
```
xcode-select --install
```

Ensure SDL2 is installed.  Download the latest *.dmg files from both of the links below, and install per the READMEs in the .dmgs (i.e. in "/Library/Frameworks")

* SDL2: https://github.com/libsdl-org/SDL/releases

* SDL_net: https://github.com/libsdl-org/SDL_net/releases


And then build Supermodel:

```
make -f Makefiles/Makefile.OSX
```

### Note: running on macOS
If you try and run a macOS binary that was downloaded from the internet and/or built on a different machine, you need to grant macOS permission to execute the binary (just 1-time):

* Open the folder containing the binary in Finder, and right (or ctrl) click on it:

* Click "Open" when the following dialogue box appears : "macOS cannot verify the developer of “supermodel-git-xxxx”. Are you sure you want to open it?"

* Close the terminal window that opens (after clicking open)

Details: https://support.apple.com/guide/mac-help/open-a-mac-app-from-an-unidentified-developer-mh40616/mac

## License

Supermodel is distributed under the terms of the [GNU General Public License](Docs/LICENSE.txt).

Parts of it, mainly the Sega Model 1 and Model 2 support, are based on code from [MAME](https://www.mamedev.org) by Aaron Giles, Andreas Naive, Angelo Salese, Ariane Fugmann, David Haywood, ElSemi, Ernesto Corvi, Farfetch'd, Matthew Daniels, Miguel Angel Horna, Morten Shearman Kirkegaard, Olivier Galibert, Peter Wilhelmsen, R. Belmont, Robbbert, Samuel Neves, smf and Ville Linde. Their code was made available under the BSD 3-Clause License: the full notice is in the Acknowledgments section of [Docs/README.txt](Docs/README.txt).
Download original README

Original project README source

Release log

Selected releases and changes, with coverage from our weekly emulation roundup.

    Sources & further reading

    FROM THE COMMUNITY

    Player reviews

    0 reviews
    6.0/ 10

    Overall rating

    Provisional site rating and approved member scores, each counted once.

    Starting site scores are provisional editorial scores. Established mainstream projects receive a higher starting score; other imported entries begin at a neutral 6/10 pending individual review. Member scores change the average after approval.

    Your take on Supermodel

    Spam has been overwhelming. To help us approve your review, sign up and introduce yourself in the Introductions forum so we know you’re not a bot.

    Sign in with your Retro Replay account to rate this project and share your experience.

    Sign in to review