RIX File Format

RIX files are ColoRIX indexed bitmap images. Fallout and Fallout 2 use a narrow subset of the format for startup/loading splash screens, stored under art\splash in master.dat or in the unpacked data tree.

The wider ColoRIX format can describe several palette and storage variants, including compressed or planar data. Fallout's splash loader expects the simple VGA form: a RIX3 signature, little-endian dimensions, a 256-color palette, and one linear byte per pixel. For Fallout modding tools, support that subset first.

Where Fallout Uses It

Fallout 2 CE looks for splash files named splashN.rix, where N is the current splash index. It searches up to ten possible indexes, wrapping from 9 back to 0, and displays the first existing file. English games use:

art\splash\splash0.rix
art\splash\splash1.rix
...

For non-English languages, CE checks a localized folder first:

art\<language>\splash\splashN.rix

Classic Fallout 2 data is commonly described as having six RIX splash screens. The CE loader's search range is ten slots, so tools should not hard-code six as a format limit.

Fallout Subset

PropertyFallout expectation
SignatureRIX3
EndiannessLittle-endian control values
Typical dimensions640 x 480
Palette type0xAF, VGA palette: 256 mapped colors, 6 bits per channel
Storage type0x00, linear uncompressed pixels
Palette length256 * 3 = 768 bytes
Pixel lengthwidth * height bytes
TransparencyNone in the splash-screen use case
AnimationNone

A vanilla-size 640 x 480 Fallout RIX file is 10 + 768 + 640 * 480 = 307978 bytes (0x4B30A).

File Structure

OffsetSizeDescription
0x00004Signature. Fallout splash files use ASCII RIX3.
0x00042Image width in pixels, little-endian. Fallout splash art is normally 640 (0x0280).
0x00062Image height in pixels, little-endian. Fallout splash art is normally 480 (0x01E0).
0x00081Palette type. Fallout files use 0xAF.
0x00091Storage type. Fallout files use 0x00 for linear, uncompressed data.
0x000A768Palette: 256 RGB triples.
0x030Awidth * heightPixel indexes, one byte per pixel, left-to-right and top-to-bottom.
 
struct FalloutRixHeader {
    char signature[4];      // "RIX3"
    uint16_t width;         // little-endian
    uint16_t height;        // little-endian
    uint8_t palette_type;   // usually 0xAF
    uint8_t storage_type;   // usually 0x00
};

The original RIX documentation describes the first four bytes as "RIX" in a 4-byte field; Fallout files use the visible four-character value RIX3. Treat RIX3 as the required magic for Fallout splash screens.

Palette Type

The RIX palette type byte encodes whether a palette exists and what kind of indexed color it contains. Fallout's 0xAF is the standard VGA mapped-color case:

Bits/valueMeaning
0x80Palette table is present.
0x28Six RGB bits per channel, encoded as (6 - 1) << 3.
0x07Eight pixel bits, encoded as 8 - 1, giving 256 palette entries.

Other RIX palette types exist, such as EGA, Targa, and PGA variants, but they are not part of Fallout's normal splash-screen subset.

Storage Type

Fallout splash screens use storage type 0x00: linear one-byte-per-pixel data. The broader RIX format defines flags and modes for compression, extension blocks, encryption, planar EGA data, and text-mode data. Fallout's splash loader does not implement those variants; a compressed or extension-bearing RIX should be converted to the plain linear form before use.

Fallout 2 CE only checks the RIX3 signature before reading splash data. It then seeks to offset 0x000A, reads 768 palette bytes, and reads width * height pixel bytes. A stricter external tool should still validate palette_type == 0xAF, storage_type == 0x00, and file length before accepting the image.

Palette Data

The palette is stored immediately after the header as 256 RGB triples:

palette_index_0: red, green, blue
palette_index_1: red, green, blue
...
palette_index_255: red, green, blue

VGA palette components are 6-bit values in the range 0..63, stored in full bytes. Fallout's palette code uses this 0..63 range directly. When converting to modern 24-bit or 32-bit RGB, scale the values to 0..255. A common quick conversion is component << 2; a slightly fuller mapping is (component << 2) | (component >> 4).

Unlike FRM art, a Fallout RIX carries its own palette. It does not use color.pal, and switching from the game palette to the RIX palette is part of the splash display. This is why a screenshot or conversion that ignores the embedded palette will show the wrong colors.

Pixel Data

Pixel data starts at offset 0x030A for the normal 256-color Fallout subset. Each byte is a palette index. Pixels are stored in screen order:

offset = 0x030A + y * width + x
palette_index = file[offset]

The first pixel byte is the top-left pixel. The last pixel byte is the bottom-right pixel. There is no row padding in the Fallout subset.

Displaying a RIX

A simple reader for Fallout RIX files can follow this process:

  1. Read the 10-byte header.
  2. Require signature RIX3.
  3. Read little-endian width and height.
  4. Warn or reject if palette_type is not 0xAF or storage_type is not 0x00.
  5. Read 768 palette bytes.
  6. Read exactly width * height pixel bytes.
  7. Convert each pixel index through the embedded palette.

Fallout fades from black to the RIX palette, then blits the indexed pixel buffer. Modern engines may scale the image if the game is running at a non-640x480 resolution.

Validation Checklist

Authoring Notes

Relationship to Other Art Formats

FormatDifference from RIX
FRMUsed for almost all game art, may contain multiple frames/directions, and relies on external palettes. Splash screens are the main exception.
PALExternal palette files used by FRM and other UI/game art. RIX embeds its own palette.
DATArchive container that stores RIX files; it does not change the RIX byte format.
BMPSome high-resolution patch configurations can load 8-bit BMP splash art, but BMP is not the original Fallout splash format.

Source References

Tools