openmtm2

MTM2 track format version 6: taller tracks and larger worlds

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.

1. Summary

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:

Tracks that use none of this are unchanged and keep loading everywhere as before.

2. Motivation

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.

3. Conventions

4. The format today

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.

4.1 World size

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.

4.2 Heights

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:

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.

4.3 Grid files

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).

4.4 How tracks are found

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.

5. The version 6 track

5.1 The situation file: .SI3

5.2 The .TXV

5.3 Placed objects

6. .TXV keys

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.

7. Terrain heights

7.1 The height of a sample

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

7.2 Grid sizes and modes

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.

7.3 Storing heights

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

8. Larger worlds

8.1 What changes in an engine

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.

8.2 Grid files

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.

8.3 Ground boxes

.RA0 and .RA1 (and the cavern pair .RA4/.RA5) MAY be 8-bit or 16-bit, told apart by size:

A top of 0 still means “no box”. The two files of a pair MUST have the same depth. .CL0 does not change.

8.4 Positions in the .SI3

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).

9. CP4 lakes, vegetation, waterfalls and fog

9.1 Lakes (WORLD\<stem>.WTR), version 2

Version 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.

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.

9.2 Vegetation (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.

9.3 Waterfalls (WORLD\<stem>.WFL), version 2

Version 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):

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.

9.4 Fog volumes

A fog volume’s distance to the view is wrapped at W.

9.5 Masks and detail normals

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.

10. Reader checklist

A version 6 reader MUST:

  1. List .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).
  2. Read the keys of section 6 from a .SI3 track’s .TXV, and refuse bad values (5.2).
  3. Read heights by 7.1 and 7.2 and store them as 7.3.
  4. Take every world constant from N (8.1), and check every grid file’s size against N (8.2).
  5. Read 8 and 16-bit ground boxes (8.3).
  6. Read .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).
  7. Accept object, lake and fog heights across the whole terrain range. The track’s own water, the .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.
  8. Map world-space masks over W (9.5).
  9. Check anything else tied to height or world size. Our CP4 analysis has not traced:
    • camera far plane and fog distance;
    • sky and sun placement;
    • placed objects’ visibility around the view;
    • any overhead map;
    • the AI’s search for its course segment;
    • replays and saved games;
    • any value assumed to fit in fewer bits than a position in [0, W).
  10. Keep up to 16,384 placed objects (5.3).

11. Writer guidance

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:

12. Compatibility

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.

13. Why this design

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  

15. The editor’s working file: .TXX generation TRAXXV99

This 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.

15.1 Background

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.

15.2 When it is written

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.

15.3 Layout

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):

  1. The 10-byte header.
  2. Strings: comment, prefix, track name, locale; logo and map bitmap names (V7).
  3. i32 track type, water level (whole part), version flags, ambient sound, weather mask.
  4. Blobs: logo bitmap, map bitmap, music, text; the info bitmap and text (V8); the detail and mask maps, each an extension string and a blob (V9); three HD UI pictures, each an extension string and a blob (V10); i32 water level remainder (V11).
  5. The palette name and its 768 bytes.
  6. Textures (i32 count; each a name, i32 type, i32 depth, i32 0), models (count, names), boxes (count, records as in TRAXXV20, each ending with the i32 allWx).
  7. The primary course, then the extended courses (count, courses).
  8. V99: i32 worldCells.
  9. The terrain: u16 file flags, then ten run-length coded planes (u8 run, u8 value pairs, runs of 1 to 255, a 0 run ending the plane): the 8-bit heights, the .CLR low and high bytes, and the seven .LTE planes. N x N cells in V99.
  10. Nine trucks.
  11. The backdrop (a string, or a 32-byte stadium record).
  12. i32 misc flags (fog map, sun position, no RAW fallback, PNG heights), and the 32 KB fog map when flagged.
  13. Ground boxes: i32 count; each i32 x, y, width, height (cells), bottom and top (f64 in V99), six u16 face texture words.
  14. Sounds, animations, the sun.
  15. Vegetation (V15): two masks (extension string and blob each) and the .VEG bytes as a blob.
  16. Lakes (V16): i32 count; each i32 height (half-feet), i32 flags, i32 seed count (0 to 8), seeds as i32 x, z (0 to N - 1 in V99).
  17. The terrain mode (V17): i32, 0 Classic 8-bit, 1 Classic 16-bit, 2 Spline, 3 Full Map; then, unless Classic 8-bit, the heights. V99: i32 store width, then the samples in 1/128 ft as the store holds them (section 7.3’s h128 when 32 bits).
  18. Waterfalls (V18): i32 block version (3; a reader also takes 1 and 2), i32 count; each fall’s source, point count, flags, speed, crest height, 8 crest points (x, z), opacity, mist, volume, mist depth, mist height and roughFrom (block version 3) as i32, then the sound and texture stems as char[16]. In V99 the crest points and heights are the track’s world’s (9.3).
  19. The water detail map (V19): an extension string and a blob (ART\<stem>_WDTL). In V99 always present: an empty extension and length 0 when there is none.
  20. The water mask map (V19): an extension string and a blob (ART\<stem>_WMSK). In V99 always present, as record 19.
  21. The version 6 block (V99): i32 block version (1); i32 flags (0x1 the track was opened from a .SI3, 0x2 a height step and base are set); i32 terrainHeightStep; i32 terrainHeightBase (both 0 without flag 0x2).
  22. JSTraxx’s optional trailer (JSTRAXX1, its extra backdrops), after everything Traxx reads.

15.4 Reading it back

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.

15.5 Compatibility

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).

16. Implementation in the OpenMTM2 projects

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.

17. Open questions

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: