Constants

api.modifyConstants(overrides): Deep-merge overrides into the game rules object RULES and push a snapshot to the sim host worker when one is running. The top-level RULES object keeps its identity; every nested object on an override path is replaced by a merged copy, so a nested reference taken earlier (const cc = api.utils.getConstants().CONSTRUCTION_COSTS) goes stale.

modifyConstants#

api.modifyConstants(overrides: Partial<typeof RULES>): void

Deep-merge overrides into the game rules object RULES and push a snapshot to the sim host worker when one is running. The top-level RULES object keeps its identity; every nested object on an override path is replaced by a merged copy, so a nested reference taken earlier (const cc = api.utils.getConstants().CONSTRUCTION_COSTS) goes stale.

Nested objects merge key by key. Arrays and scalars replace the existing value. Unknown keys are added without a warning. STARTING_MONEY also sets the store's current money and logs [Modding API] Auto-synced STARTING_MONEY to store (development builds only). DEFAULT_TICKET_COST also sets the store's current ticket price and, when the first fare group is flat, that group's fare, and logs [Modding API] Auto-synced DEFAULT_TICKET_COST to store (development builds only). Logs [Modding API] Modifying game constants: (development builds only) with the top-level keys.

Parameter overrides (Partial<typeof RULES>): partial RULES tree; must be an object.

Errors:

• overrides missing or not an object: logs [Modding API] Invalid overrides - must be an object, changes nothing.
• exception: logs [Modding API] Error modifying constants:.

Hooks fired: onTicketPriceChanged (only when DEFAULT_TICKET_COST is present and differs from the current price).

Side effects: top-level RULES keys reassigned; constants snapshot sent to the sim host worker when one is running; store money, transitCost and fareGroups written for the two synced keys.

Changed: WALKING_SPEED_STRAIGHT_LINE and WALKING_SPEED_ACCURATE_PATH overrides reach the commute worker with the next commute simulation (PR #1090).

api.modifyConstants({ CONSTRUCTION_COSTS: { TUNNEL: { SINGLE_MULTIPLIER: 0.5 } } });
// other CONSTRUCTION_COSTS.TUNNEL keys keep their values

modifyColors#

api.modifyColors(overrides: Partial<typeof GAME_COLORS>): void

Deep-merge overrides into the map visual constants object GAME_COLORS. The top-level object keeps its identity; nested objects on an override path are replaced by merged copies.

Nested objects merge key by key. Arrays and scalars replace the existing value. Unknown keys are added without a warning. Top-level keys of GAME_COLORS: ROAD_VISUALS, ROAD_STRUCTURES, AREA_VISUALS, MODE_COLORS, BUILDING_FOUNDATION_DEPTHS, TRACK_SPEED_COLORS, TRACK_TPH_COLORS, ROUTE_UTILIZATION_COLORS, ROUTE_RELIABILITY_COLORS, SECTION_DELAY_COLORS, TRACK_ELEVATIONS, TRACK_ARROWS, MIN_TRACK_BASE_PIXEL_WIDTH, JOURNEY_WALK_DOTS, TRACK_DETAIL, MIN_ROAD_PIXEL_WIDTH, MIN_LINE_WIDTH_MODIFIER, LINE_WIDTH_MODIFIER, OFFSET_MULTIPLIER, JOURNEY_LINE_WIDTH_MODIFIER, STATION_MARKER_WIDTH_MODIFIER, TRAIN_PATH_WIDTH_MODIFIER, PICKABLE_TRACK_WIDTH_MODIFIER, SIMPLE_ROUTE_ZOOM, PORTOLAN, STATION_GROUP_DISTANCE_THRESHOLD, STATION_MARKER_HOVER_RESIZE, STATION_MARKER, EDIT_ROUTE_MARKER, RAIL_CROSSING_MARKER_SIZE_PX. The rail, tie and catenary shader reads TRACK_DETAIL once when its module loads; later TRACK_DETAIL overrides do not reach it. Logs [Modding API] Modifying colors: (development builds only) with the top-level keys.

Parameter overrides (Partial<typeof GAME_COLORS>): partial GAME_COLORS tree; must be an object.

Errors:

• overrides missing or not an object: logs [Modding API] Invalid colors overrides - must be an object, changes nothing.
• exception: logs [Modding API] Error modifying colors:.

Side effects: top-level GAME_COLORS keys reassigned.

api.modifyColors({ TRACK_SPEED_COLORS: [{ speedKmh: 50, hex: '#22C55E' }, { speedKmh: 130, hex: '#A855F7' }] });
// the whole array is replaced; a one-entry array leaves one entry

modifyPathfindingRules#

api.modifyPathfindingRules(overrides: PathfindingRulesOverrides): void

Merge numeric overrides into the commute pathfinding rules PATHFINDING_RULES in place.

The commute worker receives the merged rules with the next commute simulation. Nested objects (PERCEIVED_TIME, DRIVING_TIMES) are mutated key by key. Every leaf must be a finite number. Keys named __proto__, constructor or prototype are skipped without a log. Logs [Modding API] Modifying pathfinding rules: (development builds only) with the top-level keys.

Parameter overrides (PathfindingRulesOverrides): nested partial of PATHFINDING_RULES; must be an object.

Errors:

• overrides missing or not an object: logs [Modding API] Invalid pathfinding rules overrides - must be an object, changes nothing.
• overrides is an array: logs [Pathfinding Rules] Ignoring invalid overrides with the expectation, changes nothing.
• key not in PATHFINDING_RULES: logs [Pathfinding Rules] Ignoring unknown key PATHFINDING_RULES.<path>, skips it.
• non-object or array value for an object key: logs [Pathfinding Rules] Ignoring PATHFINDING_RULES.<path> with the expectation, skips it.
• non-finite or non-numeric leaf: logs [Pathfinding Rules] Ignoring PATHFINDING_RULES.<path> with the expectation, skips it.
• exception: logs [Modding API] Error modifying pathfinding rules:.

Side effects: PATHFINDING_RULES mutated in place; the merged rules sent to the commute worker with each commute batch.

// riders walk up to 60 minutes to a station and take up to 2 transfers
api.modifyPathfindingRules({ MAX_WALK_TO_FROM_STATION: 60 * 60, MAX_TRANSFERS: 2 });

PathfindingRulesOverrides#

Nested partial of PATHFINDING_RULES accepted by modifyPathfindingRules. Each leaf must be a finite number.

type PathfindingRulesOverrides = DeepPartial<typeof PATHFINDING_RULES>

Rules with their own behaviour#

Simulation cadence: TICKS_PER_UPDATE#

The simulation advances in fixed ticks of 0.5 in-game seconds (GAME_SECONDS_PER_TICK in shared data, a module constant outside RULES, so mods cannot change it). Ticks run in batches, one update each. The game loop's real-time interval scales with the batch size: a bigger batch runs more ticks per update, and updates come at longer intervals. The target rate of game time is the same either way.

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: 16, // Half the default batch of 32
            trainCoords: 8,
            popMovement: 8,
            popMovementGeojson: 16
        }
    }
});

Changes apply on the next update, without a reload. The loop picks up the new interval without the player touching the speed controls.

Every value must be a whole number from 1 to RULES.MAX_TICKS_PER_UPDATE (default 1000). A larger value is clamped to the cap and a fraction of 1 or more is rounded down, each with a console warning. Anything else (zero, a negative number, a fraction below 1, a string, NaN) falls back to that key's shipped default with a console warning. The cap is moddable: raising MAX_TICKS_PER_UPDATE permits bigger batches, and each update runs its whole batch synchronously.

Game speed: GAME_SECONDS_PER_SECOND#

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

ultrafast is not paced: it runs the simulation back to back, as fast as the machine allows, so its value (500) does not set its speed. On a large save that is a few thousand game seconds per real second, and more on a small one.

window.SubwayBuilderAPI.modifyConstants({
    GAME_SECONDS_PER_SECOND: {
        normal: 50, // Double-speed "normal" tier
        fast: 500 // 1 day = about 3 real minutes
    }
});

Values are read live on every game-loop fire, so changes apply at once, 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. setSpeedMultiplier multiplies the values captured at its first call and rounds the result, so a later call for a tier overwrites a modifyConstants change made to that tier after the first call.

Capacity warnings: WARNING_CONSTS#

RULES.WARNING_CONSTS controls train capacity warnings: a train boarding passengers with no more empty spots than the active threshold can raise a warning for that station (at most one per station each time the game builds warnings), and the warning 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 the cursor snaps to existing track nodes and lines while drawing. It is read live on every pointer move while drawing. During the tutorial, track snapping uses a fixed radius of 30 px instead. The same rule also sets the radius for picking an existing waypoint dot while editing a route, where the tutorial radius does not apply.

window.SubwayBuilderAPI.modifyConstants({
    PIXEL_SNAP_THRESHOLD: 20 // Twice the default 10 px radius
});

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 when the marker model is rebuilt: when the zoom rounded to a tenth changes, and on other changes such as the network, the selection, edit mode, the route line width setting, station layer visibility or the theme. Panning alone does not rebuild it.

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 center and the closest qualifying station plus a zoom-derived altitude term (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.

Delay recovery dwell: DWELL.DELAY_RECOVERY_MIN_FRACTION#

RULES.DWELL.DELAY_RECOVERY_MIN_FRACTION lets a late train cut its scheduled dwell short to claw back time. The value is a fraction of the train type's stop time plus the station type's extra dwell: the shipped default of 1 means no recovery at all. A lower value lets a late train dwell for as little as that fraction of the scheduled stop. The cut never goes below the passenger-exchange (dynamic dwell) time for that stop, and never recovers more than the train is actually behind schedule, so a train cannot depart ahead of its original timetable. Values are clamped to 0 through 1.

window.SubwayBuilderAPI.modifyConstants({
    DWELL: {
        DELAY_RECOVERY_MIN_FRACTION: 0.5 // A late train can dwell for half its scheduled stop
    }
});

The value is read each time a stop's dwell is computed, so a change applies to the next stop a train makes.

Bond financing: BOND_TYPES#

RULES.BOND_TYPES holds everything behind the three bond offerings (SMALL, MEDIUM, LARGE). Keys per bond: displayName (shown in the financial dashboard), principal, interestRate (daily, charged hourly at 1/24 on the remaining principal), principalPaymentRate (fraction of the original principal repaid per game hour) and requiredDailyRevenue (operational revenue over the previous game day 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; an already-issued bond keeps the principal, interest rate and hourly payment it was issued with, while its displayed name is read live from BOND_TYPES. The bond ids (small, medium, large) key issued bonds in save data and are fixed. Keys added to BOND_TYPES are never read.

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

The station marks (STATION_MARKER)#

Two station marks share these values: the dot drawn for most stops, and the interchange pill drawn for a stop whose lines fill a bundle of the schematic diagram. The pill stands exactly where that dot would have been and hides it.

window.SubwayBuilderAPI.modifyColors({
    STATION_MARKER: {
        DOT_DIAMETER: 9, // Bigger station dots
        PILL_DIAMETER: 9, // Fatter interchange pills (MAX_DIAMETER caps them at 9)
        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 (8) is the ordinary station dot's diameter in screen pixels at zoom 14. At other zooms it scales with PORTOLAN.RIBBON_WIDTH_STOPS, so dots thicken and thin with the route lines; the zoom scaling is capped at MAX_DIAMETER (9) and the route width scale then multiplies the result. SELECTED_DOT_DIAMETER (10) is the enlarged dot on the open station, the selected route's stops and journey stops. PILL_DIAMETER (8) is the interchange pill's height and twice its corner radius; a pill is a dot stretched along its bundle. Wider zooms scale the pill down by PORTOLAN.MARKER_ICON_SCALE_STOPS, and MAX_DIAMETER caps it too. Also here: GROUP_DOT_SPLIT_SPREAD_PX, GROUP_DOT_SPLIT_MIN_ZOOM, GROUP_DOT_SPLIT_ZOOM_STEP and PILL_OFF_CORRIDOR_M, which decide when a station complex splits into separate dots and when a pill falls back to a dot, plus FADE_MS and LABEL_ZOOM; the Map Visuals Reference below lists each.

BORDER_WIDTH is in screen pixels. Both marks are sized in screen pixels at zoom 14 and scale from there. The dot's ring is drawn at BORDER_WIDTH at every zoom. The pill's ring is baked into an image that the marker scale ramp then shrinks, so the game draws it into that image divided by the scale (rounded to 0.1) it is about to be shown at.

BORDER_DARK rings every white dot, every diagram pill, and every dot in the dark theme. BORDER_LIGHT rings every other dot in the light theme: route-colored, black and gray dots.

Every STATION_MARKER value is read live, with no reload. FADE_MS and the dots' BORDER_WIDTH apply the next time the marker layers render. The dot diameters, the dot ring colors and LABEL_ZOOM show when the station marker model next rebuilds, which happens when any of its inputs changes (among them the zoom rounded to a tenth, the network, the selection, the theme and the Route line width setting).

The route diagram (PORTOLAN)#

With Show interlined routes turned on (Settings), a built diagram and no route edit in progress, 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. GAME_COLORS.PORTOLAN controls how that geometry is presented across zoom levels: where the handoff sits, how wide a ribbon draws, how big a marker gets, and how far a bundle spreads. Everything except BAND_GAP_SCALE is read as the map redraws, so it applies without a reload. BANDS min values are also read when the diagram is built, to slice it, so a change there takes full effect at the next build.

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 the pill; STATION_MARKER.PILL_DIAMETER is what it scales. The plain dots follow RIBBON_WIDTH_STOPS instead.

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.

BAND_GAP_SCALE is informational: the game never reads it. Curved route lettering on the ribbons follows OFFSET_SCALE_STOPS; route bullets and straight labels follow a fixed ramp from zoom 11 to 14, so changing OFFSET_SCALE_STOPS moves the ribbons without moving the bullets and straight labels.

Game Rules Reference#

Every rule in RULES, its default value, and what it does. Generated from the game's rule definitions, so it 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. Most deck.gl map layers and the station markers receive the map zoom rounded to a tenth, so a zoom threshold they read takes effect on the rounded zoom; the interchange pills read the exact zoom.

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"
    }
]