Just Solve the File Format Problem - User contributions [en]

Remedy Archive System

2025-11-23T23:08:05Z

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ clarify reduction-to-s8

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftS8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): s32
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 with the corresponding bits of operand2
// with the sign bits treated equally to all the other bits
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as an 8-bit signed two's-complement integer;
// no modification is made to the topmost remaining bit
// (which becomes the result's sign bit)
return ...

function ReduceU32ToS8(u: u32): s8
// remove the topmost 24 bits of `u`,
// returning the remaining bits as an 8-bit signed two's-complement integer;
// no modification is made to the topmost remaining bit
// (which becomes the result's sign bit)
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftS8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceU32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

Remedy Archive System

2025-11-23T23:03:39Z

RavuAlHemio: reformulate sign bit treatment in xor

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftS8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): s32
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 with the corresponding bits of operand2
// with the sign bits treated equally as all the other bits
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function ReduceU32ToS8(u: u32): s8
// remove the topmost 24 bits of `u`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftS8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceU32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

Remedy Archive System

2025-11-23T23:02:51Z

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ improve bitwise xor explanation

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftS8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): s32
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 with the corresponding bits of operand2
// with no special provisions for the sign bit
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function ReduceU32ToS8(u: u32): s8
// remove the topmost 24 bits of `u`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftS8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceU32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

Remedy Archive System

2025-11-23T18:59:45Z

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ define and use ReduceU32ToS8 on i

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftS8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): s32
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 and operand2
// with no special provisions for the sign bit
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function ReduceU32ToS8(u: u32): s8
// remove the topmost 24 bits of `u`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftS8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceU32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

Remedy Archive System

2025-11-23T18:51:04Z

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ fix DivideS32U8 return type

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftS8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): s32
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 and operand2
// with no special provisions for the sign bit
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftS8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceS32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

Remedy Archive System

2025-11-23T18:46:56Z

RavuAlHemio: S/I inconsistency

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftS8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): u8
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 and operand2
// with no special provisions for the sign bit
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftS8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceS32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

Remedy Archive System

2025-11-23T18:41:14Z

RavuAlHemio: /* RAS1+2 (Max Payne 1+2) */ precise description of the algorithm

{{FormatInfo
|formattype=electronic
|subcat=Game data files
|extensions={{ext|ras}}
|released=2001
}}
'''Remedy Archive System''' is used to store game data for Remedy Entertainment games such as Max Payne and Max Payne 2. The metadata (central directory) following the header is encrypted.

== Identification ==
Files begin with signature bytes {{magic|52 41 53 00}}.

== Format details ==

Numbers are in little-endian byte order.

=== Metadata ===

The file's header has the following structure:
<pre>
struct RASHeader {
uint8_t magic[4]; // "RAS\0"
int32_t encryptionKey;
};
</pre>

The next section of the header must be decrypted first:
<pre>
// decrypted structure
struct RASMetadata {
uint32_t fileCount;
uint32_t dirCount;
uint32_t fileListLength;
uint32_t dirListLength;
float32_t version; // binary32 according to IEEE 754
uint32_t unknown5;
uint32_t unknown6;
uint32_t unknown7;
uint32_t compatibility;
};
</pre>

The following version and compatibility values are known:

{| class="wikitable"
|-
! Version
! Compatibility
! Game
|-
|| 1.2 || 3 || Max Payne
|-
|| 1.2 || 4 || Max Payne 2
|}

What follows are <code>fileListLength</code> encrypted bytes of file metadata that can be decrypted using <code>encryptionKey</code>. (It is not necessary to remember the last value of <code>key</code> from decrypting <code>RASMetadata</code>.) Each entry has the following structure:

<pre>
// decrypted structure
struct RASFileListEntry {
char name[]; // NUL-terminated
uint32_t uncompressedSize;
uint32_t compressedSize;
uint32_t unknown2;
uint32_t dirIndex;
uint32_t unknown4;
uint32_t compressionMode; // 1 = some form of Lempel-Ziv, 3 = uncompressed
RASTimestamp timestamp;
};
</pre>

Next is a directory list of <code>dirCount</code> elements which must be decrypted similarly.

<pre>
// decrypted structure
struct RASDirListEntry {
char name[]; // NUL-terminated
RASTimestamp timestamp;
};
</pre>

Each directory is listed with its full name which starts and ends with a backslash (<code>\</code>). The top-most directory is named <code>\</code>. A file's <code>dirIndex</code> is a 0-based index into the directory list.

Timestamps are encoded using the same structure as SYSTEMTIME on Windows:

<pre>
struct RASTimestamp {
uint16_t year;
uint16_t month;
uint16_t dayOfWeek; // 0 = Sunday, 1 = Monday, ..., 6 = Saturday
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint16_t millisecond;
};
</pre>

=== Data ===

The file data follows directly after the file and directory lists. Each file is stored in turn with no padding; skipping to a specific file requires adding up the <code>compressedSize</code> members of all files preceding it.

== Encryption ==

Depending on the generation of the RAS file format, different encryption schemes are used.

=== RAS1+2 (Max Payne 1+2) ===

<pre>
void decrypt(uint8_t *buf, size_t count, int32_t key) {
size_t i;

if (key == 0) {
key = 1;
}
for (i = 0; i < count; i++) {
uint8_t a = buf[i];
uint8_t b = ((uint8_t)(i % 5)) & 7;
buf[i] = rotateLeftByte(a, b);
key = key * 171 + (key / 177) * -30269;
buf[i] = (uint8_t)((((((int8_t)i) + 3) * 6) ^ buf[i]) + ((int8_t)key));
}
}
</pre>

If your programming language doesn't support the <code>rotateLeftByte</code> operation, it can be emulated using:

<pre>
uint8_t rotateLeftByte(uint8_t a, uint8_t b) {
return (uint8_t)((a << b) | (a >> (8 - b)));
}
</pre>

Note that the algorithm relies heavily on signed-integer wraparound and C's integer promotion rules; an operation like <code>((int8_t)i) + 3</code> will sign-extend the 8-bit value of <code>i</code> to 32 bits before adding 3.

A more complete description of the algorithm is as follows:

<pre>
function BitCastU8ToS8(u: u8): s8
// reinterpret the bits of `u`, an 8-bit unsigned integer,
// as an 8-bit signed two's-complement integer
return ...

function BitCastS8ToU8(i: s8): i8
// reinterpret the bits of `i`, an 8-bit signed two's-complement integer,
// as an 8-bit unsigned integer
return ...

function SignExtendS8ToS32(i: s8): s32
// expand `i` from 8 bits to 32 bits
// by copying its topmost bit into the top 24 bits
// and the bottom 8 bits being the same as the bits of `i`
return ...

function RotateLeftI8(i: s8, by: u8): s8
// rotate the 8-bit value `i` left by the number of bits in `by`
// (shift the value `i` left by `by` bits,
// shifting in the bits on the right that "fall out" on the left)
return ...

function MultiplyS32(factor1: s32, factor2: s32): s32
// sign-extend `factor1` and `factor2` each to s64,
// multiply them, then take the bottom 32 bits of the product
// and return it as s32
return ...

function ModuloU32U8(dividend: u32, divisor: u8): u8
// divide `dividend` by `divisor` and return the remainder;
// this must be a value 0 ≤ value < divisor
return ...

function DivideS32U8(dividend: s32, divisor: u8): u8
// divide `dividend` by `divisor` and return the quotient;
// always round toward 0
return ...

function AddS32(summand1: s32, summand2: s32): s32
// add `summand1` and `summand2`;
// wrap around (drop any carry bits) if addition overflows
return ...

function BitwiseXorS32(operand1: s32, operand2: s32): s32
// perform a bitwise exclusive-or operation
// on the bits of operand1 and operand2
// with no special provisions for the sign bit
return ...

function ReduceS32ToS8(i: s32): s8
// remove the topmost 24 bits of `i`,
// returning the remaining bits as a signed 8-bit integer;
// if the topmost bit of the resulting integer happens to be 1,
// the result is negative
return ...

function Decrypt(buf: u8[], key: s32): void
if key == 0
key := 1

for i from 0 to buf.length-1
a := BitCastU8ToS8(buf[i])
b := ModuloU32U8(i, 5)
c := RotateLeftI8(a, b)
buf[i] := BitCastS8ToU8(c)

d := MultiplyS32(key, 171)
e := DivideS32U8(key, 177)
f := MultiplyS32(e, -30269)
key := AddS32(d, f)

g := ReduceS32ToS8(i)
h := SignExtendS8ToS32(g)
j := AddS32(h, 3)
k := MultiplyS32(j, 6)
l := BitCastU8ToS8(buf[i])
m := SignExtendS8ToS32(l)
n := BitwiseXorS32(k, m)
o := ReduceS32ToS8(key)
p := SignExtendS8ToS32(o)
q := AddS32(n, p)
r := ReduceS32ToS8(q)
buf[i] := BitCastS8ToU8(r)
</pre>

[[Category:Remedy Entertainment]]

MIDI

2025-11-23T17:58:39Z

RavuAlHemio: /* Alternative formats */ add RIFF MIDS

{{FormatInfo
|subcat=Audio and Music
|extensions={{ext|mid}}, {{ext|midi}}
|mimetypes={{mimetype|audio/midi}} {{mimetype|audio/mid}} {{mimetype|audio/x-midi}} {{mimetype|audio/m}} {{mimetype|application/x-midi}}
|locfdd={{LoCFDD|fdd000102}} {{LoCFDD|fdd000119}}
|pronom={{PRONOM|x-fmt/230}}
|wikidata={{wikidata|Q80535}}
|kaitai struct=standard_midi_file
}}
'''Musical Instrument Digital Interface''' ('''MIDI''') is an industry specification that permits digital musical instruments, computers and other related devices to connect and communicate with one another. The MIDI Specification was published in August 1983, and is widely used in electronic music.

For many, the name "MIDI" is associated with music synthesized with cheesy, lifeless software instruments from the 90's. There is considerable confusion resulting in the conflation of several things:

* The core MIDI protocol, which is a real-time messaging format that encodes musical events such as note on/note off, velocity, tempo, controls, etc.
* The '''General MIDI''' sub-specification of MIDI, which associates MIDI program numbers with a specific bank of 175 instruments such as oboes, pianos, drums, and so forth.
* The MIDI file format, officially '''SMF''' (Standard MIDI Format), which is simply a score of timed MIDI messages. MIDI files may or may not be intended for interpretation as General MIDI.
* The synthesis methods used to realize MIDI and/or General MIDI as audio, which run the whole spectrum from cheesy to non-cheesy.

Back in the day, high-quality audio files were a bit large to send over the Internet, so nerds would listen to MIDI file renditions instead. Since MIDI itself does not specify how program numbers map to instruments, General MIDI ensures that the Third Eye Blind song you send to your buddy over AOL will not inexplicably have bagpipes in it. Nowadays, MIDI files are used primarily as a storage and interchange format for music producers rather than an consumers. In music production, the synthesizer associated with a given MIDI channel is generally known ''a priori'', so the interopability of General MIDI is less useful. The ghost of bad General MIDI synthesizers nevertheless persists in the public view of MIDI.

"Black MIDI" is a style of MIDI music that has notes so densely placed that a graphical rendition has large patches of solid black.

== Sound Fonts ==
Originally created and used by Emu and Creative Labs software and equipment, [[SoundFont_1.0|sound fonts]] are instrument description extensions, or voice files, used, usually, for a cleaner high quality sound. Sound fonts are available from and for: Roland, Yamaha, Allen Organ, and Wurlitzer, among others.

== Alternative formats ==
As well as the standard MIDI specification, a number of (often proprietary) MIDI clones and variants have been created over the years. These include:

* [[Compact MIDI]]
* [[GMD]]
* [[HMI]]
* [[HMP]]
* [[HMZ]]
* [[KAR]]
* [[MIDS]]
* [[MIZ]]
* [[MSS (MIDI)|MSS]]
* [[RIFF MIDI]]
* [[RIFF MIDS]]
* [[Scalable Polyphony MIDI]]
* [[Synthetic Music Application Format]]
* [[Doom MUS]]

== Sample files ==
* {{DexvertSamples|music/mid}}

