Valdrada 0.3.1

Valdrada is a city-scale digital twin of New York City compiled from public municipal records: buildings, streets,
street furniture, traffic and pedestrians, with pixel-exact ground truth and a CARLA-style Python API. This release
packages the server as Valdrada.exe in Valdrada-0.3.1-win64.zip, with the compiled city and the Python package
valdrada.

Assets

File	Contents
Valdrada-0.3.1-win64.zip	server (Electron), compiled city (Content/), Python API (source, wheel, examples, tests, tutorials), documentation, launchers
valdrada-0.1.0-py3-none-any.whl	Python API 0.1.0
SHA256SUMS	checksums of the two files above

Content/ is also published as the Hugging Face dataset mehmetkeremturkcan/valdrada at tag v0.3.1, with the
assets of the offline renderers in Blender/; the tags v0.3.0, v0.2.1, v0.2.0 and v0.1.0 keep the earlier
releases.

Quick start

Extract the archive, then:

Valdrada_0.3.1_win64\StartServer.bat
pip install Valdrada_0.3.1_win64/PythonAPI/dist/valdrada-0.1.0-py3-none-any.whl
python Valdrada_0.3.1_win64/PythonAPI/examples/quickstart.py

The changes of 0.3.0 are described in its release notes.

BoundlessNYC 0.3.0

Simulation server for Windows x64: the BoundlessNYC digital twin behind a CARLA-style TCP API, with the compiled
city and the Python client. This release adds Unreal Engine 5 as a third renderer beside the three.js client and
Blender Cycles: a recorded take exported to OpenUSD now renders in both offline renderers under the same physical
light, with a new street tree set, CC0 layered materials and Nanite foliage in Unreal, walkers and turning wheels, and
a cinematic preset. Parked vehicles on 125th Street take slots as long as their models, the recorder fails a take in
which parked vehicles overlap, and the export decks the parkway ramps that the client leaves open. New pages document
the renderer architecture and the Unreal workflow.

Assets

File	Contents
BoundlessNYC-0.3.0-win64.zip	server (Electron), compiled city (Content/), Python API (source, wheel, examples, tests, tutorials), documentation, launchers
boundless-0.1.0-py3-none-any.whl	Python API 0.1.0, unchanged
SHA256SUMS	checksums of the two files above

Content/ is also published as the Hugging Face dataset mehmetkeremturkcan/boundless-nyc at tag v0.3.0, with the
assets of the offline renderers in Blender/, now including the tree set Blender/bxtrees2; the tags v0.2.1,
v0.2.0 and v0.1.0 keep the earlier releases.

Quick start

Extract the archive, then:

BoundlessNYC_0.3.0_win64\StartServer.bat
pip install BoundlessNYC_0.3.0_win64/PythonAPI/dist/boundless-0.1.0-py3-none-any.whl
python BoundlessNYC_0.3.0_win64/PythonAPI/examples/quickstart.py

Unreal Engine 5 renderer. boundlessjs/tools/ar34/export/ue_take.py renders the OpenUSD export of a take with
Unreal Engine 5.8: ue_prep.py packs the per-vertex data into UV sets and turns the time-sampled instancers (vehicles,
trains, signal lenses) into animated transforms, the editor's USD Stage importer brings in the take as Nanite meshes,
ue_mat.py makes each tagged material an instance of its family's master material (ue_project/Python/ue_masters.py,
one Custom HLSL master per material family of the export, set from the table ue_families.json), ue_light.py sets
up the sun, the sky, the street lamps with their measured throw and the vehicle lamps, and Movie Render Queue renders
the frames with Lumen and hardware ray tracing. At night the lit signs and shop interiors light their surroundings as
rect lights. On RTX 6000 Ada GPUs at 2560 × 1440 a frame took 0.13 to 0.23 s and a 108 frame take 4.7 to 5.6 minutes
including the import, against 6.9 to 8.5 s a frame for the same takes in Cycles. bx_render_all.mjs --target ue
renders a list of shots through the same gates as the Cycles takes, and ue_check.py compares every frame region by
region (sky, buildings, ground, vegetation, structure) in CIELAB with the web and Cycles takes of the same shot. In 24
Unreal takes of 125th Street the temporal scan passed on all 24 and the colour check against the web takes on 21. The
engine is not part of the release; the scripts have been run with 5.8.3 built from source on Linux.

