Game Constants

The game's tunable numbers live in three objects: RULES (construction, costs, trains, physics), PATHFINDING_RULES (how pops choose between transit, driving, and walking), and GAME_COLORS (map visuals: road rendering, mode colors, map-layer color scales). Mods can override any of them at runtime.

All modifier methods are top-level API methods on window.SubwayBuilderAPI, not under .actions. Overrides are deep-merged, so you only pass the keys you want to change.

modifyConstants#

Modify game rules (RULES) at runtime.

window.SubwayBuilderAPI.modifyConstants({
    STARTING_MONEY: 10_000_000_000, // 10B instead of 3B
    DEFAULT_TICKET_COST: 5,
    CONSTRUCTION_COSTS: {
        TUNNEL: {
            SINGLE_MULTIPLIER: 0.5 // Half the normal cost
        }
    }
});

Read the current values with window.SubwayBuilderAPI.utils.getConstants().

Simulation cadence: TICKS_PER_UPDATE#

The simulation advances in fixed ticks of 0.5 in-game seconds (GAME_SECONDS_PER_TICK in shared data — the whole simulation is built around a fixed tick length, so unlike RULES it is read once at app load and cannot be changed at runtime). Ticks are run in batches — one update — and the game loop's real-time interval scales with the batch size, so a bigger batch does more work per fire and fires less often. Game time passes at the same rate either way; what changes is how finely the simulation is sliced, and how much CPU it costs.

RULES.TICKS_PER_UPDATE has an entry per speed tier (slow, normal, fast, ultrafast), each with four values:

window.SubwayBuilderAPI.modifyConstants({
    TICKS_PER_UPDATE: {
        ultrafast: {
            gameState: 24, // Half the default batch: smoother motion, more CPU
            trainCoords: 12,
            popMovement: 12,
            popMovementGeojson: 24
        }
    }
});

Changes apply on the next update — no reload needed, and the loop picks up the new interval without the player touching the speed controls.

Every value must be a whole number of at least 1, and is capped at RULES.MAX_TICKS_PER_UPDATE (default 1000). Anything else (zero, a fraction, a string, NaN) falls back to that key's shipped default with a console warning: a fractional batch breaks the loop's end-of-batch check, and an unbounded one would run the whole batch inside a single frame and freeze the app. The cap itself is moddable — raise MAX_TICKS_PER_UPDATE if you genuinely want bigger batches, accepting that each game-loop fire stalls the app for as long as its batch takes.

Smaller batches at fast and ultrafast are the usual reason a mod tanks the frame rate on a large network — the simulation does the same amount of work per game-hour, but hands results to the renderer several times more often.

Game speed: GAME_SECONDS_PER_SECOND#

RULES.GAME_SECONDS_PER_SECOND sets how many in-game seconds pass per real second at each speed tier (slow, normal, fast, ultrafast). Unlike TICKS_PER_UPDATE, this actually changes how fast game time passes.

window.SubwayBuilderAPI.modifyConstants({
    GAME_SECONDS_PER_SECOND: {
        fast: 500, // Double-speed "fast" tier
        ultrafast: 2000 // 1 day = 43 real seconds
    }
});

Values are read live on every game-loop fire, so changes apply immediately without the player touching the speed controls. Every value must be a positive finite number; anything else falls back to that tier's shipped default with a console warning. `actions.setSpeedMultiplier` writes to these same values — modifyConstants sets absolute numbers, while setSpeedMultiplier scales the base value non-compoundingly.

Capacity warnings: WARNING_CONSTS#

RULES.WARNING_CONSTS controls train capacity warnings: a train boarding passengers with fewer empty spots than the active threshold triggers a warning, which expires after CAPACITY_WARNING_DURATION game seconds. Which threshold is active depends on the player's "Capacity Warning Threshold" feature flag: CAPACITY_WARNING_THRESHOLD (50) when enabled, CAPACITY_WARNING_THRESHOLD_OLD (100) when disabled (the default).

window.SubwayBuilderAPI.modifyConstants({
    WARNING_CONSTS: {
        CAPACITY_WARNING_THRESHOLD_OLD: 25, // Only warn when trains are nearly full
        CAPACITY_WARNING_DURATION: 60 * 30 // Keep warnings around for 30 game-minutes
    }
});

Track drawing snap radius: PIXEL_SNAP_THRESHOLD#

RULES.PIXEL_SNAP_THRESHOLD is the radius in screen pixels within which drawn track endpoints snap to existing tracks, stations, and endpoints. It is read live on every pointer move while drawing. The larger radius used during the tutorial is fixed — the tutorial depends on predictable snapping.

window.SubwayBuilderAPI.modifyConstants({
    PIXEL_SNAP_THRESHOLD: 20 // Easier snapping for touchpads / precision building
});

Station marker bullets: MARKER_ROUTE_BULLETS#

RULES.MARKER_ROUTE_BULLETS sizes the row of route bullets shown under station and station-group names on the map. The game projects the row's total width from the bullet text (TEXT_SIZE_MULTIPLIER, CHAR_WIDTH_RATIO) plus ICON_GAP_PX between bullets, and hides the whole row when the projection exceeds MAX_ROW_WIDTH_PX — the default cutoff of 300px hides the row at stations served by very many routes.

window.SubwayBuilderAPI.modifyConstants({
    MARKER_ROUTE_BULLETS: {
        MAX_ROW_WIDTH_PX: 500, // Show the bullet row at busier stations
        ICON_GAP_PX: 4 // More breathing room between bullets
    }
});

The values are read live, so changes apply the next time the markers re-render (panning, zooming, or any game-state change).

Station crowd ambience: SOUND_SETTINGS#

RULES.SOUND_SETTINGS controls the crowd noise heard when the camera is zoomed in near a constructed station with routes. Volume falls off linearly with the distance between the camera and the closest qualifying station (including the camera's height above the ground, so zooming out fades it too), reaching zero at NEAR_STATIONS_THRESHOLD meters and peaking at CROWD_MAX_VOLUME.

window.SubwayBuilderAPI.modifyConstants({
    SOUND_SETTINGS: {
        CROWD_MAX_VOLUME: 0.5, // Louder platforms
        NEAR_STATIONS_THRESHOLD: 2000 // Audible from further away
    }
});

The values are read live, so changes apply the next time the camera moves.

Bond financing: BOND_TYPES#

RULES.BOND_TYPES holds everything behind the three bond offerings (SMALL, MEDIUM, LARGE): the display name shown in the financial dashboard, the principal, the daily interest rate charged hourly on the remaining principal, the fraction of the principal repaid per game hour, and the previous-day revenue required to qualify.

window.SubwayBuilderAPI.modifyConstants({
    BOND_TYPES: {
        SMALL: {
            displayName: '$200M Bond', // Rename to match the new principal
            principal: 200_000_000,
            interestRate: 0.02, // Cheaper starter loans
            requiredDailyRevenue: 5_000_000 // Easier to qualify for
        }
    }
});

Changes apply to bonds issued after the override; already-issued bonds keep the terms they were issued with. The bond ids (small, medium, large) are structural — they key issued bonds in save data — so they cannot be changed, and bonds cannot be added or removed.

Read the current bond types (names included) with window.SubwayBuilderAPI.gameState.getBondTypes().

modifyPathfindingRules#

Modify the pathfinding and mode-choice rules (PATHFINDING_RULES) at runtime. Every value is a number; non-numeric or non-finite values and unknown keys are ignored with a console warning.

Changes take effect on the next commute simulation — no reload needed.

window.SubwayBuilderAPI.modifyPathfindingRules({
    MAX_TRANSFERS: 6, // Allow more transfers per journey
    MAX_WALK_TO_FROM_STATION: 60 * 30, // Shrink walk catchment to 30 min
    PARKING_COST: 10, // Make driving less attractive
    PERCEIVED_TIME: {
        WALK_MULTIPLIER: 1.6, // Pops perceive walking as more costly
        WAIT_MULTIPLIER: 1.5
    },
    DRIVING_TIMES: {
        HIGH_DEMAND: 2.0 // Heavier rush-hour traffic
    }
});

Read the current values (including any overrides already applied) with window.SubwayBuilderAPI.utils.getPathfindingRules().

modifyColors#

Modify the map visual constants (GAME_COLORS) at runtime: per-road-class widths and fade zoom windows, the fade windows and opacities of the flat area layers (buildings, parks, commercial/college areas), travel mode colors, the color scales for the building foundation depth, track speed, track TPH, and track elevation layers, the size and ring of the station marks (STATION_MARKER), and the zoom ramps of the schematic route diagram (PORTOLAN).

The area and building colors themselves are part of the map theme (the in-game custom color presets), not GAME_COLORS.

Objects are deep-merged, but arrays are replaced wholesale — to change one entry of TRACK_SPEED_COLORS, pass the whole array.

Call modifyColors at mod load time for everything to pick up the new values. Some values are only read when the map style is built or the city is loaded (e.g. AREA_VISUALS, BUILDING_FOUNDATION_DEPTHS, STATION_GROUP_DISTANCE_THRESHOLD), so if you change them mid-game, the save may need to be reloaded for the changes to take effect. Others (like ROAD_VISUALS and the track color scales) are read as the map redraws and apply without a reload.

window.SubwayBuilderAPI.modifyColors({
    ROAD_VISUALS: {
        highway: { zoomWindow: [10, 10.5] } // Keep highways visible further out
    },
    AREA_VISUALS: {
        buildings: { zoomWindow: [12, 12.5], opacity: 0.8 }, // Buildings appear earlier and more opaque
        parksSmall: { zoomWindow: null } // Small parks always visible (null = no fade)
    },
    MODE_COLORS: {
        transit: '#8B5CF6' // Purple transit trips in charts and the demand key
    },
    TRACK_SPEED_COLORS: [
        // Arrays are replaced wholesale, not merged
        { speedKmh: 50, hex: '#22C55E' },
        { speedKmh: 130, hex: '#A855F7' }
    ]
});

Read the current values with window.SubwayBuilderAPI.utils.getColors().

The station marks (STATION_MARKER)#

A station is drawn two different ways and both draw the same mark. Most stops are a dot; a stop whose lines fill a bundle of the schematic diagram gets an interchange pill instead, which stands exactly where that dot would have been and hides it. They sit side by side on the map, so what they have in common comes from one place:

window.SubwayBuilderAPI.modifyColors({
    STATION_MARKER: {
        DOT_DIAMETER: 9, // Fatter interchange pills
        BORDER_WIDTH: 2, // A heavier ring, on the dots and the pills alike
        BORDER_DARK: '#1b1b3a' // The ring on white dots and on every pill
    }
});

DOT_DIAMETER is the mark's full-size diameter in screen pixels, at zoom 14 and closer. It is the pill's height and twice its corner radius — a pill is a dot stretched along its bundle, and it overhangs the outermost ribbon at each end by half of this. Wider zooms scale it down by PORTOLAN.MARKER_ICON_SCALE_STOPS. It does not resize the plain station dots, which are sized in rem so they follow the interface scale rather than the camera.

BORDER_WIDTH is in screen pixels and holds at that width however far you zoom out. The dot gets it directly — its border does not scale with the camera — while the pill's ring is baked into an image that the marker scale ramp then shrinks, so the game draws it into that image already divided by the scale it is about to be shown at.

BORDER_DARK rings anything that has to separate from a pale background — every white interchange dot, every diagram pill, and route-colored dots in the dark theme. BORDER_LIGHT rings a route-colored dot in the light theme, where the ring reads as the page showing through rather than as an outline. Any CSS color works.

All four are read as the map redraws, so a change applies without a reload.

The route diagram (PORTOLAN)#

With visual interlining turned on, zooming out swaps the track-accurate route lines for a schematic diagram: routes that share a corridor are merged into one bundle of parallel ribbons, with an interchange marker where a station's lines fill the bundle. Zooming back in past PORTOLAN.ROUTE_ZOOM hands the map back to lines that follow the actual rails.

The diagram's geometry is computed by the game when the network changes, and mods cannot edit it. What GAME_COLORS.PORTOLAN controls is how that geometry is presented as you zoom: where the handoff sits, how wide a ribbon draws, how big a marker gets, and how far a bundle spreads. All of it is read as the map redraws, so it applies without a reload — the one exception is BANDS, whose min values decide how the diagram is sliced when it is built.

The interchange marker's own size and ring are not here: they belong to the station marks it replaces, under STATION_MARKER above. MARKER_ICON_SCALE_STOPS scales that mark; STATION_MARKER.DOT_DIAMETER is what it scales.

window.SubwayBuilderAPI.modifyColors({
    PORTOLAN: {
        ROUTE_ZOOM: 14, // Hand back to track-accurate lines earlier
        MARKER_ZOOM: 12, // Hold the interchange markers back until closer in
        RIBBON_WIDTH_STOPS: [
            // Arrays are replaced wholesale — pass every stop, in ascending zoom order
            { zoom: 10, width: 1.5 },
            { zoom: 14, width: 4 }
        ]
    }
});

Values between two stops are interpolated linearly; outside the listed stops the nearest stop's value holds flat, so a two-stop table is a ramp with a floor and a ceiling. A single stop is a constant.

Two things to know before reaching for these. BAND_GAP_SCALE is documentation, not a control — the spacing it describes is already baked into the diagram's geometry, and the renderer deliberately does not apply it a second time. And the route lettering that rides the ribbons was laid out against the shipped OFFSET_SCALE_STOPS ramp, so widening or narrowing that ramp slides the lettering off the line it names.

Game Rules Reference#

Every rule in RULES, its default value, and what it does. This reference is generated from the game's own rule definitions, so it always matches the shipped defaults.

CONSTRUCTION_COSTS#

Multipliers and line items for construction and maintenance costs.

CONSTRUCTION_COSTS.TUNNEL#

Track cost multipliers by lane count.

CONSTRUCTION_COSTS.STATION#

Station cost multipliers.

CONSTRUCTION_COSTS.ELEVATION_MULTIPLIERS#

Cost multipliers by construction elevation type.

CONSTRUCTION_COSTS.WATER_MULTIPLIERS#

Multipliers for construction over water, applied on top of the base elevation multiplier.

CONSTRUCTION_COSTS.ELEVATION_THRESHOLDS#

Elevation boundaries in meters between construction types.

CONSTRUCTION_COSTS.GRADE_CROSSING#

Grade crossing cost multipliers.

CONSTRUCTION_COSTS.GRADE_CROSSING.ROAD_CLASS_MULTIPLIER#

Cost multiplier by road class.

CONSTRUCTION_COSTS.GRADE_CROSSING.LANE_COUNT_MULTIPLIER#

Cost multiplier by number of track lanes crossing the road.

CONSTRUCTION_COSTS.BUILDING_OVERPASS#

Costs and limits for elevated tracks spanning over buildings.

YARDS#

Train yard rules (yards-enabled saves only).

STREET_RUNNING#

Rules for street-running (tram) tracks.

ROAD_SPEED_LIMITS#

Speed limits in m/s by road class, used only for street-running trains.

MARKER_ROUTE_BULLETS#

Sizing for the route bullet row shown under station and station-group markers on the map.

SOUND_SETTINGS#

Station crowd ambience settings.

WARNING_CONSTS#

Thresholds and lifetimes for train capacity warnings.

BOND_TYPES#

The bond offerings players can issue for financing. Interest accrues on the remaining principal. Already-issued bonds keep the terms they were issued with.

BOND_TYPES.SMALL#

Small bond ($100M at 6%).

BOND_TYPES.MEDIUM#

Medium bond ($500M at 4%).

BOND_TYPES.LARGE#

Large bond ($1B at 2%).

GAME_SECONDS_PER_SECOND#

How many in-game seconds pass per real second at each speed tier. Values must be positive finite numbers; bad values fall back to the shipped defaults.

TICKS_PER_UPDATE#

How many simulation ticks are batched into one game-loop update, per speed tier. Every value must be a whole number of at least 1. Raising them trades smoothness for CPU cost; it does not change how fast game time passes, because the interval between updates scales with gameState.

TICKS_PER_UPDATE.slow#

Tick batching at the slow speed tier.

TICKS_PER_UPDATE.normal#

Tick batching at the normal speed tier.

TICKS_PER_UPDATE.fast#

Tick batching at the fast speed tier.

TICKS_PER_UPDATE.ultrafast#

Tick batching at the ultrafast speed tier.

Pathfinding Rules Reference#

Every rule in PATHFINDING_RULES, its default value, and what it does. Also generated from the game's rule definitions.

PERCEIVED_TIME#

Weights for how pops perceive each component of a transit journey, relative to a minute riding the train (1.0). Journeys are ranked and priced into mode choice by this perceived ("generalized") time. Values come from the Wardman et al. 2026 meta-analysis (Transportation Research Part A).

DRIVING_TIMES#

Traffic multipliers applied to driving times by time-of-day demand level. A value of 1.5 means drives take 50% longer than free-flow.

Map Visuals Reference#

Every value in GAME_COLORS, its default, and what it does. Also generated from the game's own definitions.

ROAD_STRUCTURES#

Rendering of road structures: how bridge and tunnel road segments are drawn differently from surface roads. All values are read as the map redraws.

MODE_COLORS#

Colors for travel modes, used in charts and the demand map key.

TRACK_ARROWS#

The directional arrows drawn along tracks and routes when the track arrows layer is on and the camera is zoomed in. Track arrows sit on the rails themselves; route arrows are the bigger set drawn on route lines. All values are read as the map redraws.

PORTOLAN#

The Portolan schematic diagram for visually interlined routes: the merged, offset route ribbons the map draws instead of track-accurate lines when visual interlining is on and the camera is zoomed out. These control how the diagram is presented, not the geometry itself, which comes from the diagram build.

PORTOLAN.CATERPILLARS#

The caterpillars: the route bullets chained along the ribbons between stations, and the route-name lettering that runs along a ribbon when a name does not fit in a bullet. These only show when visual interlining is enabled.

PORTOLAN.CATERPILLARS.TEXT_SIZE_STOPS#

Route-name lettering size in pixels by zoom, interpolated linearly and held flat outside the listed stops. Read as the map redraws.

[
    {
        "zoom": 12,
        "size": 10
    },
    {
        "zoom": 16,
        "size": 13
    }
]

PORTOLAN.BANDS#

Zoom bands, widest-zoom first. The diagram build emits one full copy of the network per band, progressively less detailed as you zoom out, and exactly one band may draw at a time - two bands drawn together doubles every ribbon. A camera at zoom z draws the first band whose min is at or below z, so min is what selects a band and max is documentation. The keys are fixed by the build format; changing them leaves the renderer asking for band data that was never emitted. Changing min re-slices the diagram, so it takes effect on the next diagram build rather than immediately.

[
    {
        "key": 15,
        "min": 15,
        "max": 24
    },
    {
        "key": 14,
        "min": 14,
        "max": 15
    },
    {
        "key": 13,
        "min": 13,
        "max": 14
    },
    {
        "key": 0,
        "min": 0,
        "max": 13
    }
]

PORTOLAN.BAND_GAP_SCALE#

Slot-pitch multiplier per band, keyed by band key: how far apart two routes sharing a corridor sit in that band, relative to the innermost band. Reference values only. The build has already baked them into each vertex offset, so this table is for reasoning and assertions and the renderer must not apply it again - doing so narrows every bundle twice over.

{
    "0": 0.75,
    "13": 0.85,
    "14": 0.95,
    "15": 1
}

PORTOLAN.OFFSET_SCALE_STOPS#

How far a ribbon sits from its bundle centre, as a fraction of the offset baked into the build, interpolated linearly by zoom and held flat outside the listed stops. Bundles narrow as you zoom out so they never swamp the map. Note that the route-name lettering rides the ribbons using a z11 to z14 ramp fixed by the build, so moving these stops drifts the lettering off the line it labels. Read as the map redraws.

[
    {
        "zoom": 11,
        "scale": 1
    },
    {
        "zoom": 14,
        "scale": 0.8
    }
]

PORTOLAN.RIBBON_WIDTH_STOPS#

On-screen ribbon width in pixels by zoom, interpolated linearly and held flat outside the listed stops. Multiplied by the per-mode width from the diagram build style, so a metro ribbon and a commuter-rail ribbon keep their relative weights. The station dots also ride this curve: their diameter scales by the ribbon width relative to its zoom-14 value, so the marks thicken with the lines. Read as the map redraws.

[
    {
        "zoom": 7,
        "width": 1
    },
    {
        "zoom": 10,
        "width": 1.5
    },
    {
        "zoom": 13,
        "width": 2
    },
    {
        "zoom": 15,
        "width": 3
    },
    {
        "zoom": 16,
        "width": 3.6
    }
]

PORTOLAN.MARKER_ICON_SCALE_STOPS#

Size of every station mark by zoom - the diagram interchange pills AND the ordinary station dots, which share the ramp so the two marks never disagree in size - as a fraction of full size, interpolated linearly and held flat outside the listed stops. It dips further at the outer end than OFFSET_SCALE_STOPS does, because a pill has to stop swamping the ribbons it lies across as well as keep reaching them. Read as the map redraws.

[
    {
        "zoom": 11,
        "scale": 0.38
    },
    {
        "zoom": 12,
        "scale": 0.5
    },
    {
        "zoom": 14,
        "scale": 1
    }
]

STATION_MARKER#

The station mark: the dots the map draws on stations, and the schematic diagram interchange pills, which replace those dots on an interchange and sit beside them elsewhere. Both marks are their configured diameter at zoom 14 and scale with the camera from there - the dots by the ribbon-width curve, the pills by their own icon ramp - and they share the ring.

ROAD_VISUALS#

Per-road-class rendering config: line width in meters and the zoom window [start, end] over which the road fades in while zooming in. Highways and major roads stay visible further out than smaller roads.

{
    "highway": {
        "width": 12,
        "zoomWindow": [
            6.5,
            7
        ]
    },
    "major": {
        "width": 8,
        "zoomWindow": [
            6.5,
            7
        ]
    },
    "medium": {
        "width": 6,
        "zoomWindow": [
            12,
            12.5
        ]
    },
    "minor": {
        "width": 4,
        "zoomWindow": [
            12,
            12.5
        ]
    }
}

AREA_VISUALS#

Zoom fade windows and final opacities for the flat map area layers. zoomWindow is the [start, end] zoom range over which the layer fades in while zooming in (null means always shown at full opacity). parksLarge covers parks of at least 100,000 square meters. commercial covers both commercial and college areas (one tile layer, so they share a fade and opacity; their colors come from the map theme).

{
    "buildings": {
        "zoomWindow": [
            12,
            12.5
        ],
        "opacity": 0.65
    },
    "parksLarge": {
        "zoomWindow": null,
        "opacity": 0.8
    },
    "parksSmall": {
        "zoomWindow": [
            12,
            12.5
        ],
        "opacity": 0.8
    },
    "commercial": {
        "zoomWindow": [
            12.25,
            12.75
        ],
        "opacity": 0.7
    }
}

BUILDING_FOUNDATION_DEPTHS#

Depth bands (in meters) and per-theme colors for the building foundation depth map layer. maxDepth Infinity means no upper bound.

[
    {
        "minDepth": 10,
        "maxDepth": 14,
        "colors": {
            "light": "#009c27",
            "dark": "#006b1b"
        },
        "label": "10-14m"
    },
    {
        "minDepth": 14,
        "maxDepth": 18,
        "colors": {
            "light": "#ff9124",
            "dark": "#cc7319"
        },
        "label": "14-18m"
    },
    {
        "minDepth": 18,
        "maxDepth": 22,
        "colors": {
            "light": "#ff3d24",
            "dark": "#cc3119"
        },
        "label": "18-22m"
    },
    {
        "minDepth": 22,
        "maxDepth": 26,
        "colors": {
            "light": "#8B0000",
            "dark": "#5c0000"
        },
        "label": "22-26m"
    },
    {
        "minDepth": 26,
        "maxDepth": 30,
        "colors": {
            "light": "#d324ff",
            "dark": "#a91acc"
        },
        "label": "26-30m"
    },
    {
        "minDepth": 30,
        "maxDepth": Infinity,
        "colors": {
            "light": "#CBC3E3",
            "dark": "#9d96b5"
        },
        "label": "30m+"
    }
]

TRACK_SPEED_COLORS#

Track speed color mapping for the track speeds layer: speeds in km/h to colors.

[
    {
        "speedKmh": 10,
        "hex": "#3B82F6"
    },
    {
        "speedKmh": 25,
        "hex": "#06B6D4"
    },
    {
        "speedKmh": 50,
        "hex": "#22C55E"
    },
    {
        "speedKmh": 75,
        "hex": "#F97316"
    },
    {
        "speedKmh": 90,
        "hex": "#F43F5E"
    },
    {
        "speedKmh": 130,
        "hex": "#A855F7"
    }
]

TRACK_TPH_COLORS#

Track TPH color mapping for the track TPH layer: total trains-per-hour through a track (summed across all routes) to colors.

[
    {
        "tph": 0,
        "hex": "#94a3b8"
    },
    {
        "tph": 10,
        "hex": "#3B82F6"
    },
    {
        "tph": 20,
        "hex": "#22C55E"
    },
    {
        "tph": 30,
        "hex": "#F97316"
    },
    {
        "tph": 40,
        "hex": "#F43F5E"
    },
    {
        "tph": 50,
        "hex": "#A855F7"
    }
]

ROUTE_UTILIZATION_COLORS#

Route utilization color mapping for the route stats utilization view: percent of offered train capacity in use to colors, interpolated between stops.

[
    {
        "percent": 0,
        "hex": "#22C55E"
    },
    {
        "percent": 25,
        "hex": "#EAB308"
    },
    {
        "percent": 50,
        "hex": "#F97316"
    },
    {
        "percent": 75,
        "hex": "#cb0025"
    },
    {
        "percent": 100,
        "hex": "#ba00cb"
    }
]

ROUTE_RELIABILITY_COLORS#

Route reliability color mapping for the reliability panel: percent of arrivals that were on time to colors, interpolated between stops.

[
    {
        "percent": 0,
        "hex": "#cb0025"
    },
    {
        "percent": 50,
        "hex": "#F97316"
    },
    {
        "percent": 75,
        "hex": "#EAB308"
    },
    {
        "percent": 90,
        "hex": "#84CC16"
    },
    {
        "percent": 100,
        "hex": "#22C55E"
    }
]

SECTION_DELAY_COLORS#

Section delay color mapping for the reliability map mode: seconds of lateness a route section adds to colors, interpolated between stops and clamped past the last one.

[
    {
        "seconds": 0,
        "hex": "#22C55E"
    },
    {
        "seconds": 10,
        "hex": "#84CC16"
    },
    {
        "seconds": 20,
        "hex": "#EAB308"
    },
    {
        "seconds": 40,
        "hex": "#F97316"
    },
    {
        "seconds": 60,
        "hex": "#cb0025"
    }
]

TRACK_ELEVATIONS#

Elevation steps (in meters) and per-theme colors for the track elevations layer.

[
    {
        "depth": 20,
        "colors": {
            "light": "#0100cb",
            "dark": "#0100cb"
        },
        "label": "20m"
    },
    {
        "depth": 10,
        "colors": {
            "light": "#00b7cb",
            "dark": "#00b7cb"
        },
        "label": "10m"
    },
    {
        "depth": 0,
        "colors": {
            "light": "#14cb00",
            "dark": "#14cb00"
        },
        "label": "0m"
    },
    {
        "depth": -10,
        "colors": {
            "light": "#cbad00",
            "dark": "#cbad00"
        },
        "label": "-10m"
    },
    {
        "depth": -20,
        "colors": {
            "light": "#cb0025",
            "dark": "#cc3119"
        },
        "label": "-20m"
    },
    {
        "depth": -30,
        "colors": {
            "light": "#ba00cb",
            "dark": "#ba00cb"
        },
        "label": "-30m"
    }
]