== External links ==
* [[Wikipedia:MIDI]]
* [http://localhostr.com/file/LJUEw0K/midiformat.pdf Standard MIDI-File Format Spec. 1.1]
* [http://www.midi.org/techspecs/midispec.php The Complete MIDI 1.0 Detailed Specification] Available for purchase from MMA (MIDI Manufacturers Association)
* [http://www.blitter.com/~russtopia/MIDI/~jglatt/tech/midispec.htm The MIDI Specification] Not the official specification, but an adaptation.
* [http://www.digitalpreservation.gov/formats/fdd/fdd000102.shtml MIDI Sequence Data, from Library of Congress resource on Sustainability of Digital Formats]
* [http://www.digitalpreservation.gov/formats/fdd/fdd000119.shtml Standard MIDI File Format, from Library of Congress resource on Sustainability of Digital Formats]
* [ftp://ftp.modland.com/pub/documents/format_documentation/MIDI%20(General%20MIDI%20Level%201%20Spec)%20(.mid).txt Brief Overview of Proposed General MIDI Level 1 Spec]
* [ftp://ftp.modland.com/pub/documents/format_documentation/MIDI%20(Sample%20Dump%20Standard)%20(.mid).txt MIDI Sample Dump Standard]
* [ftp://ftp.modland.com/pub/documents/format_documentation/MIDI%20(The%20Usenet%20MIDI%20Primer)%20(.mid).txt The USENET MIDI Primer]
* [https://www.techdirt.com/blog/innovation/articles/20130412/09091522689/heres-another-inventor-who-willingly-gave-his-greatest-idea-away-order-to-establish-it-as-global-standard.shtml Inventor of MIDI willingly gave idea away to establish it as a standard]
* [http://rhizome.org/editorial/2013/sep/23/impossible-music-black-midi/ The impossible music of black MIDI]
* [https://www.youtube.com/watch?v=FqjSYtKWyX8 Black MIDI songs will kill your brain and your computer]
* [https://midimusic.github.io/tech/midispec.html Standard MIDI-File Format Spec. 1.1]

MIDI

2025-11-23T17:57:32Z

RavuAlHemio: reunite alternative format list with its section

{{FormatInfo
|subcat=Audio and Music
|extensions={{ext|mid}}, {{ext|midi}}
|mimetypes={{mimetype|audio/midi}} {{mimetype|audio/mid}} {{mimetype|audio/x-midi}} {{mimetype|audio/m}} {{mimetype|application/x-midi}}
|locfdd={{LoCFDD|fdd000102}} {{LoCFDD|fdd000119}}
|pronom={{PRONOM|x-fmt/230}}
|wikidata={{wikidata|Q80535}}
|kaitai struct=standard_midi_file
}}
'''Musical Instrument Digital Interface''' ('''MIDI''') is an industry specification that permits digital musical instruments, computers and other related devices to connect and communicate with one another. The MIDI Specification was published in August 1983, and is widely used in electronic music.

For many, the name "MIDI" is associated with music synthesized with cheesy, lifeless software instruments from the 90's. There is considerable confusion resulting in the conflation of several things:

* The core MIDI protocol, which is a real-time messaging format that encodes musical events such as note on/note off, velocity, tempo, controls, etc.
* The '''General MIDI''' sub-specification of MIDI, which associates MIDI program numbers with a specific bank of 175 instruments such as oboes, pianos, drums, and so forth.
* The MIDI file format, officially '''SMF''' (Standard MIDI Format), which is simply a score of timed MIDI messages. MIDI files may or may not be intended for interpretation as General MIDI.
* The synthesis methods used to realize MIDI and/or General MIDI as audio, which run the whole spectrum from cheesy to non-cheesy.

Back in the day, high-quality audio files were a bit large to send over the Internet, so nerds would listen to MIDI file renditions instead. Since MIDI itself does not specify how program numbers map to instruments, General MIDI ensures that the Third Eye Blind song you send to your buddy over AOL will not inexplicably have bagpipes in it. Nowadays, MIDI files are used primarily as a storage and interchange format for music producers rather than an consumers. In music production, the synthesizer associated with a given MIDI channel is generally known ''a priori'', so the interopability of General MIDI is less useful. The ghost of bad General MIDI synthesizers nevertheless persists in the public view of MIDI.

"Black MIDI" is a style of MIDI music that has notes so densely placed that a graphical rendition has large patches of solid black.

== Sound Fonts ==
Originally created and used by Emu and Creative Labs software and equipment, [[SoundFont_1.0|sound fonts]] are instrument description extensions, or voice files, used, usually, for a cleaner high quality sound. Sound fonts are available from and for: Roland, Yamaha, Allen Organ, and Wurlitzer, among others.

== Alternative formats ==
As well as the standard MIDI specification, a number of (often proprietary) MIDI clones and variants have been created over the years. These include:

* [[Compact MIDI]]
* [[GMD]]
* [[HMI]]
* [[HMP]]
* [[HMZ]]
* [[KAR]]
* [[MIDS]]
* [[MIZ]]
* [[MSS (MIDI)|MSS]]
* [[RIFF MIDI]]
* [[Scalable Polyphony MIDI]]
* [[Synthetic Music Application Format]]
* [[Doom MUS]]

== Sample files ==
* {{DexvertSamples|music/mid}}

== External links ==
* [[Wikipedia:MIDI]]
* [http://localhostr.com/file/LJUEw0K/midiformat.pdf Standard MIDI-File Format Spec. 1.1]
* [http://www.midi.org/techspecs/midispec.php The Complete MIDI 1.0 Detailed Specification] Available for purchase from MMA (MIDI Manufacturers Association)
* [http://www.blitter.com/~russtopia/MIDI/~jglatt/tech/midispec.htm The MIDI Specification] Not the official specification, but an adaptation.
* [http://www.digitalpreservation.gov/formats/fdd/fdd000102.shtml MIDI Sequence Data, from Library of Congress resource on Sustainability of Digital Formats]
* [http://www.digitalpreservation.gov/formats/fdd/fdd000119.shtml Standard MIDI File Format, from Library of Congress resource on Sustainability of Digital Formats]
* [ftp://ftp.modland.com/pub/documents/format_documentation/MIDI%20(General%20MIDI%20Level%201%20Spec)%20(.mid).txt Brief Overview of Proposed General MIDI Level 1 Spec]
* [ftp://ftp.modland.com/pub/documents/format_documentation/MIDI%20(Sample%20Dump%20Standard)%20(.mid).txt MIDI Sample Dump Standard]
* [ftp://ftp.modland.com/pub/documents/format_documentation/MIDI%20(The%20Usenet%20MIDI%20Primer)%20(.mid).txt The USENET MIDI Primer]
* [https://www.techdirt.com/blog/innovation/articles/20130412/09091522689/heres-another-inventor-who-willingly-gave-his-greatest-idea-away-order-to-establish-it-as-global-standard.shtml Inventor of MIDI willingly gave idea away to establish it as a standard]
* [http://rhizome.org/editorial/2013/sep/23/impossible-music-black-midi/ The impossible music of black MIDI]
* [https://www.youtube.com/watch?v=FqjSYtKWyX8 Black MIDI songs will kill your brain and your computer]
* [https://midimusic.github.io/tech/midispec.html Standard MIDI-File Format Spec. 1.1]

Remedy Archive System

2025-11-22T15:47:03Z

RavuAlHemio:

Remedy Archive System

2025-11-22T15:36:08Z

RavuAlHemio: table row

Remedy Archive System

2025-11-22T15:32:43Z

RavuAlHemio: MP2 uses the same decryption method

Remedy Archive System

2025-11-22T15:23:55Z

RavuAlHemio:

Remedy Archive System

2025-11-22T13:32:07Z

RavuAlHemio:

Remedy Archive System

2025-11-22T13:24:24Z

RavuAlHemio:

Remedy Archive System

2025-11-22T12:01:55Z

RavuAlHemio: clean up decryption code slightly

Remedy Archive System

2025-11-22T09:05:47Z

RavuAlHemio: decrypt: i and key are cast to signed char, not unsigned char

Remedy Archive System

2025-11-22T07:18:31Z

RavuAlHemio: RASDirListEntry

Remedy Archive System

2025-11-22T07:05:58Z

RavuAlHemio: document file list entry structure

Remedy Archive System

2025-11-21T16:47:58Z

RavuAlHemio: add general structure of metadata

Remedy Archive System

2025-11-21T16:12:28Z

RavuAlHemio: translate description to C due to range of int32_t

Remedy Archive System

2025-11-21T15:31:29Z

RavuAlHemio: /* Format details */ LE

Remedy Archive System

2025-11-21T15:30:18Z

RavuAlHemio: MP1 crypt: ensure last value fits in a byte

Remedy Archive System

2025-11-21T15:23:31Z

RavuAlHemio: no semicolons in pseudocode

Remedy Archive System

2025-11-21T15:22:35Z

RavuAlHemio: initial info on header and decryption, WIP

Game data files

2025-11-21T14:55:50Z

RavuAlHemio: /* Archiving / Compression */

{{FormatInfo
|formattype=electronic
|thiscat=Game data files
|image=
}}

==Overview==
Many popular games use proprietary file formats to store their assets. These include custom image, sound and video formats and custom archive formats. There is no way that all of these can be enumerated here in some way or another. And as long as the games can still be run by an [[Emulation_Software|Emulator]] it's not that much of a deal. However, a lot of work has been put into deciphering, decrypting and hacking these files, and that work should be preserved.

See also: [[Interactive Fiction]] for data formats related to text adventure games, [[Puzzles]] for puzzle-game files, and [[Saved Games]] for data saved by games to store a player's game status.

==References==
* [http://wiki.xentax.com Xentax Wiki]
* [http://rewiki.awiki.org ReWiki]
* [http://aluigi.altervista.org/quickbms.htm QuickBMS], a tool suite to describe archives in an abstract BASIC-like language, and lots of scripts for even more games

==General Game Formats==

This section details formats such as [[Interplay ACM]] and [[Unreal Music Format]] which are used in a number of games.

=== Archiving / Compression ===
* [[CFL]]
* [[Electronic Arts LIB Game Archive]]
* [[FAR (The Sims)]]
* [[HMM Packfile]] (.PAK)
* [[Remedy Archive System]]
* [[Unity package file]]

===Audio / Music===
(see also [[Audio and Music]])

* [[BAKA]] (PCM 16 bit)
* beatmania / IIDX simulation
** [[BMS]]
* [[BH2PCM]] (extracted from [[Doom WAD]] by eXtendable WAD Editor)
* [[BNSF]] (IS14)
* Commodore Amiga
** [[AC1D-DC1A Packer]]
** [[AMOS Music Bank]]
** [[Channel Players]]
** [[Digital Illusions]]
** [[Game Music Creator]]
** [[Jason Page]]
* Electronic Arts
** [[Electronic Arts MUS]]
* [[Epic Megagames MASI]]
* id Software
** [[Doom MUS]]
** [[id Software Music Format]]
* [[Interplay ACM]]
* [[Inverse Frequency Sound format]]
* [[Ken's Adlib Music]]
* [[Sierra AGI]]
* [[Sierra SCI]]
* [[Westwood Studios ADL]]
* [[Westwood Studios AUD]]
* [[Xbox IMA ADPCM]]
* Nintendo GameCube / Wii
** [[Nintendo GameCube / Wii AST]]
** [[Nintendo GameCube / Wii BRSTM]]

=== Game programming languages ===

* [[Blitz3D]]
** [[Blitz3D Model]]

(see also [[Programming Languages]])

=== Other ===

* Allegro (game programming library)
** [[Allegro packfile]]

* Atari
** [[STOS memory bank]] (.mbk)

* Bitsboard
** [[Bitsboard board]]

* Blizzard Entertainment
** [[BLP]]
** [[MDX (Blizzard)|MDX]]
** [[MoPaQ]]

* Build Engine
** [[ART (Build Engine ART)]]
** [[DAT (Build Engine Palette)]]
** [[GRP (Build Engine Group Archive)]]

* [[D3TV]]
* [[DIV Games Studio]]

* Electronic Arts
** [[Electronic Arts CMV]]
** [[Electronic Arts INF]]
** [[Electronic Arts MAD]]‎
** [[Electronic Arts MOV]]
** [[Electronic Arts MPC‎]]
** [[Electronic Arts TGV]]
** [[Electronic Arts WVE]]

* Free Hero Mesh
** [[Free Hero Mesh class definition file]] (.class)
** [[Free Hero Mesh class resource file]] (.xclass)
** [[Free Hero Mesh level file]] (.level)
** [[Free Hero Mesh solution file]] (.solution)
** [[Free Hero Mesh code page file]]
** [[Free Hero Mesh composite puzzle set]]

* Hero Mesh
** [[Hero Mesh puzzle set]] (.mb)

* id Software
** [[BSP]] (map format used in Quake)
** [[Doom WAD]]
** [[Quake PAK]]
** [[Quake PK3]] (actually [[ZIP]])
** [[Quake WAD]]

* Infinity Engine
** [[BAM]]

* [[MegaZeux]]

* NetImmerse / Gamebryo Engine
** [[KF]]
** [[NIF]]

* Nintendo GameCube
** [[Nintendo GameCube Opening.bnr]]

* Nintendo GameCube / Wii
** [[DOL (Nintendo)]]
** [[RARC]]
** [[Yaz0]]

* Nintendo Wii
** [[BootMii NAND Dump]]
** [[BRFNT]]
** [[Mii Data]]
** [[Nintendo Wii BRLAN]]
** [[Nintendo Wii BRLYT]]
** [[Nintendo Wii BRRES]]
** [[Nintendo Wii Content.bin]]
** [[Nintendo Wii Data.bin]]
** [[Nintendo Wii Opening.bnr]]
** [[Nintendo Wii PAC]]
** [[Nintendo Wii PCS]]
** [[Nintendo Wii REL]]
** [[Nintendo Wii Savegame]]
** [[Nintendo Wii SEL]]
** [[Nintendo Wii Ticket]]
** [[Nintendo Wii TPL]]
** [[Nintendo Wii U8]]
** [[Nintendo Wii Update.inf]]
** [[Nintendo Wii VFF]]
** [[Title metadata]]
** [[Virtual Console CCF]]
** [[WAD (Wii)]]
** [[WiiConnect24 file]]

* [[OHRRPGCE]]

* [[Outerra engine]] (.otx) (used in Anteworld game)

* Raven Software game engine
** [[GLA]] - Ghoul animation (.gla)
** [[GLM]] - Ghoul mesh (.glm)

* Sokoban
** [[Softdisk Publishing UDF files]] (used for Softdisk's version of Sokoban)
** [[SOK (Sokoban)]]
** [[Sokoban XML]]

* Terminal Reality [https://github.com/jopadan/termpod/wiki/Terminal-Reality]
** [[POD1]] (.pod) [https://github.com/jopadan/termpod/wiki/Pod-1-Format-Reference] (no CRC)
** [[POD2]] (.pod) [https://github.com/jopadan/termpod/wiki/Pod-2-Format-Reference] (CRC=[[CRC-32#CRC-32/MPEG-2|CRC-32/MPEG-2]])
** [[POD3]] (.pod) [https://github.com/jopadan/termpod/wiki/Pod-3-Format-Reference] (CRC=CRC-32/MPEG-2)
** [[POD4]] (.pod) [https://github.com/jopadan/termpod/wiki/Pod-4-Format-Reference] (CRC=CRC-32/MPEG-2)
** [[POD5]] (.pod) [https://github.com/jopadan/termpod/wiki/Pod-5-Format-Reference] (CRC=CRC-32/MPEG-2)
** [[POD6]] (.pod) [https://github.com/jopadan/termpod/wiki/Pod-6-Format-Reference] (no CRC)
** [[EPD]] (.epd) [https://github.com/jopadan/termpod/wiki/Epd-Format-Reference] (CRC=CRC-32/MPEG-2)

* Tiled
** [[Tiled JSON]]
** [[Tiled TMX]]
** [[Tiled TSX]]

* Torque 3D game engine
** [[DTS]] (.dts)

* Valve Source Engine
** [[Valve Model Format]] (.mdl) [https://developer.valvesoftware.com/wiki/MDL Source Code]
** [[Valve Collision Model]] (.phy)
** [[Valve Map Format]] (.vmf)
** [[Valve Material Type]] (.vmt)
** [[Valve Vertex Data]] (.vvd)
** [[Valve Texture Format]] (.vtf)

* Xtremeworlds
** [[Xtremeworlds PWX]]
** [[Xtremeworlds map]]

* [[ZZT]]
** [[ZXT/ZAX]]

* [[ZZ Zero]]

==Individual Game Formats==

This section details formats which are specific to a single game (or perhaps a game series), such as [[God of Thunder Music Format]].
* 7 Days to Die
** [[TTS Prefab]] (.tts)
** [[7DTD Map File]] (.map)
* Age of Empires
** [[Data Resource File]] (.drs)
** [[Age of Empires Graphics File]] (.slp)
* Age of Mythology
** [[BAR (Age of Mythology)]] (.bar archive)
* Alter Ego (1986)
** [[Alter Ego Vignette Script format]]
* Arma
** [[Arma PBO]] (.pbo)
* Barony
** [[Barony Voxel]] (.vox)
* Blur
** [[BAF]] (Blur ADPCM)
* BVE, OpenBVE, Boso View Express (railroad simulator)
** [[BVE object formats]]
** [[BVE route formats]]
** [[BVE train.dat file]]
* Carnivores
** [[CAR (Carnivores)]] (.car)
* Cartooners
** [[Cartooners actor file]] (.act)
** [[Electronic Arts INF‎]] (.inf)
** [[Electronic Arts MOV]] (.mov)
** [[Electronic Arts MUS]] (.mus)
* Chasm: The Rift
** [[CAR (Chasm: The Rift)]]
* Cities Skylines
** [[Cities Skylines CRP]] (.crp)
* Commander Keen 1
** [[Commander Keen 1 Level format]] (.ck1)
* Core Wars
** [[RBJ (Redcode oBJect)]] (.rbj)
* Crystal Caves
** [[Crystal Caves Sound format]] (.snd)
* Dance With Intensity
** [[Dance With Intensity simfile]] (.dwi)
* Dangerous Dave
** [[Dangerous Dave level format]]
** [[Dangerous Dave tileset format]]
** (also uses [[Inverse Frequency Sound format]])
* Dark Reign
** [[FTG (Dark Reign)]]
** [[PAL (Dark Reign)]]
* Dofus
** [[Dofus localization]]
* Donkey Konga 2
** [[Donkey Konga 2 DSP]]
* Doom
** [[Doom cheat code encryption]]
** [[Doom MUS]] (.mus)
** [[Doom WAD]] (.wad)
** [[Doom DWD]] (.dwd)
** [[DeHackEd patch]] (used by the Doom modding community)
* DTX Mania
** [[DTX Mania simfile]]
* Duke Nukem
** [[ART (Duke Nukem 3D)]]
** [[DAT (Duke Nukem 3D)]]
** [[Duke Nukem level format]]
** [[Duke Nukem graphics format]]
** [[GRP (Duke Nukem 3D)]]
* Fallout
** [[Fallout character description]] (.gcd)
* Friday Night Funkin
** [[Friday Night Funkin mod]]
* Garry's Mod
** [[Garry's Mod Addon]] (.gma)
* God of Thunder
** [[DAT (God of Thunder)]]
** [[God of Thunder Music Format]]
* Grand Theft Auto
** [[RAGE Package Format]] (.rpf)
** [[RenderWare binary stream file]] (.dff)
* In the Groove
** [[In the Groove PCK]] (.pck)
* Jack Nicklaus Golf & Course Design: Signature Edition
** [[JNSE golf course]]
* Kick It Up
** [[Kick It Up simfile]] (.ksf)
* Lego Island
** [[Lego Island World Database]] (.wdb)
* Magic & Mayhem
** [[Magic & Mayhem sprites file]]
* Mario Kart Wii
** [[Wii BTI]]
* Mario Paint
** [[Mario Paint Composer]]
** [[SHI]]
** [[SHO]]
* Mass Effect
** [[AFC]] (AFX audio file; Mass Effect 2)
* MegaZeux
** [[MegaZeux Property List]]
* Minecraft
** [[Minecraft Alpha level format]]
** [[Minecraft Anvil format]]
** [[Minecraft Bedrock Edition level format]]
** [[Minecraft chunk format]]
** [[Minecraft classic level format]]
** [[Minecraft classic server protocol]]
** [[Minecraft generated structures format]]
** [[Minecraft Indev level format]]
** [[Minecraft Java Edition level format]]
** [[Minecraft loot table]]
** [[Minecraft map item format]]
** [[Minecraft model]]
** [[Minecraft NBT format]]
** [[Minecraft player format]]
** [[Minecraft raids.dat format]]
** [[Minecraft Region format]]
** [[Minecraft server_level.dat]]
** [[Minecraft server list format]]
** [[Minecraft structure block file format]]
** [[Minecraft scoreboard format]]
** [[Minecraft sounds.json]]
** [[Minecraft villages.dat format]]
** [[Schematic file format]]
* Mortal Kombat 4
** [[Mortal Kombat 4 filesys.dat]]
* Pokémon
** [[Pokémon Mystery Dungeon]]
** [[Pokémon ROM]]
** [[RMC]]
* Quake
** [[MD2]] - Quake 2 model format (.md2)
** [[MD3]] - Quake 3 model format (.md3)
** [[MD4 (Quake)|MD4]] - Quake MD4 model format (used in later Quake 3 versions) (.md4)
* Rise of the Triad
** [[Rise of the Triad level format]]
** (also uses [[Doom WAD]])
* RobotWar
** [[RobotWar|RobotWar programming language]]
* Sims, The
** [[CFP]] (Compressed Floating Point)
** [[CMX/BCF]]
** [[FAR (The Sims)]]
** [[IFF (The Sims)]] (.iff, .flr, .wll, .spf, .stx)
** [[SKN/BMF]]
* StarCraft
** [[StarCraft group file]] (.grp)
* StepMania
** [[StepMania simfile]] (.sm)
** [[StepMania 5 simfile]] (.ssc)
** [[StepMania AMX simfile]] (.sma)
* Stronghold
**[[Stronghold GM1]] (.gm1)
**[[TGX Graphics]] (.tgx)
* Supaplex
** [[Supaplex Level format]] (.dat)
* Super Mario Galaxy
** [[Super Mario Galaxy savefile]]
* Super Paper Mario
** [[BRSTMPSM]] (music data)
* Total War
** [[Total War ESF]] (.esf)
* Vinyl Goddess From Mars
** [[Vinyl Goddess From Mars Instrument Format]]
** [[Vinyl Goddess From Mars Music Format]]
* Warcraft
** [[Warcraft II PUD]] (.pud) (custom maps)
* Wiggle Planet
** [[Wiglet]]
* Wii Fit / Wii Fit Plus
** [[Wii Fit BMG]]

== Game hints ==
* [[UHS]]

== Board/card games ==
* [[Magic Set Editor]]
** [[Magic Set Editor card set]] (.mse-set)
** [[Magic Set Editor export template]] (.mse-export-template)
** [[Magic Set Editor game definition]] (.mse-game)
** [[Magic Set Editor include package]] (.mse-include)
** [[Magic Set Editor installer]] (???)
** [[Magic Set Editor style sheet]] (.mse-style)
** [[Magic Set Editor symbol font]] (.mse-symbol-font)
* [[REKO Cardset]]
* [[TeXnicard]]
** [[TeXnicard card database]]
** [[TeXnicard template]]
* [[Wiz Solitaire]]

== Uncategorized ==

* [[RBPACK]]

== External links ==

* [http://www.osti.gov/accomplishments/videogame.html Possibly the first video game, in 1958]
* [https://archive.org/details/Nintendo_Ultra64_Programming_Manual Nintendo Ultra64 Programming Manual]
* [http://ukvac.com/forum/topic335921.html Sega Pengo: bug found in maze generating algorithm]
* [http://www.stavros.io/posts/winning-candy-crush/ How to 'hack' Candy Crush]
* [http://www.glitchthegame.com/public-domain-game-art/ Glitch game files, released into the public domain]
* [https://github.com/jmechner/Prince-of-Persia-Apple-II Prince of Persia source code (Apple II)]
* [http://sourceforge.net/projects/dice/ DICE: emulator of early discrete-circuit video games]
* [http://www.polygon.com/2014/4/22/5640114/maze-invaders-atari-arcade-source-code-strong-museum-icheg Museum acquires 'virtually complete' source code from Atari's arcade heyday]
* [https://archive.org/details/pdp1_spacewar Spacewar! for the PDP-1 (1962)] (with in-browser emulation)
* [http://tcrf.net/Category:Games_with_hidden_developer_messages Games with hidden developer messages]
* [http://www.loc.gov/preservation/resources/rfs/softgame.html Library of Congress Recommended Format Specifications: Software/Gaming]
* [https://github.com/keendreams/keen Keen Dreams Source Code (open-source release)]