Physical light. Cycles and Unreal now light a take alike by default (--light phys): the sun and the street and
vehicle lamps at the client's own levels, the visible sky dome as the only sky light, no fill lights, untrimmed albedos
and a fixed exposure per time of day, all read from one table, phys_light.json. --light web keeps the rig
calibrated against the web takes.

CC0 layered materials. In Unreal, 13 CC0 material sets from Poly Haven at 4K (asphalt, sidewalk concrete,
granite, three brick colours, painted brick, sandstone blocks, two concretes, stucco, the viaducts' painted steel and
rust) replace the client's textures for 19 sets of the PBR library, the ground's asphalt, flags and kerbs, the
viaducts' paint and rust, and the brick, stone and concrete classes of the facade bake. Each set keeps its material's
own mean colour and is laid at its real size, with whole-tile offsets for coursed brick and blocks, and the master adds
a macro tone, a detail normal and cavity grime. tools/assets/fetch_hq.py downloads the sets and records their
sources, licences and sizes; without them a take uses the export's own textures.

Street trees. A second tree set, bxtrees2, is the default of the OpenUSD export: 51 trees of the 12 species forms
the client plants (London plane, honeylocust, pin oak, zelkova, Callery pear, littleleaf linden, maple, sophora,
cherry, purple-leaf plum, small ornamentals and ginkgo) in up to three sizes, grown procedurally with branches to the
twigs and leaves cut from CC0 scans, 62K to 1.37M triangles a tree. Each tree instance of the client gets a prototype
by its size and a hashed variant on its unchanged matrix, so Cycles and Unreal draw the same trees. In Unreal the trees
are Nanite foliage with a two-sided foliage master (per-instance and per-leaf hue and lightness, the inner crown's
occlusion, transmission fitted to the Cycles takes) and wind as world position offset. On the golden hour shot
t7ArchTrack the vegetation's mean b* in Unreal went from 5.5 with the first set to 20.2, against 23.1 in Cycles.

Walkers and wheels in Unreal. The walkers are imported as skinned meshes and recoloured per walker as the client
does (634 in a golden hour take), and the cars' wheels turn and steer from the client's spin and steer (626 cars in
one take).

Cinematic preset. ue_take.py --cine renders 8 temporal samples per frame over a 180 degree shutter centred on
the frame, with depth of field on the subject at f/2.8, the client's bloom, film grain, a deeper vignette, light
volumetric fog by day and the analytic haze at night, at 1.05 to 1.25 s a frame.

Parked vehicles. On 125th Street a parked vehicle took a slot from a size table that did not yet hold the fleet's
sizes when a tile parked early, so a 9.84 m box truck or a 5.59 m SUV got a 4.6 m slot and stood inside its
neighbour. Each slot is now the drawn model's length plus the kerb gap, and a tile parked before the sizes were known is
parked again once they are (?pk41=0 restores the earlier packing). The overlap test of the film recorder now covers
pairs of parked vehicles (?ov41=0 restores the earlier test), and tools/ad/record.mjs fails a take with parked
vehicles inside each other in view (--noparkgate only logs them). On one shot two parked SUVs stood 0.30 m into each
other in every frame with the earlier packing, and no pair remained with the new one.

Ramp decks in the export. The client's road graph joins some elevated roads to the street by ramps that its
traffic follows but its road builder does not deck, such as the Henry Hudson Parkway's ramps by West 125th Street, so
vehicles drove through the air there. The writer's new hook usd_ramps.py lays a deck under every such path, asphalt
on top, concrete on its sides and underside and 1 m parapets along its edges, so that both offline renderers draw the
vehicles on a surface. The client still draws these ramps without a deck.

