Status: draft open specification, 2026-11-13
Applies to: Monster Truck Madness 2 tracks, for any engine or tool that reads or writes them (OpenMTM2, Community Patch 4, track editors, converters)
Maintained by: the OpenMTM2 project
Replaces: the earlier drafts “tall tracks with fine height steps” (2026-11-09) and “maps four times larger” (2026-11-13)
Revised: 2026-11-16 (fourth): a version 6 track may place up to 16,384 objects, four times Traxx’s 4,096 (5.3, 10 item 10, 14).
Revised: 2026-11-16 (third): Traxx 1.8.0 is released with TRAXXV20 (a light’s all-weather flag at the end of every box record), and TRAXXV99 now builds on it (15).
Revised: 2026-11-16 (second): masks cover the track’s own world and detail normals are tiles (9.5); the track’s own water keeps its units and may reach the top of a taller version 6 terrain (10, item 7).
Revised: 2026-11-16: the editor’s working file is .TXX generation TRAXXV99, a temporary number, since Traxx 1.7.2 already uses TRAXXV19 for its water maps (15); the .WTR header flags and the .WFL roughFrom byte that Traxx 1.7.3 added, kept by version 2 (9.1, 9.3); what Traxx would change, in a separate document (16)
Earlier revision: 2026-11-13, after the first implementations: .WFL version 2 (9.3); the world’s size picks the .WTR and .WFL versions (9.1, 9.3); the editor’s working file (15, then numbered TRAXXV19); .SI3 listing and terrainGrid clarified (5.1, 10)
This is an open specification. Anyone may implement it, in any engine or tool, without asking and without a fee. It is written so that an engine developer can implement it from this document alone; the background it relies on is summarised in section 4, with the analysis documents it comes from named there.
Today every MTM2 track is the same size, a square 8,192 ft a side that wraps around at its edges, and can be at most about 512 ft tall from its lowest point to its highest. Format version 6 lifts both limits:
terrainHeightStep) and where its height range starts (terrainHeightBase). Heights are still an ordinary 16-bit greyscale PNG or 16-bit RAW. A track can be up to 8,192 ft tall, or keep Community Patch 4’s 2.4 mm steps under 512 ft.worldCells): 256 as today, or 512, a world 16,384 ft a side with four times the area. A cell is still 32 ft and the fine terrain is still 8 ft..SI3. A version 6 track’s situation file is WORLD\<stem>.SI3, in the same text format as a .SI2 for now. Older builds do not list .SI3 files, so they never offer a track they would load wrongly.Tracks that use none of this are unchanged and keep loading everywhere as before.
Height: Pikes Peak. 4x4 Evolution 2’s Pikes Peak climbs from 12 ft to 1,821 ft, about 1,800 ft in one track.
| Game | Height step | Tallest track |
|---|---|---|
| MTM2 (original) | 2 ft | 510 ft |
| Community Patch 4 beta 0.52 | 1/128 ft (2.4 mm) in the file | 512 ft |
| 4x4 Evolution 2 | 1/32 ft (9.5 mm) | about 2,048 ft |
To convert it today the mountain must be squashed to under a third of its height (the road becomes three times less steep and the jumps and banks change), or cut into pieces. Community Patch 4’s 16-bit heights give more steps, not more height. Evo 2 shows both can be had at once: its steps are 4 times coarser than CP4’s file, yet its tracks look smooth (the smoothing comes from interpolating between grid points, which CP4’s spline mode also does) and are 4 times taller.
Size: Chicago. Midtown Madness’s Chicago is a whole city at real-world scale, being converted to MTM2 (mm1conversion).
| Extent | Metres | Feet at true scale | Against 8,192 ft |
|---|---|---|---|
| The drivable city | 2,729 x 2,900 | 8,954 x 9,514 | 1.16 x as long |
| The same with a 256 ft margin per side against the wrap | 9,466 x 10,026 | 1.22 x | |
| Everything the game has collision for (lake, edges) | 3,341 x 3,819 | 10,962 x 12,530 | 1.53 x, 2.05 x the area |
The city does not fit, so the conversion shrinks it to 0.83 of its size: buildings, bridges, ramps and the distances between jumps are all 17% smaller than they should be. The smallest world that holds it is 384 cells (12,288 ft); the next power of two, which the engine’s bit masks need (section 4.1), is 512 cells.
worldCells (256 or 512). W = 32 N ft is the world’s side (8,192 or 16,384 ft).index = row * size + column, as today.<stem> is the track’s name, the stem of its situation file.This section is the baseline version 6 extends. It comes from the OpenMTM2 project’s analysis of the retail MONSTER.EXE 2.00.42 and of the Community Patch 4 beta 0.52 executable 2.0.52.2, with the Traxx 1.7 editor’s source for comparison. CP4’s developer has published no source code or written specification of its own; the CP4 parts below are our reading of the binary and may change before CP4 is final.
The 8,192 ft size is in the engine’s code, not in any file:
| Where | What it does | Value today |
|---|---|---|
| Cell lookup (terrain, surface, ground boxes) | (pos >> 13) & 255 |
256 cells |
| Grid index | row * 256 + col |
256 a row |
| CP4 fine terrain lookup | (pos >> 11) & 0x3ff |
1024 fine cells |
| CP4 spline expansion | indices wrap at 256 | 256 |
| Truck and moving-object position, every frame | above 8,192 ft subtract 8,192, below 0 add 8,192 | 8,192 ft |
| Objects, ramps, course ends at load | a negative x or z gets 8,192 added | 8,192 ft |
| Drawing a truck at the copy nearest the view | moved when more than 4,096 ft away | half the world |
| Drawing the ground around the view | view cell (x & 0x1fe000) >> 13 |
256 cells |
| CP4 fog volumes | distance to the view wrapped | 8,192 ft |
Distances in the simulation are not taken the short way across the wrap: two things either side of the edge do not meet until one is wrapped across.
The height file’s size picks the grid (CP4 0.52):
DATA\<stem>.RAW size |
Samples | Grid spacing |
|---|---|---|
| 65,536 bytes | 8-bit, 256 x 256 | 32 ft (original MTM2) |
| 131,072 bytes | 16-bit, 256 x 256 | 32 ft, or smoothed to 8 ft with terrainGrid=spline |
| 2,097,152 bytes | 16-bit, 1024 x 1024 (“Full Map”) | 8 ft |
CP4 adds DATA\<stem>.TXV, key = value lines with # comments, keys case-insensitive, 1 to 65,536 bytes:
terrainGrid=classic|spline|fine: how to read a 16-bit file (the size wins when they disagree).terrainHeights=DATA\<stem>_H.PNG: a greyscale PNG (8 or 16-bit, 256 or 1024 square) used instead of the .RAW.formatVersion: computed by the writer from the track’s contents (2 lights and moving boxes, 3 vegetation, 4 fog volumes, 5 a 16-bit or smoothed terrain), the highest that applies. It is information, not a gate: CP4 0.52 shows “This track needs a newer build.” for a number above 5 and keeps loading.The scale is fixed: a 16-bit sample v means v / 128 ft, 0 to 511.99 ft. An 8-bit sample b counts as b << 8. CP4 keeps v >> 1 (1/64 ft) in a signed 16-bit number, so its internal ceiling is also about 512 ft.
Other heights: object positions are text in feet; CP4 lakes (.WTR) store a u32 height in half-feet and refuse values above 4,096 (2,048 ft); ground boxes (.RA0/.RA1) store bottom and top as one byte each, 2 ft a step, 0 to 510 ft.
| File | Contents | Bytes per cell | Size today |
|---|---|---|---|
DATA\<stem>.CLR |
terrain texture word | 2 | 131,072 |
DATA\<stem>.LTE |
baked light | 7 | 458,752 |
DATA\<stem>.RA0 to .RA5 |
ground box heights | 1 | 65,536 each |
DATA\<stem>.CL0, .CL2 |
ground box face textures | 12 | 786,432 each |
DATA\<stem>.CL1 |
4 | 262,144 | |
WORLD\<stem>.WTR tile map |
lake id per tile | 1 | 65,536 |
Already independent of the world’s size: object positions, the grid, checkpoints and courses (text feet in the .SIT/.SI2); models (.BIN) and surfaces (.SRF); vegetation grass tiles (u16); multiplayer truck positions in CP3 and CP4 (32-bit floats in feet, which still resolve 1/500 ft at 16,384 ft); the engine’s 32-bit 1/256 ft positions (16,384 ft is 4,194,304 units).
The retail game builds its track list from every .SIT entry in the mounted PODs (CRace::init, at most 100). Community Patch 3 introduced .SI2, the same text, for tracks that need its engine; a 1998 install does not list them. When a stem has both, CP3-era readers take the .SI2.
.SI3WORLD\<stem>.SI3. In this version its text is exactly a .SI2’s (MTM2 SIT syntax); only the rules in this document differ. Later versions of this specification may extend the .SI3 text itself..SI3 entries as tracks, with .SI2 and .SIT..SIT (retail) or .SIT and .SI2 (CP3, CP4 0.52), so they never see a .SI3 track. (That they skip an unknown extension is INFERRED from how the retail list is built; it is the purpose of the new name.).SI3 when it uses worldCells, terrainHeightMap, terrainHeightStep or terrainHeightBase. A writer MUST NOT use those keys in a .SIT or .SI2 track. (terrainGrid and formatVersion are CP4’s own keys, which .SI2 tracks already use.).SIT or .SI2 in the same POD is a different track, read by today’s rules. It is not a version of the .SI3 track for older builds: a quarter of a 512 world, or a squashed mountain, is not the same track. A writer SHOULD give it a different stem..SI3 track MUST have DATA\<stem>.TXV with formatVersion=6..SI3 track whose keys of section 6 have a value outside the allowed ones, with a message naming the key, rather than guess.formatVersion above 6 is up to the reader. Since the .SI3 format is likely to be updated in later versions, a reader SHOULD at least warn that the track may need a newer build..SI3 track MAY place up to 16,384 objects. They are counted as Traxx counts them: the objects, ramps and top-crush cars of the situation file together, in one list (Traxx’s MAXNPODBOXES, 4,096 today)..SIT or .SI2 track keeps today’s limits.formatVersion=6
worldCells=512
terrainHeightMap=DATA\CHI1_H.PNG
terrainHeightStep=128
terrainHeightBase=0
terrainGrid=fine
| Key | Value | Default |
|---|---|---|
formatVersion |
6 |
|
worldCells |
256 or 512. |
256 |
terrainHeightMap |
The entry holding the heights: a .PNG (greyscale, colour type 0 or 4, 8 or 16-bit, alpha ignored) or a .RAW (unsigned 16-bit). |
none: CP4’s rules (DATA\<stem>.RAW or terrainHeights), allowed only when worldCells=256 |
terrainHeightStep |
Steps per foot: 1, 2, 4, 8, 16, 32, 64 or 128. | 128 |
terrainHeightBase |
Whole feet added to every height, -32768 to 32767. | 0 |
terrainGrid |
classic, spline or fine, as in CP4 (section 7.2). CP4’s own key: a .SI2 track may use it too. |
classic for an N square file, fine for 4N |
With worldCells=512, terrainHeightMap is required.
height_ft = terrainHeightBase + sample / terrainHeightStep
An 8-bit PNG sample b counts as sample = b << 8, as in CP4. With terrainHeightMap absent, heights follow CP4’s rules (section 4.2) and the step and base do not apply.
What the step buys:
| Step | Smallest change | Height range | Good for |
|---|---|---|---|
| 128 | 2.4 mm | 512 ft | Every CP4 track today |
| 64 | 4.8 mm | 1,024 ft | Most hilly tracks |
| 32 | 9.5 mm | 2,048 ft | Evo 2, Pikes Peak |
| 16 | 1.9 cm | 4,096 ft | Mountains |
| 8 | 3.8 cm | 8,192 ft | As tall as a 256 world is wide |
The height file is N x N (32 ft spacing) or 4N x 4N (8 ft spacing): 256 or 1024 in a 256 world, 512 or 2048 in a 512 world. A RAW terrainHeightMap is therefore 2N² or 32N² bytes (131,072 or 2,097,152; 524,288 or 8,388,608). A reader MUST refuse any other size with a message.
| Height file | classic |
spline |
fine |
|---|---|---|---|
| N square | flat 32 ft triangles | smoothed to 4N square at 8 ft | classic, with a warning |
| 4N square | fine, with a warning | fine, with a warning | 8 ft heights as stored |
Between samples, heights are linear within the cell’s two triangles, split in a checkerboard, as in retail (MTM2_PHYSICS.md 2.1) and in CP4’s fine mode. The spline is CP4’s (terrainspline.c version 2, the same in Traxx 1.7), with its indices wrapping at N instead of 256; OpenPhotex terrainSplineExpand is an exact port with Traxx’s test vectors. It works in sample units, before step and base are applied.
A reader MUST hold heights in at least 32-bit integers or floats; CP4 0.52’s signed 16-bit store at 1/64 ft cannot exceed 512 ft. For bit-identical results between engines (multiplayer), the RECOMMENDED store is 32-bit integers at 1/128 ft, where every allowed step converts with a shift:
h128 = (sample << (7 - log2(terrainHeightStep))) + terrainHeightBase * 128
Every constant of section 4.1 MUST come from N:
| Where | Today | Version 6 |
|---|---|---|
| Cell lookup | (pos >> 13) & 255 |
(pos >> 13) & (N - 1) |
| Grid index | row * 256 + col |
row * N + col |
| Fine terrain lookup | (pos >> 11) & 0x3ff |
(pos >> 11) & (4N - 1) |
| Spline wrap | 256 | N |
| Position wrap, every frame | 8,192 ft | W |
| Negative positions at load (objects, ramps, top-crush cars, course ends) | + 8,192 ft | + W |
| Nearest copy for drawing | 4,096 ft | W / 2 |
| View cell for the ground | (x & 0x1fe000) >> 13 |
(x >> 13) & (N - 1) |
| Fog volume distance wrap | 8,192 ft | W |
The shifts do not change: a cell is still 32 ft and a fine cell 8 ft. Also unchanged: the view range in cells, the number of cells drawn, the checkerboard split, ground boxes of 32 x 32 ft, the collision code. A larger world is not drawn further; there is just more of it.
Memory, in CP4’s layout:
| Grid | 256 world | 512 world |
|---|---|---|
| Classic grid, 6 bytes a cell | 384 KiB | 1.5 MiB |
| Fine grid, 16-bit (32-bit as section 7.3) | 2 MiB (4 MiB) | 8 MiB (16 MiB) |
| Two shading maps | 2 x 1 MiB | 2 x 4 MiB |
.LTE |
448 KiB | 1.75 MiB |
A 2048 x 2048 16-bit PNG is 8 MiB before compression, inside CP4’s 16 MiB limit on a height PNG.
Each grid file keeps its name and layout and holds N x N cells. A reader MUST refuse a file whose size does not match:
| File | Bytes per cell | 256 world | 512 world |
|---|---|---|---|
DATA\<stem>.CLR |
2 | 131,072 | 524,288 |
DATA\<stem>.LTE |
7 | 458,752 | 1,835,008 |
DATA\<stem>.RA0 to .RA5, 8-bit |
1 | 65,536 | 262,144 |
DATA\<stem>.RA0 to .RA5, 16-bit (section 8.3) |
2 | 131,072 | 524,288 |
DATA\<stem>.CL0, .CL2 |
12 | 786,432 | 3,145,728 |
DATA\<stem>.CL1 |
4 | 262,144 | 1,048,576 |
No older build reads these files at the wrong size, since they belong to a .SI3 track it never lists.
.RA0 and .RA1 (and the cavern pair .RA4/.RA5) MAY be 8-bit or 16-bit, told apart by size:
height_ft = terrainHeightBase + 2 * byte;height_ft = terrainHeightBase + value / terrainHeightStep, the terrain’s rule.A top of 0 still means “no box”. The two files of a pair MUST have the same depth. .CL0 does not change.
Object, grid, checkpoint and course positions are in feet, in [0, W). A negative x or z is wrapped by +W at load, as today by +8,192. A writer SHOULD write positions already in [0, W).
WORLD\<stem>.WTR), version 2Version 1 holds only a 256 x 256 map, u8 bounding boxes and heights from 0.5 to 2,048 ft. Version 2 widens all three for the 512-cell world. The world’s size picks the version: a 256-cell track (.SIT, .SI2, or a .SI3 of 256 cells) MUST use version 1, and a 512-cell track MUST use version 2. A reader MUST refuse any other pairing. A lake that version 1 cannot hold (above 2,048 ft) cannot be part of a 256-cell track. A version 6 reader MUST read both.
| Offset | Field | Version 2 |
|---|---|---|
| +0 | magic MWTR |
same |
| +4 | u16 major | 2 |
| +6 | u16 minor: 1 when the flags below are set (Traxx 1.7.3), else 0 | same |
| +8 | u32 directory offset, at least 0x20 | same |
| +0x0c | u32 chunk count | same |
| +0x10 | u16 width, u16 height | 512, 512 |
| +0x14 | u32 flags: bit 0, the lakes were filled with the edge rule (Traxx 1.7.3); 0 in older files | same |
The edge rule flag. Traxx 1.7.3 added the minor 1 and the flags word (BuildWTR and ParseWTR, TrackPODLakes.cpp). With bit 0 set, the lakes were filled with the edge rule: water crosses from a tile to a neighbouring tile only through an edge whose lowest point is at or below the lake’s height. Without it, they were filled with the tile rule of earlier files. Traxx 1.7.3 writes only edge rule files (minor 1, flags 1), and reads bit 0 whatever the minor says. A version 2 file carries the same minor and flags at the same offsets.
Directory entries are 16 bytes, {tag, version 1, offset, size}, as in version 1.
TMAP: exactly 512² bytes, one lake id per tile (0 none), index z * 512 + x.BODY: u32 count, u16 stride (at least 0x40), records from +8:| Offset | Version 1 | Version 2 |
|---|---|---|
| +0 | u8 id, 1..255, unique | same |
| +1 | u8 seed count, 1..8 | same |
| +2 | u16 flags (1 reflective) | same |
| +4 | u32 height, half-feet, 1..4096 | i32 height, half-feet |
| +8 | 8 x (u16 x, u16 z) seeds | same |
| +0x28 | u8 box x0, z0, x1, z1 | u16 x0, z0, x1, z1 (tiles, 0..N-1) |
| +0x2c / +0x30 | u32 tile count, equal to the lake’s TMAP count | same field, moved |
The surface is height * 128 in 1/256 ft. In version 2 a height is valid from 2 * terrainHeightBase + 1 to 2 * (terrainHeightBase + 65536 / terrainHeightStep): anywhere in the terrain’s range. The other checks (a lake with no tiles, a surface at or below the track’s own water, a bed at or below it) are version 1’s. CP4 0.52 refuses a major version other than 1, so it never misreads a version 2 file.
WORLD\<stem>.VEG)The layout does not change. TREE x and z MUST be in 0 to W * 256 (exclusive) 1/256 ft units, instead of below 0x200000. GRAS tile numbers run 0 to N - 1.
WORLD\<stem>.WFL), version 2Version 1 (CP4 beta 0.53) holds only a 256 x 256 header, crest points below 8,192 ft and crest heights from 0.5 to 2,048 ft, and CP4 builds its falls in a 256 world: segment lengths wrapped at 8,192 ft, the source lake looked up in a 256 x 256 map, the walk on 16-bit heights at 1/64 ft. Version 2 widens all of these for the 512-cell world. As for lakes, the world’s size picks the version: a 256-cell track (.SIT, .SI2, or a .SI3 of 256 cells) MUST use version 1 (a fall above 2,048 ft cannot be part of one), and a 512-cell track MUST use version 2. A version 6 reader MUST read both, and MUST refuse any other pairing (a header that is not the track’s N x N: 256 x 256 in version 1, 512 x 512 in version 2), as CP4 refuses a file “authored for a different terrain size”.
| Offset | Field | Version 2 |
|---|---|---|
| +0 | magic MWFL |
same |
| +4 | u16 major | 2 |
| +6 | u16 minor | 0, or 1 when the records are 132 bytes (as version 1.1: mist size and roughFrom) |
| +8 | u32 directory offset, at least 0x20 | same |
| +0x0c | u32 chunk count | same |
| +0x10 | u16 tiles x, u16 tiles z | 512, 512 |
The directory and the FALL chunk (version 1, u32 count, u16 stride of 128 or 132) do not change. In each record:
| Offset | Version 1 | Version 2 |
|---|---|---|
| +8 | u32 crest height, half-feet, 1..4096 | i32 crest height, half-feet, in a version 2 lake’s range (9.1) |
| +0x0c | 8 x (u32 x, u32 z) crest points, 1/16 ft, each below 0x20000 (8,192 ft) | each below 0x40000 (16,384 ft) |
| +0x80 | v1.1 records: u8 mist depth %, 0 meaning 100, capped at 250 | same |
| +0x81 | v1.1 records: u8 mist height %, 0 meaning 100, capped at 250 | same |
| +0x82 | v1.1 records: u8 roughFrom (byte 130; Traxx 1.7.3) | same |
| +0x83 | v1.1 records: reserved, 0 | same |
roughFrom is the flow speed from which a fall’s water turns rough: 0 is the engine’s default, 25 ft/s; 1 to 250 is that speed in ft/s; 255 turns rough water off. 251 to 254 are invalid: Traxx 1.7.3 refuses them (FALLERR_ROUGH), and CP4 beta 0.53 hotfix 3 treats them as 0. Traxx 1.7.3 writes 132-byte records (minor 1) only when some fall’s mist size is not the default or its roughFrom is not 0, and 128-byte records (minor 0) otherwise (BuildWFL and ParseWFL, TrackPODFalls.cpp). Before 1.7.3, bytes 130 and 131 were both reserved. A version 2 file carries the same fields at the same offsets, with the same minor rule.
Every other field and check is version 1’s. Building the falls of either version on a version 6 track, a reader MUST take the world constants from N (8.1):
floor(p / 32) & (N - 1) per axis, looked up in the N x N TMAP (9.1);TMAP;A crest height still has to equal its source lake’s height exactly. CP4 0.53 refuses a major version other than 1 (“This track’s waterfalls need a newer build.”), so it never misreads a version 2 file.
A fog volume’s distance to the view is wrapped at W.
A track can carry two kinds of picture besides its textures. They behave differently when the world grows.
Masks are maps of the world. A mask is a picture laid over the whole world from above, once: its left edge is x = 0, its right edge x = W, its top row z = 0. The colour of a pixel says how much of something goes on the ground under it. The masks are:
| Mask | Says | Read by |
|---|---|---|
ART\<stem>_MASK |
where the terrain’s detail normal is strong (white) or weak (black) | the engine |
ART\<stem>_WMSK |
the same for the water’s detail normal | the engine |
<name>_V, <name>_G (vegetation masks) |
where trees and bushes (_V) or grass (_G) are planted, by colour |
the editor’s planter only; the engine reads the .VEG it writes |
On a version 6 track a mask MUST cover the track’s own world, W = 32 N ft, once. A reader maps a world point to a pixel as px = floor(x * size / W), pz = floor(z * size / W), with the world wrapping at W. On a 256-cell track nothing changes: W is 8,192 ft, as today. The rules on a mask’s size (square, the sizes an engine or editor accepts) are unchanged; a 512-cell world spreads the same picture over four times the ground, so a mask with the same detail on the ground has twice the side (four times the pixels). An engine or editor SHOULD accept twice its 256-cell maximum side on a 512-cell track for that reason.
Detail normals are tiles. ART\<stem>_DTL (terrain) and ART\<stem>_WDTL (water) are small bump pictures repeated over the ground every few dozen feet, like a texture. They do not cover the world, so they do not change with N.
A version 6 reader MUST:
.SI3 tracks alongside .SIT and .SI2. A .SIT or .SI2 of the same stem is a different track with its own entry, never a fallback (5.1)..SI3 track’s .TXV, and refuse bad values (5.2)..WTR and .WFL version 1 on a 256-cell track and version 2 on a 512-cell one, refusing any other pairing (9.1, 9.3); build waterfalls in the N world (9.3); accept .VEG positions across the world (9.2)..LVL !waterHeight, keeps its units: a quarter of an 8-bit terrain step, so 0 to 1,020 covers the classic 0 to 255 range as today. On a version 6 track whose terrain reaches higher, it may go past 1,020, up to the top of the terrain (2 * (terrainHeightBase + 65536 / terrainHeightStep)). A value under all the ground is allowed and simply shows no water, as it always has.Height step and base. Pick the values for the author:
terrainHeightBase = floor(lowest point in ft)
terrainHeightStep = the largest power of two, at most 128,
with (highest - base) * step <= 65535
World size. Use worldCells=512 only when the map does not fit in 7,936 ft (8,192 less a 256 ft margin per side against the wrap) at its true scale; a 256 world needs less memory. Leave at least 256 ft between the map and the world’s edge on every side.
Tools that rewrite a .TXV (Traxx carries unknown keys over) MUST keep the keys of section 6 untouched.
Examples:
worldCells is left at its default.worldCells=512, with 3,400 ft to spare per side; the full 12,530 ft collision extent fits too. Its 27 m of relief (89 ft) keeps step 128.| Reader | A .SI3 track |
|---|---|
| MTM2 retail | not listed |
| Community Patch 3 | not listed |
| Community Patch 4 beta 0.52 | not listed |
| A version 6 reader | listed and loaded |
A .SIT or .SI2 track without the keys of section 6 is not affected by this document.
Lakes and waterfalls: CP4 refuses a .WTR or .WFL of any major version but 1, so it never misreads a version 2 file; it never meets one either, since version 2 belongs to 512-cell .SI3 tracks. Editors: Traxx 1.7.3 refuses a TRAXXV99 .TXX, since its loader knows only the headers TRAXXV1 to TRAXXV19 and aborts on any other (section 15), so it never misreads one.
A new extension is the only reliable gate. formatVersion is information that no build refuses, so a reused key or a bigger file would load wrong in an older build without warning. CP4 0.52 reads a RAW of unknown size as classic and takes its first 64 KiB, and a 256-cell build cannot reach half of a 512 world. Older builds never list a .SI3, so they show nothing rather than something broken.
Four times the objects. A 512 world has four times the area of a 256 one, and 16,384 is four times 4,096. It is a power of two, so an editor’s fixed arrays and an engine’s object indices (14 bits) stay simple. Whole-city Chicago at true scale places 6,553 objects, so the old limit is already too small for the tracks the larger world is for.
It is a normal image. 16-bit greyscale PNG is what Photoshop, GIMP, Krita, World Machine, Gaea and GIS tools read and write, and CP4 already accepts it. There is no 24-bit greyscale format; packing heights into RGB would give files no editor can paint.
It is how other engines do it. Unity and Unreal store terrain as 16-bit heightmaps with a per-terrain height scale.
The bits go where they are visible. Below about 1 cm a height step cannot be seen; smoothness comes from interpolation, not extra bits. A step per track spends the same 16 bits on what each track needs.
Exact numbers in every engine. Powers of two convert with shifts, so two engines get the same height to the last bit, which multiplayer needs. A free min/max float scale would round differently.
Same cells, more of them. Every rule about a cell stays. Engines change constants, not algorithms, and authors keep their sense of scale. 512 keeps the engine’s shift-and-mask cell lookup.
Small change for an engine. The file layouts, the smoothing and the PNG decoder are CP4’s own, at a size given by one number. Only the lake and waterfall files need new fields, and their headers already have a size.
One world, one version. A lake or waterfall file’s version follows the world’s size, with no choice per file. A version 1 file in a 512-cell world could hold only a quarter of the data the world needs; a version 2 file in a 256-cell world would carry a larger layout for nothing, and would make a lake or a waterfall a reason for a track to stop loading in CP4. One rule keeps every reader and writer in step: version 1 with 256 cells, version 2 with 512.
Apart from placed objects, which section 5.3 raises for version 6 tracks, these limits are not part of the format, and this document does not change them. A 512 world invites four times the content, so engines may want to raise them:
| Limit | Today | Note |
|---|---|---|
| Placed objects | 4,608 (CP3’s authoring limit 4,096); 16,384 on a version 6 track (5.3) | Whole-city Chicago at true scale places 6,553, mostly props |
| CP4 surface boxes | 64 | Large cities merge streets into more surface models. OpenMTM2 has no such limit |
| Checkpoints | 20 a lap | |
| Course | about 250 straights | A lap in a 16,384 ft world can be much longer |
CP4 collidable models (.clsh cache) |
2,048 |
.TXX generation TRAXXV99This section is not part of the track format: no game reads a .TXX. It is recorded here so that every editor that saves version 6 tracks writes the same working file.
TRAXXV99 is a temporary number. It was chosen to stay clear of the generations Traxx itself defines. The final draft of this document will use whatever generation number Traxx itself takes next for version 6 tracks, and this section will then name that number instead of 99.
Traxx, the MTM2 track editor (the C++ Traxx, and its web port JSTraxx), saves a track being edited as a .TXX: one little-endian record of the whole track, in Traxx’s own units. Its first 10 bytes name the generation, NUL-padded. Each generation appends fields to the one before, and Traxx writes the lowest generation the track’s contents need, so a track that uses nothing new stays readable by an older Traxx.
The generations, as of Traxx 1.8.0 (the released source, commit 34aaa67):
| Generation | Added by | What it adds |
|---|---|---|
TRAXXV1 to TRAXXV17 |
Traxx up to 1.7.0 | up to the terrain mode and its 16-bit or 8 ft heights |
TRAXXV18 |
Traxx 1.7.1 | waterfalls |
TRAXXV19 |
Traxx 1.7.2 | the water detail map and the water mask map (ART\<stem>_WDTL, ART\<stem>_WMSK), after the waterfalls |
TRAXXV20 |
Traxx 1.8.0 | an i32 at the very end of every box record, after its fog values: the light’s allWx (0 or 1; the .SIT light line’s 13th field). Written only when some light has it set |
Traxx 1.7.2’s TRAXXV19 is its own generation. An earlier revision of this section (2026-11-13) gave the same name to the version 6 generation defined here; that generation is now TRAXXV99. Traxx 1.7.3 adds no generation, but its waterfalls block is block version 3, which adds an i32 roughFrom per fall after the mist height (the .WFL byte 130, section 9.3); it still reads block versions 1 and 2. Traxx 1.8.0 adds TRAXXV20; TRAXXV99 carries its field (15.3).
Traxx’s loader (CTrackPOD::LoadBinary, TrackPODBinary.cpp) reads the 10-byte header and compares it with strcmp against the names it defines: TRAXXV1 to TRAXXV19 in Traxx 1.7.3, to TRAXXV20 in Traxx 1.8.0. Any other header sets the version to 0, and the loader closes the file and returns FALSE (FILE_ABORT) before it reads anything past the header; Traxx then shows “Error loading txx file”.
TRAXXV20 holds the terrain as 256 x 256 cells with 8-bit and 16-bit heights, and ground boxes as two bytes. It cannot hold a version 6 track. TRAXXV99 is a generation defined by JSTraxx that can. It is not Traxx’s.
An editor MUST write TRAXXV99 for a version 6 track: one it would save with a .SI3 (section 5.1). That is a 512-cell world, heights outside 0 to 512 ft or kept in the 32-bit store, ground boxes that need 16 bits, or a track opened from a .SI3.
It MUST NOT write TRAXXV99 for any other track. Such a track keeps Traxx’s own rule: the lowest generation from TRAXXV1 to TRAXXV20 that its contents need, with the bytes Traxx 1.8.0 writes.
TRAXXV99 is TRAXXV20’s record, in the same order, with these differences (N = worldCells):
| # | Record | TRAXXV20 | TRAXXV99 |
|---|---|---|---|
| 1 | Header | TRAXXV20 |
TRAXXV99 |
| 2 | Before the terrain record | (nothing) | i32 worldCells, 256 or 512 |
| 3 | Terrain planes | 256 x 256 cells each | N x N cells each, coded the same way |
| 4 | Ground box bottom and top | u8 each, 2 ft units | f64 each, 2 ft units (any height a version 6 box holds) |
| 5 | V17 heights (not Classic 8-bit) | u16 samples, 256 x 256 or 1024 x 1024 | i32 store width (16 or 32), then N x N (Classic 16-bit, Spline) or 4N x 4N (Full Map) samples of that width |
| 6 | Lake seeds | 0..255 | 0..N - 1 |
| 7 | Waterfalls | block version 3, the 256-cell world | block version 3, the track’s world: crest points and heights as section 9.3 allows |
| 8 | Water detail and water mask maps | both records; the generation is written only when a map is set | both records always, an empty extension and length 0 for a map that is not set |
| 9 | A box’s allWx |
an i32 at the end of every box record; the generation is written only when a light has it set | always present, 0 for a box that is not a light or whose light has it clear |
| 9 | After the water mask map | (end) | the version 6 block |
The whole record, in order (strings are one length byte, counting the terminating NUL, then the bytes; a blob is an i32 length then the bytes):
allWx).worldCells..CLR low and high bytes, and the seven .LTE planes. N x N cells in V99..VEG bytes as a blob.ART\<stem>_WDTL). In V99 always present: an empty extension and length 0 when there is none.ART\<stem>_WMSK). In V99 always present, as record 19..SI3, 0x2 a height step and base are set); i32 terrainHeightStep; i32 terrainHeightBase (both 0 without flag 0x2).JSTRAXX1, its extra backdrops), after everything Traxx reads.A reader restores the world size, the heights in their store, the N x N grids, the ground boxes, the step and base, the water maps, and whether the track came from a .SI3. Saving the track again therefore writes the same pod. Like every .TXX, it names art and models without holding them (they come from the project’s ART and MODELS folders), and it does not keep the .TXV’s text: a writer writes the keys of section 6 afresh from the track.
Traxx 1.7.3 and 1.8.0 refuse a TRAXXV99 file: its header is none of the names their loaders know, so the loader aborts after the header (15.1) and never misreads it. A version 6 track’s autosave is TRAXXV99 as well. A track that is not version 6 never becomes TRAXXV99, so Traxx keeps opening it.
When Traxx takes its own generation number for version 6 tracks, the final draft will use that number in place of 99 (see the note at the top of this section).
.SI3 as an MTM2 situation file;readTxvInfo;.CLR, .LTE and ground box decoders and writers;.RA0/.RA1;.WTR and .WFL version 2, the version picked by the world’s size, and the waterfall build on an N world (sim/cp4/falls.ts);sim/mtm2/world/)..SI3 tracks (src/worker/catalog.js);WORLD_FT (src/shared/scene-frame.js) and the other 8,192 ft constants (about 40 files) with the track’s world size;.SI3 saves; lakes and waterfalls in the N world, with errors for a 256-cell lake or crest above 2,048 ft; up to 16,384 objects on a version 6 track, 4,096 on any other (5.3); the .TXX generation TRAXXV99 (section 15)..SI3 recognised; the .WTR, .VEG and .WFL previews draw a 512-cell world.Traxx, the C++ editor, reads and writes no version 6 track yet. What it would have to change, area by area, with the functions and constants involved, is in Version 6 tracks in Traxx.
What else in an engine assumes 256 cells, 8,192 ft or 512 ft (section 10, item 9)? Findings from any engine are welcome and will be added here.
Points the first implementations met that this document does not settle yet; each says what they do today:
.RAW. With terrainHeightMap no .RAW is needed, yet the .LVL still names one. Implementations take the grid files’ names from the .LVL as today and do not require the RAW entry itself to exist; the document should say so.terrainHeightMap. Section 7.1 says they do not apply to heights; section 8.3 applies the base to ground boxes. Implementations use step 128 and base 0 throughout such a track. The keys could instead be refused without a height map..RA2 and .RA3. Section 8.2 allows them 16-bit, but section 8.3 names only the .RA0/.RA1 and .RA4/.RA5 pairs. Implementations check their size only..WTR, .WFL or .VEG. Implementations drop the file with a warning and load the track; only a grid file of the wrong size refuses it..VEG header’s tile counts stay 256, as Traxx writes them..TXV. The situation file’s stem (section 3); OpenMTM2 also looks up the level’s stem first. They differ only when the stems do.base + 2 * byte cannot reach an odd-foot height, so such a box must be 16-bit.