Documentation. A page on the renderer architecture describes what reaches all three renderers with no renderer
work (geometry, placement, vehicles, trains, walkers, signals, trees by species form, materials of the existing
families, light), what a new shader family needs in each renderer, how renderer-specific improvements are bound to
existing keys, and the checks that keep the renderers coherent. A new guide takes one shot through Unreal, from
building the engine to the cinematic take, with measured times and the known limits, and the Blender Cycles guide
covers physical light, the new tree set and the ramp decks. frontend_coverage.py reports for a take's USD every
material family and pbrLib set and whether each offline renderer draws it with its own builder or master, with a
high-quality set, or on the preview surface; the batch prints its summary for every shot.

Compatibility. The wire protocol is unchanged (API 0.1.0). Requirements of the release are those of 0.2.1:
Windows 10 or 11 x64, a Direct3D 11 GPU (discrete recommended) and Python 3.8 or later. The Unreal renderer needs Linux,
an NVIDIA RTX GPU and Unreal Engine 5.8, obtained by the user under the Unreal Engine End User License Agreement; films
with credits rendered with it carry the credit notice the agreement requires (see the Unreal guide).

Licensing. Blender/bxtrees2 is listed in LICENSING.md with the original models (CC BY 4.0; leaf and bark scans
CC0 1.0, credited in its NOTICE.md). The CC0 material sets for Unreal are downloaded by the user and not
redistributed. Other components are unchanged from 0.2.1.

BoundlessNYC 0.2.1

Simulation server for Windows x64: the BoundlessNYC digital twin behind a CARLA-style TCP API, with the compiled
city and the Python client. This patch release fixes autopilot for vehicles spawned through the Python API, adds a
QuickStart, an install guide, data collection examples and a Blender Cycles tutorial, paves the bare ground on 125th
Street, places its subway entrances from MTA data, keeps turning vehicles on the carriageway, and adds earlier checks to
the Blender Cycles pipeline.

Assets

File	Contents
BoundlessNYC-0.2.1-win64.zip	server (Electron), compiled city (Content/), Python API (source, wheel, examples, tests, tutorials), documentation, launchers
boundless-0.1.0-py3-none-any.whl	Python API 0.1.0, now with the KITTI helpers of boundless.util; no required dependencies (numpy optional)
SHA256SUMS	checksums of the two files above

Content/ is also published as the Hugging Face dataset mehmetkeremturkcan/boundless-nyc at tag v0.2.1; the tags
v0.2.0 and v0.1.0 keep the earlier releases.

Quick start

Extract the archive, then:

BoundlessNYC_0.2.1_win64\StartServer.bat
pip install BoundlessNYC_0.2.1_win64/PythonAPI/dist/boundless-0.1.0-py3-none-any.whl
python BoundlessNYC_0.2.1_win64/PythonAPI/examples/quickstart.py

Python API. In 0.2.0 a vehicle spawned through the API lost its position as soon as set_autopilot(True) was called
(x, y and yaw became NaN and the client raised a TypeError), so quickstart.py, the README example and the autopilot
tutorials failed. API vehicles lacked the state variable that holds the traffic simulation's lane change spring rate
(_lfv), which made the first update NaN; bridge.js now sets it to zero at spawn and when autopilot is switched on. The
wire protocol is unchanged (API 0.1.0). boundless.util gains label_vertices, kitti_calib, kitti_object and
KITTI_TYPES, with offline tests in PythonAPI/tests.

Documentation. The QuickStart covers the release on Windows, the dataset's Content/ served by the Electron of a
source checkout on Linux, and a source install, and ends with a first frame. The install guide lists the requirements,
the Windows and Linux steps including a headless Linux server (Electron on the headless Ozone platform with ANGLE on
Vulkan), the server options, the common errors and the release build. Seven example scripts are in
PythonAPI/examples/data_collection/: first_frame.py ends the QuickStart, and the data collection guide explains the
other six (camera paths; RGB, depth and segmentation; 2D and 3D boxes in COCO and KITTI format; vehicles and pedestrians
under control; time of day and weather; recorded sequences). Each was run on a Linux server, and the guide gives its
measured output and time. The Blender Cycles tutorial goes from the dataset's Blender assets through harvest, USD, one
frame and a full take to the batch with its checks. A development page lists the URL flags, the tests and the render and
release gates.

125th Street ground. The compiled tiles left bare terrain between walks, roadways and plazas along the street. It is
now paved from the NYC Planimetric Database (sidewalk, roadbed, median, parking lot, plaza and open space polygons)
minus the compiled ground and the drawn buildings, at the height of the surface beside it, with kerb faces where a walk
meets the roadway. The result is baked per tile (49 tiles, 488,000 triangles, 17 MB in Content/data/gf38/). The ground
gap probe (tools/qa/ground_gaps.mjs) rasterizes each tile's ground at 0.25 m and counts clusters of 0.25 m² or more:
818 clusters (2,839 m²) before the fill and 85 (65 m²) after it, the remainder in Central Park's relief and at the
river's edge. ?gf38=0 turns the fill off. The compiled tiles are those of 0.2.0: the client fetches a tile's fill when
it assembles the tile, and a tile whose compiled file differs from the one the fill was baked against is left as
compiled.

Subway entrances. The eight stairs at Lenox Avenue and St Nicholas Avenue and the St Nicholas elevator are placed
from the MTA's Subway Entrances and Exits 2024 data (data.ny.gov, i9wp-a4ja): along the kerb and closed toward 125th
Street, with railings, globes, station signs and displays, and stairwells cut through the walk. Walkers treat each stair
head as an obstacle. The four Lenox corners, which showed bare terrain, are paved and the sunken corners at the median
noses are filled.

Vehicles. Every junction turn is driven in advance and kept on the carriageway: the four wheel hubs and the body
centre must stay off non road surfaces every 0.4 m. A curve that fails is replaced by the best passing shape or the turn
is refused, wide curves apply to every vehicle over 5.5 m, and a dead end U turn that would leave the carriageway is not
made. In a take at Lenox Avenue, turning vehicles were off the carriageway in 86 frame cases before and in none after.
?tn38=0 restores the earlier connectors.

Quality checks. The recorder logs vehicles off the road for every frame (CAR-OFFROAD) and the clearance audit
fails a shot with one in view. Takes recorded with the film tools keep every distance dependent state (detail levels,
the near shadow box, park trees, plants, furniture, parked cars) fixed for the whole take, hold the park water's mirror
weight steady, and move the near plane with the nearest surface above 60 m so that aerial views keep their depth
precision; the recorder fails a take that logs a switch in view. These last behaviours were already in 0.2.0, whose notes
did not describe them.

Blender Cycles pipeline. A shot is checked before its full take. Right after the USD is written, a geometry check
stops the shot when more than 100 coplanar surface pairs remain in view, when the USD was written without the coplanar
pass, or when its walkers are missing; then three preview frames (the first, the middle and the last) are rendered at 8
samples and compared with the web take of the same shot, with the limits of the take check (off colour cells over 0.4 %
of the frame, off lightness cells over 2 %). The finished take is checked as before: colour against the web take, a
temporal scan with a fine mode, the coplanar count, and a test for flicker in tree crowns. The fine mode measures only
pixels where the forward and backward motion compensations agree, so motion boundaries are not read as flicker. The USD
writer lifts apart surfaces that share a plane (decals, graffiti, repaved patches, stain layers, window mullions), and
the street kit's flag meshes are now lifted per flag instead of per tile, which brought the coplanar pairs in view in
eight shots from between 305 and 642 down to between 9 and 60. The USDs of a batch are written in parallel (--preps),
and walkers out of view and more than 30 m from the lens are hidden per frame, which took one second off a 14 second
frame of one dusk shot. Night takes no longer flicker in lamp lit crowns: street lamps whose range does not reach the
view are switched off for the frame and car beams are range limited spot lights, so the light sampler stops spending
samples on lights that light nothing. In ten takes rendered again, the frames over the crown flicker limit fell from
between 35 and 98 to none.

Compatibility. The wire protocol is unchanged (API 0.1.0). Requirements are those of 0.2.0: Windows 10 or 11 x64, a
Direct3D 11 GPU (discrete recommended) and Python 3.8 or later.

Licensing. Unchanged from 0.2.0 (LICENSING.md covers every component). The NYC Planimetric Database, used for the
ground fill, is listed in ACKNOWLEDGEMENTS.md.

BoundlessNYC 0.2.0

Simulation server for Windows x64: the BoundlessNYC digital twin behind a CARLA-style TCP API, with the compiled
city and the Python client. This release adds detailed models of 125th Street, Central Park and Hunters Point, the
city's buses, service vehicles and trains, new street trees and vegetation, an OpenUSD export for offline rendering in
Blender, and render quality checks.

Assets

File	Contents
BoundlessNYC-0.2.0-win64.zip	server (Electron), compiled city (Content/), Python API (source, wheel, examples, tutorials), documentation, launchers
boundless-0.1.0-py3-none-any.whl	Python API, unchanged from 0.1.0; no required dependencies (numpy optional)
SHA256SUMS	checksums of the two files above

Content/ is also published as the Hugging Face dataset mehmetkeremturkcan/boundless-nyc at tag v0.2.0. The
dataset's Blender/ folder holds the film-detail street trees and the window interiors used by the Blender export.

Quick start

Extract the archive, then:

BoundlessNYC_0.2.0_win64\StartServer.bat
pip install BoundlessNYC_0.2.0_win64/PythonAPI/dist/boundless-0.1.0-py3-none-any.whl
python BoundlessNYC_0.2.0_win64/PythonAPI/examples/quickstart.py

125th Street. From Twelfth Avenue to the Harlem River, every building is built from a per-building specification
(storeys, bays, materials, storefronts and signs) by a facade kit over a library of 35 CC0 material sets. The street
surface, furniture and street life are laid out along the corridor. The Riverside Drive viaduct follows its design as
published in Scientific American in 1900; the Manhattan Valley viaduct, the 1 train's 125th Street station in its 1931
layout, the Park Avenue Viaduct and the bridge approaches at the Harlem River (11 alignments from the street centreline
with solved vertical profiles) are modelled to their documented dimensions.

Central Park. The relief comes from USGS 3DEP and the water bodies, paths and landmarks from OpenStreetMap. Tree
crowns segmented by watershed on a vegetation index from NAIP near-infrared imagery yield 16,951 trees, assigned to 33
species groups fitted to the park's published composition (black cherry the most common at about 18 %). Bethesda
Terrace and its fountain, Bow Bridge, Gapstow Bridge, Belvedere Castle on Vista Rock, the Loeb Boathouse and rowboats,
and boulders from photogrammetry scans are modelled individually.

Hunters Point. The Pepsi-Cola sign, Gantry Plaza's gantries, piers and river edge, and the park south of the slip.

Vehicles and trains. Sixteen new vehicle kinds: MTA buses (Nova LFS and LFS Artic, New Flyer XD40 and XD60, local
and SBS liveries) on their routes, NYPD, USPS LLV and NGDV, DSNY, a school bus, a step van, a cargo van, a 26 ft box
truck, food and ice-cream trucks and an NV200 taxi. The 1 train runs in R62A cars on the Manhattan Valley viaduct and
Metro-North in M7A and M8 cars on the Park Avenue tracks, modelled in code from published dimensions. Spawns keep 9 m
clear of junction mouths and other vehicles, no vehicle drives into another, and general traffic keeps out of the red
bus lanes.

Trees and vegetation. Street trees are rebuilt from CC0 leaf and bark scans with species crowns and three levels of
detail. On 125th Street and in Hunters Point the 2015 census trees are matched against NYC Parks' Forestry Tree Points
(fetched 2026-10-01), so those streets carry the trees standing today. Lawns draw blades near the camera, and hedges,
planted beds and scrub grow on their OpenStreetMap outlines.

Offline rendering in Blender. A recorded take can be exported to OpenUSD (harvest.mjs, usd_write.py) and
rendered in Blender 4.5 Cycles (blender_take.py) with the client's materials rebuilt as node groups, baked facade
windows with interiors, the film-detail trees and the moving traffic, trains and pedestrians. The tools are in
boundlessjs/tools/ar34/export/; BUILDING.md lists the commands.

Quality checks. An in-page support audit (tools/qa/support_audit.js: floating, sunk and clashing pieces at
0.3 m), a temporal scan of recorded takes (tools/ad/temporal_scan.py: z-fighting, shimmer, pops and reflection
dropouts), a camera clearance audit (tools/ad/clearance.mjs) and a per-tile comparison of two compiled cities
(boundlessjs/tools/diff_tiles.mjs). The release also fixes the dusk sky, the night bloom, seams in the clouds and
the park's water reflections.

Compiled city. Recompiled on 2026-10-02: 2,884 near tiles and 210 far-field tiles, 937,965 buildings. Census
street trees now carry species classes, and each tile has a grassU section (empty; a format change only).

Compatibility. The Python API and the wire protocol are unchanged (API 0.1.0). Requirements are those of 0.1.0:
Windows 10 or 11 x64, a Direct3D 11 GPU (discrete recommended) and Python 3.8 or later.

Licensing. Code: MIT. Compiled city and the OpenStreetMap-derived data modules: ODbL 1.0. Models: CC BY 4.0 (the
CARLA Simulator; the original NYC vehicles and trees; two vehicle bodies and the Angel of the Waters from Sketchfab
models credited in ACKNOWLEDGEMENTS.md). Textures: CC0. Typefaces: SIL OFL 1.1 and Apache 2.0. LICENSING.md covers
every component.

BoundlessNYC 0.1.0

Simulation server for Windows x64: the BoundlessNYC digital twin behind a CARLA-style TCP API, with the compiled
city and the Python client.

Assets

File	Contents
BoundlessNYC-0.1.0-win64.zip	server (Electron), compiled city (Content/), Python API (source, wheel, examples, tutorials), documentation, launchers
boundless-0.1.0-py3-none-any.whl	Python API; no required dependencies (numpy optional)
SHA256SUMS	checksums of the two files above

Content/ is also published as the Hugging Face dataset mehmetkeremturkcan/boundless-nyc at tag v0.1.0.

Quick start

Extract the archive, then:

BoundlessNYC_0.1.0_win64\StartServer.bat
pip install BoundlessNYC_0.1.0_win64/PythonAPI/dist/boundless-0.1.0-py3-none-any.whl
python BoundlessNYC_0.1.0_win64/PythonAPI/examples/quickstart.py

The tutorials in PythonAPI/examples/tutorials/ go from a first connection to a recorded dataset with segmentation
masks, depth and bounding boxes; the documentation site walks through each one.

Scope

• City. Manhattan, the Bronx, Brooklyn and Queens.
• Actors. Vehicles and pedestrians, under autopilot or direct control.
• Sensors. RGB, semantic segmentation, instance segmentation with per-object visible and amodal boxes,
  occlusion and 3D pose, and metric depth.
• Stepping. Synchronous, fixed-step.

Throughput. Measured on an RTX 3060 Laptop GPU at 1280 × 720 with a 0.05 s step (benchmark.py, the second of two consecutive runs):

Sensors	ms / step
none	54
RGB	67
RGB + semantic + instance	152

Requirements. Windows 10/11 x64, a Direct3D 11 GPU (discrete recommended) and Python ≥ 3.8.

Licensing. Code: MIT. Compiled city: ODbL 1.0. Vehicle, prop and pedestrian models: CC BY 4.0 (CARLA Simulator); the Rocketbox pedestrian set (Content/models/peds24/rb27/): MIT (Microsoft Rocketbox Avatar Library).
LICENSING.md covers every component, and ACKNOWLEDGEMENTS.md lists the required attributions.