Pin simulator d8ab74c; explicit math profile and fail-closed CUDA worker

.dockerignore

@@ -0,0 +1,6 @@
+__pycache__
+**/__pycache__
+*.pyc
+**/target
+.cache
+runs

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tracks/R06[[:space:]]Mix.track filter=lfs diff=lfs merge=lfs -text
+tracks/R07[[:space:]]Mirage[[:space:]]Marina.track filter=lfs diff=lfs merge=lfs -text
+tracks/R09[[:space:]]Eau[[:space:]]Noir.track filter=lfs diff=lfs merge=lfs -text
+tracks/The[[:space:]]Champions[[:space:]]Trial.track filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,5 +1,24 @@
-FROM python:3.12-slim
+FROM rust:1.93-bookworm AS build
+WORKDIR /build
+COPY github-simulator/source /build
+ENV RUSTFLAGS="-C target-cpu=x86-64"
+RUN cargo build --locked --release --no-default-features --features cli
+FROM nvidia/cuda:13.0.0-devel-ubuntu24.04 AS cuda
+RUN apt-get update && apt-get install -y --no-install-recommends python3 g++ && rm -rf /var/lib/apt/lists/*
+WORKDIR /build
+COPY github-simulator/source /build
+ENV CUDA_ARCH=sm_75,sm_86
+RUN bash gpu/build-cuda.sh
+FROM nvidia/cuda:13.0.0-runtime-ubuntu24.04
+RUN apt-get update && apt-get install -y --no-install-recommends python3 && rm -rf /var/lib/apt/lists/*
+RUN useradd -m -o -u 1000 user
 WORKDIR /app
-COPY index.html .
+COPY --chown=user:user . /app
+COPY --from=build --chown=user:user /build/target/release/altd-sim /app/github-simulator/source/target/release/altd-sim
+COPY --from=cuda --chown=user:user /build/target/gpu/libaltd_gpu.so /app/libaltd_gpu.so
+RUN chown user:user /app
+USER user
+ENV ALD_DASHBOARD_PORT=7860 PYTHONUNBUFFERED=1
+ENV ALD_REQUIRE_GPU=1 ALTD_GPU_LIB=/app/libaltd_gpu.so
 EXPOSE 7860
-CMD ["python", "-m", "http.server", "7860"]
+CMD ["python3","server.py"]

PACKAGE_MANIFEST.json

@@ -0,0 +1,328 @@
+{
+  ".dockerignore": "640b480c91c572b6d77411d9165f786a095d04fe5bc5b74e983ab6831aa4ba23",
+  ".gitattributes": "478a5f208decd29019ad7be4fba9fdffe25a4a4c9c652032e98e4cf3cbd6ef97",
+  "Dockerfile": "c592ca9eb888525821563ddb2707ecba0eeea3b06adfbe1aaa5e811339d032a7",
+  "README.md": "e7ed341a32da89a48dd5194ede7d3066fea0700aab2752f1886f23b7970d6ca8",
+  "UPSTREAM.json": "73d973fe445d7b51caea4980f35902f393c84720c8a256fd11622f84bb843806",
+  "backend_policy.py": "3991fb88e25bebb9c36b49c0547af4e4630738c504e0c7b58a5917081deea5fe",
+  "batch_runner.py": "c14777da239116a8025f800d59b33b307bf62fcfb80e3bcb59fdf81104a7c742",
+  "cloud-contract.json": "ac4d1946a278d3cf3aae6d750249603adfd89f3c421eda4c62bb69e2bbf7490f",
+  "cloud_core.py": "be517e165180baf610f6cb7e863bc76a6704233118952045a0366d72000d821a",
+  "demo.evolution": "2743e838371d737f3309c47dc84bc7b43f13657f4b008b2b6eb6f4b429531920",
+  "github-simulator/source/Cargo.lock": "d8b8dfcfd4ddd90388a9aadae6c12a675e46277a3f26dabcce5ba8af6ff12183",
+  "github-simulator/source/Cargo.toml": "fe4d592043df0b10f6699dcf6fe6cc7b588ed3df23bfadae11afb61924f25bd9",
+  "github-simulator/source/GODOT_LICENSE": "fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304",
+  "github-simulator/source/LICENSE": "53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8",
+  "github-simulator/source/README.md": "cc11a5a17701416fbf11b392be303e0485aa308170ef2bf2f52815f60cac15de",
+  "github-simulator/source/assets/models/formula.json": "fc7849fac5e20a14427ca8adafd4dab61518920d385411a144a8798ae02de2ed",
+  "github-simulator/source/assets/models/rally.json": "5155711ab44e1db4aee6d3cb509d321e60d2a4ffabe1937603b3dd9daf187e1f",
+  "github-simulator/source/assets/networks/formula.json": "452647361c18ee196c7abd1059c384f9281ca57890135e5b164f9669fe45250c",
+  "github-simulator/source/assets/networks/rally.json": "75ecde48a073d1f343ced743955ffc3a7eaffcd035884452ce408b4d12707932",
+  "github-simulator/source/assets/random_track_settings.json": "a0c3daae1436e659a3157fcb1e4520d5a59c16f739eb6a9eb53b397862cf7179",
+  "github-simulator/source/assets/scenes/formula_template.json": "80f745df82bb7be45af52785fd582460bcddc63c5a4e1d8375d85b3122db4c6b",
+  "github-simulator/source/assets/scenes/rally_template.json": "7350a3fe28d9b4da7a0965ae6ea7ca3472fb7885303e342310d63a0dce80851c",
+  "github-simulator/source/assets/scenes/snowmobile_template.json": "12d30545876011fd6fccdd3e721f9c465938c9c58ac99338205481d5e7ac6742",
+  "github-simulator/source/assets/scenes/truck_template.json": "a83bffea4d5e818c135ab3aba68a47aa288d6ad0e7b8bd9c95ed0dea9e9df2f7",
+  "github-simulator/source/docs/cli.md": "095468c685d68362880323cd0aea56c0951517d2b9f5dbc281b67499e712cf28",
+  "github-simulator/source/docs/design.md": "5e768d010d41f021aca8bc88119709a87fe4b346aed95d31b24bb1563c7974fd",
+  "github-simulator/source/docs/fidelity.md": "1a58be54cc167aba2f8f78992382f3ae58005dfb7ecd6f7dd552466f10d66f54",
+  "github-simulator/source/docs/gpu.md": "ecdd400d988344da2a076db2b32a09d06b3578d44c6b17da67c151b2dfbecff7",
+  "github-simulator/source/docs/math-profiles.html": "69f7e3c9165e6c3c969805e77669ca0b13965a4e2b23c4a6e4dd8e234a9755f7",
+  "github-simulator/source/docs/performance.md": "fa47013ff2940458a951250166b8b4f1c406cd99734d979c701aea7b2792cca3",
+  "github-simulator/source/docs/reviews/2026-10-05-native-server-review.md": "4ed44f436e4348591d8728659d94e00f48bd8a2d559fda7c3fe2c695831e5b85",
+  "github-simulator/source/docs/server.md": "4b8899b87ba53008b66eeb878794b961f10d16280134f4716453efcab347e37a",
+  "github-simulator/source/docs/superpowers/specs/2026-10-05-native-server-design.md": "99ac6ee8e335ab71ddcfdd28ab4ed2d7d1cfbad7935101d72ebe39fe017fdf6b",
+  "github-simulator/source/docs/wasm.md": "888386a1b77546382c7ba39d4897e62b83015c6ce2ef725b436b6561031b47ef",
+  "github-simulator/source/gpu/README.md": "e831018c053fd7a47162d89b72b789d8c5ecd455e46f57282b23be2f9c460a43",
+  "github-simulator/source/gpu/benchmark.py": "413db669422dba553e54adcf083aa11372c7925232a02a23a96aef8b55954380",
+  "github-simulator/source/gpu/build-cuda.ps1": "dc5b4dbdf277c8522fe927f13db6e68df1554ccf5ecf78cb79128d34a1c63550",
+  "github-simulator/source/gpu/build-cuda.sh": "a1d64a98c968dffde896e6634914ae7312820ff04171bc29ddc4519f112c8a6d",
+  "github-simulator/source/gpu/build.sh": "563dfba35d55d33e1340fc80bd063931cc88129ff2214cc556d7205c71308183",
+  "github-simulator/source/gpu/gen_tables.py": "f0fe3dbcefa271a63093c1c7ee7c5c55166bdfd96a3daa0e7113ea37da0f6e2e",
+  "github-simulator/source/gpu/profile.sh": "f08fbab3a38ed6414548009e1b116f7cc289ea67d1baef7262c1c886926bde88",
+  "github-simulator/source/gpu/release-targets": "fdca8679baa13af1191fbc0179201e8aafdf7355ba8c5684ea378b6afeffe1a2",
+  "github-simulator/source/gpu/sim/altd_gpu.hip": "212f169713fd96a065822ef3c6fe712491a144b0cb1b63df0f083967f509065e",
+  "github-simulator/source/gpu/sim/compat.h": "23c60db69ca371dd8da6a7949911a6f69d52250448a3623e73a5c3c290331ff8",
+  "github-simulator/source/gpu/sim/double_tables.h": "472dbcd916293dcd91dcd3f882ba86ed36267ede819ffb1692daf8b6ad5a38ec",
+  "github-simulator/source/gpu/sim/engine_exceptions.h": "4568607466a307d1520d763ea2f1c7424219299caf365ffa03dd62084673a551",
+  "github-simulator/source/gpu/sim/math.h": "ae93aadb2d49492176a08a1bed4a1c5b687f99ae16da57736ef30661dcaaeb8b",
+  "github-simulator/source/gpu/sim/rays.h": "414fc93b6a5180c9ed906a0b802eea48a5d81bba8920097989dfa568bfa82f12",
+  "github-simulator/source/gpu/sim/sensors.h": "64390b210bf388abb49026ba0b8529144eb025b0d306fb3198745b345fe38942",
+  "github-simulator/source/gpu/sim/state.h": "3672b2e48d43e6696cb9a61abff7a1de6a131dc2b7cbf6d99413596565a1bb20",
+  "github-simulator/source/gpu/sim/stats.h": "dc0d785dceaa06e27d90f5aa2a4513eb75aea6d149bbfde9ed8965f79c233d82",
+  "github-simulator/source/gpu/sim/step.h": "022390d8f2eb5276969826c5b650dba05de9ffc9264f03c1cee012060693bec7",
+  "github-simulator/source/gpu/sim/track.h": "2dcb2a8ae356115965a5047cf3843e0bdb9c547e0b297b9ab87772385549184c",
+  "github-simulator/source/gpu/sim/vec.h": "715afdaaff174668892bc5ada76edab317445a770bc0d6e7e0e0e83cb459740c",
+  "github-simulator/source/gpu/sim/world.h": "cff41441c08ff645384d972ec56412122b5a38ff5d618e09c979870f70d15f6f",
+  "github-simulator/source/gpu/test_constructor_cleanup.py": "bdd1fc42aa1494e20558f8c7ce20a9ca4a3775aeae4c836fd9688581f5bb87e6",
+  "github-simulator/source/math/README.md": "33b210248e6ed5c4abe4104940abc27fd1728af2a5af07bf442c1dfa2bd4caf4",
+  "github-simulator/source/math/fixtures/atan2f.bin": "9ecf9251878ddcb789a43119f1f060e24025db3e3485cccdbcb1f4366cb68ed2",
+  "github-simulator/source/math/fixtures/cosf.bin": "c84017673fdbe2a29f03e8ae4f410292da3ee93f5f74d91e169053a04c6273d6",
+  "github-simulator/source/math/fixtures/exp.bin": "b0b063fc5bba32294b399f7305718a15797f4df65ba81cfbc785264e11126a9a",
+  "github-simulator/source/math/fixtures/log.bin": "9ef1de3473a7b1d8a2416eee3f2263a88eea073ad9c2af53bb751bca7e45813c",
+  "github-simulator/source/math/fixtures/pow.bin": "d2475d6b050e7b842f868c093591b4095509cd2e1350ba8ebb06df64452bf3cc",
+  "github-simulator/source/math/fixtures/sinf.bin": "bae316adc7a9ceb4a61a8375a7eb94004d9e9058e5563cc81e14c9ffe911a104",
+  "github-simulator/source/math/fixtures/tanh.bin": "b0f438bcf53c685c622158e0ab2f47b9a2c714e8c35cb8b90da1e539a53c7e2c",
+  "github-simulator/source/math/kernels/ucrt.h": "cf0787112fc4f3cadd88d965ba69f9250ea6fced7ab33fe2a3d669caae5dda5a",
+  "github-simulator/source/math/kernels/ucrt_tables.h": "0f2fd20c1513b5c88c6a138cdabdedfa68d652d07f6f19910e1a6a8a290af028",
+  "github-simulator/source/math/verification.md": "419e78815edbc8e47e3a39919d973a399cfa2d97b1556ac25fdfdd71540431c1",
+  "github-simulator/source/src/bin/altd-sim/args.rs": "9f833f026d1f71ef76fe05d948464c619c76c15e43cedc11b5f510bfc337bda2",
+  "github-simulator/source/src/bin/altd-sim/bench.rs": "76ddf4778cfafa0e8f2f821605c876fd250f2df37ef0d025028e7acaafc6ea0f",
+  "github-simulator/source/src/bin/altd-sim/comparisons.rs": "9e6859b759f5f0f181e3a0130478237187472a242d2b615d545cb3d19aad7c6e",
+  "github-simulator/source/src/bin/altd-sim/inputs.rs": "7c9c1b814dc9c072c2f77399836421c54547ef3029a2626f32c717434ef9c51d",
+  "github-simulator/source/src/bin/altd-sim/io.rs": "e90bd9b1dd7028d5187872bed08763e7ee8437a80b1491cd9a9bcfb8c47fcc97",
+  "github-simulator/source/src/bin/altd-sim/main.rs": "841956a5a1a927b1a31369ccbd9aa18161b6328745a5a3ca4f02bdcfedd7230c",
+  "github-simulator/source/src/bin/altd-sim/platform.rs": "da8d6ffbf03990ed04e9fe8ac6ccecc1c5f5da292708eebd2f68621043b882d0",
+  "github-simulator/source/src/bin/altd-sim/scratch/checkpoint.rs": "408f4c8438f8d8a8db2dd3888a55a7390a89723d1af1656ab7399897bf207eb5",
+  "github-simulator/source/src/bin/altd-sim/scratch/mod.rs": "524e9033a1fb29ac7b4d689a21fede12b7bb77a772c078fce4c0bf4763568bbe",
+  "github-simulator/source/src/bin/altd-sim/scratch/runner.rs": "20a78bd99dc6bd69cc9314ba2d531dac13b5d9f21fb6ca676d34c0fa472a46c0",
+  "github-simulator/source/src/bin/altd-sim/scratch/stop.rs": "b13d0b473376b0fb90d71d82713ae79d862337f5b1d874c1d53fa14ecf677c50",
+  "github-simulator/source/src/bin/altd-sim/scratch/tests.rs": "c59cbe78aca660ee9327c316d260e3d18cfbf302f41430e1985856090409a740",
+  "github-simulator/source/src/bin/altd-sim/train.rs": "7397016461d6d8a6642f03a2466d9bf22f1daabc1ab74ab22aaf7212821e23f1",
+  "github-simulator/source/src/data/tilemap_initial_cells.json": "97b5c28b80993f263e35fe22279944a91e7016f6f1471ef05317239c655acb53",
+  "github-simulator/source/src/data/track_catalog.json": "b1f71cd4c15aee7dcd81897ebe8549115bb270a26dc33728e9c5a4546f4408fe",
+  "github-simulator/source/src/data/track_resources.json": "e8b23c8a98f9c0c6573044ab0e7a01e8f707e6c46b234e96f9834a5370a61fab",
+  "github-simulator/source/src/gpu/hip.rs": "6618d96c39049e95a8dee98aa9656d27b1998ac71dd15fdb036210fedd68884f",
+  "github-simulator/source/src/gpu/mod.rs": "c8be62ad28ac998af80ebc9f5fb06320f8b791ab7f8a53db47c72b496506a7ae",
+  "github-simulator/source/src/gpu/simulation.rs": "3da4252813c8d7e83d48858a67b0f1a64ca75c274f4d930f656f80bc6e509b05",
+  "github-simulator/source/src/lib.rs": "a5d365de4631e9d4f7e1d049307f510c315dd74bb6a9ad6dec0e4e12a5c72138",
+  "github-simulator/source/src/math/double_math.rs": "9e5cce0ab7ab000ad2a40bd0315a09bc3af7910db97bc9296a8813b36ee6804b",
+  "github-simulator/source/src/math/double_math_tables.rs": "d27b8bbb61a1493efabb0a6a24dc095568fe096e4e34ba58470aefcdeb9735e2",
+  "github-simulator/source/src/math/float_reduction.rs": "21a5b0a46ecebe0c7fcb7bdeb1c9d3ae2589bc1796573615e8e00f2a1674d0ed",
+  "github-simulator/source/src/math/godot_math.rs": "5537ed27280374a776615baa9bfe8a134c479d38a15cacb9cba1dccb4e0c9d50",
+  "github-simulator/source/src/math/managed_sine_tables.rs": "fc4534f09a984ad78ca64f5584a2c2c868291841ff96f35353b8f82e89c31d8a",
+  "github-simulator/source/src/math/managed_trig.rs": "7497fdc77380ffc09dfea7921a938906cd12f6831faca118ad745c70053fc8c2",
+  "github-simulator/source/src/math/mod.rs": "c94f7656088d04220b5d59a9d28a340843f3f101fb39baec5aa48411d2290fd7",
+  "github-simulator/source/src/math/native_math.rs": "67efb2ce5a45c69c13006aa8b37c52ab3feb807b2d4b1e0d6bf04738e2ce8414",
+  "github-simulator/source/src/math/profile.rs": "df925dfdd799fed5691865c272e3e0ec1dea5bdd5961663edce4ccbd8c962d0c",
+  "github-simulator/source/src/math/pymath.rs": "ccadf6379fd4f4c7ba38e3c5aaab5e09d6d3f0388a7861a5c4525c70e7852357",
+  "github-simulator/source/src/math/ucrt.rs": "5cb27a66798d592f053ee1ecd8b5cc71a5cf250c31d2cbfbe00eb194fa4a57a4",
+  "github-simulator/source/src/math/vec2.rs": "18111a5d6412b7e4d6010c90d36f1892dd5553611b0c0778cea44db26b527afc",
+  "github-simulator/source/src/nn/mod.rs": "56200ce58b1191aadf594a44d2d967eb8ecd0e19d5f0d68b1299fdefd5d49e12",
+  "github-simulator/source/src/nn/network.rs": "af897658264b6bcc0c0cb4c6218da28a417fdee82b3531b90f833bab59502ca3",
+  "github-simulator/source/src/nn/network_simd.rs": "b4339e7da61d54aa617098981c3e27bb4757bac160f6d39c5c7bbb0c5ab86e60",
+  "github-simulator/source/src/physics/broadphase.rs": "65e90c5bbdd975b7dfa4ab9f81130e36a21df28f04faf193213c8522c39a837b",
+  "github-simulator/source/src/physics/car.rs": "b47eee90cd42d1bb9c9f8f98b1794ec85c3e3ca13b862d053f2dcc8048dab615",
+  "github-simulator/source/src/physics/collision.rs": "eb4b3ccc9d668a8054b843bd31624dd5602bd3db92c01f11dda8d8852a1d4a31",
+  "github-simulator/source/src/physics/mod.rs": "f24b54fe129527d6032bfda7f24704db6abc500130cc0d499937593dd4a61b48",
+  "github-simulator/source/src/physics/simulation.rs": "730da7a2a910f924cb23e2c4f67f9e59ac822ca3011596766953cf6188617e4f",
+  "github-simulator/source/src/physics/trace_state.rs": "83ac2de24529f195c506f90445ffef8e6c03d4d310264509d2a8ac915cc59699",
+  "github-simulator/source/src/server/dispatch.rs": "cf5206817e1eb2bcf52ae1a55f5cafde5d4b3583638eb6f8a250dfc933c29a82",
+  "github-simulator/source/src/server/mod.rs": "17672296ff7e9c6562443a913bdf290a12688b23bdadd61d57982ec40eb522e5",
+  "github-simulator/source/src/server/protocol.rs": "05b17adc585357659bd301495bd2026a39f52faa45fca61eb94fc42bc16c29c1",
+  "github-simulator/source/src/track/bsp.rs": "1555c30fdc8f1c2f68a877986095c6bb5146546e82394ed2c412bb89bade8be3",
+  "github-simulator/source/src/track/curve.rs": "b01a5d140b92a8eca03bfe7ca1d58fcf5e8455388d394b2f86d3094d98352b00",
+  "github-simulator/source/src/track/mod.rs": "4548f19925c2f61fac6a076ddbafacd062b29b75c8eecffcd7d7eb3037482900",
+  "github-simulator/source/src/track/path_segments.rs": "afa22462a3c5486d5bd9873313786cbb3aa28b932293fbebce37721ad9add24c",
+  "github-simulator/source/src/track/random_track.rs": "f60118f42f04b257188f89199956bad52139727ed4cff4376377a7bfb64d56e6",
+  "github-simulator/source/src/track/segment_grid.rs": "636b56c997ee10c5a56ed19a06f8525ff1e7a0756fbdc4dd4a73f8a02534f642",
+  "github-simulator/source/src/track/training_tracks.rs": "af7207f94db09f8e5d221844de25bb2a7fba44e82cacaa973c58e058a95332a3",
+  "github-simulator/source/src/track/world.rs": "81b4fab7ad2030629859cd7d725461b4e6adf6667f88b68629d289e8eb18fe52",
+  "github-simulator/source/src/training/agent.rs": "e3c0362788b7a23e47104d897c1d12025c8658f361c79f6328db0504c9416e02",
+  "github-simulator/source/src/training/ars.rs": "74672f1717b1eeea227e3f04479bbb951dc8289850a25e0c8ca59cecd6b77218",
+  "github-simulator/source/src/training/ars/tests.rs": "4273896832a470a0f10dd7c913b07726d21e3dceb6b7786abc89a195ecee05fe",
+  "github-simulator/source/src/training/batch_evaluation.rs": "6b975431eac59bfb197f3e5632ad58e1baa86c96f272360d351a4908df896f23",
+  "github-simulator/source/src/training/evaluation.rs": "66a6b86cdd3a052be533271a0012fb38a5a2ca2f973644681d013350f0b5ea27",
+  "github-simulator/source/src/training/evolution.rs": "d050036c9346561411feefc6c94d598cb0f3ee69e85a8960cf911d60b2129a61",
+  "github-simulator/source/src/training/game_random.rs": "04e90273f4960b36dbbba831bc4f95390998e31fd874fc3cca308580fe59228b",
+  "github-simulator/source/src/training/lineage.rs": "35ae0755d172ce54b7e26682ff626ef71d4ab724c553a2bb958084540d257c42",
+  "github-simulator/source/src/training/mod.rs": "8ef89fe999edd56502e85aba2b20664ab63871b9a03977c5c4b40293d945d905",
+  "github-simulator/source/src/training/optimizer.rs": "ee0ccc79494840e566e919d75879c2ceddd126fe5b5b49622f8c8d08af4aca92",
+  "github-simulator/source/src/training/pyrandom.rs": "1890f3338964d87e892589fea12d673ff181b2945ad7c121ecc0cde586e9d758",
+  "github-simulator/source/src/training/runner.rs": "5dcac344de3256dd27c6dead9cee92ab6ec1e782db38409002c7540fa11f2d42",
+  "github-simulator/source/src/training/runner/gpu.rs": "12475cb92731f5e9c311a9ca62c4e17f0dfde17bc46efe9f827f6ba4a91ebbac",
+  "github-simulator/source/src/training/runner/rays.rs": "e6467baf46fb091e81ca40aaa0ccc5b0f316f264cd8871e2a7f897cc4ae75320",
+  "github-simulator/source/src/training/runner/schedule.rs": "7bae3c881f2f2b086f1007734008056fcedab3316626cd9a5b13909daec02890",
+  "github-simulator/source/src/training/runner/tests.rs": "26fe931db6894bd72813136daf77fe0991307d1d715ffceea5f0e398e3e05b86",
+  "github-simulator/source/src/training/sensors.rs": "c3fe5cf32fb6ae0f75eaf08d826b482d3002ba9871a17e5c9b224c37cc9eda7c",
+  "github-simulator/source/src/training/session.rs": "608545b42d523766492d58e927b77e1beb5f4914476480ea5e64d0c325d62289",
+  "github-simulator/source/src/training/session/hip.rs": "a498f4712d2482d4229869748e3958c2ed502309b33e3465ac939d6d50ab3b2b",
+  "github-simulator/source/src/training/session/input.rs": "8d2ae4c9121a0a561797dbd394493c73a012d1687fbd5248ced4aa06c49eae90",
+  "github-simulator/source/src/training/stats.rs": "94075a6d675927b083c734e36049d12ec3faed67cb420e9a4c35e1de15a2a764",
+  "github-simulator/source/src/training/training_profile.rs": "2f801070e7e5b93fa774f2fe253642940f605167c8bb8a9e5f697e9dbacc36bc",
+  "github-simulator/source/src/wasm/float.wgsl": "6bfd8df71111352061ae5da4c6a0d496cfa3ff801a9c9ac9346a8dd940225584",
+  "github-simulator/source/src/wasm/gpu.rs": "065e78fe19c01f9ce4f09ff370d47696f77c3f53512fe54bb3d239f3a2860567",
+  "github-simulator/source/src/wasm/math_profile.rs": "63a59813aeb49686fa20ced1f0f379338ac12bffcda5d124f32abaa6a8fa524c",
+  "github-simulator/source/src/wasm/mod.rs": "96caf3e5bd084cbfb16e589430c952c6f4713fd843a63d3ca087d1b6aa391f2d",
+  "github-simulator/source/src/wasm/rays.wgsl": "0717e2a36bab9dd88cf2225104f6a5db198b767e9e4997ad40681a9bdf567448",
+  "github-simulator/source/src/wasm/sim/f64.wgsl": "b171bed33b9761f90ffd8222c36ff2532e9a260ff706fa85a10fb6f3ccb7cc46",
+  "github-simulator/source/src/wasm/sim/generated.wgsl": "a2f2947ecbd4b7eef088e074cf339c99e485c0d6c03365502686e3f9c80b0cf2",
+  "github-simulator/source/src/wasm/sim/helpers.wgsl": "bded7a38f12f5f5b37ccebb9e5a0701b476d353dad5f1cde230d97cae30e2737",
+  "github-simulator/source/src/wasm/sim/mod.rs": "1f4f7d45024a70768c6f0ff771991eadfb844118c0b64b17305f3ae40df611b7",
+  "github-simulator/source/src/wasm/sim/runtime.js": "fa6094b141f2db440d9627eb5eb203ed01a7670c3f3ba3933cc72cf49a046834",
+  "github-simulator/source/src/wasm/sim/window.wgsl": "532b56c9dd694381269513e0aec5831244aa7e5eb5dfdacf8ff66ec35b649f30",
+  "github-simulator/source/src/wasm/sim/world.rs": "76ebd261bb47ffe59f671451df00a769bc450c595780abeabfe542ed2aa31954",
+  "github_adapter.py": "7555cff8bceab47777386ee90a50074befa3711c433ad22cdca2ad4c1f652b3b",
+  "godot/assets/imported/A01 Beginner.model.json": "1d46f92b1c7d91af75e9f16423194f0fce5453d78b2cc0e7fb18eeb1842b5dd8",
+  "godot/assets/imported/A02 Sharp Turns.model.json": "40dbec0a1fa0bb029524cc71e0b420fe7dbcb7f4135a1f9ac21e1a6cd32786dc",
+  "godot/assets/imported/A03 High Speed.model.json": "2e7406e4292259a3bddf66c92dca6bf37237d80694cf6a68003744d179bf22bb",
+  "godot/assets/imported/A04 Dirt.model.json": "2dbcd29b0db5344dc2ae81be60c352a2dbddc3f2ac7b3427d2b76a8512d9733d",
+  "godot/assets/imported/A05 Two Terrains.model.json": "562b16348c0d79dfa5a22f483922acedd36446461bf44d2e4f94693f4910c58f",
+  "godot/assets/imported/A06 Ice.model.json": "56ccc3fa4149f3be4b25b5808482ca21edfcbf9559d497ff6fdb300aea14c76c",
+  "godot/assets/imported/A07 Three Terrains.model.json": "e0dad6f3dfdb8261e7a88b584a8120b69573634403c411ab48b9c69648d453e9",
+  "godot/assets/imported/A08 Long.model.json": "304998ba1effaecdfe8d9fcdaf59d8811db779c877458c454b355f70ad142d65",
+  "godot/assets/imported/A09 Sharpest.model.json": "a6948598cad6238f0c5802d67e1be56bb1748b648dfff675d23f6a61a05d0f56",
+  "godot/assets/imported/B01 Oval.model.json": "921fedb31214281dff3a64717da07abc6d85bb1bf0679411768c623a2dde02e9",
+  "godot/assets/imported/B02 Snake.model.json": "b319d59a1a21ca094ce50b781938e108582de7752036e5da0c028447964f462d",
+  "godot/assets/imported/B03 Slalom.model.json": "43008c2ea7475da7319f882a11a58d185ad093e46e002e5325eddbf80b00887a",
+  "godot/assets/imported/B04 Rally.model.json": "d5458902717421ab99680f8106de6472425b34f85a8e7842fdc639be442a6c1b",
+  "godot/assets/imported/B05 Racetrack.model.json": "203217155ac7d3d37e3bce4bf50199cfdece32a75533557435e78f3b1375f1d1",
+  "godot/assets/imported/B06 Hard.model.json": "c4460d0bddedd7d4be6d00976b6554994476d68bec39684a680cd6019cd32e7c",
+  "godot/assets/imported/B07 Drift.model.json": "d5b8b4418b84fe8a9d20f90e65abb1600510e122905b5eaa3e9d4f942549c97e",
+  "godot/assets/imported/B08 Arctic Circle.model.json": "e9b12a0194692bd90980ade5e5d852eb91ab43a55522a9cfb997c79811d4131a",
+  "godot/assets/imported/B09 Checkered.model.json": "183036504d32c8dfc1a58bae183d64501c629ab5c40e31908da4784cbdef8e0c",
+  "godot/assets/imported/R01 Blitzring.model.json": "3b0ec1c62d4d75f1ff7a27e8bcfc7e88495de97482037d213a5d661ca8249855",
+  "godot/assets/imported/R02 Desert Rally.model.json": "d3794fc462b24b6eaadd17f88c50fd98843cbae5b63f5e9765f9997e0244e04b",
+  "godot/assets/imported/R03 Glacier.model.json": "ec9b3c8201c8f7546c366c1aa9715dc76d875acbe5c0b0771c4abf0a25270d36",
+  "godot/assets/imported/R04 Truck Maze.model.json": "3ce6b887fdbf31a98e581715d77f7101251a1225e52bc072d0e8642a5d5e2fbe",
+  "godot/assets/imported/R05 Endurance 500.model.json": "19529f1a12cf2c5cd9ca5f1f9479e7323eb598d7db6b12332d16bf69f561c33e",
+  "godot/assets/imported/R06 Mix.model.json": "bee132139cf13457e293ce8cffe81ca8e8d5885e3276eea5a65465cc53594531",
+  "godot/assets/imported/R07 Mirage Marina.model.json": "b541eb4cd0cd714dff4e7e5e493e15ea0a01d99a6aa3a65b4a97044a87003a09",
+  "godot/assets/imported/R08 Demolition Derby.model.json": "b391029ce0b19f3ba6dea0831e53838337710136c9433ef84fce80317f4c9c07",
+  "godot/assets/imported/R09 Eau Noir.model.json": "25b9bf89b5ebb2fac8d18a547a1086d37f92563ff667b6cfa2a3afff83e4539d",
+  "godot/assets/imported/The Champions Trial.model.json": "9230869539197143ace6762107286000dba2cc050e6d35df7ef1d0c13fb5dc9b",
+  "index.html": "78e54dd9173c70d57b15003bf44f69f2a299c2e12b64216d9cedfca6f4177ca3",
+  "network_legality.py": "90196a2a6366768dda19fbb91dc03b2eeffa913b9af2ebffd33baa8f7a5067ec",
+  "preset_store.py": "c0edd11430c93d7015373d3e8579c0781e1a4ff51372808aed7872247d84b735",
+  "reward-catalog.json": "53b25e10a9e14b2ab1bd27259ca93d8fb0d49c4e27b3987f0ba2fc572bc63bf6",
+  "server.py": "0a261ed7fe3c9d0c532c4062d76fba24a4fef7bb719de0d66f9c31ae4d79e805",
+  "tracks/A01 Beginner-compatible.track": "c52056d88edf9bebb9d3daf6f9839ddf67deb43ff93d93a93fb0fbb3566993c1",
+  "tracks/A01 Beginner.saved.json": "23c93ec4443c269978ede5901b4c66a3f627cc273f3b5f6fa96d8a190a7e365b",
+  "tracks/A01 Beginner.scene.json": "d79cc49de2a5dce8690cf3422ac74b76f3980f845f98235188a443a717cd1f10",
+  "tracks/A01 Beginner.spawn.json": "c491511a8202b0bb4ba996c9f96a8d579dc30b443f5ff09984a18c5daee2ad89",
+  "tracks/A01 Beginner.track": "d3261eda8f6cbf73c55fb55ced0404aa6cba162fbf24bdc7780638b23c29d6ed",
+  "tracks/A02 Sharp Turns.saved.json": "cab708be9732a30f67d6cb3f2c639260844b003744ab061c6b06f5986024cb6d",
+  "tracks/A02 Sharp Turns.scene.json": "ded6165101f191332485a311f453537816248adb177822558dd86d917db882cd",
+  "tracks/A02 Sharp Turns.spawn.json": "03f1c1a3e2c720643e64f812a7bd619da8bc9ef27c108ab29be6fea982880763",
+  "tracks/A02 Sharp Turns.track": "ade4031c6292f0342008a3479948bb32ed6f95235d74b5a4d0fe2762fdf9790f",
+  "tracks/A03 High Speed.saved.json": "f21aa853ba2becd9c9e9118404545d19c4bd6c45d64ee3ecd4b6bafcefd97fbc",
+  "tracks/A03 High Speed.scene.json": "b486b6b47cd36e609f5ec1be67d385e373df351c379c47193f8a0aba54c88924",
+  "tracks/A03 High Speed.spawn.json": "7f8a9020b2aef433d876679262fc337928a4218cea3d2efa3ac6798b2eb122eb",
+  "tracks/A03 High Speed.track": "0fb8666063a4ee503cb5ad453d3135d7aae00a030254c5538581e73e7b94325e",
+  "tracks/A04 Dirt.saved.json": "5feac332a0b8e72fdbc5b9aa29f38750ba22b02ef809eaacb9f58daae54e1b64",
+  "tracks/A04 Dirt.scene.json": "dd28eaccaf7d270ff2ce4ebe572bf69a61349e107d05dff9792ea2f2c793ccb1",
+  "tracks/A04 Dirt.spawn.json": "28d8b916b84e3073c1ba5d0dff9c9a7d85c375858ac8c6818b1d6314847961fe",
+  "tracks/A04 Dirt.track": "483adf3e712436d448bf1187c467649f93cc7812f60db43345d4d0e061daa752",
+  "tracks/A05 Two Terrains.saved.json": "847f869d1d9f3e410043ccbf253d3def0725afa730c695b1519ef642cebab60c",
+  "tracks/A05 Two Terrains.scene.json": "a1e767ed6ddfd1fdaabed07a13ca71beaa074c051cb9ce70ad6c476880562bf1",
+  "tracks/A05 Two Terrains.spawn.json": "f8969c365d01c04a7a95b8abd5596618b70f52531eb03689ff908a27228056c3",
+  "tracks/A05 Two Terrains.track": "3493c825514e7304110db828e5a0fc58cce18dfa1a2a118b50addb2d71d4ff08",
+  "tracks/A06 Ice.saved.json": "97b93faa93ffea17dbac296c610228b5e452d0c1dfb14de30062e3e680d6cc1c",
+  "tracks/A06 Ice.scene.json": "da6fce1651fbb318fcc312632feca8961dcf85a79b7e74813b2427e696c716a1",
+  "tracks/A06 Ice.spawn.json": "b0f8af0dc885fc751eab1522da10592b5493bbc64843869e2426e1eca64e440d",
+  "tracks/A06 Ice.track": "a9acc1478f1d48808b30077f94c8a55ed64027cd0aa4c65cf0a2e1718c524bd1",
+  "tracks/A07 Three Terrains.saved.json": "a13bc4079a744791d2831aa971781bec349daedbe6bc104084741a561a637825",
+  "tracks/A07 Three Terrains.scene.json": "2888b82fa94b84c3b679a7c0ce81b7b2ccaaac7756907c893f85aed17f1059b8",
+  "tracks/A07 Three Terrains.spawn.json": "6e010816e7b8acd2401b89473fb22e9894cbfb88ec58060b47ae48e3091cbd21",
+  "tracks/A07 Three Terrains.track": "c157d8246d250940b9601b7c87b6c4edeef1bd75b5bab9aa69427d76d95cc7e6",
+  "tracks/A08 Long.saved.json": "99557126538ff8d2fac553262178427a91094eceaca39b32949141a310673113",
+  "tracks/A08 Long.scene.json": "f02099b86907f7cad9696ccadd814c626c59da47550f00d53307a4da535774e0",
+  "tracks/A08 Long.spawn.json": "6c082f62cb29b0a3cbc791b7531a4c9aeaf774f7e6dfa644f9ab40a2c3c6a815",
+  "tracks/A08 Long.track": "ef34644dd6f9900bb76a41fbe759a183830b17b1b6eea7f19cab1ba43ea7d96e",
+  "tracks/A09 Sharpest.saved.json": "8eae9b874f9b05050afa36370fa47f78b762ccba6d0d9665113b947a1a9e18d7",
+  "tracks/A09 Sharpest.scene.json": "05d4907988d0b9343c1800c74d0b3d0ea3f13ecd96514426b2303a211a9610b4",
+  "tracks/A09 Sharpest.spawn.json": "1027c03c0ef1bfd373e913c7dc77b256d0058e7b3b3cc6dc7d014a534019d972",
+  "tracks/A09 Sharpest.track": "407106de14243819966ddf30cad20979d979f94a798e94551a31a5538b705b5d",
+  "tracks/B01 Oval.saved.json": "0c42ed69583b7a6041837b10a4d2de7d4bcf4426ca91f657b5c1ce005a77f9b7",
+  "tracks/B01 Oval.scene.json": "f90567dcbbf2e7ed4dd8e578c63efe2962bc8fa836692e6c8c9494f4788b05e8",
+  "tracks/B01 Oval.spawn.json": "38bbe40879c18d9187eda23c9850c70f7762ea769b5d72208607b49bc2327c71",
+  "tracks/B01 Oval.track": "b4152d06083e5c871ec356ceff917de1ef5f72d6e27b9618959125a5e41e5a8c",
+  "tracks/B02 Snake.saved.json": "54c4f010a73e3549115ab9b160c9823d0f96fa920602507fcf251a9fd29619b4",
+  "tracks/B02 Snake.scene.json": "5ed52574b620de959a0c2005c7fd371f6d2f29b5dc2f20e930b13e8d93fc0f4c",
+  "tracks/B02 Snake.spawn.json": "2fb95139538ed66324e10750278ee250e8bc159ccab3d27320efc21de7601e5b",
+  "tracks/B02 Snake.track": "fbd98acba4c3580b6e37cf72ed63b5b2e0477b86ce64320a8423449b59df7e0d",
+  "tracks/B03 Slalom.saved.json": "6132213bdb3ece3f3ba1297200169aebd818fdff7e64ddc37d212c097322e9fc",
+  "tracks/B03 Slalom.scene.json": "13acb54facddc61b033070621dc92bdcd82cc35deadfa811020b788f15c90b5c",
+  "tracks/B03 Slalom.spawn.json": "f8969c365d01c04a7a95b8abd5596618b70f52531eb03689ff908a27228056c3",
+  "tracks/B03 Slalom.track": "f0014f7d33fd982fdf56d3f5fcfbccf5470ae5b3735480d4bcc959f2d5e61707",
+  "tracks/B04 Rally.saved.json": "1ba74c6c2e3dedddc9864379b6f824e8f32d45bd9cf566fcfdcf4074d633d817",
+  "tracks/B04 Rally.scene.json": "b61381b0932d40bc99f422f550d5d04612b8902dafb48e6e99752de817f40c2e",
+  "tracks/B04 Rally.spawn.json": "a864506108c968ab8e5949403825a387a9ab679aa3c97c2f85f51f593530cf17",
+  "tracks/B04 Rally.track": "6e03ca93bbd59f6e1cb05e3382c7959cc09f3abb5d9f76e8a224dd7365a21844",
+  "tracks/B05 Racetrack.saved.json": "d8fddedd268be9dda3e30f337663c3f1d42777c1cbcd6cb92055a8b50d154471",
+  "tracks/B05 Racetrack.scene.json": "1b69b006af727c249097fe996bd280f2f66751d78463678045db4bdfa7b7ccda",
+  "tracks/B05 Racetrack.spawn.json": "caf4e703eeef12f246e0456e9d4fecfd92020c86d6295813136c4dd68226aae9",
+  "tracks/B05 Racetrack.track": "43cea4d2ffd3ca3bc19de5b662b67228f7a9a35adfccf1af84a17ade07b5124a",
+  "tracks/B06 Hard.saved.json": "fe3bf789f34b9092b0c8486c80705f1aaeb38603d9a7263bbc2e4bf24fa0a7e6",
+  "tracks/B06 Hard.scene.json": "18b7dadde263aac8316ddb4b10e8d28321b799bdd17acb4c69508281dbbe949b",
+  "tracks/B06 Hard.spawn.json": "64cd8fd30bc1909522aaa0cf2df52bf980e6e4df2c5f3c4be173e4ecdd6881bb",
+  "tracks/B06 Hard.track": "b45330b2a4ec12b6cc7a62ab403c5cd7b864aa3ca7ce698da9678d80fefd5277",
+  "tracks/B07 Drift.saved.json": "549247a1c38d9f5462d416a2d3a00c3d032e8ca0358d75f2503bae9e277b3d79",
+  "tracks/B07 Drift.scene.json": "d8e3bfeea412780ae10a46bfcfee216bec1241f70dcab408a8de3b26bb7abd65",
+  "tracks/B07 Drift.spawn.json": "0c39c94ec48e01cde57873716585fc104b61d5bca9c3eff841342129d9b02078",
+  "tracks/B07 Drift.track": "73e0f3b11458f16e99b5c67987253a0d2e31a8dddf93bbae95ccf2ef09f206a0",
+  "tracks/B08 Arctic Circle.saved.json": "02b2be3a2c62083835f7fefe31788e666e523e4681b9c840ef6b8f2375b213d6",
+  "tracks/B08 Arctic Circle.scene.json": "af5c3bbb39ba6c143244d604df0c8b68ad7d8ef2889299cca52ed53dbf2b0980",
+  "tracks/B08 Arctic Circle.spawn.json": "ee1454cbec1c9b48ca0cf88e4337ada23a62827716a1ff10e1a480cace798043",
+  "tracks/B08 Arctic Circle.track": "4ec9803238b933999c5a1a16f8718b7a6b12ebb2aa88615212b9caddef3cc154",
+  "tracks/B09 Checkered.saved.json": "9c015b35fb7085c622852b27f30881e28c0c02aeb5c82cc24e069cd5b838b878",
+  "tracks/B09 Checkered.scene.json": "1f8927da796828fde4b2f86bec1650a7896ab0cbf3855d59894b9c499e43c52d",
+  "tracks/B09 Checkered.spawn.json": "cd6e0efcdf24be3ce06afbeaefa2c956085172612f73b2c773dfcc4220debd5b",
+  "tracks/B09 Checkered.track": "a9df6dc6a7817eaab6d7233846e29ae44f826a9e035aa578ceaef386e12dcdd3",
+  "tracks/R01 Blitzring.saved.json": "92741bab01c659d294d6e5ddcb09905655f681de170dd9b9c850bb2a50ddb19b",
+  "tracks/R01 Blitzring.scene.json": "a2e6d19aadc4cc7e614f974c5db399e0ff0a105682e38a8fbfe6e9e4ece4686e",
+  "tracks/R01 Blitzring.spawn.json": "7795cac05e10bfe8f16a0cb0ef5a93edf0df443085df22d81d8955a8fb39ab2d",
+  "tracks/R01 Blitzring.track": "560aafb1ecb7fa07671cfaa79ea429e5db7c64ffa625f25a24fbb046732f13bc",
+  "tracks/R02 Desert Rally.saved.json": "3f5e88bb2c3ea08ed933d529112b8e99cce6817cb19e1896ac7f3f478eb4256e",
+  "tracks/R02 Desert Rally.scene.json": "3ae7ee8cb62758d5ac09004536dce9ce19b99b0d732459e1a753bdf433c28ef1",
+  "tracks/R02 Desert Rally.spawn.json": "fc8dc10779bb6750039b84308aaeb8e5b046fffd07932f82c88eb17654cfbe9c",
+  "tracks/R02 Desert Rally.track": "15269225ce25cc964e79783ba5833c9135f561a7ae7c482b1f1f402feb83aa67",
+  "tracks/R03 Glacier.saved.json": "899727f504a4552522a66f65803498dbc535b943280ba2e41979018ed7a6d77f",
+  "tracks/R03 Glacier.scene.json": "5926a121ab9fe5a37cda9037357ef27a53d1ba79c217a6ee1e8561bb199d23b7",
+  "tracks/R03 Glacier.spawn.json": "ae91e75e037ba1d8b039a638860b6a93535d25e0804638dd1ec533296394e82f",
+  "tracks/R03 Glacier.track": "93d85045b4af30be986fb1cf9e5a2462ed25f34dd17b1dc5bdebcc06f2f58f0c",
+  "tracks/R04 Truck Maze.saved.json": "3a0de310132581c730acdf493dbd9d6506f9d78479e5cfe83c55f8f788f0895e",
+  "tracks/R04 Truck Maze.scene.json": "6d0955f94394a2786601053aa6c3da3135457b470df069ae102e90238a96e295",
+  "tracks/R04 Truck Maze.spawn.json": "6632d1b815145ef63173b33f740a8038ace886fc80d3d19d153dc0317e700b64",
+  "tracks/R04 Truck Maze.track": "69f3b7813716bc408853f76368b9640a8b5fac60c0fe84bf68bb19f2f8cf5680",
+  "tracks/R05 Endurance 500.saved.json": "b13fe6d518cf8754ca362f8b04e09e5f1b58c5255c113879645b01c09df5c09f",
+  "tracks/R05 Endurance 500.scene.json": "3d61c23d726261d3d05f69561e80d21ae9335fe40d311953a9f1833b4130e4c1",
+  "tracks/R05 Endurance 500.spawn.json": "4012030b01cb4fd551aa5944a442ad6ec13e5afa66804728a4df855854eee339",
+  "tracks/R05 Endurance 500.track": "ab701400945b302b600270a3d510e6a3604a9ae29a3f7aa00df9628f7ecd9ac3",
+  "tracks/R06 Mix.saved.json": "e897ba1f8697b137c4866ebb76b8a50b873cd1ec2d185cb86389b1e8e166341c",
+  "tracks/R06 Mix.scene.json": "ead016d8e9ad39bb56f58d7456284321aef6d31f67684a5573845a5ac63a7c97",
+  "tracks/R06 Mix.spawn.json": "c491511a8202b0bb4ba996c9f96a8d579dc30b443f5ff09984a18c5daee2ad89",
+  "tracks/R06 Mix.track": "140d6aa9a0e4bfa1a6776ac05597bbcd7a75c073935426a74b540374312f9460",
+  "tracks/R07 Mirage Marina.saved.json": "a87a65b016d8ae787ec60f928c55184615d7bdcae9417ccae728d2ed8284295f",
+  "tracks/R07 Mirage Marina.scene.json": "6c9df3b4faf505605db29b48e4d86ca99c86ff6493859f93724b06ba8cfbf3cf",
+  "tracks/R07 Mirage Marina.spawn.json": "5f60a1fa3a25211fa2a9b3b4320565001c65e7600c8de6bf1bf33206b1fe6a2d",
+  "tracks/R07 Mirage Marina.track": "5eb0d06262c6e78dc00872591dec541780a1c9a0835ad608cea474f4b038d68f",
+  "tracks/R08 Demolition Derby.saved.json": "f1d4f738570d6f4d3139839c1b1bec01f22f4fb43ac272d971df30960e7a7736",
+  "tracks/R08 Demolition Derby.scene.json": "8526629ee38c06c7d10b490316aae5fde5be185c286678d7304bd5e0208bb743",
+  "tracks/R08 Demolition Derby.spawn.json": "62cf46bf13fd9a3fb57a8891edcbd74af430174346bd5782f57796c18653a12c",
+  "tracks/R08 Demolition Derby.track": "00816f68f620008cbe560a9098883834d5fb3eef664c37f00504c8fe9d025f0e",
+  "tracks/R09 Eau Noir.saved.json": "be13d95668e41982fe0aac22a3a69df934fdbb57234e80c53c5ef9bbdfbd6f55",
+  "tracks/R09 Eau Noir.scene.json": "e27ca05758a1ae98c7021f62d255745c1fd25350076ee9735131f4ce407a6a5e",
+  "tracks/R09 Eau Noir.spawn.json": "045e758d23b577e4a44597e1fef831b8689253bb3cbae3ad6d4309f4a4d79359",
+  "tracks/R09 Eau Noir.track": "ba77ee9396d44f13bf079ebcbbfb6aa6f44bae83fd8725b20eb559ac383ed79a",
+  "tracks/The Champions Trial.saved.json": "ccb4b73d7c01c607ae7afc655c476d92d15809cfd7ac66c1750646368ddfa2f2",
+  "tracks/The Champions Trial.scene.json": "5aead756212996a349023f4cfa2046ab0eced2a226777f9f32e27f9d533bf332",
+  "tracks/The Champions Trial.spawn.json": "b0ffd429583ecc6806854b672c2cf683ea305f17a49800942c9242d4490a95da",
+  "tracks/The Champions Trial.track": "27e612b7e5f4c0356a02c2d6ee0d0d03383543ce84dc36fc74a62a259e8493c3",
+  "tracks/catalog.json": "a043d34c557d35871bbf3b9c5ba018e882158a53b7e55d9ee8eec9782efad7ce",
+  "tracks/compatibility-receipt.json": "00948fe53db0995281e9a4593186d1322baaeaae0c41414b77724d8e59980122",
+  "vendor/games/__init__.py": "f6701b872373bd606865daad0cb3d55c6815b78a6bdf1a780ac6fa99f53f0a3a",
+  "vendor/games/ai_learns_to_drive/__init__.py": "53b2d4f6dac65249b79fd40331d2668f3d4ecf999616cf728912be39bf77431f",
+  "vendor/games/ai_learns_to_drive/batched_controller.py": "f1386798ab6a74a095720003fc4a7dbb5e01ada6e114c130e558e8a54215d2c1",
+  "vendor/games/ai_learns_to_drive/cli.py": "716d092b390dd205f2689c779f1a3a47b8c2dbd77597e01049ce4ba1d1f63856",
+  "vendor/games/ai_learns_to_drive/collision.py": "6179d7581c1a2f42d8f028ab30e701dd11c3ecd125eec270fc73c256ae114a39",
+  "vendor/games/ai_learns_to_drive/evolution.py": "adee47e38d62f1c9b7f303171552a7000f4c281384b03daa8410bf8c6fbd7fc7",
+  "vendor/games/ai_learns_to_drive/evolutionary_trainer.py": "739d11b924f2232ae57570da5d9f6dd395f2a272a2ac9f2ea383b9646ab0420a",
+  "vendor/games/ai_learns_to_drive/managed_math.py": "90d88e3376d8ec49b5913e26c6a5923d355a3aa303977d28ec74a027f690d59b",
+  "vendor/games/ai_learns_to_drive/physics.py": "942abdf7dee4d9d5b0644decf6351e9f9d7956a8e7613e46575fa361da68d547",
+  "vendor/games/ai_learns_to_drive/physics_profiles.py": "5e5dd4cf5ebc5be09c2180b0b69af9833b95e6a7e801da5cbd1b46f4527cddc9",
+  "vendor/games/ai_learns_to_drive/presentation.py": "6ffc09d2ca5d1791d7147ec1fded6c94860d66b51c411441d16c9a93b5e095d3",
+  "vendor/games/ai_learns_to_drive/provenance.py": "e739f162e3c863085b3fb960638f1d66a726456e2b4434a2e964c6b9888b8b2e",
+  "vendor/games/ai_learns_to_drive/records.py": "b7c65c165adb814b75dabad5595a139220a1a549958990315a9d3659194b0345",
+  "vendor/games/ai_learns_to_drive/reproduction.py": "02f096286d3f629f6a0feecf173dbcdfca4b7f898f07e55b853a490c5a953be9",
+  "vendor/games/ai_learns_to_drive/rewards.py": "a9f2833ca923dcc5c51d35f802615559cbd7cf0c8468803d83c94ce3efbcf3de",
+  "vendor/games/ai_learns_to_drive/runtime_cache.py": "b5d0f9e92cc15da25e5039b666733a7d7dd0d660b9db7516672945f2498ac846",
+  "vendor/games/ai_learns_to_drive/scoring.py": "66038035a63d181c60a4a657f39ac38ebf72aab6e0d91432edbcdb46d1a03f6f",
+  "vendor/games/ai_learns_to_drive/sensors.py": "77309aa3cbda26d521db81413cd2be8bee18f305358c9f849e346523efc9377c",
+  "vendor/games/ai_learns_to_drive/sessions.py": "072a306ebb1c8286a875c1476f4e56a4de1b7468b6f168d0a7778407391c672d",
+  "vendor/games/ai_learns_to_drive/settings.py": "b802210677437f0537e2902dd3fdbe72006a943e519f08ff53c7c2ee40383dc7",
+  "vendor/games/ai_learns_to_drive/simulation.py": "30b69106673f62e8ced5e58077058941a75abda2865d704c2a4e715781d7e406",
+  "vendor/games/ai_learns_to_drive/tracks.py": "24d8e098108d8be033da1292c9c72d2047935dd5dc1084fb2cdd24e6c55efa3d",
+  "vendor/games/ai_learns_to_drive/trainer.py": "5e17bcc7bc594a4bc27223106313497112488f7e6bb6c75618239878426355cd",
+  "vendor/reward_extraction.py": "69d10fb82594ec5f391ac6814f2677355a6448c5eb1a9d28a3c677333cdc6384"
+}

README.md

@@ -1,11 +1,15 @@
 ---
-title: TAO GPU Training Lab · backend pending
-emoji: 🧪
-colorFrom: blue
-colorTo: purple
+title: TAO GPU Training Lab
+emoji: 🏎️
+colorFrom: green
+colorTo: blue
 sdk: docker
 app_port: 7860
 pinned: false
 ---
 
-Private GPU comparison deployment reserved. Not a working GPU trainer yet. Native comparison backend currently uses AMD HIP/ROCm; Hugging Face offers NVIDIA GPU hardware. A verified CUDA/NVIDIA backend or independent compatible implementation is required. No paid hardware has been requested. CPU runs belong in ald-tao-cpu. This app must not silently fall back to CPU and label it GPU.
+Private CUDA deployment candidate pinned to Zorro909/driving_sim_rs d8ab74c25df70b6a86ed101080e33d5fb785ea6f, matching ald-tao-cpu. Builds unchanged upstream Rust CLI and CUDA library together. Explicit proton math profile; no fast-math override. CUDA 13.0 sm_75/sm_86 plus PTX for compatible newer devices. Driver/device acceptance remains unverified.
+
+Hardware stays CPU Basic until separately authorized. This is NOT a verified GPU trainer yet. Without a usable GPU library/device, jobs fail preflight; CPU fallback is disabled. Only positive-mutation train-scratch jobs are supported by this wrapper; frozen replay stays on ald-tao-cpu. Existing Formula-only, bounded network/sensor and steering/acceleration restrictions remain. No upstream WebSocket service is exposed. CPU/GPU matched-output and benchmark acceptance remain pending.
+
+Open upstream PRs 19 and 21 are not included. Keep use private and bounded. No original-game parity claim. Storage is ephemeral: download checkpoints and receipts before restart. PACKAGE_MANIFEST.json covers deployment files; UPSTREAM.json records provenance. No local saved-car library is uploaded.

UPSTREAM.json

@@ -0,0 +1,12 @@
+{
+  "repository": "https://github.com/Zorro909/driving_sim_rs",
+  "commit": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f",
+  "previous_space_commit": "a3b395b0b608fb7caa2081348be153feabc38a69",
+  "math_profile": "proton",
+  "role": "gpu",
+  "gpu_runtime_verified": false,
+  "open_prs_not_included": [
+    19,
+    21
+  ]
+}

backend_policy.py

@@ -0,0 +1,21 @@
+"""Deployment identity and fail-closed GPU selection, independent of UI labels."""
+import os
+import json
+import subprocess
+
+UPSTREAM = 'd8ab74c25df70b6a86ed101080e33d5fb785ea6f'
+
+
+def backend_args(config, binary, scratch):
+    args = ['--math-profile', 'proton']
+    if os.environ.get('ALD_REQUIRE_GPU') != '1':
+        return args, []
+    if not scratch:
+        raise ValueError('GPU worker currently supports positive-mutation training only; replay stays on the CPU Space')
+    check = subprocess.run([str(binary), 'gpu-info'], capture_output=True, text=True, timeout=30)
+    if check.returncode:
+        raise RuntimeError('GPU preflight failed; CPU fallback is disabled: ' + check.stderr[-1500:])
+    info=json.loads(check.stdout)
+    if not info.get('device') or info.get('kernels') != 'ok' or info.get('layout') != 'ok':
+        raise RuntimeError('GPU device and kernel acceptance missing; CPU fallback is disabled')
+    return args, ['--gpu']

batch_runner.py

@@ -0,0 +1,42 @@
+"""Serial finite batches, frozen recipes, explicit parent lineage, no auto-resume."""
+import base64,copy,hashlib,json,threading,time,uuid
+from pathlib import Path
+class Batches:
+ def __init__(self,root,store,parse,make_job,execute):
+  self.root=Path(root);self.root.mkdir(exist_ok=True);self.store=store;self.parse=parse;self.make_job=make_job;self.execute=execute;self.items={};self.guard=threading.RLock()
+  for p in sorted(self.root.glob('*/status.json')):
+   b=json.loads(p.read_text());b['cancel']=threading.Event()
+   if b['state'] in ('queued','running'):b['state']='interrupted';self.save(b)
+   self.items[b['id']]=b
+ def public(self,b):return {k:v for k,v in b.items() if k!='cancel'}
+ def save(self,b):
+  with self.guard:
+   f=self.root/b['id']/'status.json';tmp=f.with_suffix('.tmp');tmp.write_text(json.dumps(self.public(b),indent=2));tmp.replace(f)
+ def active(self):return any(b['state'] in ('queued','running') for b in self.items.values())
+ def start(self,slot,data):
+  template,_=self.parse(data);manifest=self.store.resolve(slot)
+  id='batch-'+time.strftime('%Y%m%d-%H%M%S')+'-'+uuid.uuid4().hex[:6];d=self.root/id;d.mkdir();(d/'input.evolution').write_bytes(data)
+  manifest['input_sha256']=hashlib.sha256(data).hexdigest();(d/'manifest.json').write_text(json.dumps(manifest,indent=2))
+  b={'id':id,'name':manifest['name'],'slot':slot,'state':'queued','step':0,'total':len(manifest['steps']),'carry':manifest['carry'],'manifest':manifest,'jobs':[],'current_job':None,'cancel':threading.Event()};self.items[id]=b;self.save(b)
+  threading.Thread(target=self.worker,args=(b,data),daemon=True).start();return self.public(b)
+ def worker(self,b,original):
+  current=original
+  try:
+   b['state']='running';self.save(b)
+   for i,step in enumerate(b['manifest']['steps']):
+    if b['cancel'].is_set():raise InterruptedError('Batch stopped')
+    parent=current if b['carry'] else original
+    job=self.make_job(copy.deepcopy(step['config']),parent,b['id']);b['current_job']=job['id'];b['step']=i+1;b['jobs'].append({'id':job['id'],'run_slot':step['run_slot'],'input_sha256':hashlib.sha256(parent).hexdigest()});self.save(b)
+    if b['cancel'].is_set():job['cancel'].set()
+    self.execute(job)
+    if job['state']=='stopped' or b['cancel'].is_set():raise InterruptedError('Batch stopped')
+    if job['state']!='complete':raise RuntimeError(f'Run {step["run_slot"]} failed: {job.get("error",job["state"])}')
+    current=(Path(job['output_dir'])/'candidate.evolution').read_bytes();b['last_candidate']=str(Path(job['output_dir'])/'candidate.evolution');self.save(b)
+   b['state']='complete'
+  except InterruptedError:b['state']='stopped'
+  except Exception as e:b['state']='failed';b['error']=str(e)
+  finally:self.save(b)
+ def stop(self,id,jobs):
+  b=self.items[id];b['cancel'].set();j=jobs.get(b['current_job'])
+  if j:j['cancel'].set()
+  return self.public(b)

cloud-contract.json

@@ -0,0 +1 @@
+{"sensors": [{"$type": "raycast", "Length": 200.00003, "Degrees": -90}, {"$type": "raycast", "Length": 719.61523, "Degrees": -30}, {"$type": "raycast", "Length": 800, "Degrees": 0}, {"$type": "raycast", "Length": 719.61523, "Degrees": 30}, {"$type": "raycast", "Length": 200.00003, "Degrees": 90}, {"$type": "speed"}]}

cloud_core.py

@@ -0,0 +1,5 @@
+import json
+from pathlib import Path
+ENTRY=json.loads((Path(__file__).parent/'cloud-contract.json').read_text())
+def network(v):
+ return {'weights':[[v[i*4:(i+1)*4] for i in range(6)],[v[28+i*2:28+(i+1)*2] for i in range(4)]],'biases':[v[24:28],v[36:38]]}

github-simulator/source/Cargo.lock

@@ -0,0 +1,792 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "altd_sim"
+version = "1.1.0"
+dependencies = [
+ "clap",
+ "console_error_panic_hook",
+ "js-sys",
+ "libc",
+ "libloading",
+ "rayon",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tungstenite",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-bindgen-rayon",
+ "web-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+
+[[package]]
+name = "chacha20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.1",
+ "rand_core",
+]
+
+[[package]]
+name = "clap"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "crypto-common 0.1.7",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer 0.12.1",
+ "const-oid",
+ "crypto-common 0.2.2",
+]
+
+[[package]]
+name = "either"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "futures-core"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
+
+[[package]]
+name = "futures-task"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
+
+[[package]]
+name = "futures-util"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "rand_core",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "http"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "js-sys"
+version = "0.3.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "libloading"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60"
+dependencies = [
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "log"
+version = "0.4.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
+dependencies = [
+ "chacha20",
+ "getrandom",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+ "wasm_sync",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "wasm_sync",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha1"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.1",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio"
+version = "1.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
+dependencies = [
+ "pin-project-lite",
+]
+
+[[package]]
+name = "tungstenite"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48ac77174b19c110a50ab2128b24215ac9cb40e0e12e093fb602d175c569d22"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand",
+ "sha1",
+ "thiserror",
+]
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cbab34de2d982e9b48e18d216d04c4a6f641066ff19ffb699980f591ee3610e"
+dependencies = [
+ "js-sys",
+ "tokio",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-rayon"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a16c60a56c81e4dc3b9c43d76ba5633e1c0278211d59a9cb07d61b6cd1c6583"
+dependencies = [
+ "crossbeam-channel",
+ "js-sys",
+ "rayon",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm_sync"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff360cade7fec41ff0e9d2cda57fe58258c5f16def0e21302394659e6bbb0ea"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

github-simulator/source/Cargo.toml

@@ -0,0 +1,77 @@
+[package]
+name = "altd_sim"
+version = "1.1.0"
+edition = "2021"
+description = "CPU game-fidelity simulator and trainer for AI Learns To Drive"
+license = "MIT"
+repository = "https://github.com/Zorro909/driving_sim_rs"
+readme = "README.md"
+keywords = ["simulation", "driving", "training", "neural-network", "wasm"]
+categories = ["simulation", "science", "command-line-utilities"]
+rust-version = "1.93"
+exclude = ["tests/fixtures/", "wasm/test/"]
+
+[lib]
+# Keep native test artifacts distinct. wasm/build.sh selects cdylib explicitly.
+crate-type = ["rlib"]
+
+[features]
+default = ["cli", "server"]
+# The `altd-sim` command line (native only).
+cli = ["dep:clap"]
+# `altd-sim serve`: the WebSocket server Drive Lab can train on (native only).
+server = ["cli", "dep:tungstenite"]
+# The WebAssembly library in src/wasm: JavaScript bindings and the WebGPU raycaster.
+wasm = ["dep:wasm-bindgen", "dep:js-sys", "dep:wasm-bindgen-futures", "dep:web-sys", "dep:console_error_panic_hook"]
+wasm-threads = ["wasm", "dep:wasm-bindgen-rayon"]
+# Browser integration diagnostics, excluded from distributed packages.
+wasm-thread-test = ["wasm"]
+
+[dependencies]
+clap = { version = "4", features = ["derive"], optional = true }
+rayon = "1"
+serde = { version = "1", features = ["derive"] }
+# float_roundtrip parses JSON floats exactly like Python's float().
+serde_json = { version = "1", features = ["float_roundtrip", "preserve_order"] }
+wasm-bindgen = { version = "0.2", optional = true }
+js-sys = { version = "0.3", optional = true }
+wasm-bindgen-futures = { version = "0.4", optional = true }
+console_error_panic_hook = { version = "0.1", optional = true }
+web-sys = { version = "0.3", optional = true, features = [
+    "Window", "Navigator", "WorkerGlobalScope", "WorkerNavigator",
+    "Gpu", "GpuAdapter", "GpuDevice", "GpuQueue",
+    "GpuBuffer", "GpuBufferDescriptor", "GpuBufferBinding",
+    "GpuShaderModule", "GpuShaderModuleDescriptor", "GpuCompilationInfo", "GpuCompilationMessage", "GpuCompilationMessageType",
+    "GpuComputePipeline", "GpuComputePipelineDescriptor", "GpuProgrammableStage", "GpuPipelineLayout",
+    "GpuBindGroup", "GpuBindGroupDescriptor", "GpuBindGroupEntry", "GpuBindGroupLayout",
+    "GpuCommandEncoder", "GpuComputePassEncoder", "GpuCommandBuffer",
+    "gpu_buffer_usage", "gpu_map_mode",
+] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# Runtime loading of the HIP simulator (src/gpu/hip.rs).
+libloading = "0.9"
+sha2 = "0.10"
+# Synchronous WebSockets for `altd-sim serve`, without TLS.
+tungstenite = { version = "0.30", default-features = false, features = ["handshake"], optional = true }
+
+# Process statistics in the CLI (src/bin/altd-sim/platform.rs).
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.61", features = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_System_ProcessStatus", "Win32_System_SystemInformation", "Win32_System_Threading"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen-rayon = { version = "=1.3.0", optional = true, features = ["no-bundler"] }
+
+[profile.release]
+codegen-units = 1
+lto = "fat"
+panic = "abort"
+debug = "line-tables-only"
+
+[[bin]]
+name = "altd-sim"
+path = "src/bin/altd-sim/main.rs"
+required-features = ["cli"]

github-simulator/source/GODOT_LICENSE

@@ -0,0 +1,43 @@
+Godot Engine source adaptations in src/physics/broadphase.rs
+
+Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md).
+Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Modified tree-balancing algorithm, originally Randy Gaul qu3e:
+/**
+ * @file    q3DynamicAABBTree.h
+ * @author  Randy Gaul
+ * @date    10/10/2014
+ *  Copyright (c) 2014 Randy Gaul http://www.randygaul.net
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty. In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *    1. The origin of this software must not be misrepresented; you must not
+ *       claim that you wrote the original software. If you use this software
+ *       in a product, an acknowledgment in the product documentation would be
+ *       appreciated but is not required.
+ *    2. Altered source versions must be plainly marked as such, and must not
+ *       be misrepresented as being the original software.
+ *    3. This notice may not be removed or altered from any source distribution.
+ */
+

github-simulator/source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zorro909
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

github-simulator/source/README.md

@@ -0,0 +1,183 @@
+# altd-sim
+
+[![CI](https://github.com/Zorro909/driving_sim_rs/actions/workflows/ci.yml/badge.svg)](https://github.com/Zorro909/driving_sim_rs/actions/workflows/ci.yml)
+
+`altd-sim` is a Rust vehicle simulator and neural-network trainer for AI Learns To Drive. It runs headless on the CPU, through a runtime-loaded AMD HIP library, or in WebAssembly. It reproduces the game's floating-point arithmetic, contact ordering, sensors and evolution behavior against captured regression fixtures. Exactness claims apply to the tested inputs; [fidelity](docs/fidelity.md) records the limits.
+
+The repository includes vehicle and sensor templates, tile resources, fixed generated tracks and self-contained tests. Campaign tracks are not distributed.
+
+## Getting started
+
+This guide sets up `altd-sim serve`, the local simulator for [Drive Lab](https://drivinglab.jectrum.de). Drive Lab keeps your tracks, runs and downloads in the browser; the server drives the cars on your CPU threads or an AMD GPU. That removes the browser's limits on cars and network size and its eight-thread cap.
+
+### 1. Download
+
+Download the archive for your system from [Releases](https://github.com/Zorro909/driving_sim_rs/releases). Tagged versions are stable; the `nightly` pre-release is rebuilt from every push to `main` and keeps the same file names. `SHA256SUMS` lists the archive checksums.
+
+| System | Archive | Training on |
+| --- | --- | --- |
+| Linux x86_64 | `altd-sim-<version>-x86_64-unknown-linux-gnu.tar.gz` | CPU, or AMD GPU through HIP |
+| Windows x86_64 | `altd-sim-<version>-x86_64-pc-windows-msvc.zip` | CPU |
+| macOS, Apple silicon | `altd-sim-<version>-aarch64-apple-darwin.tar.gz` | CPU |
+
+Unpack it and open a terminal in the unpacked folder:
+
+```sh
+tar -xzf altd-sim-nightly-x86_64-unknown-linux-gnu.tar.gz
+cd altd-sim-nightly-x86_64-unknown-linux-gnu
+./altd-sim --version
+```
+
+On Windows, extract the `.zip`, then open PowerShell in the folder and use `.\altd-sim.exe` wherever this guide says `./altd-sim`. macOS binaries are unsigned, so first remove the download quarantine with `xattr -d com.apple.quarantine altd-sim`. Apple silicon uses the portable trigonometry described in [fidelity](docs/fidelity.md).
+
+### 2. Start the server
+
+```sh
+./altd-sim serve
+```
+
+```text
+altd-sim serve: listening on ws://127.0.0.1:47800/v1
+  allowed origins: https://drivinglab.jectrum.de
+  CPU threads: 16
+  HIP: available (AMD Radeon RX 7900 XTX)
+```
+
+Keep the terminal open while you train; <kbd>Ctrl</kbd>+<kbd>C</kbd> stops the server. It listens only on `127.0.0.1`, so the browser must run on the same computer.
+
+### 3. Connect Drive Lab
+
+1. In Drive Lab, open **New run**. Under **Compute**, enable **Use a local altd-sim**. The port field defaults to 47800.
+2. If the browser asks to allow access to devices on your local network, allow it.
+3. The status shows the connection, the CPU thread count and the GPU, if HIP is available. Choose **Native CPU** or **Native GPU (HIP)** and start the run.
+
+Each browser connection gets its own session. Only one session at a time can use the GPU; another one asking for HIP trains on CPU and says why. If the server stops during training, the run stops and keeps its last saved generation. Start the server again and resume the run.
+
+### Options
+
+| Option | Use it to |
+| --- | --- |
+| `--threads N` | Limit the CPU threads, for example to keep the computer responsive. The default is every logical CPU the process may use. |
+| `--math-profile PROFILE` | Reproduce `proton`, `win10-fma3` or `win11-fma3` arithmetic. The default follows the server's operating system; clients can select a profile for each session. |
+| `--port N` | Listen on another port when 47800 is taken. Set the same port in Drive Lab. |
+| `--allow-origin ORIGIN` | Allow another Drive Lab address, such as a development copy: `--allow-origin http://127.0.0.1:5173`. It replaces the default; repeat the option to allow several. |
+
+```sh
+./altd-sim serve --threads 8 --port 47801
+```
+
+All builds include all three math profiles. Windows 11 24H2 and newer default to `win11-fma3`; earlier Windows releases use `win10-fma3`; Linux and macOS use `proton`. To train on Linux for a game running on current Windows, for example, pass `--math-profile win11-fma3`. Checkpoints retain their profile. [Math profiles](math/README.md) describes the kernels and captured reference data.
+
+### Training on an AMD GPU
+
+The Linux archive contains `libaltd_gpu.so` next to `altd-sim`. It needs a ROCm 7.x runtime and one of the [covered GPU architectures](gpu/README.md). `./altd-sim gpu-info` checks that the library loads and prints `"layout": "ok"`; with a GPU present it also runs one kernel and prints the device, and fails if the library has no code for that GPU; the server's `HIP:` line shows the device or why HIP is unavailable.
+
+A HIP session drives its first 12 ticks on both the GPU and the CPU and compares them. If they differ, or the network or track needs something HIP does not support, the session trains on CPU and Drive Lab shows the reason. Native CPU and HIP produce the same results. Browser training can differ from both in the last digits of a few values ([issue #3](https://github.com/Zorro909/driving_sim_rs/issues/3)), so a run moved between the browser and the server can develop differently from then on.
+
+NVIDIA GPUs use the same backend: build the library with `gpu/build-cuda.sh` (Linux) or `gpu/build-cuda.ps1` (Windows) as described in the [GPU guide](gpu/README.md#nvidia-cuda). The release archives do not include it.
+
+### Troubleshooting
+
+- **`cannot listen on 127.0.0.1:47800: Address already in use`**: another server is already running, or another program uses the port. Stop it or choose another `--port`.
+- **Drive Lab cannot connect**: check that the server is running and that both use the same port. A Drive Lab address other than `https://drivinglab.jectrum.de` must be allowed with `--allow-origin`, including its scheme and port. If you denied local network access, allow it again in the browser's site settings.
+- **`HIP: unavailable`**: the line gives the reason. `./altd-sim gpu-info` reports library problems, and [GPU setup](gpu/README.md) covers ROCm and other GPU architectures.
+
+[Server documentation](docs/server.md) describes the protocol and its security checks for other clients.
+
+### Training without Drive Lab
+
+The CLI can also train on its own. This example trains Rally networks on generated tracks and writes them to `runs/example`:
+
+```sh
+./altd-sim train-scratch --scene assets/scenes/rally_template.json --track-mode random \
+  --random-track-settings assets/random_track_settings.json \
+  --population 256 --generations 3 --ticks 600 --out-dir runs/example
+```
+
+Add `--gpu` to train on an AMD GPU. `./altd-sim --help` lists every command, and the [CLI reference](docs/cli.md) describes their inputs and outputs.
+
+## Build from source
+
+Rust 1.94 or newer is the tested native toolchain. Build from the repository root. `--offline` works when dependencies are already cached; omit it on the first build if needed.
+
+```sh
+cargo build --release --offline
+python3 tools/benchmark.py --population 1024 --ticks 600 --repeats 5 \
+  --report target/benchmark.json
+
+target/release/altd-sim --threads 8 train-scratch \
+  --scene assets/scenes/rally_template.json --track-mode random \
+  --random-track-settings assets/random_track_settings.json \
+  --population 256 --generations 3 --ticks 600 --seed 1729 \
+  --eliminate-on-wall --idle-eliminate --save-final-candidate \
+  --out-dir runs/example
+```
+
+The training command starts Xavier networks and generates a reproducible track each generation. Increase the population, generations and tick limit for longer runs. Supply the same scene and track settings when resuming, with `--resume` and a higher `--generations` target.
+
+`.cargo/config.toml` uses `target-cpu=native` for x86 local builds, including the published CPU measurements. For a portable x86_64 binary, override it explicitly:
+
+```sh
+RUSTFLAGS='-C target-cpu=x86-64' cargo build --release --offline
+```
+
+AVX2 network and geometry paths use runtime detection and retain scalar fallbacks. Exact native trigonometry uses x87 on x86; other targets use the portable implementation described in the fidelity notes.
+
+## Other backends
+
+AMD GPU builds need ROCm and `hipcc`. The default architecture is `gfx1100`, for the RX 7900 XTX.
+
+```sh
+gpu/build.sh
+# Add --gpu to the train-scratch command above.
+```
+
+For other AMD GPUs, set `GPU_ARCH` to one or more architectures when building. Rust builds do not require ROCm. See [GPU setup](gpu/README.md) for validation and profiling.
+
+The default build also includes a local WebSocket server for native CPU or HIP sessions:
+
+```sh
+target/release/altd-sim --threads 8 serve
+```
+
+[Getting started](#getting-started) explains its options and how to connect Drive Lab; [server documentation](docs/server.md) covers the protocol, security checks and checkpoint resume.
+
+WebAssembly builds need the wasm32 target and the matching `wasm-bindgen` CLI:
+
+```sh
+rustup target add wasm32-unknown-unknown
+cargo install wasm-bindgen-cli --version "$(wasm/bindgen-version.sh)" --locked
+wasm/build.sh
+```
+
+The JavaScript library includes CPU simulation, a threaded CPU package and optional WebGPU backends. See [WASM setup](wasm/README.md) for initialization, browser requirements and tests. Expanded native/WASM comparisons have known last-bit differences; serial and threaded WASM are compared separately.
+
+## CLI and output
+
+`target/release/altd-sim --help` and `target/release/altd-sim COMMAND --help` show arguments. `bench` measures a fixed population; `train` evolves an exported network; `train-scratch` starts Xavier networks and supports checkpoints, generated-track batches and stop conditions; `evaluate` runs a frozen candidate against a hash-validated suite; `serve` exposes sessions over a loopback WebSocket. The `compare-*` commands compare user-supplied captures with the simulator. Scenes and recorded traces are explicit inputs. [CLI reference](docs/cli.md) covers defaults, resume behavior and report formats.
+
+A `train-scratch` run writes:
+
+| File | Contents |
+| --- | --- |
+| `run.json`, `log.jsonl`, `progress.json` | Effective options, completed generations and current progress |
+| `checkpoint.json`, `checkpoint_gNNNNN.bin` | Generation-boundary population and RNG state |
+| `best.json`, `best_laps/` | Networks that set a new best lap |
+| `candidate.json` | Final fitness leader when `--save-final-candidate` is enabled |
+| `tracks/` | Generated track geometry for replay |
+
+## Code and tests
+
+`src/math/` contains runtime-compatible arithmetic and vectors. `src/physics/` implements vehicles and contacts, while `src/track/` owns scene geometry, spatial queries and generated tracks. `src/nn/` provides scalar and AVX2 inference. `src/training/` owns populations, evolution, RNGs, evaluation and embedding sessions. `src/gpu/hip.rs` loads HIP; `src/gpu/simulation.rs` shares device layouts with `src/wasm/`, which supplies JavaScript and WebGPU bindings. The CLI entrypoint is `src/bin/altd-sim/main.rs`, beside its argument, comparison, benchmark and checkpoint modules. Rust imports follow these groups, such as `altd_sim::physics::car::Car` and `altd_sim::training::session::Session`. See [design notes](docs/design.md).
+
+```sh
+cargo test --release --offline
+cargo test --offline
+cargo build --offline --target wasm32-unknown-unknown --no-default-features --features wasm
+```
+
+Tests retain self-contained native captures and label generated golden data as current-code regressions. Browser integration checks live in `wasm/test/`; HIP equivalence checks use `gpu_check`. The exhaustive trigonometry scan and hardware-dependent tests are opt-in. See [performance](docs/performance.md), [GPU internals](docs/gpu.md) and [WASM fidelity](docs/wasm.md).
+
+GitHub Actions checks formatting, native and WASM Clippy, native release and debug tests, Windows and macOS Clippy and release tests, the HIP library build and layout, rustdoc, Rust 1.93 compatibility, and WASM packages with CPU browser comparisons. The release workflow builds and smoke-tests the archives, then publishes tags and nightly builds. Its native jobs override `target-cpu=native` with `x86-64` and include the flags in their cache keys, so cached builds can move between runner CPUs. Serial/threaded browser tests retain the documented expanded native differences. HIP equivalence and hardware WebGPU checks run separately because the hosted runners have no GPU.
+
+The project uses the [MIT license](LICENSE). Godot-derived code retains the [Godot notice](GODOT_LICENSE), and numerical modules retain their source notices.

github-simulator/source/assets/models/formula.json

@@ -0,0 +1,73 @@
+{
+  "vehicle_type": "formula",
+  "vision": [
+    {
+      "angle": -135,
+      "length": 624.2640380859375
+    },
+    {
+      "angle": -90,
+      "length": 200.00003051757812
+    },
+    {
+      "angle": -60,
+      "length": 499.9999694824219
+    },
+    {
+      "angle": -35,
+      "length": 691.4912109375
+    },
+    {
+      "angle": -20,
+      "length": 763.8155517578125
+    },
+    {
+      "angle": -10,
+      "length": 790.8846435546875
+    },
+    {
+      "angle": 0,
+      "length": 800
+    },
+    {
+      "angle": 10,
+      "length": 790.8846435546875
+    },
+    {
+      "angle": 20,
+      "length": 763.8155517578125
+    },
+    {
+      "angle": 35,
+      "length": 691.4912109375
+    },
+    {
+      "angle": 60,
+      "length": 499.9999694824219
+    },
+    {
+      "angle": 90,
+      "length": 200.00003051757812
+    },
+    {
+      "angle": 135,
+      "length": 624.2640380859375
+    }
+  ],
+  "sensors": [
+    "angular_velocity",
+    "boost_capacity",
+    "wheel_angle",
+    "grip",
+    "velocity_front",
+    "velocity_side",
+    "track_curvature"
+  ],
+  "outputs": [
+    "steering",
+    "acceleration",
+    "handbrake",
+    "brake",
+    "boost"
+  ]
+}

github-simulator/source/assets/models/rally.json

@@ -0,0 +1,74 @@
+{
+  "vehicle_type": "rally",
+  "vision": [
+    {
+      "angle": -135,
+      "length": 624.2640380859375
+    },
+    {
+      "angle": -90,
+      "length": 200.00003051757812
+    },
+    {
+      "angle": -60,
+      "length": 499.9999694824219
+    },
+    {
+      "angle": -35,
+      "length": 691.4912109375
+    },
+    {
+      "angle": -20,
+      "length": 763.8155517578125
+    },
+    {
+      "angle": -10,
+      "length": 790.8846435546875
+    },
+    {
+      "angle": 0,
+      "length": 800
+    },
+    {
+      "angle": 10,
+      "length": 790.8846435546875
+    },
+    {
+      "angle": 20,
+      "length": 763.8155517578125
+    },
+    {
+      "angle": 35,
+      "length": 691.4912109375
+    },
+    {
+      "angle": 60,
+      "length": 499.9999694824219
+    },
+    {
+      "angle": 90,
+      "length": 200.00003051757812
+    },
+    {
+      "angle": 135,
+      "length": 624.2640380859375
+    }
+  ],
+  "sensors": [
+    "angular_velocity",
+    "boost_capacity",
+    "correct_direction",
+    "grip",
+    "velocity_front",
+    "velocity_side",
+    "track_curvature"
+  ],
+  "outputs": [
+    "steering",
+    "acceleration",
+    "handbrake",
+    "brake",
+    "boost"
+  ],
+  "fidelity_provenance": "Sensor lengths retain the captured single-precision values."
+}

github-simulator/source/assets/networks/formula.json

@@ -0,0 +1,31 @@
+{
+  "inputs": [
+    "↑ -135°",
+    "↑ -90°",
+    "↑ -60°",
+    "↑ -35°",
+    "↑ -20°",
+    "↑ -10°",
+    "↑ 0°",
+    "↑ 10°",
+    "↑ 20°",
+    "↑ 35°",
+    "↑ 60°",
+    "↑ 90°",
+    "↑ 135°",
+    "AngVel",
+    "Boost",
+    "Wheel",
+    "Grip",
+    "VelF",
+    "VelS",
+    "Curve"
+  ],
+  "outputs": [
+    "Steering",
+    "Acceleration",
+    "Handbrake",
+    "Brake",
+    "Boost"
+  ]
+}

github-simulator/source/assets/networks/rally.json

@@ -0,0 +1,31 @@
+{
+  "inputs": [
+    "↑ -135°",
+    "↑ -90°",
+    "↑ -60°",
+    "↑ -35°",
+    "↑ -20°",
+    "↑ -10°",
+    "↑ 0°",
+    "↑ 10°",
+    "↑ 20°",
+    "↑ 35°",
+    "↑ 60°",
+    "↑ 90°",
+    "↑ 135°",
+    "AngVel",
+    "Boost",
+    "Dir",
+    "Grip",
+    "VelF",
+    "VelS",
+    "Curve"
+  ],
+  "outputs": [
+    "Steering",
+    "Acceleration",
+    "Handbrake",
+    "Brake",
+    "Boost"
+  ]
+}

github-simulator/source/assets/random_track_settings.json

@@ -0,0 +1,7 @@
+{
+  "length": { "min": 12, "max": 40 },
+  "allow_double": [false, true],
+  "surfaces": { "pool": [0, 1, 2], "count": [1, 2, 3] },
+  "distribution": [0, 1],
+  "start": null
+}

github-simulator/source/assets/scenes/formula_template.json

@@ -0,0 +1,111 @@
+{
+  "vehicle": {
+    "type": "Formula",
+    "mass": 2,
+    "inertia_property": 0,
+    "inertia_server": 1038.1666259765625,
+    "shape_size": [
+      73,
+      30
+    ],
+    "shape_position": [
+      0,
+      0
+    ],
+    "shape_rotation": 1.5708,
+    "gravity_scale": 1,
+    "linear_damp": 0,
+    "angular_damp": 0,
+    "max_contacts_reported": 4,
+    "friction": 0.95,
+    "bounce": 0.1,
+    "grip": 2,
+    "steering_speed": 0.4000000059604645,
+    "center_steering": true,
+    "air_resistance": 0.10000000149011612,
+    "max_velocity": 1200,
+    "surfaces": {
+      "asphalt": {
+        "grip": 1,
+        "power": 1,
+        "steering": 1
+      },
+      "dirt": {
+        "grip": 0.8,
+        "power": 0.5,
+        "steering": 1
+      },
+      "ice": {
+        "grip": 0.3,
+        "power": 0.5,
+        "steering": 1
+      }
+    },
+    "wheels": [
+      {
+        "position": [
+          -11,
+          -17
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 0,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          11,
+          -17
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 0,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          -13,
+          29
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 6,
+        "brake_power": 3,
+        "handbrake_power": 3
+      },
+      {
+        "position": [
+          13,
+          29
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 6,
+        "brake_power": 3,
+        "handbrake_power": 3
+      }
+    ]
+  },
+  "physics": {
+    "real_precision": "single",
+    "contact_recycle_radius": 1,
+    "contact_max_separation": 1.5,
+    "contact_max_allowed_penetration": 0.3,
+    "contact_default_bias": 0.8,
+    "solver_iterations": 16
+  },
+  "track": {
+    "name": "Generated track template",
+    "tiles": [],
+    "path": [],
+    "walls": [],
+    "physics_shapes": []
+  },
+  "reset_position": [
+    0,
+    0
+  ],
+  "reset_rotation": 0
+}

github-simulator/source/assets/scenes/rally_template.json

@@ -0,0 +1,112 @@
+{
+  "vehicle": {
+    "type": "Rally",
+    "mass": 3,
+    "inertia_property": 0,
+    "inertia_server": 1171.25,
+    "shape_size": [
+      62,
+      29
+    ],
+    "shape_position": [
+      0,
+      0
+    ],
+    "shape_rotation": 1.5708,
+    "gravity_scale": 1,
+    "linear_damp": 0,
+    "angular_damp": 0,
+    "max_contacts_reported": 4,
+    "continuous_cd": "Disabled",
+    "friction": 0.95,
+    "bounce": 0.1,
+    "grip": 2.25,
+    "steering_speed": 0.4000000059604645,
+    "center_steering": true,
+    "air_resistance": 0.15,
+    "max_velocity": 1000,
+    "surfaces": {
+      "asphalt": {
+        "grip": 1,
+        "power": 0.77,
+        "steering": 1
+      },
+      "dirt": {
+        "grip": 0.9,
+        "power": 0.82,
+        "steering": 1
+      },
+      "ice": {
+        "grip": 0.42,
+        "power": 0.6,
+        "steering": 1
+      }
+    },
+    "wheels": [
+      {
+        "position": [
+          -14,
+          -24
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 2.5,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          14,
+          -24
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 2.5,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          -14,
+          24
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 3.5,
+        "brake_power": 0,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          14,
+          24
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 3.5,
+        "brake_power": 0,
+        "handbrake_power": 0
+      }
+    ]
+  },
+  "physics": {
+    "real_precision": "single",
+    "contact_recycle_radius": 1,
+    "contact_max_separation": 1.5,
+    "contact_max_allowed_penetration": 0.3,
+    "contact_default_bias": 0.8,
+    "solver_iterations": 16
+  },
+  "track": {
+    "name": "Generated track template",
+    "tiles": [],
+    "path": [],
+    "walls": [],
+    "physics_shapes": []
+  },
+  "reset_position": [
+    0,
+    0
+  ],
+  "reset_rotation": 0
+}

github-simulator/source/assets/scenes/snowmobile_template.json

@@ -0,0 +1,123 @@
+{
+  "vehicle": {
+    "type": "Snowmobile",
+    "mass": 1.5,
+    "inertia_property": 0,
+    "inertia_server": 552.625732421875,
+    "shape_size": [
+      65,
+      14.0002
+    ],
+    "shape_position": [
+      -0.000114441,
+      0.499986
+    ],
+    "shape_rotation": 1.5708,
+    "gravity_scale": 1,
+    "linear_damp": 0,
+    "angular_damp": 0,
+    "max_contacts_reported": 4,
+    "continuous_cd": "Disabled",
+    "friction": 0.95,
+    "bounce": 0.1,
+    "grip": 2,
+    "steering_speed": 0.2,
+    "center_steering": true,
+    "air_resistance": 0.3,
+    "max_velocity": 600,
+    "surfaces": {
+      "asphalt": {
+        "grip": 0.9,
+        "power": 0.9,
+        "steering": 0.25
+      },
+      "dirt": {
+        "grip": 0.7,
+        "power": 0.8,
+        "steering": 0.7
+      },
+      "ice": {
+        "grip": 0.4,
+        "power": 0.8,
+        "steering": 0.7
+      }
+    },
+    "wheels": [
+      {
+        "position": [
+          -10,
+          -25
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 0,
+        "brake_power": 0,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          10,
+          -25
+        ],
+        "steering": true,
+        "max_angle_deg": 35,
+        "power": 0,
+        "brake_power": 0,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          0,
+          28
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 1.3,
+        "brake_power": 1.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          0,
+          22
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 1.3,
+        "brake_power": 1.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          0,
+          16
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 1.3,
+        "brake_power": 1.5,
+        "handbrake_power": 0
+      }
+    ]
+  },
+  "physics": {
+    "real_precision": "single",
+    "contact_recycle_radius": 1,
+    "contact_max_separation": 1.5,
+    "contact_max_allowed_penetration": 0.3,
+    "contact_default_bias": 0.8,
+    "solver_iterations": 16
+  },
+  "track": {
+    "name": "Generated track template",
+    "tiles": [],
+    "path": [],
+    "walls": [],
+    "physics_shapes": []
+  },
+  "reset_position": [
+    0,
+    0
+  ],
+  "reset_rotation": 0
+}

github-simulator/source/assets/scenes/truck_template.json

@@ -0,0 +1,112 @@
+{
+  "vehicle": {
+    "type": "Truck",
+    "mass": 8,
+    "inertia_property": 0,
+    "inertia_server": 11059.5,
+    "shape_size": [
+      124.5,
+      33
+    ],
+    "shape_position": [
+      0,
+      1.25
+    ],
+    "shape_rotation": 1.5708,
+    "gravity_scale": 1,
+    "linear_damp": 0,
+    "angular_damp": 0,
+    "max_contacts_reported": 4,
+    "continuous_cd": "Disabled",
+    "friction": 0.95,
+    "bounce": 0.1,
+    "grip": 12,
+    "steering_speed": 0.15,
+    "center_steering": true,
+    "air_resistance": 0.4,
+    "max_velocity": 600,
+    "surfaces": {
+      "asphalt": {
+        "grip": 1,
+        "power": 0.85,
+        "steering": 1
+      },
+      "dirt": {
+        "grip": 0.65,
+        "power": 0.8,
+        "steering": 1
+      },
+      "ice": {
+        "grip": 0.15,
+        "power": 0.7,
+        "steering": 1
+      }
+    },
+    "wheels": [
+      {
+        "position": [
+          -17,
+          -51
+        ],
+        "steering": true,
+        "max_angle_deg": 22,
+        "power": 0,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          17,
+          -51
+        ],
+        "steering": true,
+        "max_angle_deg": 22,
+        "power": 0,
+        "brake_power": 3.5,
+        "handbrake_power": 0
+      },
+      {
+        "position": [
+          -17,
+          46
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 6,
+        "brake_power": 3,
+        "handbrake_power": 3
+      },
+      {
+        "position": [
+          17,
+          46
+        ],
+        "steering": false,
+        "max_angle_deg": 0,
+        "power": 6,
+        "brake_power": 3,
+        "handbrake_power": 3
+      }
+    ]
+  },
+  "physics": {
+    "real_precision": "single",
+    "contact_recycle_radius": 1,
+    "contact_max_separation": 1.5,
+    "contact_max_allowed_penetration": 0.3,
+    "contact_default_bias": 0.8,
+    "solver_iterations": 16
+  },
+  "track": {
+    "name": "Generated track template",
+    "tiles": [],
+    "path": [],
+    "walls": [],
+    "physics_shapes": []
+  },
+  "reset_position": [
+    0,
+    0
+  ],
+  "reset_rotation": 0
+}

github-simulator/source/docs/cli.md

@@ -0,0 +1,115 @@
+# CLI reference
+
+Run commands from the repository root or an unpacked release archive; both contain `assets/`. `altd-sim --version` identifies the build, including nightly packages. `--threads N` sets the Rayon pool; the default respects CPU affinity. `--mode independent|lockstep` selects native scheduling. Both are global flags. Each command's `--help` is the complete argument reference.
+
+`--math-profile proton|win10-fma3|win11-fma3` is also global and selects the game's C runtime arithmetic independently of the CPU or GPU backend. Every build includes all three profiles. Omitted profiles use `proton` on Linux/macOS, `win10-fma3` on Windows before build 26100, and `win11-fma3` on Windows build 26100 and newer. For example, `altd-sim --math-profile win11-fma3 train-scratch ...` trains for current Windows on any supported host. [Math profiles](../math/README.md) describes the version boundaries and implementation.
+
+## Commands and inputs
+
+| Command | Required inputs and purpose |
+| --- | --- |
+| `bench` | `--scene`, `--network` with weights, `--spawn-trace`; fixed-population timing and optional state dumps |
+| `train` | `--scene`, weighted `--network`, `--model`, `--output`; evolution of an existing network |
+| `train-scratch` | `--scene`; Xavier initialization, checkpoints, generated batches and candidate export |
+| `evaluate` | `--network`, `--model`, `--suite`, `--report`; evaluate a frozen candidate without evolution |
+| `serve` | No input files; expose CPU or HIP sessions over a loopback WebSocket |
+| `compare-trace` | Positional scene, trace and report; replay controls from a recorded trace |
+| `compare-one-step` | Positional scene, trace and report; restore each recorded frame before stepping |
+| `compare-closed-loop` | Positional scene, trace, network, model and report; network-driven trajectory comparison |
+| `compare-network` | Positional network, trace and report; compare inference with recorded controls |
+| `compare-sensors` | Positional scene, trace, model, trajectory and report; compare sensor observations |
+| `compare-score` | Positional scene, trace and report; compare lap/score statistics |
+| `gpu-info` | Optional `--library`; load the GPU library used by `--gpu`, check its struct layouts and exports and, when a GPU is present, run one kernel on it |
+
+Scene and capture paths have no campaign defaults. `bench` and `train-scratch` default their sensor model to `assets/models/rally.json`. Scratch training defaults its sensor/control names to `assets/networks/rally.json`; these templates have no trained weights. The defaults are compiled into the binary, and `run.json` records them as `builtin:<path>`. Formula runs should explicitly use the Formula network/model assets and scene template.
+
+A fixed track requires `--spawn-trace` for `train` and `train-scratch`. The trace's first frame supplies the initial pose. Random mode needs only a geometry-free scene template; generated geometry supplies its reset pose. `--spawn-trace` is ignored in random mode. `bench` always requires its explicit spawn trace and supports `--spawn-index`.
+
+```sh
+target/release/altd-sim --threads 8 bench \
+  --scene wasm/test/scenarios/rally_mixed.scene.json \
+  --spawn-trace wasm/test/scenarios/rally_mixed.spawn.json \
+  --network wasm/test/scenarios/benchmark.network.json \
+  --population 1024 --ticks 600
+
+cargo run --release --offline --example extract_saved_track -- \
+  tests/fixtures/generated_saved_track.json example \
+  assets/scenes/rally_template.json target/imported-scene.json
+```
+
+The importer takes a saved-track export, a track name, a scene template and an output scene. Its bundled input is generated regression data. `tools/benchmark.py` runs the public generated-track bench repeatedly and keeps every report.
+
+## Local server
+
+```sh
+target/release/altd-sim --threads 8 serve --port 47800
+target/release/altd-sim serve --allow-origin http://127.0.0.1:5173
+```
+
+`serve` binds `127.0.0.1` only and defaults to port 47800. Repeat `--allow-origin` to replace the default `https://drivinglab.jectrum.de` allowlist. The shared Rayon pool uses the global `--threads` flag. The server prints its address, allowed origins, thread count and HIP availability. It is included by the default `server` feature. See [the server protocol](server.md) for handshake checks, session operations, binary frames and resume behavior. Drive Lab client integration is a separate change.
+
+## Scratch training
+
+Defaults are 8,192 cars, 50,000 target generations, a 5,400-tick time limit, seed 1, two inference batches and network shape `20,16,16,16,16,12,12,8,5`. The output directory defaults to `runs/example`. Pass short explicit limits for a smoke run. `--init-network` uses supplied weights; `--init-population` imports a compatible checkpoint into a new run directory.
+
+Evolution starts with tournament selection of 20 parents, no crossover, four preserved parents, adaptive mutation and no weight decay. Mutation decays geometrically from 0.4 to 0.0125; `--schedule linear` changes that schedule. `--settings FILE` overrides evolution defaults except requested population and scheduled mutation. It accepts a plain object or a nested `settings` object. Explicit elimination switches and `--reward` take precedence over the file.
+
+Elimination defaults off. `--eliminate-on-wall` deactivates cars after native wall contact. `--idle-eliminate` deactivates cars after more than 80 consecutive statistics updates with insufficient forward progress. The corresponding `--no-*` switches disable them. Passive physics and pending contacts continue for inactive cars.
+
+`--reward distance` selects on `total_score`; `--reward best-lap-time` selects on reciprocal best completed lap time. Without an explicit reward, settings-file rewards remain, with distance as the fallback. Cars without a completed lap have no best-lap signal.
+
+## Generated track batches
+
+```sh
+target/release/altd-sim --threads 8 train-scratch \
+  --scene assets/scenes/rally_template.json --track-mode random \
+  --random-track-settings assets/random_track_settings.json \
+  --tracks-per-generation 3 --track-buffer-size 8 \
+  --population 256 --generations 3 --ticks 600 --seed 1729 \
+  --save-final-candidate --out-dir runs/example
+```
+
+Each unchanged population evaluates the same track batch, with fresh spawn and a separate tick limit on each track. Selection uses the mean of normalized per-track reward ranks. Reproduction and the mutation schedule advance once after the complete batch. Fixed mode allows one track only. Queue depth changes preparation capacity, not the RNG stream.
+
+Without a settings file, track lengths range from 12 to 40 even tiles, all block types are enabled, and one, two or three distinct surfaces are sampled with equal probability into consecutive sections. `assets/random_track_settings.json` is an explicit variant that also samples double-block choices and random/section surface distribution.
+
+| Track field | Values |
+| --- | --- |
+| `length` | Fixed even count, or inclusive `{"min": 12, "max": 40}` range; supported grid capacity 4 to 76 |
+| `allow_double` | Boolean or list of boolean choices |
+| `surfaces` | Fixed distinct IDs, list of sets, or `{"pool": [0,1,2], "count": [1,2,3]}` |
+| `distribution` | `0` random per tile, `1` consecutive sections, or choices |
+| `start` | `null` for a fresh position, or fixed grid `[x,y]` |
+
+Surface IDs are asphalt 0, dirt 1 and ice 2. Failed generation retries are bounded; invalid or impossible settings fail rather than silently changing a fixed requested length. Track seeds depend on run seed, generation and batch slot independently of reproduction RNG, worker count and backend.
+
+## Outputs, resume and stopping
+
+`run.json` stores effective options from the latest invocation. `log.jsonl` has one completed-generation row, with per-track statistics for random batches. `progress.json` publishes current batch progress atomically. Generated track exports live under `tracks/`. `best.json` and `best_laps/` retain the fastest individual lap, even when selection uses another reward.
+
+Checkpoints are saved every `--checkpoint-every` generations, default 100, and after normal termination. Zero disables them. `checkpoint.json` identifies a binary population file and stores shape, population, generation and RNG state. `--resume` restores the latest complete generation boundary and removes replayed log/geometry entries. It cannot preserve every mid-tick native contact cache.
+
+```sh
+target/release/altd-sim train-scratch --resume \
+  --scene assets/scenes/rally_template.json --track-mode random \
+  --random-track-settings assets/random_track_settings.json \
+  --population 256 --generations 6 --ticks 600 --out-dir runs/example
+```
+
+`--generations` is the total target, including saved generations. Supply desired options again: omitted options use CLI defaults, except track seed/count retained in checkpoint metadata. An explicit `--tracks-per-generation` replaces the saved count. Preserve scene and track settings to reproduce the original sequence. Saved networks/RNG take precedence over a new `--seed` or `--init-network` during resume.
+
+`train-scratch --resume` also retains the checkpoint's math profile; an explicit different `--math-profile` is rejected. Checkpoints predating profiles use `proton`. New `run.json` and checkpoint metadata record `math_profile` so moving a run to another host does not change its arithmetic.
+
+Shape must match every checkpoint layer; matching parameter counts alone is insufficient. Population reductions keep the first networks, while expansions repeat them in order. Mutation uses the newly supplied schedule at the restored generation. Earlier checkpoints without shape/population recover those fields from adjacent `run.json` before updating current options.
+
+`--save-final-candidate` writes the complete-batch fitness leader before breeding, with lowest-index tie breaking. It preserves exact weights, ordered names, generation and reward metadata without consuming RNG. A completed checkpoint confirms its filename/hash/generation. A candidate without that confirmation is not a completed-stage result.
+
+`--stop-score-above`, `--stop-lap-below`, `--stop-lapped-percent` and `--stop-plateau` stop after a qualifying complete batch. Lap targets require a car to lap every track. Plateau counters restart per invocation, using `--plateau-metric lap|score`. A `stop_request` file in the run directory stops after the current batch; a stale file is removed at startup. SIGTERM does not write a final checkpoint. Negative thresholds use `=`, for example `--stop-score-above=-100`.
+
+## Frozen evaluation
+
+`evaluate` reads a version-1 suite containing `vehicle`, `options` and distinct `tracks`. Every track specifies relative scene/spawn filenames, their SHA-256 hashes and a finite tick limit. Options specify CPU backend, inference batch count and elimination. The evaluator validates finite network parameters, shape, ordered sensor/control names, vehicle compatibility and input hashes.
+
+A suite may set `options.math_profile` to a supported profile. An explicit CLI profile must agree with it. Without either, evaluation detects the host's profile; the report records the effective `math_profile`.
+
+Each track gets fresh state, contacts, controls, sensors and statistics. The evaluator never breeds or modifies training checkpoints/logs. Its atomic report records candidate/suite/simulator hashes, per-track score, progress, lap completion, optional best lap, collisions and executed ticks. An interrupted run does not publish a successful report. Existing tests build fully contained suites from fixed generated tracks.

github-simulator/source/docs/design.md

@@ -0,0 +1,59 @@
+# Design notes
+
+The simulator keeps arithmetic and execution ordering visible. A small algebraic rewrite can change rounding, contact choices or evolution, so numeric code and scheduling need stronger regression evidence than ordinary I/O changes.
+
+## Modules and ownership
+
+| Directory | Modules | Responsibility |
+| --- | --- | --- |
+| `src/math/` | `godot_math`, `native_math`, `managed_trig`, `double_math`, `pymath`, `vec2` | Captured rounding, runtime arithmetic and vectors |
+| `src/physics/` | `car`, `collision`, `simulation`, `broadphase`, `trace_state` | Forces, passive bodies, contacts, population physics and recorded-state reconstruction |
+| `src/track/` | `world`, `curve`, `bsp`, `segment_grid`, `path_segments`, `random_track`, `training_tracks` | Scene loading, geometry queries, tile generation and bounded preparation queue |
+| `src/nn/` | `network`, `network_simd` | Flat parameters and scalar/AVX2 inference |
+| `src/training/` | `agent`, `lineage`, `sensors`, `stats`, `runner`, `evolution`, `batch_evaluation`, `game_random`, `pyrandom` | Populations, statistics, ordered execution, reproduction and RNG backends |
+| `src/training/` | `session`, `evaluation` | Embedding, generation checkpoints and evaluation reports |
+| `src/gpu/` | `hip`, `simulation` | Runtime-loaded HIP C API, shared layouts and GPU windows |
+| `src/wasm/` | `gpu`, `sim` | JavaScript bindings, WebGPU rays and full simulation |
+
+Library imports follow the directory groups. For example, `physics::car::Car` and `track::world::World` describe their roles directly. The training scheduler types remain available from `training`, and embedding sessions live in `training::session`. HIP loading uses `gpu::hip`; portable GPU layouts live in `gpu::simulation`.
+
+The CLI entrypoint is `src/bin/altd-sim/main.rs`. Its sibling modules use Cargo's standard binary layout: `args` defines the command contract, `comparisons` produces recorded-trace reports, `bench` and `train` run their workloads, and `scratch` owns run configuration, stopping rules, checkpoint I/O and execution. Scratch parameter checkpoints and Session lineage checkpoints remain separate formats.
+
+The GPU validation example uses private modules in `examples/gpu_check/` for math, rays, simulation, evolution and benchmarks. Shared fixture setup and mismatch reporting stay outside the checked numerical implementations.
+
+CPU runners own populations and checkpoint serialization. HIP retains uploaded networks and geometry between windows; CPU evolution installs offspring and preserves the CPU/GPU resume format. WebGPU full simulation mirrors state in browser buffers and commits complete windows back to the Session. A failed window leaves the last committed state available for CPU continuation.
+
+## Execution modes
+
+Independent mode advances each car through a window, keeping its state and network near the CPU. Lockstep advances the population one tick at a time. Scenes requesting native shared broadphase require tick-major execution to preserve population contact ordering. Generated CLI training disables that shared broadphase so CPU and GPU use independent car physics.
+
+Statistics run before driving. Inference uses eight original index-based batches, so compacting inactive work must preserve each car's batch identity. Eliminated cars stop driving and scoring, but passive physics and pending contact accounting continue. The generation limit is checked on the statistics callback, so actual callback counts can slightly exceed a requested tick cap.
+
+Raycaster windows keep physics and inference on the CPU and replace only ray queries. HIP and full WebGPU windows run those phases on-device. These paths have distinct scheduling and memory costs; shared arithmetic names do not make their loop structure interchangeable.
+
+## Reproducible tracks and checkpoints
+
+Track seeds depend on the run seed, generation and batch slot. Their RNG stream is separate from network reproduction. Bounded queue depth and worker timing therefore do not affect which tracks a generation receives. Each batch shares a track across its population and breeds once after all tracks.
+
+Scratch CLI checkpoints save the next generation's population and RNG state at generation boundaries. Session checkpoints can encode parent lineage instead of every child network while retaining exact reconstruction. Those formats have different consumers and should be treated as separate contracts. Neither promises to serialize every mid-tick native contact cache.
+
+## Numerical constraints
+
+Keep float32/float64 transitions, reduction order, runtime transcendental behavior and equal-distance query decisions explicit. Disable FMA contraction in HIP builds. Preserve cached Gaussian draws and both captured game RNG streams. Generate shared numeric tables from their bit patterns and check the generated header before building; GPU builds must not rewrite source files.
+
+Performance changes need workload medians as well as exact state, checkpoint and RNG comparisons. Profiling paths alter launch behavior, so final timing should use production settings. [Fidelity](fidelity.md) and [performance](performance.md) describe the evidence and its boundaries.
+
+## Formatting and lint checks
+
+`cargo fmt --all -- --check` uses the repository's 120-column width. Native checks use `cargo clippy --offline --all-targets -- -D warnings`. Browser bindings use `cargo clippy --offline --target wasm32-unknown-unknown --no-default-features --features wasm -- -D warnings`. Scoped lint allowances explain preserved runtime constants, nonfinite comparisons, indexed numerical loops and packed GPU layouts. They do not relax warnings for unrelated code.
+
+## Optimizers
+
+`TrainingRunner` evaluates a whole population, scores it with `reward_values` (ranks within the generation), and hands the cars and scores to an `Optimizer` (`src/training/optimizer.rs`), which returns the next population. `settings.algorithm` chooses one; the runner replaces its optimizer when the name changes, and the new one continues from the cars it is next given.
+
+- `"ga"` is the default: selection, crossover, mutation and decay as in `evolution.rs`. Its random draws, and so every GA checkpoint and test, are unchanged.
+- `"ars"` (`src/training/ars.rs`) is Augmented Random Search V2-t with an elite pool. It keeps a search point `theta`; the population is the elites, `theta`, and antithetic probes `theta ± nu·d`, and the scores steer one step `alpha/(b·nu)·Σ(r+ − r−)·d` over the best `top_frac` of the pairs. The step is skipped when the scores are all alike. Elites are the best distinct cars of the last population, old elites included; they are re-run unchanged every generation, so ranks from different generations are never compared. Settings live under `settings.ars` (`nu`, `alpha`, `top_frac`, `elite_count`, `max_weight`), and `population` must be at least `elite_count + 3`.
+
+Rewards stay rank based for every algorithm. ARS therefore behaves like rank-based OpenAI-ES with top-b pair selection rather than reference ARS on raw magnitudes.
+
+Session checkpoints record how a population was made, so each optimizer has its own format: `ALTDCKP2` for GA parent lineage and `ALTDCKP3` for ARS, which stores `theta`, the elite pool, the sampling settings and the generator before the directions were drawn. Restoring one resamples the population and the directions exactly. A full population checkpoint (`ALTDCKP1`, JSON checkpoints, scratch CLI checkpoints) carries no search state, so ARS continues from the best restored car. A changed population size does the same.

github-simulator/source/docs/fidelity.md

@@ -0,0 +1,37 @@
+# Fidelity and regression coverage
+
+The simulator targets the captured behavior of AI Learns To Drive. Physics mixes float32 state with float64 calculations, and callbacks, contact caches and inference batches have observable ordering. Matching formulas alone does not reproduce those results.
+
+Numerical implementations retain operation order, intermediate precision, rounding boundaries, tie-breaking and RNG consumption. Scalar and AVX2 inference accumulate in the same order. HIP builds disable multiply-add contraction and require correctly rounded float32 division and square root. Spatial acceleration preserves traversal and first-equal-result decisions. A change to any of these rules needs exact comparisons before performance measurements.
+
+## What the tests establish
+
+The game captures in `tests/fixtures/` exercise native vehicle transitions, population lifecycle, contact/reset behavior, runtime math, sensors, statistics and training. Their track geometry comes from synthetic cases or generated tracks. Campaign tracks are not distributed. Short recorded vehicle-state samples retain positions, contact points and scalar sensor outputs, with collider exports removed. They are finite oracle samples. Older traces sometimes omit body matrices or contact caches, so restoring their visible state cannot prove complete native state reconstruction.
+
+Packed-game captures use Godot 4.3 build 77dcf97d8 and Windows .NET 8.0.2 where the fixture records that setup. The capture harnesses and raw logs are not distributed. Fixture provenance names the runtime and harness without presenting unavailable paths as public tooling. Packed-sine lookup tables were extracted from Windows .NET 8.0.2 coreclr.dll; their source hash remains in the table header, and the extraction script is not distributed.
+
+Generated-track game captures cover parked TileMaps, native wall insertion order, single-vehicle and population contacts, live resizing, redraws, coalesced creation, Truck and Snowmobile behavior, terrain grip and ordered/path sensors. Their `recipe` fields select a fixed generator seed, generation and slot using the public settings and vehicle template. Tests rebuild the geometry and apply explicit scene overrides; output states, curve samples and sensor values come from the game. These captures are separate from simulator-generated goldens.
+
+Generated-track goldens record the simulator's current results for controlled contacts, restored states, scoring, population redraw and Session checkpoints. They detect regressions; they are not independent game captures. Fixtures and their origins are documented in [the fixture README](../tests/fixtures/README.md). Differential tests compare accelerated queries with brute force, and CLI tests cover settings, checkpoints, resume, generated batches and evaluation.
+
+A historical diagnostic comparison against a captured campaign run matched 1,393 of 1,398 one-step frames exactly. The remaining five differed in angular velocity, rotation or velocity. Network inference matched all 1,398 frames with zero error. These results predate the public generated-track replacements and describe that capture, not every scene or closed-loop run. The campaign run and its geometry are not public inputs.
+
+## Platform limits
+
+On x86, native `engine_sin_cos` uses x87 `FSINCOS`. Its large-argument reduction preserves the extended pi constant across x87 precision modes. Tests cover 24, 53 and 64-bit precision and check that the caller's control word is unchanged. The portable fdlibm-based implementation is validated against x87 over float32 arguments with absolute value at most 16; the regular suite samples the domain and an ignored exhaustive test scans it. Larger arguments are not covered by that claim.
+
+Nonfinite float32 trig outputs retain the captured NaN signs and payloads on every target. Scalar and engine routines quiet NaNs. Managed `SinCos` preserves the sine input bits and clears the sign while quieting cosine. Both infinities produce the captured x86 indefinite NaN, `0xffc00000`.
+
+The distance-from-wall sensor also returns the x86 indefinite for zero divided by zero and infinity divided by infinity, including float32 conversion boundaries. Quotients from NaN operands retain their payloads.
+
+Seeded Python Xavier tests keep the captured parameter checksum on Linux and Windows. On macOS, `cargo test --lib nn::network::tests::xavier_matches_python -- --exact` requires `python3` and compares every parameter bit, the MT state and the cached Gaussian draw with CPython on that host. This checks host parity without assuming libSystem and glibc round identically.
+
+Seeded initialization uses host float64 transcendental functions. Equal RNG draws can therefore produce different parameter bits across native hosts. Session regressions compare both execution modes with the legacy `TrainingRunner` on each host and require exact checkpoint replay. Stored Session snapshot and checkpoint goldens remain exact comparisons on their capture platform, Linux x86_64 GNU.
+
+Native and WASM use different host implementations for some float64 transcendental operations. The public generated Formula state scenario matched 2,773 native values, while expanded snapshots found 2,285 native differences per scheduling mode: 703 controls, 405 metrics and 1,177 checkpoint bytes. Serial and threaded WASM had the same native differences and matched each other in all 253,341 checked values per mode, including the optional score aggregates. A passing state-only comparison does not imply exact expanded native parity. Counts depend on the scenario and checkpoint layout.
+
+The RX 7900 XTX WebGPU raycaster matched 4,000 random rays, 4,000 nearest-wall points and 119,743 in-simulation rays in that baseline. WGSL floating-point behavior, subnormal handling and NaN payloads still vary by device. Runtime verification counts discrepancies without replacing GPU results. See [WASM notes](wasm.md) for the comparison layers.
+
+## Checking a change
+
+Run native tests in debug and release, regenerate observations to temporary outputs, and compare exact float bits, RNG state and checkpoint bytes. Exclude only named timing and path metadata when comparing reports. Keep generated references separate from captured oracle data. Measure throughput only after those checks pass.

github-simulator/source/docs/gpu.md

@@ -0,0 +1,31 @@
+# HIP implementation notes
+
+The HIP library runs statistics, sensing, network inference and vehicle physics for independent cars. It also supports GPU turnover through the runner API. Population mean and novelty run on the GPU with reductions in the original order; that turnover path keeps offspring weights uploaded for the next generation. Rust owns resets and checkpoints.
+
+The same sources build for NVIDIA GPUs with `nvcc` (`gpu/build-cuda.*`, `gpu/sim/compat.h`); this page applies to both. NVIDIA warps are 32 lanes and use the `*_sync` warp operations with a full mask, so every lane of a wave must reach `reserve`, `append` and the active-count ballot, as on AMD. NVIDIA arithmetic returns its canonical NaN where the CPU returns a NaN operand, so those results are built explicitly on both vendors (`altd_nan_operand`, `altd_invalid`).
+
+## HIP sessions
+
+Native `SessionOptions` accepts `backend: "hip"` as well as the default `"cpu"`. The same option is available to [local server](server.md) clients. WASM sessions reject HIP. The process opens the HIP library once and allows one HIP session at a time; a session that cannot use HIP reports CPU through `backend()` and a reason through `backend_note()`.
+
+HIP sessions drive through the existing GPU window and generation paths, then read car and agent state back into the CPU runner. Readers, metrics and checkpoints therefore use the same runner state as CPU sessions. The simulator grows when a restored or started population exceeds its capacity, and track replacement uploads a new GPU world.
+
+Before the first window after a start or restore, a session compares 12 CPU and HIP ticks exactly from a backed-up state. It restores that state before real driving. Track replacement also requires a new comparison. A mismatch or verification error switches the session to CPU; a later HIP window error returns an error without retrying.
+
+Session turnover uses CPU `next_generation_traced`, which retains the parent records needed by format-2 checkpoints. The next HIP window uploads the new networks. Start, restore and network replacement also invalidate the uploaded network cache. This differs from the runner's GPU turnover path, which does not produce those parent records.
+
+Native CPU and HIP sessions share checkpoint formats with WASM. Native and WASM results have known last-bit differences; switching engines preserves the checkpoint but may change later training.
+
+## Kernels and validation
+
+Kernels compact live work into eight original inference batches. Only due batches run sensing and inference. A separate physics list retains inactive cars until they settle exactly. Windows replay a HIP graph over the 24-tick statistics/inference period, with direct launches for remainders. Compatible windows reuse the graph; changing track, schedule, shape, population or output mapping invalidates it.
+
+The split physics path separates collision phases and preserves ordered per-car contact generation. `ALTD_GPU_SPLIT=0` selects the fused alternative. `ALTD_GPU_GRAPH=0` bypasses graphs. These are differential validation options, not promises of better performance.
+
+The network forward path uses double parameters and adds products in input order. This can dominate at large populations on GPUs with low double-precision throughput. Host buffers retain mutation noise and upload packing space. A 262,144-car population with 1,661 parameters requires about 3.24 GiB for that host double buffer alone; device memory, car state and checkpoint populations are additional.
+
+`gpu::simulation` mirrors C layouts explicitly and exports/imports canonical car and agent state. The loader resolves the shared library at runtime, so ordinary CPU builds do not link ROCm. Rebuild the Rust executable and library together when their C API or layouts change.
+
+Historical CPU/HIP checks cover primitive math, queries, sensors, inference, physics, turnover, batch wrapping, uneven populations, simulator reuse and resumed training. They compare flags, exact values, RNG state and population bytes. These finite checks do not establish exactness for every scene or device. Run the generated-input checks on your own GPU using [the GPU guide](../gpu/README.md). [Performance notes](performance.md) retain measured results and timing boundaries.
+
+On Linux, `python3 gpu/test_constructor_cleanup.py` checks the built library's constructor failure paths without allocating GPU memory. It requires a C++17 compiler and the ROCm runtime. A temporary HIP shim injects allocation and copy failures, then checks that device buffers, host buffers, events and streams are released. The ROCm CI job runs this check without a GPU.

github-simulator/source/docs/math-profiles.html

@@ -0,0 +1,415 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Math profiles: supporting Windows UCRT variants on every backend</title>
+<style>
+  :root {
+    --bg: #0f1216; --panel: #171b21; --ink: #e6e9ee; --mute: #98a2b3; --line: #2a313b;
+    --musl: #3b82f6; --ucrt: #f59e0b; --ucrt2: #ef4444; --ok: #22c55e; --gen: #a855f7; --hand: #f97316;
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--bg); color: var(--ink); font: 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; }
+  main { max-width: 1240px; margin: 0 auto; padding: 32px 28px 64px; }
+  h1 { font-size: 28px; margin: 0 0 6px; }
+  h2 { font-size: 21px; margin: 44px 0 12px; padding-bottom: 6px; border-bottom: 1px solid var(--line); }
+  h3 { font-size: 16px; margin: 22px 0 8px; }
+  p, li { color: #cfd5de; }
+  .sub { color: var(--mute); margin: 0 0 22px; }
+  code { font: 13px ui-monospace, "SF Mono", Menlo, Consolas, monospace; background: #1f252d; padding: 1px 5px; border-radius: 4px; color: #e2e8f0; }
+  .tldr { background: var(--panel); border: 1px solid var(--line); border-left: 4px solid var(--ok); border-radius: 8px; padding: 14px 18px; }
+  .tldr ul { margin: 6px 0 0; padding-left: 20px; }
+  table { border-collapse: collapse; width: 100%; margin: 10px 0; font-size: 14px; }
+  th, td { border: 1px solid var(--line); padding: 7px 9px; text-align: left; vertical-align: top; }
+  th { background: #1b2027; color: #dbe1ea; font-weight: 600; }
+  td { background: var(--panel); }
+  .matrix td { text-align: center; font: 13px ui-monospace, Menlo, monospace; }
+  .matrix td:first-child, .matrix th:first-child { text-align: left; font-family: system-ui, sans-serif; }
+  .v0 { background: #14243f !important; color: #93c5fd; }
+  .v1 { background: #3a2a0c !important; color: #fcd34d; }
+  .v2 { background: #3f1a12 !important; color: #fdba74; }
+  .v3 { background: #3b1220 !important; color: #fda4af; }
+  .v4 { background: #2a1840 !important; color: #d8b4fe; }
+  .na { color: #5b6574 !important; }
+  .grid2 { display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }
+  .card { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 14px 16px; }
+  .card h3 { margin-top: 0; }
+  .figure { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 10px; margin: 10px 0 6px; overflow-x: auto; }
+  .caption { color: var(--mute); font-size: 13px; margin: 4px 2px 0; }
+  .legend { display: flex; gap: 16px; flex-wrap: wrap; font-size: 13px; color: var(--mute); margin: 6px 2px; }
+  .sw { display: inline-block; width: 12px; height: 12px; border-radius: 3px; vertical-align: -1px; margin-right: 5px; }
+  .bad { color: #fca5a5; } .good { color: #86efac; }
+  .tag { display: inline-block; font-size: 11px; padding: 1px 7px; border-radius: 10px; border: 1px solid var(--line); color: var(--mute); margin-left: 6px; }
+  ol.phases > li { margin-bottom: 10px; }
+  svg text { font-family: system-ui, -apple-system, "Segoe UI", sans-serif; }
+</style>
+</head>
+<body>
+<main>
+
+<h1>Math profiles</h1>
+<p class="sub">Historical design draft for issue #7, based on code at <code>e96a2e8</code> and the 56-build UCRT survey. The original proposal and diagrams below are retained as design history.</p>
+
+<div class="tldr">
+<strong>Implemented profiles</strong>
+<p>The implementation supports <code>proton</code>, <code>win10-fma3</code> and <code>win11-fma3</code>. Every native/WASM/GPU build includes all three. Defaults detect the host's operating system and version; resumed runs retain their saved profile. SSE2 variants are outside the supported scope.</p>
+<p>The new Windows kernels share restricted C source in <code>math/kernels/ucrt.h</code>, translated to Rust/WASM and WGSL and included by HIP/CUDA. The established musl and AVX2 ports remain. WebGPU pipeline creation specializes the generated module for the session's profile. <a href="../math/README.md">Current kernel, fixture and verification documentation</a> describes the implemented architecture.</p>
+</div>
+
+<h2>Original proposal</h2>
+
+<div class="tldr">
+<strong>TL;DR</strong>
+<ul>
+  <li>Make the platform's C runtime a <b>runtime parameter</b> (<code>MathProfile</code>) instead of a fact baked into every backend. Five profiles cover everything we measured: Proton and four Windows ones.</li>
+  <li>Write each math variant <b>once</b>, in the restricted C subset that <code>gpu/sim/*.h</code> already uses, and <b>generate</b> the Rust, AVX2, HIP and WGSL versions from it. This extends the existing <code>gen-sim.py</code> / <code>gen_tables.py</code> pipeline instead of adding a new one.</li>
+  <li>Use <b>exception tables</b> where exhaustive proof is possible (<code>sinf</code>/<code>cosf</code>: every float32 can be checked, as <code>engine_exceptions.h</code> already does for x87). Use <b>algorithm ports</b> for the rest (<code>atan2f</code>, <code>exp</code>, <code>log</code>, <code>pow</code>, <code>tanh</code>).</li>
+  <li>Verify each (profile × backend) pair against golden vectors captured from genuine DLLs under Wine. Only the output bits are stored; the DLLs are not.</li>
+  <li>The default stays <code>proton</code>, so existing goldens, checkpoints and behaviour don't change until a user chooses another profile.</li>
+</ul>
+</div>
+
+<h2>1. What has to be supported (measured)</h2>
+<p>Results of the 56-build survey: genuine x64 <code>ucrtbase.dll</code> builds signed 2020–2026, each tested with FMA3 on and off. Each cell shows which implementation a profile needs. A different colour means a different implementation, i.e. not bit-identical.</p>
+
+<table class="matrix">
+  <tr><th>Function (who uses it)</th><th>proton</th><th>win10-fma3<br><span class="tag">Win10, Win11 ≤23H2</span></th><th>win10-sse2</th><th>win11-fma3<br><span class="tag">Win11 24H2+</span></th><th>win11-sse2</th><th>impls</th></tr>
+  <tr><td><code>sinf</code> (ray directions, vision)</td><td class="v0">musl</td><td class="v1">ucrt·F</td><td class="v2">ucrt·S</td><td class="v1">ucrt·F</td><td class="v2">ucrt·S</td><td>3</td></tr>
+  <tr><td><code>cosf</code> (ray directions, vision)</td><td class="v0">musl</td><td class="v1">ucrt·F</td><td class="v2">ucrt·S</td><td class="v1">ucrt·F</td><td class="v2">ucrt·S</td><td>3</td></tr>
+  <tr><td><code>atan2f</code> (rotation, sensors, slip, tracks)</td><td class="v0">musl</td><td class="v1">ucrt</td><td class="v1">ucrt</td><td class="v1">ucrt</td><td class="v1">ucrt</td><td>2</td></tr>
+  <tr><td><code>exp</code> (tyre grip)</td><td class="v0">musl</td><td class="v1">A·F</td><td class="v2">S</td><td class="v3">B·F</td><td class="v2">S</td><td>4</td></tr>
+  <tr><td><code>log</code> (Box-Muller, evolution; CPU only)</td><td class="v0">musl</td><td class="v1">ucrt</td><td class="v1">ucrt</td><td class="v1">ucrt</td><td class="v1">ucrt</td><td>2</td></tr>
+  <tr><td><code>pow</code> (input easing, novelty)</td><td class="v0">musl</td><td class="v1">A·F</td><td class="v2">A·S</td><td class="v3">B·F</td><td class="v4">B·S<sup>†</sup></td><td>5</td></tr>
+  <tr><td><code>tanh</code> (network activation)</td><td class="v0">musl</td><td class="v1">A</td><td class="v1">A</td><td class="v3">B·F</td><td class="v1">A</td><td>3</td></tr>
+  <tr><th>Total implementations</th><th colspan="5" style="text-align:left">today: 7 (one per function) · needed: <b>22</b></th><th>22</th></tr>
+</table>
+<p class="caption">A = Windows 10 / Win11 ≤23H2 behaviour, B = Win11 24H2+ behaviour, F = FMA3 path, S = SSE2 path. Profile-independent and unchanged: x87 <code>engine_sin_cos</code>, .NET <code>MathF.SinCos</code> (<code>managed_sin_cos</code>). <sup>†</sup>B·F and B·S <code>pow</code> agree on all game-range inputs and differ on 10 of 4M wide inputs.</p>
+
+<div class="grid2">
+  <div class="card">
+    <h3>Where each function runs today</h3>
+    <table>
+      <tr><th></th><th>CPU scalar</th><th>AVX2</th><th>HIP</th><th>WebGPU</th></tr>
+      <tr><td>sinf / cosf</td><td>✓</td><td class="na">–</td><td>✓</td><td>✓</td></tr>
+      <tr><td>atan2f</td><td>✓</td><td class="na">–</td><td>✓</td><td>✓</td></tr>
+      <tr><td>exp, pow</td><td>✓</td><td class="na">–</td><td>✓</td><td>✓</td></tr>
+      <tr><td>log</td><td>✓</td><td class="na">–</td><td class="na">–</td><td class="na">–</td></tr>
+      <tr><td>tanh</td><td>✓</td><td>✓ <code>tanh4</code></td><td>✓</td><td>✓</td></tr>
+    </table>
+    <p class="caption">WASM CPU compiles the same Rust as native scalar. <code>log</code> only runs in reproduction, which stays on the CPU in HIP and WebGPU sessions.</p>
+  </div>
+  <div class="card">
+    <h3>Why a naive port doesn't scale</h3>
+    <p>Hand-porting 22 implementations to every backend would mean 22 Rust + 20 HIP + 3 AVX2 bit-exact ports, each needing review, plus 22 generated WGSL functions to validate. Today 7 Rust + 6 HIP + 1 AVX2 are maintained by hand.</p>
+    <p>The FMA3 variants also need <b>explicit fused multiply-adds</b>. HIP builds deliberately use <code>-ffp-contract=off</code>, and WGSL has no <code>f64</code> at all (<code>f64.wgsl</code> is software binary64). So "just enable FMA" isn't an option anywhere.</p>
+  </div>
+</div>
+
+<h2>2. Current state</h2>
+<div class="figure">
+<svg viewBox="0 0 1200 470" width="100%" role="img" aria-label="Current architecture">
+  <defs>
+    <marker id="ah" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#98a2b3"/></marker>
+    <marker id="ahh" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#f97316"/></marker>
+    <marker id="ahg" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#a855f7"/></marker>
+  </defs>
+  <!-- column labels -->
+  <text x="20" y="28" fill="#98a2b3" font-size="13">SPECIFICATION (one fixed platform: Proton / musl)</text>
+  <text x="470" y="28" fill="#98a2b3" font-size="13">BACKEND IMPLEMENTATIONS</text>
+  <text x="900" y="28" fill="#98a2b3" font-size="13">CALLERS (hard-wired)</text>
+
+  <!-- Rust spec -->
+  <rect x="20" y="45" width="370" height="170" rx="8" fill="#14243f" stroke="#3b82f6"/>
+  <text x="36" y="70" fill="#e6e9ee" font-size="15" font-weight="600">Rust scalar = the reference</text>
+  <text x="36" y="94" fill="#cfd5de" font-size="13">src/math/native_math.rs  — sinf, cosf, atan2f</text>
+  <text x="36" y="114" fill="#cfd5de" font-size="13">src/math/double_math.rs — exp, log, pow</text>
+  <text x="36" y="134" fill="#cfd5de" font-size="13">src/nn/network.rs — game_tanh / game_expm1</text>
+  <text x="36" y="154" fill="#cfd5de" font-size="13">src/math/double_math_tables.rs</text>
+  <text x="36" y="182" fill="#93c5fd" font-size="12.5">Free functions; no notion of "which platform".</text>
+  <text x="36" y="200" fill="#93c5fd" font-size="12.5">Also compiled for WASM CPU.</text>
+
+  <!-- AVX2 -->
+  <rect x="470" y="45" width="360" height="62" rx="8" fill="#2a1d10" stroke="#f97316"/>
+  <text x="486" y="70" fill="#e6e9ee" font-size="14" font-weight="600">AVX2  src/nn/network_simd.rs</text>
+  <text x="486" y="92" fill="#fdba74" font-size="12.5">tanh4 / expm1_tanh — hand port of game_tanh</text>
+
+  <!-- HIP -->
+  <rect x="470" y="127" width="360" height="88" rx="8" fill="#2a1d10" stroke="#f97316"/>
+  <text x="486" y="152" fill="#e6e9ee" font-size="14" font-weight="600">HIP  gpu/sim/math.h</text>
+  <text x="486" y="174" fill="#fdba74" font-size="12.5">native_sin/cos/atan2, dexp, dpow, game_tanh</text>
+  <text x="486" y="194" fill="#fdba74" font-size="12.5">hand port; -ffp-contract=off</text>
+
+  <!-- tables gen -->
+  <rect x="470" y="235" width="360" height="50" rx="8" fill="#1f1530" stroke="#a855f7"/>
+  <text x="486" y="258" fill="#e6e9ee" font-size="14" font-weight="600">gpu/gen_tables.py → double_tables.h</text>
+  <text x="486" y="276" fill="#d8b4fe" font-size="12.5">bit-copied from Rust tables</text>
+
+  <!-- WGSL -->
+  <rect x="470" y="305" width="360" height="88" rx="8" fill="#1f1530" stroke="#a855f7"/>
+  <text x="486" y="330" fill="#e6e9ee" font-size="14" font-weight="600">WebGPU  src/wasm/sim/generated.wgsl</text>
+  <text x="486" y="352" fill="#d8b4fe" font-size="12.5">wasm/gen-sim.py transpiles gpu/sim/*.h (pycparser)</text>
+  <text x="486" y="372" fill="#d8b4fe" font-size="12.5">doubles via f64.wgsl (software binary64)</text>
+
+  <!-- arrows spec -> backends -->
+  <path d="M390,90 C430,90 430,76 466,76" stroke="#f97316" stroke-width="2" fill="none" marker-end="url(#ahh)"/>
+  <path d="M390,150 C430,150 430,170 466,170" stroke="#f97316" stroke-width="2" fill="none" marker-end="url(#ahh)"/>
+  <path d="M390,165 C430,190 430,255 466,258" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#ahg)"/>
+  <path d="M650,215 L650,232" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#ahg)"/>
+  <path d="M845,170 C880,170 880,250 845,335" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#ahg)" />
+  <text x="862" y="260" fill="#d8b4fe" font-size="11.5">gen</text>
+
+  <!-- callers -->
+  <rect x="900" y="45" width="280" height="170" rx="8" fill="#171b21" stroke="#2a313b"/>
+  <text x="916" y="70" fill="#e6e9ee" font-size="14" font-weight="600">21 Rust call sites</text>
+  <text x="916" y="92" fill="#cfd5de" font-size="12.5">physics/car.rs, training/*.rs,</text>
+  <text x="916" y="110" fill="#cfd5de" font-size="12.5">track/curve.rs, random_track.rs …</text>
+  <text x="916" y="134" fill="#cfd5de" font-size="12.5">call native_math::atan2(...) etc.</text>
+  <text x="916" y="158" fill="#cfd5de" font-size="12.5">gpu/sim step/sensors/stats/track.h</text>
+  <text x="916" y="176" fill="#cfd5de" font-size="12.5">call native_* / dexp / dpow</text>
+  <text x="916" y="200" fill="#fca5a5" font-size="12.5">→ no way to choose a platform</text>
+
+  <!-- problems box -->
+  <rect x="20" y="240" width="420" height="215" rx="8" fill="#2a1416" stroke="#ef4444"/>
+  <text x="36" y="266" fill="#fecaca" font-size="15" font-weight="600">Limits for issue #7</text>
+  <text x="36" y="292" fill="#fca5a5" font-size="13">• One implementation per function, compiled in.</text>
+  <text x="36" y="314" fill="#fca5a5" font-size="13">• Rust and HIP are two hand-maintained sources;</text>
+  <text x="48" y="332" fill="#fca5a5" font-size="13">AVX2 is a third for tanh.</text>
+  <text x="36" y="354" fill="#fca5a5" font-size="13">• FMA is forbidden everywhere (contract=off);</text>
+  <text x="48" y="372" fill="#fca5a5" font-size="13">no explicit fma primitive in Rust/HIP/WGSL code.</text>
+  <text x="36" y="394" fill="#fca5a5" font-size="13">• Golden fixtures describe Proton only.</text>
+  <text x="36" y="416" fill="#fca5a5" font-size="13">• Adding Windows naïvely = 22 × (Rust + HIP)</text>
+  <text x="48" y="434" fill="#fca5a5" font-size="13">+ 3 AVX2 bit-exact hand ports.</text>
+
+  <!-- legend -->
+  <rect x="470" y="410" width="12" height="12" fill="#f97316"/><text x="488" y="421" fill="#98a2b3" font-size="12.5">hand-written port</text>
+  <rect x="610" y="410" width="12" height="12" fill="#a855f7"/><text x="628" y="421" fill="#98a2b3" font-size="12.5">generated</text>
+  <rect x="720" y="410" width="12" height="12" fill="#3b82f6"/><text x="738" y="421" fill="#98a2b3" font-size="12.5">source of truth</text>
+</svg>
+</div>
+<p class="caption">Rust is the reference; HIP is a second hand-written copy; WGSL is generated from HIP; AVX2 has a third copy of tanh. Each backend's math is fixed when it is compiled.</p>
+
+<h2>3. Proposed architecture</h2>
+<div class="figure">
+<svg viewBox="0 0 1200 760" width="100%" role="img" aria-label="Proposed architecture">
+  <defs>
+    <marker id="a2" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#a855f7"/></marker>
+    <marker id="a3" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#22c55e"/></marker>
+    <marker id="a4" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" fill="#98a2b3"/></marker>
+  </defs>
+
+  <!-- Layer labels -->
+  <text x="20" y="26" fill="#98a2b3" font-size="13">① EVIDENCE (dev-only, Wine)</text>
+  <text x="330" y="26" fill="#98a2b3" font-size="13">② SINGLE SOURCE</text>
+  <text x="690" y="26" fill="#98a2b3" font-size="13">③ GENERATED BACKENDS</text>
+  <text x="990" y="26" fill="#98a2b3" font-size="13">④ RUNTIME SELECTION</text>
+
+  <!-- Evidence -->
+  <rect x="20" y="40" width="280" height="250" rx="8" fill="#171b21" stroke="#2a313b"/>
+  <text x="36" y="64" fill="#e6e9ee" font-size="14" font-weight="600">UCRT reference harness</text>
+  <text x="36" y="86" fill="#cfd5de" font-size="12.5">tools/ucrt-ref (from ucrt_harness.c)</text>
+  <text x="36" y="104" fill="#cfd5de" font-size="12.5">genuine DLL × FMA3 on/off, under Wine</text>
+  <text x="36" y="130" fill="#e6e9ee" font-size="13" font-weight="600">Outputs (committed):</text>
+  <text x="36" y="150" fill="#cfd5de" font-size="12.5">• golden vectors per profile</text>
+  <text x="48" y="168" fill="#cfd5de" font-size="12.5">tests/fixtures/math_profiles/*.bin</text>
+  <text x="36" y="188" fill="#cfd5de" font-size="12.5">• exhaustive sinf/cosf scans</text>
+  <text x="48" y="206" fill="#cfd5de" font-size="12.5">→ exception tables</text>
+  <text x="36" y="226" fill="#cfd5de" font-size="12.5">• build → profile map (profiles.toml)</text>
+  <text x="36" y="252" fill="#fcd34d" font-size="12.5">DLLs are never committed;</text>
+  <text x="36" y="270" fill="#fcd34d" font-size="12.5">only versions, hashes and output bits.</text>
+
+  <!-- Single source -->
+  <rect x="330" y="40" width="330" height="330" rx="8" fill="#14243f" stroke="#3b82f6"/>
+  <text x="346" y="64" fill="#e6e9ee" font-size="14" font-weight="600">math/kernels/  (restricted C subset)</text>
+  <text x="346" y="86" fill="#93c5fd" font-size="12.5">the subset gen-sim.py already parses</text>
+  <rect x="346" y="98" width="298" height="122" rx="6" fill="#0f1a2e" stroke="#2b4a7a"/>
+  <text x="358" y="118" fill="#cfd5de" font-size="12.5">musl/   sinf cosf atan2f exp log pow tanh</text>
+  <text x="358" y="138" fill="#cfd5de" font-size="12.5">ucrt/   atan2f log</text>
+  <text x="358" y="158" fill="#cfd5de" font-size="12.5">ucrt/   exp_{a_fma,b_fma,sse2}</text>
+  <text x="358" y="178" fill="#cfd5de" font-size="12.5">ucrt/   pow_{a_fma,a_sse2,b_fma,b_sse2}</text>
+  <text x="358" y="198" fill="#cfd5de" font-size="12.5">ucrt/   tanh_{a,b_fma}   sincos = musl + table</text>
+  <text x="346" y="244" fill="#e6e9ee" font-size="13" font-weight="600">Primitives every backend must provide</text>
+  <text x="346" y="264" fill="#cfd5de" font-size="12.5">add/sub/mul/div (correctly rounded),</text>
+  <text x="346" y="282" fill="#cfd5de" font-size="12.5">fma() explicit and exact, bits casts, select()</text>
+  <text x="346" y="306" fill="#e6e9ee" font-size="13" font-weight="600">profiles.toml</text>
+  <text x="346" y="326" fill="#cfd5de" font-size="12.5">profile → variant per function (the matrix in §1)</text>
+  <text x="346" y="346" fill="#cfd5de" font-size="12.5">+ the UCRT builds each profile stands for</text>
+
+  <!-- Generator -->
+  <rect x="330" y="400" width="330" height="80" rx="8" fill="#1f1530" stroke="#a855f7"/>
+  <text x="346" y="424" fill="#e6e9ee" font-size="14" font-weight="600">wasm/gen-math.py</text>
+  <text x="346" y="446" fill="#d8b4fe" font-size="12.5">reuses gen-sim.py's pycparser front end;</text>
+  <text x="346" y="464" fill="#d8b4fe" font-size="12.5">4 emitters; CI runs it with --check</text>
+  <path d="M495,370 L495,396" stroke="#a855f7" stroke-width="2" marker-end="url(#a2)"/>
+
+  <!-- evidence -> source -->
+  <path d="M300,190 L326,190" stroke="#98a2b3" stroke-width="2" marker-end="url(#a4)"/>
+
+  <!-- Backends -->
+  <g>
+    <rect x="690" y="40" width="270" height="78" rx="8" fill="#1f1530" stroke="#a855f7"/>
+    <text x="706" y="64" fill="#e6e9ee" font-size="14" font-weight="600">Rust scalar (+ WASM CPU)</text>
+    <text x="706" y="84" fill="#d8b4fe" font-size="12.5">src/math/platform/generated.rs</text>
+    <text x="706" y="102" fill="#d8b4fe" font-size="12.5">fma → f64::mul_add (always exact)</text>
+
+    <rect x="690" y="132" width="270" height="78" rx="8" fill="#1f1530" stroke="#a855f7"/>
+    <text x="706" y="156" fill="#e6e9ee" font-size="14" font-weight="600">AVX2 (tanh variants only)</text>
+    <text x="706" y="176" fill="#d8b4fe" font-size="12.5">emitted from branch-free kernels</text>
+    <text x="706" y="194" fill="#d8b4fe" font-size="12.5">fma → _mm256_fmadd_pd / scalar fallback</text>
+
+    <rect x="690" y="224" width="270" height="78" rx="8" fill="#1f1530" stroke="#a855f7"/>
+    <text x="706" y="248" fill="#e6e9ee" font-size="14" font-weight="600">HIP</text>
+    <text x="706" y="268" fill="#d8b4fe" font-size="12.5">gpu/sim/platform_math.h (#include)</text>
+    <text x="706" y="286" fill="#d8b4fe" font-size="12.5">fma → __fma_rn; contract stays off</text>
+
+    <rect x="690" y="316" width="270" height="96" rx="8" fill="#1f1530" stroke="#a855f7"/>
+    <text x="706" y="340" fill="#e6e9ee" font-size="14" font-weight="600">WGSL, one module per profile</text>
+    <text x="706" y="360" fill="#d8b4fe" font-size="12.5">src/wasm/sim/math_&lt;profile&gt;.wgsl</text>
+    <text x="706" y="378" fill="#d8b4fe" font-size="12.5">fma → new f64_fma in f64.wgsl,</text>
+    <text x="706" y="396" fill="#d8b4fe" font-size="12.5">f32 fma via exact f64 product</text>
+  </g>
+  <path d="M660,440 C690,440 670,80 686,80" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#a2)"/>
+  <path d="M660,440 C690,440 672,172 686,172" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#a2)"/>
+  <path d="M660,440 C690,440 674,264 686,264" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#a2)"/>
+  <path d="M660,440 C690,440 676,364 686,364" stroke="#a855f7" stroke-width="2" fill="none" marker-end="url(#a2)"/>
+
+  <!-- Runtime selection -->
+  <rect x="990" y="40" width="190" height="372" rx="8" fill="#12261a" stroke="#22c55e"/>
+  <text x="1004" y="64" fill="#e6e9ee" font-size="14" font-weight="600">MathProfile</text>
+  <text x="1004" y="86" fill="#bbf7d0" font-size="12.5">proton | win10-fma3 |</text>
+  <text x="1004" y="104" fill="#bbf7d0" font-size="12.5">win10-sse2 | win11-fma3 |</text>
+  <text x="1004" y="122" fill="#bbf7d0" font-size="12.5">win11-sse2</text>
+  <text x="1004" y="150" fill="#e6e9ee" font-size="12.5" font-weight="600">SessionOptions</text>
+  <text x="1004" y="168" fill="#bbf7d0" font-size="12.5">mathProfile (default proton)</text>
+  <text x="1004" y="192" fill="#e6e9ee" font-size="12.5" font-weight="600">Checkpoint header</text>
+  <text x="1004" y="210" fill="#bbf7d0" font-size="12.5">records profile; resume</text>
+  <text x="1004" y="228" fill="#bbf7d0" font-size="12.5">rejects a mismatch</text>
+  <text x="1004" y="252" fill="#e6e9ee" font-size="12.5" font-weight="600">Rust</text>
+  <text x="1004" y="270" fill="#bbf7d0" font-size="12.5">Math{profile} passed to</text>
+  <text x="1004" y="288" fill="#bbf7d0" font-size="12.5">world/runner; 21 sites call</text>
+  <text x="1004" y="306" fill="#bbf7d0" font-size="12.5">m.atan2(), m.exp() …</text>
+  <text x="1004" y="330" fill="#e6e9ee" font-size="12.5" font-weight="600">HIP</text>
+  <text x="1004" y="348" fill="#bbf7d0" font-size="12.5">wave-uniform profile arg</text>
+  <text x="1004" y="372" fill="#e6e9ee" font-size="12.5" font-weight="600">WebGPU</text>
+  <text x="1004" y="390" fill="#bbf7d0" font-size="12.5">concat chosen module only</text>
+  <path d="M960,80 L986,80" stroke="#22c55e" stroke-width="2" marker-end="url(#a3)"/>
+  <path d="M960,172 L986,172" stroke="#22c55e" stroke-width="2" marker-end="url(#a3)"/>
+  <path d="M960,264 L986,264" stroke="#22c55e" stroke-width="2" marker-end="url(#a3)"/>
+  <path d="M960,364 L986,364" stroke="#22c55e" stroke-width="2" marker-end="url(#a3)"/>
+
+  <!-- Verification band -->
+  <rect x="20" y="510" width="1160" height="230" rx="8" fill="#171b21" stroke="#22c55e" stroke-dasharray="5 4"/>
+  <text x="36" y="536" fill="#e6e9ee" font-size="15" font-weight="600">⑤ Verification matrix (every profile × every backend, bit-exact)</text>
+  <g font-size="12.5">
+    <rect x="36" y="552" width="260" height="170" rx="6" fill="#0f1a14" stroke="#1f5133"/>
+    <text x="50" y="574" fill="#e6e9ee" font-weight="600">Math level</text>
+    <text x="50" y="596" fill="#bbf7d0">Golden vectors vs. Rust scalar</text>
+    <text x="50" y="616" fill="#bbf7d0">and AVX2 (cargo test).</text>
+    <text x="50" y="640" fill="#bbf7d0">HIP math_kernel op tests</text>
+    <text x="50" y="660" fill="#bbf7d0">gain a profile argument.</text>
+    <text x="50" y="684" fill="#bbf7d0">WGSL: wasm/test/exact.js</text>
+    <text x="50" y="704" fill="#bbf7d0">over the same vectors.</text>
+
+    <rect x="316" y="552" width="260" height="170" rx="6" fill="#0f1a14" stroke="#1f5133"/>
+    <text x="330" y="574" fill="#e6e9ee" font-weight="600">Exhaustive (f32 unary)</text>
+    <text x="330" y="596" fill="#bbf7d0">All 2³² inputs for sinf/cosf</text>
+    <text x="330" y="616" fill="#bbf7d0">per variant: musl + table</text>
+    <text x="330" y="636" fill="#bbf7d0">== genuine DLL. Ignored test,</text>
+    <text x="330" y="656" fill="#bbf7d0">runs under Wine (~45 s/pair),</text>
+    <text x="330" y="676" fill="#bbf7d0">like examples/</text>
+    <text x="330" y="694" fill="#bbf7d0">gpu_engine_scan.rs.</text>
+
+    <rect x="596" y="552" width="260" height="170" rx="6" fill="#0f1a14" stroke="#1f5133"/>
+    <text x="610" y="574" fill="#e6e9ee" font-weight="600">Simulation level</text>
+    <text x="610" y="596" fill="#bbf7d0">Existing CPU↔HIP↔WebGPU</text>
+    <text x="610" y="616" fill="#bbf7d0">parity tests, parameterised</text>
+    <text x="610" y="636" fill="#bbf7d0">by profile. proton goldens</text>
+    <text x="610" y="656" fill="#bbf7d0">must stay byte-identical</text>
+    <text x="610" y="676" fill="#bbf7d0">(refactor guard).</text>
+
+    <rect x="876" y="552" width="290" height="170" rx="6" fill="#0f1a14" stroke="#1f5133"/>
+    <text x="890" y="574" fill="#e6e9ee" font-weight="600">Game level (optional)</text>
+    <text x="890" y="596" fill="#bbf7d0">Windows player records a trace</text>
+    <text x="890" y="616" fill="#bbf7d0">via the game's MCP server; the</text>
+    <text x="890" y="636" fill="#bbf7d0">sim replays it under each profile.</text>
+    <text x="890" y="656" fill="#bbf7d0">The matching profile confirms the</text>
+    <text x="890" y="676" fill="#bbf7d0">setup end to end and can</text>
+    <text x="890" y="696" fill="#bbf7d0">auto-detect a user's profile.</text>
+  </g>
+  <path d="M600,412 L600,505" stroke="#22c55e" stroke-width="2" stroke-dasharray="4 3" marker-end="url(#a3)"/>
+</svg>
+</div>
+<p class="caption">One source per variant, four generated backends, and the profile chosen at run time. The Wine harness that produced the survey becomes the permanent oracle.</p>
+
+<h2>4. Current vs proposed</h2>
+<table>
+  <tr><th style="width:18%">Concern</th><th style="width:41%">Current</th><th>Proposed</th></tr>
+  <tr><td>Platform choice</td><td class="bad">Fixed at compile time: Proton/musl only</td><td class="good"><code>MathProfile</code> chosen per session and recorded in checkpoints; default <code>proton</code></td></tr>
+  <tr><td>Sources of truth</td><td>Rust (reference) + HIP (hand copy) + AVX2 tanh (hand copy)</td><td>One C-subset kernel per variant; Rust, AVX2, HIP and WGSL are generated</td></tr>
+  <tr><td>Cost of one new variant</td><td class="bad">Up to 3 bit-exact hand ports + regenerate WGSL + new fixtures</td><td class="good">1 kernel + 1 line in <code>profiles.toml</code> + regenerated golden vectors</td></tr>
+  <tr><td>FMA</td><td>Forbidden everywhere (<code>-ffp-contract=off</code>); no fma primitive</td><td>Still no implicit contraction; an explicit <code>fma()</code> primitive with an exact implementation on each backend</td></tr>
+  <tr><td>sinf / cosf</td><td>musl port</td><td>musl port + per-variant exception table (6–51k entries), proven over every float32</td></tr>
+  <tr><td>atan2f, exp, log, pow, tanh</td><td>musl ports</td><td>musl + UCRT algorithm ports (can't be proven exhaustively; validated with golden vectors)</td></tr>
+  <tr><td>HIP selection</td><td>n/a</td><td>Profile kernel argument (uniform per launch, so no divergence); template instantiation only if profiling shows register pressure</td></tr>
+  <tr><td>WebGPU selection</td><td>n/a</td><td>Assemble the shader with only the chosen <code>math_&lt;profile&gt;.wgsl</code>, keeping compile cost flat</td></tr>
+  <tr><td>Track generation</td><td>Uses <code>atan2f</code> (random_track.rs, curve.rs)</td><td>Uses the profile too, so generated geometry matches the player's platform</td></tr>
+  <tr><td>Fixtures</td><td>Proton captures only</td><td>Proton captures unchanged + per-profile golden vectors from genuine DLLs (outputs only)</td></tr>
+  <tr><td>Unaffected</td><td colspan="2">x87 <code>engine_sin_cos</code>, .NET <code>managed_sin_cos</code>, all ordinary arithmetic, RNG streams, and <code>pyrandom</code>'s host libm (separate CPython-compat concern)</td></tr>
+</table>
+
+<h2>5. Implementation strategy per function</h2>
+<table>
+  <tr><th>Function</th><th>Approach</th><th>Why</th><th>Proof level</th></tr>
+  <tr><td>sinf, cosf</td><td>musl kernel + sorted exception table + branch-free binary search (existing <code>engine_sin_cos</code> pattern)</td><td>Only 6,254–50,872 of 2³² inputs differ, all 1 ULP; the table is generated from the scan</td><td class="good">Exhaustive</td></tr>
+  <tr><td>atan2f</td><td>Port the UCRT algorithm</td><td>16% of inputs differ, too many for a table, and there are 2 arguments</td><td>Golden vectors</td></tr>
+  <tr><td>tanh</td><td>Port both UCRT variants in branch-free form (also feeds AVX2)</td><td>About 10% of inputs differ; it's the hottest path (inference)</td><td>Golden vectors</td></tr>
+  <tr><td>exp, pow, log</td><td>Port UCRT algorithms; FMA and SSE2 variants differ only where <code>fma()</code> is used</td><td>Double-precision inputs can't be enumerated</td><td>Golden vectors</td></tr>
+</table>
+
+<h2>6. Phased rollout</h2>
+<ol class="phases">
+  <li><b>Phase 0: spike (decides feasibility).</b> Recover the algorithms behind UCRT <code>atan2f</code> and <code>tanh</code>, the two highest-impact functions, and reproduce the golden vectors bit-exactly in a throwaway Rust prototype. Turn <code>ucrt_harness.c</code> and the 56-build survey into <code>tools/ucrt-ref</code>. <i>Exit criterion:</i> 0 differences on golden vectors for both functions on both paths.</li>
+  <li><b>Phase 1: plumbing, no behaviour change.</b> Add <code>MathProfile</code>, <code>SessionOptions.mathProfile</code> and the checkpoint field; route the 21 Rust call sites and the HIP/WGSL call sites through a profile-aware layer that still only knows <code>proton</code>. All existing goldens stay byte-identical.</li>
+  <li><b>Phase 2: single source, no behaviour change.</b> Move the musl kernels into <code>math/kernels/</code>, write <code>gen-math.py</code> with Rust/AVX2/HIP/WGSL emitters, and replace the hand ports with generated code. Guard: exhaustive f32 checks and fixture checks against the old code.</li>
+  <li><b>Phase 3: Windows variants.</b> Add them in order of impact: atan2f, tanh, exp, pow, log, then the sin/cos tables. Add <code>f64_fma</code> to <code>f64.wgsl</code> and the scalar fma fallback for CPUs without FMA.</li>
+  <li><b>Phase 4: parity matrix.</b> Parameterise CPU↔HIP↔WebGPU parity and session regressions by profile; run the full set for <code>proton</code> and one Windows profile in CI, all profiles nightly.</li>
+  <li><b>Phase 5: user-facing.</b> Profile picker in Drive Lab and the CLI (<code>--math-profile</code>), with a short "which one am I?" helper (Windows version, FMA3 support); optional detection from a recorded game trace.</li>
+</ol>
+
+<h2>7. Risks and open questions</h2>
+<div class="grid2">
+  <div class="card">
+    <h3>Deriving the UCRT algorithms <span class="tag">largest risk</span></h3>
+    <p>For atan2f, exp, log, pow and tanh we need Microsoft's actual algorithm, not just its outputs. Studying the binary may conflict with Microsoft's licence terms, and interoperability exceptions vary by jurisdiction, so <b>this needs a decision before Phase 0</b>. Black-box fitting against golden vectors is a fallback, but it may not converge to bit-exactness. One unverified hypothesis: the x64 CRT's transcendentals may share ancestry with AMD's open-source libm. If so, that would be a clean starting point to test against the vectors.</p>
+  </div>
+  <div class="card">
+    <h3>Coverage the survey didn't test</h3>
+    <ul>
+      <li>All results came from one CPU (Zen 4 with AVX-512). It's unknown whether newer builds use AVX-512 paths that CPUs without AVX-512 wouldn't take.</li>
+      <li>FMA3 vs SSE2 was forced with <code>_set_FMA3_enable</code>, not observed on a CPU without FMA3.</li>
+      <li>Windows on ARM (x64 emulation) wasn't tested.</li>
+      <li>Profiles may need splitting if any of these show differences; <code>profiles.toml</code> makes that a data change.</li>
+    </ul>
+  </div>
+  <div class="card">
+    <h3>Performance</h3>
+    <ul>
+      <li>FMA3 profiles on targets without hardware FMA: <code>f64::mul_add</code> on WASM and pre-Haswell CPUs, and <code>f64_fma</code> in WGSL soft-float, are much slower than a multiply plus an add. This mainly affects tanh in inference.</li>
+      <li>The per-call profile <code>match</code> in Rust should be close to free (well predicted); switch to monomorphisation only if benchmarks show otherwise.</li>
+      <li>HIP code size grows with the number of inlined variants. Watch register pressure and occupancy.</li>
+    </ul>
+  </div>
+  <div class="card">
+    <h3>Scope and maintenance</h3>
+    <ul>
+      <li>About 3× more kernels (22 vs 7), but each is written once.</li>
+      <li>Golden vectors grow per profile: keep about 64k inputs per function per profile, so a few MB total.</li>
+      <li>A future UCRT update can add a behaviour group. The survey script reruns in about 2 minutes against Winbindex, so it can become a periodic check.</li>
+      <li>An end-to-end game confirmation still needs a Windows player's trace (Steam blocks running outside Steam).</li>
+    </ul>
+  </div>
+</div>
+
+<p class="caption" style="margin-top:28px">Sources: code at <code>e96a2e8</code> (src/math, src/nn, gpu/sim, wasm/gen-sim.py, src/wasm/sim); UCRT survey data in <code>~/altd-wine/versions/</code> (sweep.json, groupcmp_*.txt, exhaustive_*.txt).</p>
+</main>
+</body>
+</html>

github-simulator/source/docs/performance.md

@@ -0,0 +1,72 @@
+# Performance measurements
+
+All timings below describe the stated hardware and inputs. Generated-track benchmarks in this tree provide a repeatable public workload; historical campaign/checkpoint measurements are retained for context and cannot be reproduced from public assets alone.
+
+## Native CPU baseline
+
+Measured on an AMD Ryzen 9 7950X, Linux x86_64, rustc 1.94 and LLVM 21.1.8, with local `target-cpu=native`. Each workload had an untimed warmup and seven measured samples. Worker processes used eight distinct physical cores. Desktop activity and a concurrent GPU training process remained active.
+
+The fixed bench workloads used 1,024 cars, 3,600 timed ticks, two warmup ticks, a fixed seed/network/model and independent execution. The generated scene used seed 1729, generation zero, slot zero. The random batch used 512 cars, three generations, three tracks per generation, 3,600 ticks per track and eight workers. Random timing includes simulation, turnover and track installation waits. Throughput uses the requested car-tick count; elimination can reduce actual executed work.
+
+| Workload | Workers | Median seconds | Requested car-ticks/s |
+| --- | ---: | ---: | ---: |
+| Captured campaign scene | 1 | 7.474565 | 493,193 |
+| Captured campaign scene | 8 | 0.987717 | 3,732,242 |
+| Generated scene | 1 | 7.508362 | 490,973 |
+| Generated scene | 8 | 1.004230 | 3,670,872 |
+| Random training batch | 8 | 4.673350 | 3,549,660 |
+
+An identical-source repeat changed the medians by -0.15%, -0.95%, +0.06%, -2.33% and -0.37%, respectively. This measures noise; it is not a speedup claim. Public benchmark recipes use different generated geometry and Xavier weights, so their numbers need their own baseline.
+
+```sh
+cargo build --release --offline
+python3 tools/benchmark.py --population 1024 --ticks 3600 --repeats 7 \
+  --threads 1 8 --report target/cpu-benchmark.json
+```
+
+The runner works from any directory, keeps every JSON sample and reports medians. `--scene`, `--spawn-trace`, `--network`, `--model`, `--modes` and `--binary` select another workload. It measures the CLI simulation interval; process launch, loading and the initial population are outside that interval.
+
+## Historical HIP measurements
+
+AMD Radeon RX 7900 XTX, gfx1100, HIP 7.1.52802, ROCm clang 20 and Ryzen 9 7950X with eight Rayon workers. Inputs were a captured Rally campaign scene and a frozen 8,192-network checkpoint, repeated for larger populations. Shape was `20,16,16,16,16,12,12,8,5`, with 1,661 double parameters per car and two inference batches. The desktop remained active.
+
+Full generation medians after one warmup and three measured runs were 2.094 seconds at 8,192 cars, 5.715 at 32,768 and 40.315 at 262,144. Wall and idle elimination were disabled; the 5,400-tick limit ended at statistics callback 5,406. Timers included packing, transfers, simulation and state import, and excluded reset, hashing, reproduction and checkpoint I/O. A later kernel investigation recorded production wall times of about 1.86, 4.93 and 36.2 seconds with unchanged digests, but did not record the same repeated-median protocol. Treat those later values as diagnostic observations.
+
+Separate turnover optimization measurements used three consecutive generations with elimination enabled, one warmup and three timed samples. Complete-generation medians changed from 0.386 to 0.267 seconds at 8,192 cars, 1.154 to 0.790 at 32,768 and 9.663 to 6.336 at 262,144. They include turnover after the third generation and exclude loading, hashing and checkpoint I/O. All 36 before/after generation pairs matched result digests and executed ticks. This workload ended early and must not be compared as a full 5,400-tick run.
+
+Use [GPU tooling](../gpu/README.md) for fresh measurements on generated inputs. A GPU performance gate requires an otherwise idle GPU; these historical results do not establish throughput under concurrent training load.
+
+## Historical browser measurements
+
+Ryzen 9 7950X, Chromium 153.0.8010.12 on Linux, RX 7900 XTX with RADV 26.2.2. A Formula scene used shape `20,16,5`, two inference batches and no elimination. Four 180-tick generations ran per population; the first was warmup and the median of the next three is shown. Complete time includes evolution and coordinator yields. This was one sweep.
+
+| Cars | Serial complete ms | Eight-worker complete ms | WebGPU with eight workers ms |
+| --- | ---: | ---: | ---: |
+| 32 | 12.7 | 4.9 | 365.2 |
+| 256 | 100.4 | 18.3 | 361.5 |
+| 1,024 | 399.5 | 66.1 | 189.0 |
+| 4,096 | 1,657.3 | 263.8 | 647.7 |
+
+At 4,096 cars, eight-worker CPU advancement took 228.9 ms versus 1,577.7 ms serial. Module/pool startup was 14.1 ms serial and 94.5 ms with eight workers. Peak observed linear memory in the largest case was 97.6 MiB serial and 113.7 MiB with eight workers, excluding JavaScript workers, GPU allocations and any separate preview module. These inputs are historical; rerun the [public browser harness](../wasm/README.md) to establish results for the generated scenarios and another browser/device.
+
+## Firefox completion waits — 2026-10-06
+
+Firefox 157 on the local Linux/RX 7900 XTX system reproduced the 30 ticks/s limit. In the public Formula benchmark, six-tick calls took about 200 ms at both 32 and 1,024 cars. At 32 cars, the 120 measured ticks spent 3,975 ms in advancement while GPU timestamps covered only 192 ms. Setting GPU load to 1 retained the same limit, ruling out the configured idle budget as its cause.
+
+The runtime now prompts completion delivery with empty queue submissions every 4 ms while awaiting queued work or mapped readback. It retains the original promises and command order, cancelling the timer after completion, device loss or a submission exception. The earlier workaround was absent from this source tree. The Windows/Proton kernel sources are unchanged by this fix.
+
+| Workload | Cars | Before ticks/s | After ticks/s |
+| --- | ---: | ---: | ---: |
+| Formula, fixed six-tick windows | 32 | 30.19 | 688.07 |
+| Formula, fixed six-tick windows | 1,024 | 30.27 | 259.63 |
+| Normally served app, Rally, adaptive windows | 512 | 29.98 | 249.53 |
+
+Formula used the public default scenario, shape `20,16,5`, Proton, disabled elimination and 120 warmup ticks, with 120 measured ticks at 32 cars and 60 at 1,024 cars. The benchmark records per-pass GPU timestamps. The app used its Test Loop fixture, default shape `20,16,16,12,8,5`, one inference batch, eight CPU workers, Proton, load 0.85 and disabled elimination. App values are medians of the reported rates during a four-second observation; whole-observation rates were 29.88 and 258.92 ticks/s. The final served run used the rebuilt assets without package or runtime overrides. Compilation and startup are excluded. These are diagnostic before/after observations, not repeated benchmark medians.
+
+A separate app comparison completed three generations and 558 ticks with each runtime, using identical rebuilt WASM packages and changing only the JavaScript completion waits. Checkpoint bytes, every population network, terminal car states, summaries and stable generation logs matched exactly. The completed outcome SHA-256 was `7086f0ce5b7f555d7bc2d7a4ef5c2db321d71ebb3c21dd93eaa9324ffa02eedc`. Time through the third turnover changed from 18,688 ms to 1,405 ms; the adaptive pump used 90 calls before and 37 after.
+
+Two additional runs through normally served assets completed the same 558 ticks in 2,339 and 2,385 ms, with identical outcomes and stable logs. A prior diagnostic run with package routing reported 1,143 ticks/s; the normal served measurements above provide the conservative result. One initial instrumented run stalled while waiting for its generation outcome. Its detailed phase was not captured, and the stall did not recur in the three subsequent completed comparisons; its cause remains unresolved.
+
+Three alternating Chromium 153 comparisons kept the WASM, shader, Win11 profile, 1,024 active cars and 120-tick bulk windows identical, changing only the completion-wait runtime. Median wall time was 355.4 ms before and 355.0 ms after. Background GPU activity was present before browser launches, so these observations do not measure isolated peak throughput.
+
+Both serial and threaded production packages were rebuilt. Full Firefox simulation comparisons passed for all three profiles: 184,558 checks, zero mismatches. The Node completion-wait regression suite passes 16 tests against the fixed runtime; the frozen original runtime fails nine of them. See [the browser commands](../wasm/README.md) to repeat the Formula workload or run the regression suite without a GPU.

github-simulator/source/docs/reviews/2026-10-05-native-server-review.md

@@ -0,0 +1,51 @@
+# Native server implementation review
+
+Date: 2026-10-05
+
+Two independent reviewers used GPT-6.1-sol at ultra effort. The native comparison starts at `origin/main`, commit `0852de991c6e6e2d9868f74346bb0ac9d3260774`. The companion webapp comparison starts at `aebb7ab` and ends at `e99e65541cb502302a32ac2d1bdc4d53b9aee0a9`, branch `t3code/native-simulator-client`. The webapp repository has no configured remote.
+
+The spec is [the approved native server design](../superpowers/specs/2026-10-05-native-server-design.md). Standards sources include `docs/design.md` and the code-review skill's code-smell baseline. The reviewers checked the implementation, then reviewed the fixes below.
+
+## Standards
+
+The reviewer found no hard coding-standard violations or actionable code smells. The correctness review found that an ordinary HIP window error could panic and abort the release server. The new Session path returns errors from world creation, simulator creation, world replacement, network upload, state transfers and window execution. Unsupported scenes and networks fall back during initialization or verification.
+
+The follow-up review found leaked resources after partial GPU constructor failures. Constructors now retain ownership before copying and release partial allocations before returning null. World cleanup excludes borrowed host pointers; simulator cleanup leaves its borrowed World intact.
+
+The final review reports no remaining correctness findings, hard coding-standard violations or actionable code smells.
+
+## Spec
+
+The reviewer found that a hidden layer wider than HIP's 16 inference lanes could abort the server rather than fall back. The HIP path now validates its network limits before upload; verification restores the initial runner state before CPU fallback. Real-socket regressions cover a 32-wide hidden layer and a scene without physics shapes.
+
+The device-name export was incorrectly mandatory. Older compatible libraries now probe device availability through the legacy math function and report the loaded library path. A real-socket HIP training test passed with a library that lacks the name export.
+
+The worker now ignores queued pause and resume commands after a run fails or finishes. A deterministic browser test injects an ordinary native RPC error, checks the saved failed state, and resumes from its checkpoint. Removing the guards makes that test fail.
+
+The final review confirms the constructor cleanup and fault-injection coverage, with no remaining high-confidence spec findings.
+
+## Initial validation
+
+- Rust debug and release suites: 173 passed and five existing tests ignored in each.
+- Real-socket server suite: ten passed, including CPU parity, binary/JSON checkpoints, invalid requests, Origin/Host checks, HIP claim release and unsupported HIP fallback.
+- Actual RX 7900 XTX Session checks passed for CPU/HIP parity, restart, restore, track replacement, population growth and fallback.
+- Constructor cleanup passed all 38 World and 21 simulator injected failures, plus successful and null destruction. The same harness detects a leak in the previous library. ROCm CI runs it without a GPU.
+- Native and WASM Clippy, Rust 1.93 all-target compilation, formatting and rustdoc passed.
+- Serial and threaded WASM builds passed. CPU reference comparison checked 2,773 values with zero mismatches.
+- Webapp build, TypeScript, 31 unit tests, immutable asset publication and formatting passed.
+- Full browser suite: 45 passed, five conditional tests skipped. All ten native integration cases passed.
+- Hardware WebGPU training, partial-window CPU fallback and contact/reproduction parity checks passed.
+
+Remaining findings: Standards 0; Spec 0. Native/WASM last-bit differences remain tracked in [issue #3](https://github.com/Zorro909/driving_sim_rs/issues/3).
+
+## Size limits and platform follow-up
+
+The user requested removal of all size constraints for local simulator connections. The server now has no configured WebSocket frame or message ceiling. The companion frontend change is commit `432e7da` on `t3code/native-simulator-client`. Native settings bypass browser network, population, stage, file and checkpoint limits while retaining valid values and shared checkpoint field widths. Unsupported HIP shapes continue on native CPU.
+
+Large checkpoints, run metadata and imported tracks use 32 MiB IndexedDB chunks, with replacement and deletion in one transaction. Database version 4 closes older connections before writing the new format. Review found and fixed the unchunked track path, oversized plan edits after browser fallback, and incompatible readers in old tabs. Startup failures with no training history can restart when the local simulator returns.
+
+Both reviewers rereviewed these fixes with no remaining findings. The frontend build, TypeScript, formatting, 35 unit tests and immutable asset checks passed. The full browser suite passed 52 tests with five expected skips, including all 13 native cases and four storage cases. Storage regressions round-trip checkpoints, metadata and tracks above 127 MiB and check rollback, replacement, deletion and schema migration.
+
+Platform CI exposed x87 precision-dependent large-angle reduction on Windows, a host-specific Xavier checksum on macOS, and ARM default NaN signs. The fixes preserve captured bits rather than relax comparisons. The macOS Xavier oracle compares every parameter and RNG bit with same-host CPython. Session tests retain exact Linux GNU goldens and compare both execution modes with the legacy Runner on every host, including exact checkpoint replay.
+
+The final native release suite passed 176 tests with five existing tests ignored. All 35 vehicle tests passed under AArch64 QEMU after reproducing the macOS distance-sensor failure. Debug/release sensor checks and Darwin Clippy passed. Fresh serial/threaded WASM builds passed, with 2,773 CPU reference values and zero mismatches. The rebuilt frontend passed asset checks and all 13 native integration cases again.

github-simulator/source/docs/server.md

@@ -0,0 +1,102 @@
+# Local simulator server
+
+`altd-sim serve` exposes native `Session` simulation over a WebSocket. A client can use Rayon CPU threads or request the AMD HIP backend. The server implements the protocol for Drive Lab's planned native client; the webapp integration is a separate change.
+
+The server owns one session per connection. Clients own run storage, checkpoints, logs, stage changes and mutation schedules. Closing the socket drops its session.
+
+## Starting the server
+
+The default Cargo features include `server`. CPU use needs no ROCm installation. Build the HIP library separately using [the GPU guide](../gpu/README.md).
+
+```sh
+cargo build --release --offline
+target/release/altd-sim --threads 8 serve
+target/release/altd-sim serve --port 47800 \
+  --allow-origin http://127.0.0.1:5173
+```
+
+| Flag | Default and effect |
+| --- | --- |
+| `--port N` | `47800`; binds only `127.0.0.1:N` |
+| `--allow-origin ORIGIN` | `https://drivinglab.jectrum.de`; repeat to allow several origins, replacing the default list |
+| `--threads N` | Global flag; sizes the Rayon pool shared by all CPU sessions, with CPU affinity as the default |
+| `--math-profile PROFILE` | Global flag; the math profile of sessions whose options name none. Without it, the server detects the profile of its own machine |
+
+Allowed origins use `http://host[:port]` or `https://host[:port]`, with an ASCII hostname or IP address. Startup normalizes scheme and host case, compresses IPv6 addresses, removes a trailing slash and omits default ports. Paths, credentials, query strings and fragments are rejected. Startup prints the listening URL, allowed origins, CPU thread count, HIP availability and the default math profile.
+
+## Connection checks
+
+Connect to `ws://127.0.0.1:47800/v1`, substituting the configured port. The handshake returns HTTP 403 unless all checks pass:
+
+- The request path is `/v1`.
+- `Origin` is present and exactly matches an allowed origin. Different schemes or ports do not match; `null` is rejected.
+- `Host` names `127.0.0.1` or `localhost` with the listening port. Other hostnames are rejected to prevent DNS rebinding.
+
+There is no LAN binding, TLS or authentication token. These checks restrict browser callers; a local program can supply its own headers. At most 64 connections (including incomplete handshakes) may be active. Excess sockets are closed before spawning a worker. Handshake socket reads/writes time out after 5 seconds; established socket reads/writes after 10 minutes of blocked I/O. Long-running generation computation is not subject to those socket timeouts. Connection-worker spawn failures reject that connection while retaining the accept loop. Requests run in order on a dedicated connection thread, with no per-request timeout. Incoming frames and assembled messages are each limited to 64 MiB, including binary checkpoint headers/payloads. Equal limits allow a browser to send an admissible message in one frame: JavaScript WebSocket.send cannot select continuation framing. Larger messages must be split into protocol-level operations; fragmenting a message does not bypass its assembled limit. A rejected oversized frame/message closes only that connection. A generation may take minutes.
+
+## Protocol 1
+
+The first frame is a JSON text greeting:
+
+```json
+{"type":"hello","protocol":1,"version":"1.1.0","threads":8,"carStateStride":14,"carStateFields":["x","y","..."],"hip":{"available":true,"device":"AMD Radeon RX 7900 XTX","platform":"HIP"},"mathProfile":"proton","mathProfiles":["proton","win10-fma3","win11-fma3"]}
+```
+
+Read `carStateStride` and `carStateFields` from the greeting rather than hard-coding them. The example's fields are abbreviated. `platform` is `"HIP"` for the AMD library and `"CUDA"` for the NVIDIA one. When HIP is unavailable, `hip` instead contains `{"available":false,"reason":"..."}`. Availability means the process opened the library and device; a particular session can still fall back to CPU. `mathProfile` is the default math profile and `mathProfiles` lists every profile a session can choose; [math profiles](../math/README.md) documents their runtime variants.
+
+Requests use an unsigned integer `id`, an operation name and optional `args`:
+
+```json
+{"id":7,"op":"advance","args":{"ticks":180,"stopWhenInactive":true}}
+```
+
+A successful reply contains the same `id`, its result in `ok` and the current `state`. An error reply contains `id` and `error`, without `state`.
+
+```json
+{"id":7,"ok":180,"state":{"started":true,"generation":0,"tick":180,"population":256,"activeCount":256,"checkpointGeneration":0,"backend":"cpu","backendNote":null,"mathProfile":"proton"}}
+```
+
+`checkpointGeneration` identifies the restorable generation boundary, or is `null` before starting. It need not describe the current tick. `backend` reports what actually runs; `backendNote` explains a CPU fallback. `mathProfile` is the session's math profile. Clients can queue requests and match replies by `id`.
+
+### Operations
+
+| Operation | `args` | `ok` |
+| --- | --- | --- |
+| `create` | `scene`, `network`, `model` as JSON strings; optional `options` as a SessionOptions object | `{backend, backendNote, mathProfile}` |
+| `start` | None; seeds training from the `create` network export | `null` |
+| `startWithShape` | `shape` as an array of unsigned 32-bit integers | `null` |
+| `restoreCheckpointBytes` | Binary payload, no arguments required | `null` |
+| `restoreCheckpointJson` | `json` as a checkpoint JSON string | `null` |
+| `advance` | `ticks`, `stopWhenInactive` | Executed ticks |
+| `advanceGeneration` | `timeLimitTicks` | Executed ticks |
+| `nextGeneration` | None | `{preservedCount, rewards}` |
+| `setEvolutionSettings` | `json` as an evolution-settings JSON string; `algorithm` is `"ga"` or `"ars"` (see design notes) | `null` |
+| `replaceTrack` | `scene` as a scene JSON string | `null` |
+| `generationSummary` | None | `{bestIndex, bestScore, lapped, active, lapIndex, lapTime}`, optional `averageScore` and `worstScore` |
+| `networkJson` | `index` | Network JSON string |
+| `carStates` | None | Number of `f64` values, with a binary payload |
+| `checkpointBytes` | None | `null`, with a binary payload |
+
+Call `create` once, then start or restore before advancing. `options.backend` accepts `"cpu"`, the default, or `"hip"`. `options.mathProfile` accepts `"proton"`, `"win10-fma3"` or `"win11-fma3"` and defaults to the server's profile; checkpoints restore only into sessions of the profile they were made with. Other SessionOptions fields retain their regular defaults and unknown fields are rejected. A second successful `create` on the same connection is an error. Unknown operations and malformed JSON return errors while leaving the connection usable.
+
+`start` uses the export's `weights` and `biases` as the seed, matching `train-scratch --init-network` and the browser simulator. GA breeds mutations of that seed; ARS samples around it as its initial search point. Without weights, `start` draws a Xavier seed from `shape` (or `summary.shape`). Without either weights or a shape, use `startWithShape`. Malformed weighted exports return an error before starting and leave the connection usable.
+
+### Binary frames
+
+`restoreCheckpointBytes` requests and `carStates` or `checkpointBytes` replies use a binary WebSocket frame:
+
+```text
+[u32 little-endian JSON byte length][UTF-8 JSON header][raw payload]
+```
+
+The header has the same request or reply shape as a text frame. `carStates` payloads contain little-endian `f64` values, grouped by the greeting's stride and field order. Checkpoint payloads use the shared Session checkpoint format. All other operations use text frames. Invalid binary framing closes the connection.
+
+## HIP fallback and resume
+
+Only one session can hold the HIP device per process. Another HIP request runs on CPU with `backendNote: "another session is using the GPU"`. Library/device errors, native broadphase tracks and unsupported path sensors also cause CPU fallback with a reason. HIP requires physics shapes and at least two path points. Networks support up to 12 layers, 32 inputs and 16 neurons in each later layer; wider CPU networks fall back during verification.
+
+Before a HIP session's first driving window after a start or restore, it compares 12 ticks against CPU from the same state, then restores that state. A mismatch or verification error drops HIP and runs the requested window on CPU. Track replacement uploads the new world and repeats verification before driving. Read `state.backend` after advancing because it may change from the `create` result.
+
+HIP cars and agents stay on the device between windows; an `advance` or `advanceGeneration` reply reads back only the active car count. `generationSummary`, `carStates`, turnover, restores and track replacement read the population back into the CPU runner first; checkpoints are saved from the generation boundary and need no readback. Turnover breeds on CPU to retain the parent records in format-2 checkpoints, then uploads the new networks and cars on the next HIP window. HIP libraries without `altd_gpu_sim_active_count` read the population back after every window. Checkpoints can move between native CPU, HIP and WASM sessions. Native and WASM training have known last-bit differences, so continued training may diverge after switching engines.
+
+HIP errors after startup verification return request errors without retrying. The client should stop the run and resume from its last saved checkpoint. A closed connection loses the server's session; reconnect, create a new session and restore a saved checkpoint. Release builds use `panic = "abort"`, so a panic terminates the server and closes every connection.

github-simulator/source/docs/superpowers/specs/2026-10-05-native-server-design.md

@@ -0,0 +1,322 @@
+# Native simulator server for Drive Lab
+
+Date: 2026-10-05
+Status: implemented and reviewed
+
+## Goal
+
+Drive Lab (`driving_webapp_public`) trains in the browser on WASM, optionally with the WebGPU raycaster, and that stays the default. Users who also run the native `altd-sim` binary should be able to train faster with it: on native CPU threads without the browser's 8-thread cap and WASM overhead, or on an AMD GPU through the existing HIP simulator.
+
+The browser talks to the native binary over a WebSocket on `127.0.0.1`. By default only `https://drivinglab.jectrum.de` may connect; a CLI argument replaces that list.
+
+### Success criteria
+
+- With `altd-sim serve` running and the setting enabled, a user can create a run with backend "Native CPU" or "Native GPU (HIP)". It trains, saves checkpoints and logs to IndexedDB, and pauses, resumes and changes stages exactly as WASM runs do.
+- A native run's checkpoint resumes on WASM and the other way round. The format is shared; results are not bit-identical, see "Known limitation".
+- No request reaches the server from an origin that is not allowed, or with a `Host` other than the loopback address and port.
+- When the server is missing, unreachable or crashes, the user gets a clear message and the run falls back or resumes as the existing WebGPU and WASM-trap paths do.
+- A HIP session matches a native CPU session exactly in car state, as the existing HIP checks require, or falls back to CPU with a reason.
+
+### Non-goals
+
+- The server does not own runs, storage or the stage, plateau and mutation-schedule logic; those stay in the webapp's coordinator worker.
+- No remote or LAN access, TLS or authentication tokens.
+- No HIP version of the parent-recording turnover (see "Turnover"); that is a later optimization.
+- WASM/native bit-exactness is tracked separately in issue #3.
+
+## Architecture
+
+```
+Page (main thread)            Coordinator worker                    altd-sim serve (127.0.0.1)
+ ├─ setting + status probe ──► (hello only, then close) ──────────►  ├─ handshake: Origin + Host check
+ └─ TrainingWorker ──────────► simulation.worker.ts                  ├─ one thread per connection
+                                ├─ training loop (unchanged)          └─ one Session per connection
+                                ├─ Engine interface                        ├─ backend: cpu (rayon)
+                                │   ├─ WasmEngine (Simulation, WebGPU)     └─ backend: hip (libaltd_gpu.so)
+                                │   └─ RemoteEngine ── WebSocket ──►
+                                └─ IndexedDB (runs, logs, checkpoints)
+```
+
+The server works as a remote `Simulation`. The worker keeps its training loop and swaps the local `Simulation` for an object that sends the same calls over the socket.
+
+## Part 1: HIP backend in `Session` (`driving_sim_rs`)
+
+### Native access to Session methods
+
+Some `Session` items exist only in WASM builds and must also be compiled for the server:
+
+- `options` field (`src/training/session.rs:76`)
+- `set_evolution_settings` (`:313`)
+- `replace_track` (`:653`)
+- the `network` field the WASM build keeps
+
+Their cfg changes from "wasm" to "wasm or `server` feature". The server module lives in the library (`src/server/`) so it can use the `pub(crate)` methods directly.
+
+### Backend option
+
+`SessionOptions` gains `backend: "cpu" | "hip"` (camelCase JSON, default `"cpu"`). `deny_unknown_fields` stays.
+
+- On wasm32, `"hip"` is an error: "the HIP backend is only available in the native simulator".
+- On native, `Session` gains `hip: Option<HipState>`:
+
+```rust
+struct HipState {
+    world: GpuWorld<'static>,
+    sim: GpuSim<'static>,
+}
+static GPU: OnceLock<Result<Gpu, String>> = OnceLock::new(); // Gpu::open(None): ALTD_GPU_LIB or the default path
+```
+
+The `Gpu` handle is opened once per process and never dropped, so a `Session` can own `'static` GPU handles without self-borrowing.
+
+### When HIP is refused
+
+`Session::new` builds `HipState` only when all of these hold. Otherwise it keeps `hip = None` and records a reason that the server reports, and the session runs on CPU.
+
+- `GPU` opened successfully.
+- The track does not use the native broadphase (`runner.physics` would be `Some`); `advance_window_gpu` rejects it.
+- `runner.gpu_sim(...)` succeeds. It already rejects path sensors without `track.curve`.
+
+Population-dependent capacity is handled on the first window (below), so construction does not need the population.
+
+### Routing
+
+| Session call | CPU | HIP |
+|---|---|---|
+| `advance(ticks, stop)` | `runner.advance` | `runner.advance_window_gpu(sim, world, ticks, stop, None)` |
+| `advance_generation(limit)` | `runner.advance_generation` | `runner.advance_generation_gpu(sim, world, limit)` |
+| `next_generation()` | `next_generation_traced` | the same CPU path (see "Turnover") |
+| `replace_track(scene)` | as today | as today, then `GpuWorld::new(gpu, &runner.world)` and `sim.set_world(&world)` |
+| `start*`, `restore_checkpoint*`, `set_network_json` | as today | as today, then `sim.network_tag = None` |
+
+Each HIP window reads car and agent state back into `runner.agents`, so `car_states`, `generation_summary`, `network_json`, `metrics`, `active_count` and checkpoints read the runner as they do now.
+
+If the population is larger than `GpuSim`'s capacity, `GpuSim` is rebuilt with the new population before the window.
+
+### Turnover
+
+`next_generation_gpu` breeds on the GPU but does not produce the parent record (`Lineage`) that format 2 checkpoints store. A HIP session therefore breeds through `next_generation_traced` on the CPU, the same call CPU sessions make. The next window uploads the new networks because `network_tag` no longer matches. Breeding is small next to a generation of driving. A HIP turnover that also records parents can come later if profiling shows it matters.
+
+### Startup check
+
+A HIP session checks itself before its first real window, following `GpuSimulation::verify` in `src/wasm/sim/mod.rs:186-235`:
+
+1. Back up `runner.agents`, `tick` and `batch_index`.
+2. Advance 12 ticks on the CPU and record the canonical state (`canonical_state`, moved from `src/wasm/sim` into shared native and WASM code).
+3. Restore the backup, run 12 ticks on HIP, and compare canonical states exactly.
+4. Restore the backup again.
+
+On a mismatch or HIP error, the session drops `HipState` and continues on CPU with the reason "HIP verification differs from the CPU simulator" (or the error). It runs once per session, on the first `advance` or `advance_generation` after `start*` or `restore*`.
+
+`Session` exposes `backend() -> "cpu" | "hip"` and `backend_note() -> Option<String>`, so hosts can report what actually runs.
+
+### Errors
+
+HIP failures after the check, such as a failed window, are returned as `Err(String)` and not retried. The webapp fails the run, and resuming continues from the last checkpoint.
+
+## Part 2: `altd-sim serve`
+
+### Crate layout
+
+- Feature `server = ["cli", "dep:tungstenite"]`, added to `default`. `tungstenite` is the synchronous WebSocket crate without TLS features, so there is no async runtime.
+- `src/server/mod.rs`: listener, handshake checks and the per-connection loop.
+- `src/server/protocol.rs`: message types and frame encoding.
+- `src/server/dispatch.rs`: operations to `Session` calls.
+- `src/bin/altd-sim`: a `Serve` subcommand that parses flags and calls `altd_sim::server::run(config)`.
+
+### Flags
+
+```
+altd-sim [--threads N] serve [--port 47800] [--allow-origin ORIGIN]...
+```
+
+- `--port`: TCP port, default `47800`. The server binds `127.0.0.1:<port>` only.
+- `--allow-origin`: repeatable. When given, the list replaces the default `https://drivinglab.jectrum.de`. Values are normalized as `scheme://host[:port]`, and invalid values are rejected at startup. Local development uses `--allow-origin http://127.0.0.1:5173`.
+- `--threads`: the existing global flag; it sizes the rayon pool all CPU sessions share.
+
+On startup the server prints the address, allowed origins, thread count and HIP availability.
+
+### Handshake checks
+
+`tungstenite::accept_hdr` with a callback that rejects with HTTP 403 and a short plain-text reason unless all hold:
+
+- The path is `/v1`.
+- `Origin` is present and equals an allowed origin exactly (scheme, host and port). `null` is rejected.
+- `Host` is `127.0.0.1:<port>` or `localhost:<port>`.
+
+### Greeting
+
+Sent as the first text frame after the handshake:
+
+```json
+{"type":"hello","protocol":1,"version":"0.1.0","threads":32,
+ "carStateStride":N,"carStateFields":["..."],
+ "hip":{"available":true,"device":"..."} | {"available":false,"reason":"..."}}
+```
+
+Checking HIP availability calls `GPU.get_or_init` once per process. `device` comes from the HIP library if it exposes a name; otherwise it is the library path.
+
+### Requests and replies
+
+- Request (text frame): `{"id":7,"op":"advance","args":{"ticks":180,"stopWhenInactive":true}}`
+- Success: `{"id":7,"ok":<result>,"state":State}`
+- Failure: `{"id":7,"error":"<text>"}`
+- `State` is `{"started","generation","tick","population","activeCount","checkpointGeneration","backend","backendNote"}`.
+
+Requests are handled strictly in order on the connection's thread. Clients may send the next request before the reply arrives and match replies by `id`.
+
+### Binary frames
+
+Used by `restoreCheckpointBytes` (request), and by `checkpointBytes` and `carStates` (replies):
+
+```
+[u32 little-endian: JSON length][JSON header][raw payload]
+```
+
+The JSON header has the same shape as a text frame. `carStates` returns little-endian `f64` values. All other messages are text frames.
+
+### Operations
+
+| op | args | ok |
+|---|---|---|
+| `create` | `scene`, `network`, `model` (JSON strings), `options` (SessionOptions object, including `backend`) | `{backend, backendNote}` |
+| `startWithShape` | `shape: number[]` | `null` |
+| `restoreCheckpointBytes` | binary payload | `null` |
+| `restoreCheckpointJson` | `json: string` | `null` |
+| `advance` | `ticks`, `stopWhenInactive` | executed ticks |
+| `advanceGeneration` | `timeLimitTicks` | executed ticks |
+| `nextGeneration` | none | `{preservedCount, rewards: number[]}` |
+| `setEvolutionSettings` | `json: string` | `null` |
+| `replaceTrack` | `scene: string` | `null` |
+| `generationSummary` | none | `{bestIndex, bestScore, lapped, active, lapIndex, lapTime}` |
+| `networkJson` | `index` | string |
+| `carStates` | none | binary `f64` payload |
+| `checkpointBytes` | none | binary payload |
+
+Rules:
+
+- Any op before `create`, or a second `create`, is an error.
+- Only one HIP session may exist per process at a time. A second `create` with `backend: "hip"` falls back to CPU with the note "another session is using the GPU".
+- Unknown ops and malformed JSON are errors and leave the session usable. Malformed binary framing closes the connection.
+- The session is dropped when the socket closes.
+
+### Panics and timeouts
+
+The release profile keeps `panic = "abort"`, so a panic ends the server. The client sees the socket close (see "Disconnect" below), and a session that panicked part-way would not be trustworthy anyway. There is no per-request timeout, because `advanceGeneration` can take minutes on large populations.
+
+## Part 3: webapp client (`driving_webapp_public`)
+
+### Setting and status
+
+- In `#compute-choices` (`src/views.ts` `computeChoices`, wired in `src/main.ts` `bindCompute`), above the backend radios:
+  - a "Use a local altd-sim" checkbox and a port input;
+  - help text with the command `altd-sim serve` and the note that the browser may ask once for local network access.
+- The setting is stored in `localStorage` (`drivelab.native` = `{enabled, port}`) and is per machine.
+- When enabled, the page opens a WebSocket to `ws://127.0.0.1:<port>/v1`, reads `hello`, closes it, and shows one of:
+  - "Connected: altd-sim 0.1.0 · 32 threads · HIP: <device>"
+  - "Not reachable on port N"
+  - "Update altd-sim: protocol N is not supported"
+
+  It probes again when the setting changes and whenever the compute choices are drawn. The page timeout is 3 s.
+- New radios:
+  - "Native CPU · N threads": enabled when connected.
+  - "Native GPU (HIP) · device": enabled when `hip.available`, otherwise disabled with the server's reason.
+  - Both carry the note "Results differ slightly from in-browser training", linking to issue #3.
+- When the selected native backend becomes unavailable while the user is editing a draft, the draft switches to `"cpu"`, as WebGPU does in `main.ts:115`.
+
+### Domain and protocol
+
+- `Setup.backend` becomes `"cpu" | "webgpu" | "native-cpu" | "native-hip"`.
+- `validateSetup` accepts the new values; run summaries and the "Computing on" line show "Native CPU, N threads" and "Native GPU (HIP), <device>".
+- `StartCommand` gains `native?: { port: number }`, set by the page from the setting.
+- The `engine` event's `backend` gains `"native-cpu" | "native-hip"` and an optional `device`.
+
+### Engine interface (`src/engine.ts`)
+
+```ts
+interface Engine {
+  readonly started: boolean; readonly generation: number; readonly tick: number;
+  readonly population: number; readonly activeCount: number;
+  readonly checkpointGeneration: number | undefined;
+  startWithShape(shape: Uint32Array): Promise<void>;
+  restoreCheckpointBytes(bytes: Uint8Array): Promise<void>;
+  restoreCheckpointJson(json: string): Promise<void>;
+  advance(ticks: number, stopWhenInactive: boolean): Promise<number>;
+  advanceGeneration(timeLimitTicks: number): Promise<number>;
+  nextGeneration(): Promise<void>;
+  setEvolutionSettings(json: string): Promise<void>;
+  replaceTrack(sceneJson: string): Promise<void>;
+  generationSummary(): Promise<Summary>;
+  networkJson(index: number): Promise<string>;
+  carStates(): Promise<Float64Array>;
+  checkpointBytes(): Promise<Uint8Array>;
+  free(): void;
+}
+```
+
+- `WasmEngine` wraps `lib.Simulation` and holds the existing WebGPU logic (`prepareGpu`, `dropGpu`, the GPU-to-CPU fallback in `advance`).
+- `RemoteEngine` opens the socket, checks `hello.protocol === 1`, sends `create`, and updates the cached getters from every reply's `state`. Its getters are synchronous because they return those cached values.
+- `simulation.worker.ts` replaces `sim` and `gpu` with one `engine: Engine` and adds `await` to the calls that become asynchronous. The training loop, storage queue, stage logic and messages are otherwise unchanged.
+- The WASM library still loads for every backend, because `trackScene` and `randomTrackScene` run in the worker.
+
+### Fallback and disconnect
+
+- **Server unreachable at `buildSession`, `hello` rejected, or `create` failing:** the run uses `WasmEngine` on CPU and emits an `engine` event with a note, for example "The local altd-sim could not be reached on port 47800, so this run trains in the browser. <reason>".
+- **HIP refused or failing its check:** the server reports `backend: "cpu"` with `backendNote`, and the worker emits `engine` `native-cpu` with that note.
+- **Disconnect during a run:** `RemoteEngine` rejects all pending and future calls with "The native simulator closed the connection. Resuming continues from the last saved checkpoint." The worker treats this like a WASM trap: it sets `trapped`, so `publishRun(true)` skips `checkpointBytes`, marks the run failed, stores it, and reports the error. Resuming goes through the same start path, including the fallback above.
+
+### Content Security Policy
+
+Add `ws://127.0.0.1:*` to `connect-src` in `public/_headers` and in `vite.config.ts`. `deploy/deploy.sh` reads `_headers`, and `scripts/serve-test.mjs` reads the same policy. COOP/COEP do not apply to WebSocket connections.
+
+## Known limitation
+
+WASM and native CPU are not bit-exact (issue #3). Native CPU and HIP are expected to be exact with each other, and the startup check enforces it. Cross-engine resume works through the shared checkpoint format, but continued training diverges. The UI says so next to the native choices.
+
+## Testing
+
+### `driving_sim_rs`
+
+- **Unit:**
+  - origin normalization and matching: exact, different port, different scheme, trailing slash, `null`, missing;
+  - Host matching;
+  - binary frame encode and decode, including truncated frames;
+  - `SessionOptions` with `backend` (`"hip"` rejected on wasm by a cfg test).
+- **Integration (`tests/server.rs`):** start the server in-process on port 0 and connect with a `tungstenite` client.
+  - A disallowed origin and a wrong Host get 403.
+  - `hello` contents.
+  - `create → startWithShape → advance → advanceGeneration → nextGeneration → generationSummary → carStates → checkpointBytes → restoreCheckpointBytes` matches a direct `Session` with the same inputs bit for bit.
+  - Ops before `create` and a second `create` return errors.
+  - A dropped socket frees the session.
+- **HIP (skipped when `Gpu::open` fails):**
+  - a CPU and a HIP `Session` agree in canonical state through several `advance` windows, `advanceGeneration` and two turnovers;
+  - a checkpoint saved under HIP restores under CPU, and the other way round;
+  - fallback reasons for native broadphase and a missing curve;
+  - a second concurrent HIP session falls back to CPU.
+- Existing tests: `cargo test`, the WASM parity harness, and a WASM build that confirms the cfg changes do not leak native-only code.
+
+### `driving_webapp_public`
+
+- Domain tests: `validateSetup` with the new backends.
+- Playwright (`tests/native.spec.ts`): build `altd-sim` from `SIM_ROOT` and start `altd-sim serve --port <free> --allow-origin http://127.0.0.1:<test port>`.
+  - The setting shows "Connected".
+  - A two-generation Native CPU run stores progress and a checkpoint, with the correct engine event.
+  - Setting enabled with no server: the run falls back to CPU with a note.
+  - Killing the server mid-run fails the run with the disconnect message; restarting the server and resuming continues from the checkpoint.
+  - CSP permits the socket.
+  - The HIP case is skipped unless the server reports HIP available.
+
+## Documentation
+
+- `docs/server.md`: purpose, flags, security model, the protocol (greeting, ops, frames) and fallback behavior.
+- `docs/cli.md`: the `serve` subcommand.
+- `docs/gpu.md`: HIP through `Session`, and CPU turnover with network re-upload.
+- Webapp `README.md`: the setting, the CSP change and native testing.
+
+## Delivery order
+
+1. HIP backend in `Session`, with its tests. Independently useful; no server needed.
+2. `altd-sim serve` and the protocol, with integration tests (CPU, then HIP).
+3. Webapp client, CSP and Playwright tests.
+
+Each phase lands with green tests before the next starts.

github-simulator/source/docs/wasm.md

@@ -0,0 +1,27 @@
+# WASM and WebGPU fidelity notes
+
+The serial and threaded packages compile the same Session and TrainingRunner code. The threaded package rebuilds Rust's standard library with atomics and uses `wasm-bindgen-rayon`; it requires an initialized worker pool before constructing worlds or invoking Rayon. Both packages preserve the existing arithmetic and RNG algorithms.
+
+Three comparisons answer different questions:
+
+- Native versus WASM state/reference checks catch portability differences in the exported fields.
+- Serial versus threaded WASM checks cover states, sensors, controls, metrics, rewards, summaries and binary checkpoints, including exchange between the two packages.
+- WebGPU versus WASM checks validate query or full-window device results against the WASM CPU implementation.
+
+Expanded native parity is incomplete. On the public generated Formula scenario, serial and threaded WASM matched each other in 253,341 values per mode, including the optional score aggregates, but both differed from native in 2,285 values per mode. Those differences comprised 703 controls, 405 metrics and 1,177 checkpoint bytes. The original captured-scene baseline had 2,532 native differences with the same exact serial/threaded equality. Counts depend on the scenario, build and checkpoint representation. `STRICT_NATIVE=1` makes the browser test fail on any expanded native difference.
+
+## Device arithmetic
+
+The WebGPU raycaster keeps simulation on the CPU and casts rays or nearest-wall queries on-device. Explicit float32 rounding boundaries prevent fusion and reassociation. Division corrects a hardware estimate using an exact integer remainder, with an integer-loop fallback; square root and software binary64 division use the same principle. Full `GpuSimulation` also implements binary64 arithmetic in integer WGSL operations and keeps network accumulation ordered.
+
+Historical RX 7900 XTX checks with RADV 26.2.2 matched 65,536 rays and 65,536 nearest-wall points per scenario, and millions of in-simulation rays across Formula and three Rally scenes. A newer baseline repeated a smaller 4,000-query corpus and 119,743 in-simulation rays with zero differences. The public replacements contain four distinct generated tracks and native current-code references, not game-oracle captures.
+
+WGSL permits device-dependent subnormal and NaN behavior. Raw division fixtures check signed zero, subnormal boundaries, infinities and broad exponent coverage; NaN payloads are treated as equivalent in that arithmetic diagnostic. Simulation comparisons retain exact values and count differences without substituting CPU results. Results on one GPU do not validate every browser adapter.
+
+## Runtime and memory
+
+Threaded WASM uses imported shared memory and a 2 GiB growth ceiling. This is a maximum, not an initial allocation. Workers need stack and TLS memory; an application's separately loaded preview module has its own memory. Shared-memory packages require cross-origin isolation and complete generated helper snippets.
+
+A host must await GPU windows before mutating the Session. A failed full-GPU window keeps the last committed WASM state so it can continue on CPU. Paused physics and native shared broadphase are unsupported by full WebGPU. The raycaster has one readback per tick; full simulation batches bounded windows, which changes the population size at which device work can pay off.
+
+[The WASM guide](../wasm/README.md) contains build commands, initialization and the browser harness. [Performance notes](performance.md) distinguish CPU worker scaling, startup and WebGPU measurements.

github-simulator/source/gpu/README.md

@@ -0,0 +1,105 @@
+# GPU backends (AMD HIP, NVIDIA CUDA)
+
+The GPU library runs whole driving generations on an AMD GPU (HIP) or an NVIDIA GPU (CUDA, see below). Captured CPU/HIP checks compare simulation values, population parameters, RNG state and checkpoint bytes exactly. Rust owns evolution and checkpoint I/O; both backends can resume the same generation-boundary checkpoints. See [fidelity](../docs/fidelity.md) for the scope of that evidence.
+
+## Build and use
+
+Linux release archives include `libaltd_gpu.so` beside `altd-sim`, built with ROCm 7.1 for the targets in `release-targets`. They need a ROCm 7.x runtime that provides `libamdhip64.so.7`, but no compiler. `altd-sim gpu-info` reports the loaded library. To build the library yourself, install ROCm with `hipcc`, then build from the repository root:
+
+```sh
+gpu/build.sh
+cargo build --release --offline
+
+target/release/altd-sim --threads 8 train-scratch --gpu \
+  --scene assets/scenes/rally_template.json --track-mode random \
+  --random-track-settings assets/random_track_settings.json \
+  --population 256 --generations 3 --ticks 600 --seed 1729 \
+  --eliminate-on-wall --idle-eliminate --out-dir runs/gpu-example
+```
+
+`OUT` overrides the library output directory, default `target/gpu`. `GPU_ARCH` lists one or more architectures separated by commas or spaces, default `gfx1100` for RX 7900 XTX; `rocminfo` reports a GPU's name. `GPU_ARCH="$(cat gpu/release-targets)"` builds the release library for every consumer target.
+
+`--gpu` and `gpu-info` load `ALTD_GPU_LIB` when set. Otherwise they try `libaltd_gpu.so` beside the executable, then `target/gpu` of the checkout that built the binary. Load errors list each attempted path.
+
+| Targets | GPUs |
+| --- | --- |
+| gfx803, gfx900, gfx902, gfx906, gfx909, gfx90c | Polaris and Vega: RX 470-590, Vega 56/64, Radeon VII, Vega APUs |
+| gfx1010-gfx1013 | RDNA1: RX 5500-5700 XT |
+| gfx1030-gfx1036 | RDNA2: RX 6400-6950 XT, Steam Deck, Radeon 610M/680M |
+| gfx1100-gfx1103, gfx1150-gfx1153 | RDNA3 and RDNA3.5: RX 7600-7900 XTX, Radeon 780M/890M, Strix Halo |
+| gfx1200, gfx1201 | RDNA4: RX 9060/9070 |
+
+The ROCm 7.1 runtime officially supports fewer consumer GPUs than this list; the remaining targets are best effort. The captured CPU/HIP equivalence checks have run on gfx1100 only. The script verifies the checked-in double tables against their Rust bit patterns without rewriting tracked files. `python3 gpu/gen_tables.py --output PATH` writes a header explicitly; `--check` validates it.
+
+The compiler flags `-ffp-contract=off` and `-fhip-fp32-correctly-rounded-divide-sqrt` preserve separate multiply/add rounding and correctly rounded float32 division/square root. Explicit `fma` calls in Windows kernels still fuse and round once. Keep these flags when changing architecture. The native crate loads the library at runtime, so CPU-only builds do not require ROCm.
+
+## Math profiles
+
+Each library contains `proton`, `win10-fma3` and `win11-fma3`; a build selects GPU architectures, while each simulation selects its math profile. `--math-profile win11-fma3` works with `--gpu` on Linux, for example. Without that flag the CLI detects its host profile; resumed scratch runs retain the saved profile. Server sessions use `options.mathProfile`, defaulting to the server's profile. [Math profiles](../math/README.md) documents the shared Windows kernels and the existing musl implementations.
+
+## NVIDIA (CUDA)
+
+The same sources build for NVIDIA GPUs with `nvcc`; `sim/compat.h` maps the HIP runtime calls and warp helpers to CUDA. HIP and CUDA use the same library ABI and checkpoint formats: `--gpu`, `gpu-info` and `backend: "hip"` use whichever library is loaded. Math profiles require simulator ABI 10, so rebuild older libraries. Install the CUDA toolkit (13.x tested) and a host compiler (Visual Studio Build Tools on Windows, gcc or clang on Linux), then build from the repository root:
+
+```sh
+gpu/build-cuda.sh                  # Linux, writes target/gpu/libaltd_gpu.so
+gpu/build-cuda.ps1                 # Windows, writes target/gpu/altd_gpu.dll
+```
+
+`OUT` overrides the output directory. `CUDA_ARCH` defaults to `native`, which builds for the GPUs of the build machine. Without a GPU, nvcc 13.4 warns and builds `sm_75` code and PTX instead, which newer GPUs compile at load time. To build for other GPUs, or several, list `sm_` targets separated by commas or spaces; `nvidia-smi --query-gpu=compute_cap --format=csv` reports the number, so 8.6 is `sm_86`. A list also embeds PTX for its newest target, which the driver compiles at load time for a newer GPU. CUDA 13 builds for Turing (`sm_75`, RTX 20 series) and newer only; older GPUs need a CUDA 12 toolkit, which is untested. Both scripts check the double tables with `gpu/gen_tables.py --check` (`python3` on Linux, the `py` launcher or `python` on Windows). The binary loads `ALTD_GPU_LIB`, then the library beside the executable, then `target/gpu`, as on AMD. `altd-sim gpu-info` runs one kernel when a GPU is present, so a library built for another GPU fails there with HIP error 209.
+
+nvcc rejects a Visual Studio newer than the toolkit supports. `gpu/build-cuda.ps1 -AllowUnsupportedCompiler` (or `CUDA_ALLOW_UNSUPPORTED_COMPILER=1`) builds anyway with a warning; NVIDIA has not validated that combination, so run the checks below before trusting the library.
+
+`-fmad=false` is the CUDA counterpart of `-ffp-contract=off`; keep it, and keep nvcc's default correctly rounded float32 division and square root (no `-use_fast_math`, no `-ftz=true`). NVIDIA arithmetic also replaces every NaN result with its canonical NaN, so the places where the CPU returns a NaN operand or the x86 default NaN call `altd_nan_operand` and `altd_invalid` from `sim/compat.h`, which build those bits explicitly on both vendors.
+
+All three math profiles passed primitive and simulation checks on an RTX 3060 Ti (sm_86, Linux, CUDA 13.0); see the [verification report](../math/verification.md). Earlier Proton baseline checks passed on an RTX 4070 Laptop (sm_89, Windows, CUDA 13.4), and on Linux on an RTX 2070 (sm_75, driver 580) and an RTX 3060 (sm_86, driver 595) with `build-cuda.sh` libraries from CUDA 13.4: `native`, and `sm_75,sm_86`. They also passed with a CUDA 13.0 `sm_75` library run through its PTX (`CUDA_FORCE_PTX_JIT=1`). On those three GPUs the baseline `train-scratch --gpu` checkpoints were byte-identical to the CPU's. The driver compiles PTX only from a toolkit no newer than itself, so PTX for newer GPUs needs a driver at least as new as the CUDA toolkit that built the library. Consumer NVIDIA GPUs run float64 at 1/64 of their float32 rate, which bounds the network forward pass. A Windows GPU that drives a display kills kernels that run for more than a couple of seconds; the windowed launches stay well below that in the checks above.
+
+## Execution model
+
+GPU driving uses tick-major execution for independent cars. Native shared broadphase and paused windows are unsupported. Generated CLI tracks disable shared broadphase. Track preparation runs on a CPU producer with a bounded queue; `--track-buffer-size` sets its depth, default eight. Population/network buffers stay allocated while each fresh track replaces geometry.
+
+## Validation and measurements
+
+```sh
+cargo build --release --offline --example gpu_check
+target/release/examples/gpu_check --help
+target/release/examples/gpu_check schedules
+```
+
+The default check fixture is a fixed generated Rally track and seeded Xavier networks. `ALTD_GPU_SCENE`, `ALTD_GPU_SPAWN`, `ALTD_GPU_NETWORK`, `ALTD_GPU_MODEL` and `ALTD_GPU_CKPT` select explicit inputs or a saved population. No captured campaign scene is required. `gpu_check --help` lists primitive, query, sensing, inference, physics and generation checks. Exhaustive parts can take minutes.
+
+`gpu_check math` compares primitives under all three profiles with the CPU. `ALTD_GPU_MATH` selects the simulation fixture's profile, default `proton`. Run complete simulation checks for each profile on the library's actual GPU:
+
+```sh
+for profile in proton win10-fma3 win11-fma3; do
+  ALTD_GPU_MATH="$profile" ALTD_GPU_LIB=target/gpu/libaltd_gpu.so \
+    target/release/examples/gpu_check \
+      rays sensors infer step stats window schedules reuse novelty turnover
+done
+```
+
+Run benchmarks on an otherwise idle GPU:
+
+```sh
+RAYON_NUM_THREADS=8 python3 gpu/benchmark.py \
+  --library target/gpu/libaltd_gpu.so --cars 8192 32768 \
+  --samples 5 --warmups 1 --no-elimination --output target/gpu-fixed.json
+RAYON_NUM_THREADS=8 python3 gpu/benchmark.py --training \
+  --library target/gpu/libaltd_gpu.so --cars 8192 --samples 5 \
+  --output target/gpu-training.json
+```
+
+The runner keeps every sample and validates result digests. `--checkpoint DIR` selects a saved population; omitting it uses the fixed Xavier recipe. `--scene`, `--spawn-trace`, `--network`, `--model` and `--binary` override inputs. Fixed-window timing excludes fixture construction, reset, hashing and reproduction; training timing includes consecutive generation turnover. Elimination can finish early, so inspect executed ticks before comparing results.
+
+`gpu/profile.sh` collects phase timings, optional rocprofv3 traces/counters and diagnostic kernel builds. `--only 1,2`, `--sizes "8192 32768"`, `--checkpoint DIR` and `--output target/profile` select the work. Profiling changes execution behavior; final timing should run with profiling disabled. [Performance notes](../docs/performance.md) retain measured hardware results.
+
+| Variable | Effect |
+| --- | --- |
+| `ALTD_GPU_LIB` | Runtime shared-library path |
+| `ALTD_GPU_MATH` | Math profile of `gpu_check` simulation fixtures |
+| `ALTD_GPU_GRAPH=0` | Direct launches instead of HIP graph replay |
+| `ALTD_GPU_SPLIT=0` | Fused instead of split physics |
+| `ALTD_GPU_PROFILE=1` | Device phase timings; `host` reports host/wall time only |
+| `ALTD_TRAIN_PROFILE=1` | CPU reproduction, installation and transfer timings |
+
+[Implementation notes](../docs/gpu.md) explain batching, graph lifetime, exact reduction order and memory costs. `gpu_engine_scan` is an exhaustive native/GPU trigonometry developer tool; it requires an explicit thread count and output header, and is not part of the regular test suite.

github-simulator/source/gpu/benchmark.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Benchmark identical GPU generations; build examples/gpu_check first."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import statistics
+import subprocess
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--library", type=Path, required=True)
+    parser.add_argument("--cars", type=int, nargs="+", default=[8192, 32768, 262144])
+    parser.add_argument("--ticks", type=int, default=5400)
+    parser.add_argument("--samples", type=int, default=3)
+    parser.add_argument("--warmups", type=int, default=1)
+    parser.add_argument("--no-elimination", action="store_true")
+    parser.add_argument("--training", action="store_true", help="include turnover across consecutive generations")
+    parser.add_argument("--generations", type=int, default=3)
+    parser.add_argument("--binary", type=Path, help="gpu_check executable (also supports saved baselines)")
+    parser.add_argument("--checkpoint", type=Path, help="saved train-scratch population; otherwise use the fixed generated fixture")
+    parser.add_argument("--scene", type=Path, help="explicit scene instead of the generated track")
+    parser.add_argument("--spawn-trace", type=Path, help="spawn trace for an explicit scene")
+    parser.add_argument("--network", type=Path, help="sensor/control names")
+    parser.add_argument("--model", type=Path, help="vehicle sensor model")
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    for key, variable in [("checkpoint", "ALTD_GPU_CKPT"), ("scene", "ALTD_GPU_SCENE"),
+                          ("spawn_trace", "ALTD_GPU_SPAWN"), ("network", "ALTD_GPU_NETWORK"),
+                          ("model", "ALTD_GPU_MODEL")]:
+        value = getattr(args, key)
+        if value is not None:
+            os.environ[variable] = str(value.resolve())
+    root = Path(__file__).resolve().parent.parent
+    library = args.library.resolve()
+    binary = args.binary.resolve() if args.binary else root / "target/release/examples/gpu_check"
+    if args.samples < 1 or args.warmups < 0 or args.generations < 1:
+        parser.error("samples and generations must be positive; warmups must be nonnegative")
+    if args.training and args.no_elimination:
+        parser.error("the training benchmark uses the fixture's elimination settings")
+    report = {
+        "benchmark": "training" if args.training else "fixed_generation",
+        "binary": str(binary),
+        "binary_sha256": hashlib.sha256(binary.read_bytes()).hexdigest(),
+        "library": str(library),
+        "library_sha256": hashlib.sha256(library.read_bytes()).hexdigest(),
+        "requested_ticks": args.ticks,
+        "rayon_threads": os.environ.get("RAYON_NUM_THREADS", "default"),
+        "graph": os.environ.get("ALTD_GPU_GRAPH", "default"),
+        "split": os.environ.get("ALTD_GPU_SPLIT", "default"),
+        "profile": os.environ.get("ALTD_GPU_PROFILE", "off"),
+        "training_profile": os.environ.get("ALTD_TRAIN_PROFILE", "off"),
+        "generations": args.generations if args.training else 1,
+        "samples": args.samples,
+        "warmups": args.warmups,
+        "eliminate": not args.no_elimination,
+        "results": [],
+    }
+    report["fixture_inputs"] = {key: os.environ[key] for key in [
+        "ALTD_GPU_CKPT", "ALTD_GPU_SCENE", "ALTD_GPU_SPAWN", "ALTD_GPU_NETWORK", "ALTD_GPU_MODEL"
+    ] if key in os.environ}
+    if "ALTD_GPU_CKPT" in os.environ:
+        checkpoint = Path(os.environ["ALTD_GPU_CKPT"])
+        metadata = json.loads((checkpoint / "checkpoint.json").read_text())
+        report["checkpoint_sha256"] = hashlib.sha256((checkpoint / metadata["population_file"]).read_bytes()).hexdigest()
+    else:
+        report["population_recipe"] = {"initialization": "Xavier", "seed": 1, "shape": [20,16,16,16,16,12,12,8,5]}
+    for cars in args.cars:
+        env = dict(os.environ, ALTD_GPU_LIB=str(library), ALTD_GPU_BENCH_CARS=str(cars),
+                   ALTD_GPU_BENCH_TICKS=str(args.ticks), ALTD_GPU_BENCH_SAMPLES=str(args.samples),
+                   ALTD_GPU_BENCH_WARMUPS=str(args.warmups),
+                   ALTD_GPU_BENCH_GENERATIONS=str(args.generations),
+                   ALTD_GPU_BENCH_ELIMINATE=str(int(not args.no_elimination)))
+        command = [str(binary), "benchtrain" if args.training else "benchfixed"]
+        records = []
+        for sample in range(args.warmups + args.samples if args.training else 1):
+            trial = []
+            with subprocess.Popen(command, cwd=root, env=env, stdout=subprocess.PIPE, text=True) as process:
+                for line in process.stdout:
+                    print(line, end="", flush=True)
+                    if line.startswith("{"):
+                        record = json.loads(line)
+                        if args.training:
+                            record.update(sample=sample, warmup=sample < args.warmups)
+                        trial.append(record)
+                if process.wait():
+                    raise SystemExit(f"benchmark failed for {cars} cars")
+            if args.training and [r["generation"] for r in trial] != list(range(args.generations)):
+                raise SystemExit("missing training generations")
+            records.extend(trial)
+        if args.training:
+            generations = []
+            for generation in range(args.generations):
+                runs = [r for r in records if r["generation"] == generation]
+                timed = [r for r in runs if not r["warmup"]]
+                if len(timed) != args.samples or len({r["digest"] for r in runs}) != 1:
+                    raise SystemExit("missing samples or inconsistent training results")
+                generations.append({"generation": generation, "digest": runs[0]["digest"], **{
+                    "median_" + key: statistics.median(r[key] for r in timed)
+                    for key in ["simulate_seconds", "turnover_seconds", "total_seconds"]}})
+            timed = [sum(r["total_seconds"] for r in records if r["sample"] == sample) / args.generations
+                     for sample in range(args.warmups, args.warmups + args.samples)]
+            result = {"cars": cars, "median_seconds": statistics.median(timed), "generations": generations, "runs": records}
+        else:
+            timed = [r["seconds"] for r in records if not r["warmup"]]
+            if len(timed) != args.samples or len({r["digest"] for r in records}) != 1:
+                raise SystemExit("missing samples or inconsistent results")
+            result = {"cars": cars, "median_seconds": statistics.median(timed), "runs": records}
+        report["results"].append(result)
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(json.dumps(report, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    main()

github-simulator/source/gpu/build-cuda.ps1

@@ -0,0 +1,55 @@
+# Build altd_gpu.dll (the GPU simulator parts) for NVIDIA GPUs into $OUT.
+# CUDA_ARCH is native (the default: the GPUs of this machine; without one nvcc warns and uses
+# sm_75) or one or more sm_ targets separated by commas or spaces. A list also embeds PTX for its
+# newest target, which the driver compiles at load time for newer GPUs.
+# -fmad=false: nvcc otherwise fuses a*b+c into FMA, which rounds once. Keep the default
+# -prec-div=true -prec-sqrt=true -ftz=false and never use -use_fast_math.
+# -AllowUnsupportedCompiler (or CUDA_ALLOW_UNSUPPORTED_COMPILER=1) passes -allow-unsupported-compiler
+# to nvcc for a Visual Studio newer than the CUDA toolkit supports. NVIDIA has not validated that
+# combination; run the CPU/GPU checks in gpu/README.md before trusting the result.
+param(
+    [string]$Out = $(if ($env:OUT) { $env:OUT } else { Join-Path $PSScriptRoot "..\target\gpu" }),
+    [string]$Arch = $(if ($env:CUDA_ARCH) { $env:CUDA_ARCH } else { "native" }),
+    [switch]$AllowUnsupportedCompiler = ($env:CUDA_ALLOW_UNSUPPORTED_COMPILER -eq "1")
+)
+$ErrorActionPreference = "Stop"
+New-Item -ItemType Directory -Force $Out | Out-Null
+$Out = (Resolve-Path $Out).Path
+
+# The py launcher first: python3 on Windows is often the Microsoft Store placeholder.
+$tables = Join-Path $PSScriptRoot "gen_tables.py"
+if (Get-Command py -ErrorAction SilentlyContinue) { py -3 $tables --check } else { python $tables --check }
+if ($LASTEXITCODE -ne 0) { throw "gen_tables.py --check failed" }
+
+if ($Arch -eq "native") {
+    $archFlags = "-arch=native"
+} else {
+    $targets = @($Arch -split '[,\s]+' | Where-Object { $_ })
+    if (-not $targets) { throw "CUDA_ARCH lists no targets" }
+    $bad = @($targets | Where-Object { $_ -notmatch '^sm_\d+$' })
+    if ($bad) { throw "CUDA_ARCH target $($bad[0]) is not sm_NN (or the whole value native)" }
+    $numbers = @($targets | ForEach-Object { [int]($_ -replace '^sm_', '') })
+    $newest = ($numbers | Measure-Object -Maximum).Maximum
+    $archFlags = (@($numbers | ForEach-Object { "-gencode=arch=compute_$_,code=sm_$_" }) +
+        "-gencode=arch=compute_$newest,code=compute_$newest") -join " "
+}
+
+$unsupported = ""
+if ($AllowUnsupportedCompiler) {
+    Write-Warning "building with -allow-unsupported-compiler: NVIDIA has not validated this Visual Studio with this CUDA toolkit"
+    $unsupported = "-allow-unsupported-compiler"
+}
+
+# nvcc needs the MSVC host compiler environment; load it unless cl.exe is already on PATH.
+$src = Join-Path $PSScriptRoot "sim\altd_gpu.hip"
+$dll = Join-Path $Out "altd_gpu.dll"
+$prefix = ""
+if (-not (Get-Command cl -ErrorAction SilentlyContinue)) {
+    $vw = Join-Path ([Environment]::GetFolderPath("ProgramFilesX86")) "Microsoft Visual Studio\Installer\vswhere.exe"
+    $vs = & $vw -products * -latest -property installationPath
+    $prefix = "`"$(Join-Path $vs 'VC\Auxiliary\Build\vcvars64.bat')`" >nul && "
+}
+$cmd = "${prefix}nvcc -x cu -O3 -std=c++20 -fmad=false $unsupported $archFlags -shared -Xcompiler /MD -o `"$dll`" `"$src`""
+cmd /c $cmd
+if ($LASTEXITCODE -ne 0) { throw "nvcc failed" }
+Write-Host "built $dll for $Arch"

github-simulator/source/gpu/build-cuda.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# Build libaltd_gpu.so (the GPU simulator parts) for NVIDIA GPUs into $OUT.
+# CUDA_ARCH is native (the default: the GPUs of this machine; without one nvcc warns and uses
+# sm_75) or one or more sm_ targets separated by commas or spaces. A list also embeds PTX for its
+# newest target, which the driver compiles at load time for newer GPUs.
+# -fmad=false: nvcc otherwise fuses a*b+c into FMA, which rounds once. Keep the default
+# -prec-div=true -prec-sqrt=true -ftz=false and never use -use_fast_math.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+OUT="${OUT:-$HERE/../target/gpu}"
+mkdir -p "$OUT"
+python3 "$HERE/gen_tables.py" --check
+CUDA_ARCH="${CUDA_ARCH:-native}"
+ARCH_FLAGS=()
+if [ "$CUDA_ARCH" = native ]; then
+    ARCH_FLAGS=("-arch=native")
+else
+    newest=0
+    for arch in ${CUDA_ARCH//,/ }; do
+        if ! [[ "$arch" =~ ^sm_[0-9]+$ ]]; then
+            echo "CUDA_ARCH target $arch is not sm_NN (or the whole value native)" >&2
+            exit 1
+        fi
+        ARCH_FLAGS+=("-gencode=arch=compute_${arch#sm_},code=$arch")
+        if [ "${arch#sm_}" -gt "$newest" ]; then newest="${arch#sm_}"; fi
+    done
+    if [ "${#ARCH_FLAGS[@]}" -eq 0 ]; then
+        echo "CUDA_ARCH lists no targets" >&2
+        exit 1
+    fi
+    ARCH_FLAGS+=("-gencode=arch=compute_$newest,code=compute_$newest")
+fi
+nice -n 19 nvcc -x cu -O3 -std=c++20 -fmad=false "${ARCH_FLAGS[@]}" -shared -Xcompiler -fPIC \
+    -o "$OUT/libaltd_gpu.so" "$HERE/sim/altd_gpu.hip"
+echo "built $OUT/libaltd_gpu.so for ${CUDA_ARCH}" >&2

github-simulator/source/gpu/build.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Build libaltd_gpu.so (the GPU simulator parts) into $OUT.
+# GPU_ARCH lists one or more offload targets separated by commas or spaces.
+# -ffp-contract=off: hipcc otherwise fuses a*b+c into FMA, which rounds once.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+OUT="${OUT:-$HERE/../target/gpu}"
+mkdir -p "$OUT"
+python3 "$HERE/gen_tables.py" --check
+GPU_ARCH="${GPU_ARCH:-gfx1100}"
+ARCH_FLAGS=()
+for arch in ${GPU_ARCH//,/ }; do
+    ARCH_FLAGS+=("--offload-arch=$arch")
+done
+if [ "${#ARCH_FLAGS[@]}" -eq 0 ]; then
+    echo "GPU_ARCH lists no targets" >&2
+    exit 1
+fi
+nice -n 19 hipcc -O3 -ffp-contract=off "${ARCH_FLAGS[@]}" -fPIC -shared -std=c++20 -fhip-fp32-correctly-rounded-divide-sqrt \
+    -o "$OUT/libaltd_gpu.so" "$HERE/sim/altd_gpu.hip" -lamdhip64
+echo "built $OUT/libaltd_gpu.so for ${ARCH_FLAGS[*]#--offload-arch=}" >&2

github-simulator/source/gpu/gen_tables.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Translate src/math/double_math_tables.rs into gpu/sim/double_tables.h.
+
+Only bit patterns are copied, so the GPU tables equal the CPU ones exactly.
+"""
+import argparse
+from pathlib import Path
+import re
+import sys
+
+HERE = Path(__file__).resolve().parent
+source = (HERE.parent / "src/math/double_math_tables.rs").read_text()
+out = [
+    "// Generated by gpu/gen_tables.py from src/math/double_math_tables.rs. Do not edit.",
+    "#pragma once",
+    "#include <cstdint>",
+]
+
+
+def c_type(rust):
+    dims = []
+    while rust.startswith("["):
+        inner, count = re.fullmatch(r"\[(.*);(\d+)\]", rust).groups()
+        dims.insert(0, count)
+        rust = inner
+    base = {"f64": "double", "u64": "uint64_t"}[rust]
+    return base, "".join(f"[{d}]" for d in reversed(dims))
+
+
+def c_value(rust, top_level=True):
+    """Keep the header layout independent of Rust source formatting."""
+    rust = re.sub(r"\s+", "", rust)
+    if rust.startswith("["):
+        values = []
+        start = 1
+        depth = 0
+        for index, char in enumerate(rust[1:-1], start=1):
+            if char in "[(":
+                depth += 1
+            elif char in "])":
+                depth -= 1
+            elif char == "," and depth == 0:
+                values.append(c_value(rust[start:index], False))
+                start = index + 1
+        if start < len(rust) - 1:
+            values.append(c_value(rust[start:-1], False))
+        separator = ",\n" if top_level else ","
+        edge = "\n" if top_level else ""
+        return "{" + edge + separator.join(values) + edge + "}"
+    if match := re.fullmatch(r"f64::from_bits\((0x[0-9a-f]+)\)", rust):
+        return f"__builtin_bit_cast(double, (uint64_t){match[1]}ull)"
+    if re.fullmatch(r"0x[0-9a-f]+|0", rust):
+        return rust + "ull"
+    raise ValueError(f"unsupported table value: {rust}")
+
+
+for name, rust_type, value in re.findall(r"pub(?:\([^)]*\))? const (\w+): ([^=]+?) = (.*?);\n", source, re.S):
+    base, dims = c_type(rust_type.replace(" ", ""))
+    value = c_value(value)
+    out.append(f"__device__ constexpr {base} {name}{dims} = {value};")
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--output", type=Path, default=HERE / "sim/double_tables.h")
+parser.add_argument("--check", action="store_true", help="check the selected header without writing it")
+args = parser.parse_args()
+generated = "\n".join(out) + "\n"
+if args.check:
+    if not args.output.is_file() or args.output.read_text() != generated:
+        parser.exit(1, f"{args.output} is stale; run python3 gpu/gen_tables.py\n")
+    print(f"verified {args.output}", file=sys.stderr)
+else:
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(generated)
+    print(f"wrote {args.output}", file=sys.stderr)

github-simulator/source/gpu/profile.sh

@@ -0,0 +1,225 @@
+#!/usr/bin/env bash
+# Interactive profiling wizard for the GPU simulator. Collects, into one
+# directory, everything needed to see where a generation's time goes:
+#
+#   1  built-in per-phase GPU time (ALTD_GPU_PROFILE=1) and split/fused wall clock
+#   2  per-kernel durations with rocprofv3 (kernel trace + stats)
+#   3  hardware counters of the physics/sensor/forward kernels with rocprofv3
+#   4  step-section cycle counts (a -DALTD_STEP_TIMING library) and kernel resources
+#   5  forward-pass attribution: diagnostic libraries with parts of the network
+#      kernel removed (-DALTD_FORWARD_DIAG), and the scalar tanh for an A/B
+#
+# Every step is optional and failures are recorded, not fatal. Run from anywhere:
+#   gpu/profile.sh              # asks before each level
+#   gpu/profile.sh --yes        # accept every default without asking
+#   gpu/profile.sh --only 1,2   # run only these levels, without asking
+#   gpu/profile.sh --sizes "8192 32768"   # populations (default: 8192 32768 262144)
+#   gpu/profile.sh --checkpoint runs/example  # optional saved population
+#   gpu/profile.sh --output target/profile    # results directory
+#
+set -u
+HERE="$(cd "$(dirname "$0")" && pwd)"
+REPO="$(cd "$HERE/.." && pwd)"
+cd "$REPO"
+
+YES=0; ONLY=""; SIZES="8192 32768 262144"; PROFILE_OUT=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --yes|-y) YES=1 ;;
+    --only) ONLY="$2"; shift ;;
+    --sizes) SIZES="$2"; shift ;;
+    --checkpoint) export ALTD_GPU_CKPT="$2"; shift ;;
+    --output) PROFILE_OUT="$2"; shift ;;
+    -h|--help) sed -n '2,19p' "$0"; exit 0 ;;
+    *) echo "unknown option $1" >&2; exit 2 ;;
+  esac
+  shift
+done
+
+OUT="${PROFILE_OUT:-$REPO/prof-$(date +%Y%m%d-%H%M)}"
+mkdir -p "$OUT"
+OUT="$(cd "$OUT" && pwd)"
+LOG="$OUT/README.txt"
+CHECK="target/release/examples/gpu_check"
+LIB="${ALTD_GPU_LIB:-$REPO/target/gpu/libaltd_gpu.so}"
+export RAYON_NUM_THREADS="${RAYON_NUM_THREADS:-8}"
+# Keep the integrated GPU (the Ryzen's gfx1036) out of every run.
+export HIP_VISIBLE_DEVICES="${HIP_VISIBLE_DEVICES:-0}" ROCR_VISIBLE_DEVICES="${ROCR_VISIBLE_DEVICES:-0}"
+
+bold() { printf '\033[1m%s\033[0m\n' "$*"; }
+note() { printf '%s\n' "$*" | tee -a "$LOG"; }
+ask() { # ask "question" default(y|n) -> returns 0 for yes
+  local q=$1 d=$2 a
+  if [ "$YES" = 1 ]; then a=$d; else
+    if [ "$d" = y ]; then read -r -p "$q [Y/n] " a </dev/tty; a=${a:-y}; else read -r -p "$q [y/N] " a </dev/tty; a=${a:-n}; fi
+  fi
+  [[ $a =~ ^[Yy] ]]
+}
+want_level() { # level number: honoured --only, else asks
+  local n=$1 title=$2
+  if [ -n "$ONLY" ]; then
+    [[ ",$ONLY," == *",$n,"* ]] || return 1
+    echo; bold "Level $n: $title"; return 0
+  fi
+  echo; bold "Level $n: $title"; ask "Run level $n?" y
+}
+# run_logged <name> <command...>: runs, times, records the exit code; stdout+stderr to $OUT/<name>.txt
+run_logged() {
+  local name=$1; shift
+  local start=$SECONDS
+  printf '  %-44s' "$name"
+  "$@" > "$OUT/$name.txt" 2>&1
+  local rc=$?
+  local secs=$((SECONDS - start))
+  if [ $rc -eq 0 ]; then echo "ok    (${secs}s)"; else echo "FAILED rc=$rc (${secs}s), see $name.txt"; fi
+  echo "$name: rc=$rc seconds=$secs :: $*" >> "$LOG"
+  return $rc
+}
+bench_env() { # bench_env cars eliminate [extra VAR=val ...]
+  local cars=$1 elim=$2; shift 2
+  echo env ALTD_GPU_BENCH_CARS="$cars" ALTD_GPU_BENCH_ELIMINATE="$elim" ALTD_GPU_BENCH_WARMUPS=0 ALTD_GPU_BENCH_SAMPLES=1 "$@"
+}
+
+bold "GPU profiling wizard, output in $OUT"
+{
+  echo "altd GPU profiling run $(date -Iseconds)"
+  echo "repo: $REPO  git: $(git rev-parse --short HEAD 2>/dev/null) $(git status --short 2>/dev/null | wc -l) modified files"
+  echo "library: $LIB"; echo "checkpoint: ${ALTD_GPU_CKPT:-generated Xavier population}"; echo "sizes: $SIZES  rayon threads: $RAYON_NUM_THREADS"
+  echo
+} > "$LOG"
+
+# ---- preflight -------------------------------------------------------------
+echo; bold "Preflight"
+missing=0
+for tool in cargo hipcc rocminfo python3; do
+  if command -v "$tool" >/dev/null; then echo "  $tool: $(command -v "$tool")"; else echo "  $tool: MISSING"; missing=1; fi
+done
+if command -v rocprofv3 >/dev/null; then HAVE_ROCPROF=1; echo "  rocprofv3: $(command -v rocprofv3)"; else HAVE_ROCPROF=0; echo "  rocprofv3: missing (levels 2 and 3 will be skipped)"; fi
+[ $missing = 1 ] && { echo "install the missing tools first"; exit 1; }
+if [ -n "${ALTD_GPU_CKPT:-}" ] && [ ! -f "$ALTD_GPU_CKPT/checkpoint.json" ]; then
+  echo "  checkpoint: $ALTD_GPU_CKPT/checkpoint.json not found"; exit 1
+fi
+echo "  checkpoint: ${ALTD_GPU_CKPT:-generated Xavier population}"
+{ rocminfo | grep -E "^\s*(Name|Marketing Name|Compute Unit|Max Clock Freq|Wavefront Size):" ; } > "$OUT/device.txt" 2>&1
+{ hipcc --version; echo; rocminfo | grep -m1 -i "ROCk\|version"; [ $HAVE_ROCPROF = 1 ] && rocprofv3 --version; } > "$OUT/toolchain.txt" 2>&1
+grep -m1 "Marketing Name" "$OUT/device.txt" | sed 's/^\s*/  /'
+if [ ! -f "$LIB" ] || [ "$(find gpu/sim math/kernels gpu/build.sh -type f -newer "$LIB" | wc -l)" -gt 0 ]; then
+  if ask "GPU library missing or older than its sources or math kernels. Build it now with gpu/build.sh?" y; then run_logged build_library gpu/build.sh || exit 1; fi
+fi
+sha256sum "$LIB" >> "$LOG"
+if [ ! -x "$CHECK" ] || [ "$(find src examples -newer "$CHECK" -name '*.rs' | wc -l)" -gt 0 ]; then
+  run_logged build_examples cargo build --release --offline --example gpu_check || exit 1
+fi
+if ask "Run the exactness checks first (gpu_check math novelty turnover step, a few minutes)?" y; then
+  run_logged exactness_check "$CHECK" math novelty turnover step
+  grep -E "ALL OK|FAILURES|mismatch" "$OUT/exactness_check.txt" | tail -3 | sed 's/^/    /'
+fi
+echo "  Close games and other GPU load now; the step kernels are latency sensitive."
+ask "Continue?" y || exit 0
+
+# ---- level 1: built-in phases ---------------------------------------------
+if want_level 1 "built-in per-phase GPU time and split/fused wall clock"; then
+  note "level 1: ALTD_GPU_PROFILE=1 prints GPU seconds per phase and per 600 ticks; graphs are disabled in this mode"
+  for cars in $SIZES; do for elim in 0 1; do
+    run_logged "phases_${cars}_elim${elim}" $(bench_env "$cars" "$elim" ALTD_GPU_PROFILE=1) "$CHECK" benchfixed
+    grep -h "altd_gpu window:" "$OUT/phases_${cars}_elim${elim}.txt" | head -2 | sed 's/^/      /'
+  done; done
+  for cars in $SIZES; do [ "$cars" -le 32768 ] || continue
+    run_logged "phases_${cars}_elim1_fused" $(bench_env "$cars" 1 ALTD_GPU_PROFILE=1 ALTD_GPU_SPLIT=0) "$CHECK" benchfixed
+  done
+  note "level 1b: production-mode wall clock, split vs fused step (graph on, no profiling)"
+  : > "$OUT/split_vs_fused.jsonl"
+  for split in 1 0; do for cars in $SIZES; do [ "$cars" -le 32768 ] || continue; for elim in 0 1; do
+    run_logged "wall_split${split}_${cars}_elim${elim}" env ALTD_GPU_SPLIT=$split ALTD_GPU_BENCH_CARS=$cars ALTD_GPU_BENCH_ELIMINATE=$elim ALTD_GPU_BENCH_WARMUPS=1 ALTD_GPU_BENCH_SAMPLES=2 "$CHECK" benchfixed
+    grep '^{' "$OUT/wall_split${split}_${cars}_elim${elim}.txt" | sed "s/^{/{\"split\":$split,/" >> "$OUT/split_vs_fused.jsonl"
+  done; done; done
+fi
+
+# ---- level 2: rocprofv3 kernel trace ---------------------------------------
+if [ $HAVE_ROCPROF = 1 ] && want_level 2 "per-kernel durations with rocprofv3 (kernel trace + stats)"; then
+  note "level 2: rocprofv3 --kernel-trace --stats per run; graph mode unless kernels do not appear individually"
+  for cars in $SIZES; do for elim in 0 1; do
+    dir="$OUT/trace_${cars}_elim${elim}"
+    run_logged "trace_${cars}_elim${elim}" $(bench_env "$cars" "$elim") rocprofv3 --kernel-trace --stats --output-format csv -d "$dir" -o run -- "$CHECK" benchfixed
+    stats=$(find "$dir" -name '*kernel_stats.csv' 2>/dev/null | head -1)
+    if [ -z "$stats" ] || ! grep -q "w_step\|step_kernel" "$stats"; then
+      note "  graph launches were not traced as kernels; repeating with ALTD_GPU_GRAPH=0"
+      run_logged "trace_${cars}_elim${elim}_direct" $(bench_env "$cars" "$elim" ALTD_GPU_GRAPH=0) rocprofv3 --kernel-trace --stats --output-format csv -d "${dir}_direct" -o run -- "$CHECK" benchfixed
+      stats=$(find "${dir}_direct" -name '*kernel_stats.csv' 2>/dev/null | head -1)
+    fi
+    [ -n "$stats" ] && { echo "      top kernels by total time:"; sort -t, -k3 -g -r "$stats" 2>/dev/null | head -6 | cut -d, -f1-4 | sed 's/^/        /'; }
+  done; done
+fi
+
+# ---- level 3: hardware counters -------------------------------------------
+if [ $HAVE_ROCPROF = 1 ] && want_level 3 "hardware counters of the step, sensor and forward kernels"; then
+  note "level 3: rocprofv3 --pmc passes over 300 ticks with direct launches"
+  rocprofv3 --list-avail > "$OUT/counters_available.txt" 2>&1
+  # Candidate passes; names absent from this GPU's list are dropped, empty passes skipped.
+  passes=(
+    "SQ_WAVES SQ_BUSY_CYCLES SQ_WAVE_CYCLES GRBM_GUI_ACTIVE"
+    "SQ_INSTS_VALU SQ_INSTS_SALU SQ_INSTS_LDS SQ_INSTS_SMEM"
+    "SQ_INSTS_VMEM_RD SQ_INSTS_VMEM_WR SQ_INST_LEVEL_VMEM SQ_WAIT_INST_ANY"
+    "SQ_ACTIVE_INST_VALU SQ_ACTIVE_INST_VMEM SQ_ACTIVE_INST_LDS SQ_INST_LEVEL_LDS"
+    "GL2C_HIT GL2C_MISS TCP_TOTAL_CACHE_ACCESSES TCP_TCC_READ_REQ"
+    "SQ_LEVEL_WAVES SQ_INSTS_BRANCH SQ_INSTS_FLAT SQ_INST_CYCLES_VMEM_RD"
+    "SQ_INSTS_VALU_TRANS_F64 SQ_INSTS_VALU_FMA_F64 SQ_INSTS_VALU_ADD_F64 SQ_INSTS_VALU_MUL_F64"
+  )
+  : > "$OUT/pmc.txt"; dropped=""
+  for pass in "${passes[@]}"; do
+    keep=""
+    for c in $pass; do if grep -qw "$c" "$OUT/counters_available.txt"; then keep="$keep $c"; else dropped="$dropped $c"; fi; done
+    [ -n "$keep" ] && echo "pmc:$keep" >> "$OUT/pmc.txt"
+  done
+  note "  counter passes:"; sed 's/^/    /' "$OUT/pmc.txt" | tee -a "$LOG"
+  [ -n "$dropped" ] && note "  not available on this GPU, dropped:$dropped"
+  for cars in $SIZES; do [ "$cars" = 32768 ] && continue
+    run_logged "counters_${cars}" $(bench_env "$cars" 0 ALTD_GPU_GRAPH=0 ALTD_GPU_BENCH_TICKS=300) rocprofv3 -i "$OUT/pmc.txt" --kernel-include-regex "w_step|sat_kernel|w_sensor|w_forward|w_stats|step_kernel" --output-format csv -d "$OUT/counters_${cars}" -o run -- "$CHECK" benchfixed
+  done
+fi
+
+# ---- level 4: step sections and kernel resources ---------------------------
+if want_level 4 "step-section cycle counts (timing build) and kernel resource usage"; then
+  note "level 4: a second library built with -DALTD_STEP_TIMING (atomics slow the step; only the ratios matter)"
+  FLAGS=(-O3 -ffp-contract=off --offload-arch="${GPU_ARCH:-gfx1100}" -fPIC -shared -std=c++20 -fhip-fp32-correctly-rounded-divide-sqrt)
+  TLIB="$REPO/target/gpu/libaltd_gpu_timing.so"
+  python3 gpu/gen_tables.py --check || exit 1
+  if run_logged build_timing_library hipcc "${FLAGS[@]}" -DALTD_STEP_TIMING -o "$TLIB" gpu/sim/altd_gpu.hip -lamdhip64; then
+    : > "$OUT/step_sections.txt"
+    for cars in $SIZES; do [ "$cars" = 32768 ] && continue; for elim in 0 1; do
+      run_logged "sections_${cars}_elim${elim}" $(bench_env "$cars" "$elim" ALTD_GPU_LIB="$TLIB" ALTD_GPU_PROFILE=1) "$CHECK" benchfixed
+      { echo "== $cars cars, eliminate=$elim"; grep -E "step sections|altd_gpu window:" "$OUT/sections_${cars}_elim${elim}.txt"; } >> "$OUT/step_sections.txt"
+    done; done
+  fi
+  note "  kernel resource usage (VGPRs, SGPRs, scratch, LDS, occupancy) of the production flags"
+  run_logged kernel_resources hipcc "${FLAGS[@]}" -Rpass-analysis=kernel-resource-usage -o "$OUT/.tmp_resources.so" gpu/sim/altd_gpu.hip -lamdhip64
+  rm -f "$OUT/.tmp_resources.so"
+fi
+
+# ---- level 5: forward-pass attribution -------------------------------------
+if want_level 5 "forward-pass attribution (diagnostic builds; their results are wrong by design)"; then
+  note "level 5: forward seconds of a 32K full run per variant. diag1 = no activation, diag2 = no weight traffic, diag3 = activation only, diag4 = layer loop only, diag5 = diag4 without layer barriers, branchy = scalar tanh, cumode = -mcumode build"
+  FLAGS=(-O3 -ffp-contract=off --offload-arch="${GPU_ARCH:-gfx1100}" -fPIC -shared -std=c++20 -fhip-fp32-correctly-rounded-divide-sqrt)
+  python3 gpu/gen_tables.py --check || exit 1
+  : > "$OUT/forward_attribution.txt"
+  for variant in "current:" "cumode:-mcumode" "branchy:-DALTD_TANH_BRANCHY" "diag1:-DALTD_FORWARD_DIAG=1" "diag2:-DALTD_FORWARD_DIAG=2" "diag3:-DALTD_FORWARD_DIAG=3" "diag4:-DALTD_FORWARD_DIAG=4" "diag5:-DALTD_FORWARD_DIAG=5"; do
+    name=${variant%%:*}; define=${variant#*:}
+    DLIB="$REPO/target/gpu/libaltd_gpu_$name.so"
+    if [ "$name" = current ]; then DLIB="$LIB"; else
+      run_logged "build_$name" hipcc "${FLAGS[@]}" $define -o "$DLIB" gpu/sim/altd_gpu.hip -lamdhip64 || continue
+    fi
+    run_logged "forward_$name" $(bench_env 32768 0 ALTD_GPU_LIB="$DLIB" ALTD_GPU_PROFILE=1) "$CHECK" benchfixed
+    line=$(grep -h "altd_gpu window:" "$OUT/forward_$name.txt" | head -1)
+    echo "$name: $line" >> "$OUT/forward_attribution.txt"; echo "      $name: ${line#*cars: }"
+  done
+fi
+
+# ---- pack -------------------------------------------------------------------
+echo; bold "Done"
+TAR="$OUT.tar.gz"
+tar czf "$TAR" -C "$(dirname "$OUT")" "$(basename "$OUT")"
+echo "  results: $OUT"
+echo "  archive: $TAR ($(du -h "$TAR" | cut -f1)), send this file"
+grep -c "rc=0" "$LOG" | sed 's/^/  steps succeeded: /'
+grep "rc=[1-9]" "$LOG" | sed 's/^/  failed: /'
+exit 0

github-simulator/source/gpu/release-targets

@@ -0,0 +1,27 @@
+gfx803
+gfx900
+gfx902
+gfx906
+gfx909
+gfx90c
+gfx1010
+gfx1011
+gfx1012
+gfx1013
+gfx1030
+gfx1031
+gfx1032
+gfx1033
+gfx1034
+gfx1035
+gfx1036
+gfx1100
+gfx1101
+gfx1102
+gfx1103
+gfx1150
+gfx1151
+gfx1152
+gfx1153
+gfx1200
+gfx1201

github-simulator/source/gpu/sim/altd_gpu.hip

@@ -0,0 +1,1384 @@
+#include <chrono>
+#include <vector>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <new>
+// libaltd_gpu.so: GPU parts of the fidelity simulator behind a C ABI.
+// Rust loads it with dlopen (src/gpu/hip.rs); examples/gpu_check/main.rs compares
+// every part bit for bit with the CPU code.
+#include "compat.h"
+#include <cstdint>
+#include <cstdio>
+#include <cstddef>
+#include "math.h"
+#include "rays.h"
+#include "sensors.h"
+#include "step.h"
+#include "stats.h"
+#ifdef _WIN32
+// For GetThreadTimes. After the other headers: windows.h defines `near` and `far`, which the
+// simulator headers use as variable names.
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef near
+#undef far
+#endif
+
+using namespace altd;
+
+#define CHECK(call) do { hipError_t e_ = (call); if (e_ != hipSuccess) { \
+    fprintf(stderr, "altd_gpu %s:%d %s\n", __FILE__, __LINE__, hipGetErrorString(e_)); return (int)e_; } } while (0)
+
+namespace {
+
+enum MathOp : int {
+    OP_NATIVE_SIN = 0,     // f32 -> f32
+    OP_NATIVE_COS = 1,     // f32 -> f32
+    OP_NATIVE_ATAN2 = 2,   // (f32 y, f32 x) -> f32
+    OP_MANAGED_SINCOS = 3, // f32 -> (f32, f32)
+    OP_DEXP = 4,           // f64 -> f64
+    OP_DPOW = 5,           // (f64, f64) -> f64
+    OP_ENGINE_SINCOS = 6,  // f32 -> (f32, f32), with exceptions
+    OP_ENGINE_RAW = 7,     // f32 -> (f32, f32), without exceptions
+    OP_GAME_TANH = 8,      // f64 -> f64
+};
+// altd_gpu_math's op carries a math profile above these bits; it selects the
+// variant of the sin, cos, atan2, exp, pow and tanh ops.
+constexpr int OP_MASK = 0xff, OP_PROFILE_SHIFT = 8;
+
+__global__ void math_kernel(int op, int n, const void* in, void* out, uint32_t* err) {
+    int i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n) return;
+    uint32_t e = 0, math = (uint32_t)op >> OP_PROFILE_SHIFT;
+    const float* fi = (const float*)in;
+    const double* di = (const double*)in;
+    float* fo = (float*)out;
+    double* dout = (double*)out;
+    switch (op & OP_MASK) {
+        case OP_NATIVE_SIN: fo[i] = profile_sin(math, fi[i], e); break;
+        case OP_NATIVE_COS: fo[i] = profile_cos(math, fi[i], e); break;
+        case OP_NATIVE_ATAN2: fo[i] = profile_atan2(math, fi[2 * i], fi[2 * i + 1]); break;
+        case OP_MANAGED_SINCOS: managed_sin_cos(fi[i], fo[2 * i], fo[2 * i + 1], e); break;
+        case OP_DEXP: dout[i] = profile_exp(math, di[i]); break;
+        case OP_DPOW: dout[i] = profile_pow(math, di[2 * i], di[2 * i + 1]); break;
+        case OP_ENGINE_SINCOS: engine_sin_cos(fi[i], fo[2 * i], fo[2 * i + 1], e); break;
+        case OP_ENGINE_RAW: engine_sin_cos_raw(fi[i], fo[2 * i], fo[2 * i + 1]); break;
+        case OP_GAME_TANH: dout[i] = profile_tanh(math, di[i]); break;
+    }
+    err[i] = e;
+}
+
+// Engine sin/cos of the float with bits `first + i` (wrapping), for the
+// exhaustive x87 scan. Output: interleaved sine and cosine bits.
+__global__ void engine_scan_kernel(uint32_t first, uint32_t n, uint32_t* out) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n) return;
+    float s, c;
+    engine_sin_cos_raw(ffrom(first + i), s, c);
+    out[2 * (size_t)i] = fbits(s);
+    out[2 * (size_t)i + 1] = fbits(c);
+}
+
+size_t in_size(int op) {
+    switch (op & OP_MASK) {
+        case OP_NATIVE_ATAN2: return 8;
+        case OP_DEXP: case OP_GAME_TANH: return 8;
+        case OP_DPOW: return 16;
+        default: return 4;
+    }
+}
+size_t out_size(int op) {
+    switch (op & OP_MASK) {
+        case OP_MANAGED_SINCOS: case OP_ENGINE_SINCOS: case OP_ENGINE_RAW: return 8;
+        case OP_DEXP: case OP_DPOW: case OP_GAME_TANH: return 8;
+        default: return 4;
+    }
+}
+
+// Query kinds of altd_gpu_query.
+enum QueryOp : int {
+    Q_RAYCAST = 0,  // in (sx, sy, ex, ey) -> out (hx, hy, hit, 0)
+    Q_CLOSEST = 1,  // in (px, py, -, -)   -> out (cx, cy, 1, 0)
+};
+
+__global__ void query_kernel(World w, int op, int n, const float4* in, float4* out) {
+    int i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n) return;
+    float4 q = in[i];
+    float2 r = make_float2(0.0f, 0.0f);
+    bool ok = true;
+    if (op == Q_RAYCAST) ok = raycast(w, make_float2(q.x, q.y), make_float2(q.z, q.w), r);
+    else r = closest_wall_point(w, make_float2(q.x, q.y));
+    out[i] = make_float4(r.x, r.y, ok ? 1.0f : 0.0f, 0.0f);
+}
+
+template <typename T>
+int upload(const T* host, size_t count, const T*& device) {
+    T* d = nullptr;
+    device = nullptr;
+    if (count) {
+        CHECK(hipMalloc(&d, sizeof(T) * count));
+        // The owner must retain this allocation if copying fails.
+        device = d;
+        CHECK(hipMemcpy(d, host, sizeof(T) * count, hipMemcpyHostToDevice));
+    }
+    return 0;
+}
+
+int upload_grid(const NearGrid& host, NearGrid& device) {
+    size_t cells = host.start ? (size_t)host.nx * host.ny : 0;
+    size_t items = cells ? host.start[cells] : 0;
+    return upload(host.start, cells ? cells + 1 : 0, device.start) || upload(host.items, items, device.items);
+}
+
+// ---- simulation ----
+
+// Network layer widths, and for each control (Agent::controls order:
+// acceleration, steering, brake, handbrake, boost) the output neuron that
+// sets it: the last one with that name, or -1 for 0.0.
+struct NetShape {
+    uint32_t layers, width[MAX_LAYERS];
+    int32_t control_src[5];
+};
+
+}  // namespace
+
+// Sim and WindowArgs stay outside the anonymous namespace: g++ (nvcc's host compiler) gives the
+// extern "C" functions that take them internal linkage otherwise, and leaves them out of the library.
+struct WindowArgs {
+    uint64_t start_tick, ticks;
+    uint32_t start_batch, batches_per_tick, stats_phase, stop_when_inactive;
+    uint32_t eliminate_on_wall, eliminate_when_idle, has_time_limit, pad;
+    double time_limit;
+};
+
+namespace {
+
+struct WindowState {
+    uint32_t live_count[2][8], step_count[2];
+    uint32_t stopped;
+    uint32_t items;     // SAT items of the split step (cleared by its end kernel)
+    uint64_t executed;  // the stopping tick's k
+    uint64_t base;      // k before the current period; kernels add their offset
+};
+
+uint32_t live_total(const WindowState& st, uint32_t p) {
+    uint32_t count = 0;
+    for (uint32_t b = 0; b < 8; b++) count += st.live_count[p][b];
+    return count;
+}
+
+}  // namespace
+
+struct Sim {
+    World world;  // device pointers, owned by the world handle
+    VehicleDesc vehicle;
+    Sensors sensors;
+    uint32_t capacity, n;
+    Car* cars;
+    Agent* agents;
+    float* here;     // sensor path offset per car
+    double* inputs;  // n * sensors.count, car-major
+    NetShape shape;
+    size_t stride;   // parameters per network
+    double* params;  // capacity * stride, one network per car
+    uint32_t network_count;
+    double* mean;
+    double* novelty;
+    // altd_gpu_sim_window: work lists, settling, device state, stop polling.
+    uint32_t* live[2];
+    uint32_t* steps[2];
+    uint32_t* settled_at;
+    Car* shadow;
+    WindowState* state;
+    // The split step: carried state per car, SAT items (car * MAX_PAIRS + pair) and their pushes.
+    StepCarry* carry;
+    uint32_t* items;
+    Vec2* pushes;
+    uint32_t* host_stopped;  // pinned
+    uint32_t* active;        // altd_gpu_sim_active_count's result
+    hipEvent_t chunk_done[4];
+    hipStream_t stream;  // blocking, so ordered with the null stream
+    hipGraphExec_t graph_exec;
+    WindowArgs graph_args;
+    uint32_t graph_n;
+};
+
+namespace {
+
+// Kernel arguments captured by the period graph. The requested window length
+// only affects the host's replay count and is not part of the captured graph.
+bool same_schedule(const WindowArgs& a, const WindowArgs& b) {
+    return a.start_tick == b.start_tick && a.start_batch == b.start_batch
+        && a.batches_per_tick == b.batches_per_tick && a.stats_phase == b.stats_phase
+        && a.stop_when_inactive == b.stop_when_inactive && a.eliminate_on_wall == b.eliminate_on_wall
+        && a.eliminate_when_idle == b.eliminate_when_idle && a.has_time_limit == b.has_time_limit
+        && a.time_limit == b.time_limit;
+}
+
+// Pass 1 of the sensor read: the path offset (a nearest-segment search) per reading car.
+__global__ void path_offset_kernel(World w, ReadMask m, Car* cars, uint32_t n, float* here) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n || !reads(m, cars[i], i)) return;
+    here[i] = sensor_path_offset(w, cars[i]);
+}
+
+// Pass 2: one thread per (sensor, car), sensor-major so a wave reads one sensor kind.
+__global__ void sensor_kernel(World w, VehicleDesc v, Sensors s, ReadMask m, Car* cars, uint32_t n,
+                              const float* here, double* inputs) {
+    uint32_t t = blockIdx.x * blockDim.x + threadIdx.x;
+    uint32_t k = t / n, i = t % n;
+    if (k >= s.count || !reads(m, cars[i], i)) return;
+    uint32_t err = 0;
+    inputs[(size_t)i * s.count + k] = sensor_value(w, v, cars[i], s.s[k], s.needs_path ? here[i] : 0.0f, err);
+    if (err) atomicOr(&cars[i].error, err);
+}
+
+// `Network::forward_into` for the reading cars, then Controls(**outputs).
+// A block holds CARS_PER_BLOCK cars. Within a layer of `cols` outputs, thread
+// t computes output t % cols of the block's car t / cols, so the block's
+// CARS_PER_BLOCK * cols outputs occupy the first threads and the waves past
+// them skip the layer entirely. With one car per LANES threads, a 12-, 8- or
+// 5-wide layer would leave 4, 8 or 11 idle lanes in every wave, and idle
+// lanes still cost the double-precision issue slots that bound this kernel.
+// Each output adds its products in input order, then the bias, as the CPU does.
+constexpr int LANES = 16;
+constexpr int CARS_PER_BLOCK = 16;
+// ALTD_FORWARD_DIAG (timing builds only, results are wrong): 1 skips the
+// activation, 2 reads one weight row for every input (no weight traffic),
+// 3 skips the products and applies the activation to an input, 4 skips both
+// (the layer loop's own cost), 5 additionally drops the per-layer barriers.
+#ifndef ALTD_FORWARD_DIAG
+#define ALTD_FORWARD_DIAG 0
+#endif
+#if ALTD_FORWARD_DIAG == 5
+#define FORWARD_LAYER_BARRIER() ((void)0)
+#else
+#define FORWARD_LAYER_BARRIER() __syncthreads()
+#endif
+// Weight rows are loaded ROW_CHUNK at a time, one chunk ahead of the products
+// that use them, and a layer's first chunk and bias during the previous
+// layer's activation. Every row's weights are a fresh cache line streamed
+// from memory, so without the lookahead each row waits for its own load.
+constexpr uint32_t ROW_CHUNK = 8;
+
+// Rows first .. first + ROW_CHUNK - 1 of output j (zero past `rows` or when
+// not `active`; nothing is read there).
+__device__ inline void load_rows(double (&w)[ROW_CHUNK], const double* __restrict__ matrix, uint32_t rows, uint32_t cols, uint32_t j,
+                                 uint32_t first, bool active) {
+#pragma unroll
+    for (uint32_t u = 0; u < ROW_CHUNK; u++) {
+        bool have = active && first + u < rows;
+#if ALTD_FORWARD_DIAG == 2
+        w[u] = have ? matrix[j] : 0.0;
+#else
+        w[u] = have ? matrix[(size_t)(first + u) * cols + j] : 0.0;
+#endif
+    }
+}
+
+// Every thread of the block must call it (barriers); `car` and `live` are the
+// caller's slot (threadIdx.x / LANES).
+__device__ inline void forward_car(uint32_t math, const NetShape& shape, const double* __restrict__ params, size_t stride, bool live,
+                                   uint32_t car, const double* __restrict__ inputs, Agent* agents) {
+    // Two activation buffers: a layer reads one and writes the other, so one
+    // barrier per layer orders the writes before the next layer's reads (the
+    // previous barrier already ordered this layer's reads before those writes).
+    // Row stride of MAX_WIDTH + 1 doubles: the cars of one wave read the same
+    // column at the same time, and rows 256 bytes apart would share LDS banks.
+    __shared__ double buffers[2][CARS_PER_BLOCK][MAX_WIDTH + 1];
+    __shared__ uint32_t slot_car[CARS_PER_BLOCK];
+    __shared__ uint32_t slot_live[CARS_PER_BLOCK];
+    uint32_t t = threadIdx.x, slot = t / LANES, lane = t % LANES;
+    uint32_t n_in = shape.width[0];
+    if (lane == 0) {
+        slot_car[slot] = car;
+        slot_live[slot] = live;
+    }
+    for (uint32_t i = lane; live && i < n_in; i += LANES) buffers[0][slot][i] = inputs[(size_t)car * n_in + i];
+    __syncthreads();
+    uint32_t current = 0;  // the buffer holding this layer's inputs
+    // This thread's assignment for the current layer: car slot s, output j.
+    uint32_t rows = shape.width[0], cols = shape.width[1];
+    uint32_t s = t / cols, j = t % cols;
+    bool active = t < CARS_PER_BLOCK * cols && slot_live[s];
+    const double* matrix = active ? params + (size_t)slot_car[s] * stride : params;
+    double w[ROW_CHUNK];
+    load_rows(w, matrix, rows, cols, j, 0, active);
+    size_t position = 0;
+    for (uint32_t layer = 0; layer + 1 < shape.layers; layer++) {
+        double (&values)[CARS_PER_BLOCK][MAX_WIDTH + 1] = buffers[current];
+        double acc = 0.0, bias = 0.0, out = 0.0;
+        if (active) {
+            bias = matrix[(size_t)rows * cols + j];
+#if ALTD_FORWARD_DIAG == 3 || ALTD_FORWARD_DIAG >= 4
+            acc = values[s][j < rows ? j : 0];
+#else
+            for (uint32_t i = 0; i < rows; i += ROW_CHUNK) {
+                double next[ROW_CHUNK];
+                load_rows(next, matrix, rows, cols, j, i + ROW_CHUNK, true);
+#pragma unroll
+                for (uint32_t u = 0; u < ROW_CHUNK; u++)
+                    if (i + u < rows) acc += values[s][i + u] * w[u];
+#pragma unroll
+                for (uint32_t u = 0; u < ROW_CHUNK; u++) w[u] = next[u];
+            }
+#endif
+        }
+        // The next layer's assignment and first rows, issued before this
+        // layer's activation so their latency overlaps it.
+        bool has_next = layer + 2 < shape.layers;
+        uint32_t rows_n = cols, cols_n = has_next ? shape.width[layer + 2] : 1;
+        uint32_t s_n = t / cols_n, j_n = t % cols_n;
+        bool active_n = has_next && t < CARS_PER_BLOCK * cols_n && slot_live[s_n];
+        size_t position_n = position + (size_t)(rows + 1) * cols;
+        const double* matrix_n = active_n ? params + (size_t)slot_car[s_n] * stride + position_n : params;
+        load_rows(w, matrix_n, rows_n, cols_n, j_n, 0, active_n);
+        if (active) {
+#if ALTD_FORWARD_DIAG == 1 || ALTD_FORWARD_DIAG >= 4
+            out = acc + bias;
+#else
+            out = profile_tanh(math, acc + bias);
+#endif
+        }
+        if (active) buffers[current ^ 1][s][j] = out;
+        FORWARD_LAYER_BARRIER();
+        current ^= 1;
+        rows = rows_n; cols = cols_n; s = s_n; j = j_n; active = active_n; matrix = matrix_n; position = position_n;
+    }
+    if (live && lane < 5) {
+        int32_t src = shape.control_src[lane];
+        agents[car].controls[lane] = src >= 0 ? buffers[current][slot][src] : 0.0;
+    }
+}
+
+__global__ void __launch_bounds__(LANES * CARS_PER_BLOCK)
+    forward_kernel(uint32_t math, NetShape shape, const double* __restrict__ params, size_t stride, ReadMask m, const Car* cars,
+                   uint32_t n, const double* __restrict__ inputs, Agent* agents) {
+    uint32_t car = blockIdx.x * CARS_PER_BLOCK + threadIdx.x / LANES;
+    bool live = car < n && reads(m, cars[car], car);
+    forward_car(math, shape, params, stride, live, car, inputs, agents);
+}
+
+// The agent's side of a step of car i: a reported wall contact sets
+// AGENT_PENDING_CONTACT; a car deactivated by the step records `tick`
+// (Schedule::drive_agent).
+__device__ inline void record(const Car& car, Agent& agent, bool was_active, bool report, uint64_t tick) {
+    uint32_t flags = agent.flags | (report ? AGENT_PENDING_CONTACT : 0u);
+    if (was_active && !(car.flags & CAR_ACTIVE)) {
+        agent.deactivated_at = tick;
+        flags |= AGENT_HAS_DEACTIVATED;
+    }
+    agent.flags = flags;
+}
+
+// `Car::step` (drive) or `Car::passive_step` of car i with the agent's controls.
+__device__ inline void step_car(const World& w, const VehicleDesc& v, Car& car, Agent& agent, bool drive, bool eliminate_on_wall,
+                                uint64_t tick) {
+    bool was_active = car.flags & CAR_ACTIVE;
+    bool report = car_step(w, v, car, agent.controls, drive, eliminate_on_wall);
+    record(car, agent, was_active, report, tick);
+}
+
+constexpr uint32_t STEP_THREADS = 64;
+
+// Bound all physics kernels to their actual block size so the solver
+// contact-index array reserves LDS for STEP_THREADS threads, rather than 1024.
+__global__ void __launch_bounds__(STEP_THREADS) step_kernel(World w, VehicleDesc v, Car* cars, Agent* agents, uint32_t n, uint32_t drive, uint32_t eliminate_on_wall,
+                            uint64_t tick) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n) return;
+    step_car(w, v, cars[i], agents[i], drive != 0, eliminate_on_wall != 0, tick);
+}
+
+// ---- the split step ----
+//
+// `step_car` in three kernels, so the SAT tests of all broad pairs run side
+// by side instead of in a loop per car: `step_begin` per car reserves one
+// SAT item per broad pair (consecutive from the carry's base), the SAT kernel
+// runs one item per thread, and `step_end` per car reads the pushes. The
+// work per SAT thread varies only with its pair's axes, not with the pair
+// counts of the other cars of the wave.
+
+// Reserves `count` consecutive slots of `*total` per lane, one atomic per
+// wave; returns the lane's first slot. Every lane must call it.
+__device__ inline uint32_t reserve(uint32_t count, uint32_t* total) {
+    uint32_t lane = altd_lane_id(), prefix = count;  // inclusive scan over the wave
+    for (uint32_t o = 1; o < (uint32_t)warpSize; o <<= 1) {
+        uint32_t x = altd_shfl_up(prefix, o);
+        prefix += lane >= o ? x : 0u;
+    }
+    uint32_t sum = altd_shfl(prefix, warpSize - 1), base = 0;
+    if (lane == 0 && sum) base = atomicAdd(total, sum);
+    return altd_shfl(base, 0) + prefix - count;
+}
+
+// Every lane must call it.
+__device__ inline void begin_car(const World& w, const VehicleDesc& v, Car* cars, Agent* agents, bool valid, uint32_t i, bool drive,
+                                 StepCarry* carry, uint32_t* items, uint32_t* item_count) {
+    StepCarry k{};
+    uint32_t count = 0;
+    if (valid) {
+        k = step_begin(w, v, cars[i], agents[i].controls, drive);
+        count = cars[i].pair_count;
+    }
+    uint32_t base = reserve(count, item_count);
+    if (!valid) return;
+    k.base = base;
+    carry[i] = k;
+    for (uint32_t c = 0; c < count; c++) items[base + c] = i * MAX_PAIRS + c;
+}
+
+// The SAT items, grid-stride (the grid is sized for the cars, not the items).
+__global__ void __launch_bounds__(STEP_THREADS) sat_kernel(World w, VehicleDesc v, Car* cars, const uint32_t* items, const WindowState* st, Vec2* pushes) {
+    uint32_t total = st->items;
+    for (uint32_t t = blockIdx.x * blockDim.x + threadIdx.x; t < total; t += gridDim.x * blockDim.x) {
+        uint32_t item = items[t];
+        pushes[t] = sat_pair(w, v, cars[item / MAX_PAIRS], item % MAX_PAIRS);
+    }
+}
+
+__device__ inline bool end_car(const World& w, const VehicleDesc& v, Car& car, Agent& agent, const StepCarry& k, const Vec2* pushes,
+                               bool drive, bool eliminate_on_wall, uint64_t tick) {
+    bool report = step_end(w, v, car, k, [&](uint32_t ci) { return pushes[k.base + ci]; }, drive, eliminate_on_wall);
+    record(car, agent, k.was_active, report, tick);
+    return report;
+}
+
+__global__ void __launch_bounds__(STEP_THREADS) step_begin_kernel(World w, VehicleDesc v, Car* cars, Agent* agents, uint32_t n, uint32_t drive, StepCarry* carry,
+                                  uint32_t* items, WindowState* st) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    begin_car(w, v, cars, agents, i < n, i, drive != 0, carry, items, &st->items);
+}
+
+__global__ void __launch_bounds__(STEP_THREADS) step_end_kernel(World w, VehicleDesc v, Car* cars, Agent* agents, uint32_t n, uint32_t drive, uint32_t eliminate_on_wall,
+                                uint64_t tick, const StepCarry* carry, const Vec2* pushes, WindowState* st) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i == 0) st->items = 0;  // the SAT kernel is done with them
+    if (i >= n) return;
+    end_car(w, v, cars[i], agents[i], carry[i], pushes, drive != 0, eliminate_on_wall != 0, tick);
+}
+
+// Counts the cars with CAR_ACTIVE, one atomic per wave.
+__global__ void active_count_kernel(const Car* cars, uint32_t n, uint32_t* count) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    uint64_t mask = altd_ballot(i < n && (cars[i].flags & CAR_ACTIVE));
+    if (mask && altd_lane_id() == (uint32_t)__ffsll((unsigned long long)mask) - 1) atomicAdd(count, (uint32_t)__popcll(mask));
+}
+
+uint32_t blocks(size_t n, uint32_t size = 256) { return (uint32_t)((n + size - 1) / size); }
+
+// ALTD_GPU_SPLIT=0: the step in one kernel (car_step) instead of the split step.
+bool split_step() {
+    static const char* env = getenv("ALTD_GPU_SPLIT");
+    static const bool split = !(env && strcmp(env, "0") == 0);
+    return split;
+}
+
+// Host clocks of ALTD_GPU_PROFILE, in seconds. A negative thread CPU time is not printed.
+double wall_seconds() { return std::chrono::duration<double>(std::chrono::steady_clock::now().time_since_epoch()).count(); }
+double thread_cpu_seconds() {
+#ifdef _WIN32
+    FILETIME created, exited, kernel, user;  // 100 ns units
+    if (!GetThreadTimes(GetCurrentThread(), &created, &exited, &kernel, &user)) return -1.0;
+    ULARGE_INTEGER k, u;
+    k.LowPart = kernel.dwLowDateTime, k.HighPart = kernel.dwHighDateTime;
+    u.LowPart = user.dwLowDateTime, u.HighPart = user.dwHighDateTime;
+    return 1e-7 * (double)(k.QuadPart + u.QuadPart);
+#else
+    timespec t;
+    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &t);
+    return (double)t.tv_sec + 1e-9 * (double)t.tv_nsec;
+#endif
+}
+
+// The step kernels need ~300 MB of scratch at full occupancy, over the HSA
+// runtime's single-dispatch limit, so by default every launch allocates and
+// frees it (0.2-1.7 ms per launch). Keeping the scratch avoids that. Runs at
+// load, before the first HIP call initialises HSA; an explicit setting wins.
+#if !defined(__CUDACC__)
+__attribute__((constructor)) void keep_scratch() { setenv("HSA_NO_SCRATCH_RECLAIM", "1", 0); }
+#endif
+
+}  // namespace
+
+extern "C" {
+
+ALTD_API void altd_gpu_world_free(World* w);
+ALTD_API void altd_gpu_sim_free(Sim* s);
+
+// Copies the track data to the device; returns an opaque handle or null.
+// `desc` holds host pointers and has the layout of World.
+ALTD_API World* altd_gpu_world_create(const World* desc) {
+    if (desc->ray_depth > (uint32_t)MAX_RAY_DEPTH) {
+        fprintf(stderr, "altd_gpu: BSP depth %u exceeds MAX_RAY_DEPTH %d\n", desc->ray_depth, MAX_RAY_DEPTH);
+        return nullptr;
+    }
+    World* w = new (std::nothrow) World(*desc);
+    if (!w) return nullptr;
+    // desc contains borrowed host pointers. Cleanup may only free pointers
+    // assigned by successful device allocations, including a failed copy.
+    w->ray_nodes = nullptr;
+    w->ray_walls = nullptr;
+    w->surfaces = nullptr;
+    w->tiles = nullptr;
+    w->path_segments = nullptr;
+    w->path_offsets = nullptr;
+    w->path_grid.start = nullptr;
+    w->path_grid.items = nullptr;
+    w->curve_position = nullptr;
+    w->curve_offsets = nullptr;
+    w->curve_forwards = nullptr;
+    w->curve_grid.start = nullptr;
+    w->curve_grid.items = nullptr;
+    w->shapes = nullptr;
+    w->shape_local = nullptr;
+    w->shape_normals = nullptr;
+    w->shape_grid.start = nullptr;
+    w->shape_grid.items = nullptr;
+    w->path_xy = nullptr;
+    int bad = upload(desc->ray_nodes, desc->ray_node_count, w->ray_nodes)
+        || upload(desc->ray_walls, desc->ray_wall_count, w->ray_walls)
+        || upload(desc->surfaces, desc->surface_count, w->surfaces)
+        || upload(desc->tiles, (size_t)(desc->tile_nx * desc->tile_ny), w->tiles)
+        || upload(desc->path_segments, desc->path_points ? desc->path_points - 1 : 0, w->path_segments)
+        || upload(desc->path_offsets, desc->path_points, w->path_offsets)
+        || upload_grid(desc->path_grid, w->path_grid)
+        || upload(desc->curve_position, desc->curve_points, w->curve_position)
+        || upload(desc->curve_offsets, desc->curve_points, w->curve_offsets)
+        || upload(desc->curve_forwards, desc->curve_points, w->curve_forwards)
+        || upload_grid(desc->curve_grid, w->curve_grid)
+        || upload(desc->shapes, desc->shape_count, w->shapes)
+        || upload(desc->shape_local, desc->shape_point_count, w->shape_local)
+        || upload(desc->shape_normals, desc->shape_point_count, w->shape_normals)
+        || upload_grid(desc->shape_grid, w->shape_grid)
+        || upload(desc->path_xy, (size_t)desc->path_points * 2, w->path_xy);
+    if (bad) {
+        fprintf(stderr, "altd_gpu: world upload failed\n");
+        altd_gpu_world_free(w);
+        return nullptr;
+    }
+    return w;
+}
+
+ALTD_API void altd_gpu_world_free(World* w) {
+    if (!w) return;
+    for (const void* p : {(const void*)w->ray_nodes, (const void*)w->ray_walls, (const void*)w->surfaces,
+                          (const void*)w->tiles, (const void*)w->path_segments, (const void*)w->path_offsets,
+                          (const void*)w->path_grid.start, (const void*)w->path_grid.items,
+                          (const void*)w->curve_position, (const void*)w->curve_offsets, (const void*)w->curve_forwards,
+                          (const void*)w->curve_grid.start, (const void*)w->curve_grid.items,
+                          (const void*)w->shapes, (const void*)w->shape_local, (const void*)w->shape_normals,
+                          (const void*)w->shape_grid.start, (const void*)w->shape_grid.items, (const void*)w->path_xy})
+        if (p) (void)hipFree((void*)p);
+    delete w;
+}
+
+// Runs `n` BSP queries (see QueryOp) on host arrays.
+ALTD_API int altd_gpu_query(const World* w, int op, int n, const float4* in, float4* out) {
+    float4 *d_in, *d_out;
+    CHECK(hipMalloc(&d_in, sizeof(float4) * n));
+    CHECK(hipMalloc(&d_out, sizeof(float4) * n));
+    CHECK(hipMemcpy(d_in, in, sizeof(float4) * n, hipMemcpyHostToDevice));
+    query_kernel<<<(n + 255) / 256, 256>>>(*w, op, n, d_in, d_out);
+    CHECK(hipGetLastError());
+    CHECK(hipMemcpy(out, d_out, sizeof(float4) * n, hipMemcpyDeviceToHost));
+    CHECK(hipFree(d_in));
+    CHECK(hipFree(d_out));
+    return 0;
+}
+
+
+// Struct sizes and a few offsets, for the Rust layout check.
+ALTD_API int altd_gpu_layout(uint64_t* out, int n) {
+    uint64_t v[] = {sizeof(World), sizeof(Car), sizeof(Contact), sizeof(Agent), sizeof(VehicleDesc), sizeof(SensorDesc),
+                    sizeof(WheelDesc), sizeof(ShapeDev), sizeof(TileCell), sizeof(PathSeg), sizeof(NearGrid),
+                    offsetof(World, tiles), offsetof(World, curve_grid), offsetof(World, shape_grid),
+                    offsetof(Car, tick), offsetof(Car, pairs), offsetof(Car, contacts), offsetof(Agent, recent),
+                    offsetof(VehicleDesc, steering_speed), offsetof(VehicleDesc, gravity), offsetof(World, math_profile)};
+    int count = (int)(sizeof(v) / sizeof(v[0]));
+    for (int i = 0; i < n && i < count; i++) out[i] = v[i];
+    return count;
+}
+
+ALTD_API Sim* altd_gpu_sim_create(const World* world, const VehicleDesc* vehicle, const SensorDesc* sensors, uint32_t sensor_count,
+                         uint32_t capacity) {
+    if (sensor_count > (uint32_t)MAX_SENSORS || vehicle->wheel_count > (uint32_t)MAX_WHEELS) return nullptr;
+    Sim* s = new (std::nothrow) Sim{};
+    if (!s) return nullptr;
+    s->world = *world;
+    s->vehicle = *vehicle;
+    s->sensors.count = sensor_count;
+    for (uint32_t k = 0; k < sensor_count; k++) {
+        s->sensors.s[k] = sensors[k];
+        s->sensors.needs_path |= sensors[k].kind == S_CORRECT_DIRECTION || sensors[k].kind == S_TRACK_CURVATURE;
+    }
+    s->capacity = capacity;
+    if (hipMalloc(&s->cars, sizeof(Car) * capacity) || hipMalloc(&s->agents, sizeof(Agent) * capacity)
+        || hipMalloc(&s->here, sizeof(float) * capacity) || hipMalloc(&s->inputs, sizeof(double) * capacity * MAX_SENSORS)
+        || hipMalloc(&s->live[0], sizeof(uint32_t) * ((capacity + 7) / 8) * 8) || hipMalloc(&s->live[1], sizeof(uint32_t) * ((capacity + 7) / 8) * 8)
+        || hipMalloc(&s->steps[0], sizeof(uint32_t) * capacity) || hipMalloc(&s->steps[1], sizeof(uint32_t) * capacity)
+        || hipMalloc(&s->settled_at, sizeof(uint32_t) * capacity) || hipMalloc(&s->shadow, sizeof(Car) * capacity)
+        || hipMalloc(&s->carry, sizeof(StepCarry) * capacity) || hipMalloc(&s->items, sizeof(uint32_t) * capacity * MAX_PAIRS)
+        || hipMalloc(&s->pushes, sizeof(Vec2) * capacity * MAX_PAIRS)
+        || hipMalloc(&s->novelty, sizeof(double) * capacity)
+        || hipMalloc(&s->state, sizeof(WindowState)) || hipHostMalloc(&s->host_stopped, sizeof(uint32_t) * 4)
+        || hipMalloc(&s->active, sizeof(uint32_t))
+        || hipEventCreateWithFlags(&s->chunk_done[0], hipEventDisableTiming) || hipEventCreateWithFlags(&s->chunk_done[1], hipEventDisableTiming)
+        || hipEventCreateWithFlags(&s->chunk_done[2], hipEventDisableTiming) || hipEventCreateWithFlags(&s->chunk_done[3], hipEventDisableTiming)
+        || hipStreamCreate(&s->stream)) {
+        fprintf(stderr, "altd_gpu: sim allocation failed\n");
+        altd_gpu_sim_free(s);
+        return nullptr;
+    }
+    return s;
+}
+
+struct RefreshedSensors { Sensors sensors; uint32_t error; };
+
+// Ray endpoints belong to the world's math profile. Recompute once per profile
+// switch, retaining the precomputed endpoints in the per-car sensing kernels.
+__global__ void refresh_ray_offsets(Sensors sensors, uint32_t math, RefreshedSensors* out) {
+    uint32_t error = 0;
+    for (uint32_t i = 0; i < sensors.count; ++i) {
+        SensorDesc& sensor = sensors.s[i];
+        if (sensor.kind != S_RAYCAST) continue;
+        float angle = (sensor.a - 90.0f) * (PI_F / 180.0f);
+        sensor.offset = Vec2{profile_cos(math, angle, error) * sensor.b,
+                             profile_sin(math, angle, error) * sensor.b};
+    }
+    out->sensors = sensors;
+    out->error = error;
+}
+
+// Graph kernels capture world pointers by value. Invalidate the graph before
+// releasing the old track, while retaining all population allocations.
+ALTD_API int altd_gpu_sim_set_world(Sim* s, const World* world) {
+    CHECK(hipStreamSynchronize(s->stream));
+    Sensors sensors = s->sensors;
+    if (s->world.math_profile != world->math_profile) {
+        struct DeviceBuffer {
+            RefreshedSensors* value = nullptr;
+            ~DeviceBuffer() { if (value) (void)hipFree(value); }
+        } buffer;
+        CHECK(hipMalloc(&buffer.value, sizeof(RefreshedSensors)));
+        refresh_ray_offsets<<<1, 1, 0, s->stream>>>(sensors, world->math_profile, buffer.value);
+        CHECK(hipGetLastError());
+        CHECK(hipStreamSynchronize(s->stream));
+        RefreshedSensors refreshed{};
+        CHECK(hipMemcpy(&refreshed, buffer.value, sizeof(refreshed), hipMemcpyDeviceToHost));
+        if (refreshed.error) return -static_cast<int>(refreshed.error);
+        sensors = refreshed.sensors;
+    }
+    if (s->graph_exec) {
+        CHECK(hipGraphExecDestroy(s->graph_exec));
+        s->graph_exec = nullptr;
+    }
+    s->sensors = sensors;
+    s->world = *world;
+    return 0;
+}
+
+ALTD_API void altd_gpu_sim_free(Sim* s) {
+    if (!s) return;
+    if (s->graph_exec) (void)hipGraphExecDestroy(s->graph_exec);
+    for (void* p : {(void*)s->cars, (void*)s->agents, (void*)s->here, (void*)s->inputs, (void*)s->params, (void*)s->live[0],
+                    (void*)s->live[1], (void*)s->steps[0], (void*)s->steps[1], (void*)s->settled_at, (void*)s->shadow, (void*)s->state,
+                    (void*)s->carry, (void*)s->items, (void*)s->pushes, (void*)s->mean, (void*)s->novelty, (void*)s->active})
+        if (p) (void)hipFree(p);
+    if (s->host_stopped) (void)hipHostFree(s->host_stopped);
+    for (hipEvent_t e : s->chunk_done)
+        if (e) (void)hipEventDestroy(e);
+    if (s->stream) (void)hipStreamDestroy(s->stream);
+    delete s;
+}
+
+// Uploads `n` cars and (if not null) agents.
+ALTD_API int altd_gpu_sim_upload(Sim* s, uint32_t n, const Car* cars, const Agent* agents) {
+    if (n > s->capacity) return -1;
+    s->n = n;
+    CHECK(hipMemcpy(s->cars, cars, sizeof(Car) * n, hipMemcpyHostToDevice));
+    if (agents) CHECK(hipMemcpy(s->agents, agents, sizeof(Agent) * n, hipMemcpyHostToDevice));
+    return 0;
+}
+
+ALTD_API int altd_gpu_sim_upload_agents(Sim* s, uint32_t n, const Agent* agents) {
+    if (n != s->n) return -1;
+    CHECK(hipMemcpy(s->agents, agents, sizeof(Agent) * n, hipMemcpyHostToDevice));
+    return 0;
+}
+
+// The number of uploaded cars that are active, without reading them back.
+ALTD_API int altd_gpu_sim_active_count(Sim* s, uint32_t* out) {
+    CHECK(hipMemsetAsync(s->active, 0, sizeof(uint32_t), s->stream));
+    if (s->n) active_count_kernel<<<blocks(s->n), 256, 0, s->stream>>>(s->cars, s->n, s->active);
+    CHECK(hipGetLastError());
+    CHECK(hipMemcpyAsync(out, s->active, sizeof(uint32_t), hipMemcpyDeviceToHost, s->stream));
+    CHECK(hipStreamSynchronize(s->stream));
+    return 0;
+}
+
+ALTD_API int altd_gpu_sim_download(Sim* s, Car* cars, Agent* agents) {
+    CHECK(hipDeviceSynchronize());
+    if (cars) CHECK(hipMemcpy(cars, s->cars, sizeof(Car) * s->n, hipMemcpyDeviceToHost));
+    if (agents) CHECK(hipMemcpy(agents, s->agents, sizeof(Agent) * s->n, hipMemcpyDeviceToHost));
+    return 0;
+}
+
+// Reads the sensors of the cars selected by `mask`; if `inputs` is not null,
+// copies all n * sensor_count values back (unread cars keep stale values).
+ALTD_API int altd_gpu_sim_sensors(Sim* s, ReadMask mask, double* inputs) {
+    if (s->n == 0) return 0;
+    if (s->sensors.needs_path) path_offset_kernel<<<blocks(s->n, 64), 64>>>(s->world, mask, s->cars, s->n, s->here);
+    sensor_kernel<<<blocks((size_t)s->n * s->sensors.count, 64), 64>>>(s->world, s->vehicle, s->sensors, mask, s->cars, s->n,
+                                                                    s->here, s->inputs);
+    CHECK(hipGetLastError());
+    if (inputs)
+        CHECK(hipMemcpy(inputs, s->inputs, sizeof(double) * s->n * s->sensors.count, hipMemcpyDeviceToHost));
+    return 0;
+}
+
+// Installs one network per car: `layers` widths, then n * parameter_count(widths)
+// f64 parameters (Network::params, car-major). `control_src` as in NetShape.
+ALTD_API int altd_gpu_sim_networks(Sim* s, uint32_t layers, const uint32_t* width, uint32_t n, const double* params,
+                          const int32_t* control_src) {
+    if (layers < 2 || layers > (uint32_t)MAX_LAYERS || n > s->capacity || width[0] != s->sensors.count) return -1;
+    NetShape shape{};
+    shape.layers = layers;
+    size_t stride = 0;
+    for (uint32_t l = 0; l < layers; l++) {
+        if (width[l] == 0 || width[l] > (uint32_t)MAX_WIDTH || (l > 0 && width[l] > (uint32_t)LANES)) return -1;
+        shape.width[l] = width[l];
+        if (l > 0) stride += (size_t)(width[l - 1] + 1) * width[l];
+    }
+    for (int c = 0; c < 5; c++) {
+        if (control_src[c] >= (int32_t)width[layers - 1]) return -1;
+        shape.control_src[c] = control_src[c];
+    }
+    // The graph embeds the network shape and parameter pointer. Parameter
+    // contents may change in place without invalidating it.
+    if (s->graph_exec && memcmp(&shape, &s->shape, sizeof shape) != 0) {
+        CHECK(hipGraphExecDestroy(s->graph_exec));
+        s->graph_exec = nullptr;
+    }
+    if (stride != s->stride || !s->params) {
+        if (s->params) CHECK(hipFree(s->params));
+        if (s->mean) CHECK(hipFree(s->mean));
+        s->params = nullptr;
+        s->mean = nullptr;
+        CHECK(hipMalloc(&s->params, sizeof(double) * stride * s->capacity));
+        CHECK(hipMalloc(&s->mean, sizeof(double) * stride));
+    }
+    s->shape = shape;
+    s->stride = stride;
+    CHECK(hipMemcpy(s->params, params, sizeof(double) * stride * n, hipMemcpyHostToDevice));
+    s->network_count = n;
+    return 0;
+}
+
+// One thread per parameter preserves the CPU's left-to-right population sum.
+// Only `stride` such threads exist (a few dozen waves), so with one load in
+// flight per add the population's 8 bytes x n x stride stream far below the
+// memory bandwidth. Each block therefore stages MEAN_ROWS networks' slice of
+// its MEAN_COLS parameters in LDS with all MEAN_THREADS threads loading
+// (coalesced rows, many loads in flight), then the MEAN_COLS summing threads
+// add the staged rows in ascending network order, exactly as before.
+constexpr uint32_t MEAN_COLS = 64, MEAN_ROWS = 64, MEAN_THREADS = 256;
+
+__global__ void __launch_bounds__(MEAN_THREADS)
+population_mean_kernel(const double* params, size_t stride, uint32_t n, double* mean) {
+    __shared__ double tile[MEAN_ROWS][MEAN_COLS + 1];
+    uint32_t t = threadIdx.x;
+    size_t col0 = (size_t)blockIdx.x * MEAN_COLS;
+    bool sums = t < MEAN_COLS && col0 + t < stride;
+    double sum = 0.0;
+    for (uint32_t row0 = 0; row0 < n; row0 += MEAN_ROWS) {
+        uint32_t rows = min(MEAN_ROWS, n - row0);
+        for (uint32_t e = t; e < rows * MEAN_COLS; e += MEAN_THREADS) {
+            uint32_t r = e / MEAN_COLS, c = e % MEAN_COLS;
+            if (col0 + c < stride) tile[r][c] = params[(size_t)(row0 + r) * stride + col0 + c];
+        }
+        __syncthreads();
+        if (sums)
+            for (uint32_t r = 0; r < rows; r++) sum += tile[r][t];
+        __syncthreads();
+    }
+    if (sums) mean[col0 + t] = sum / (double)n;
+}
+
+// Parallelize the expensive pow calls, then add their results in the exact
+// parameter order used by TrainingRunner::install. pow(x, 2) is the game's
+// routine and must not be replaced by x*x or a parallel sum.
+__global__ void __launch_bounds__(64)
+population_novelty_kernel(uint32_t math, const double* params, size_t stride, const double* mean, double* novelty) {
+    __shared__ double terms[64];
+    size_t car = blockIdx.x;
+    uint32_t lane = threadIdx.x;
+    double sum = 0.0;
+    for (size_t base = 0; base < stride; base += 64) {
+        size_t j = base + lane;
+        if (j < stride) terms[lane] = profile_pow(math, params[car * stride + j] - mean[j], 2.0);
+        __syncthreads();
+        if (lane == 0)
+            for (uint32_t k = 0; k < 64 && base + k < stride; k++) sum += terms[k];
+        __syncthreads();
+    }
+    if (lane == 0) novelty[car] = sqrt(sum);
+}
+
+ALTD_API int altd_gpu_sim_novelty(Sim* s, uint32_t n, double* novelty) {
+    if (n != s->network_count || !s->params) return -1;
+    if (n == 0) return 0;
+    population_mean_kernel<<<blocks(s->stride, MEAN_COLS), MEAN_THREADS, 0, s->stream>>>(s->params, s->stride, n, s->mean);
+    population_novelty_kernel<<<n, 64, 0, s->stream>>>(s->world.math_profile, s->params, s->stride, s->mean, s->novelty);
+    CHECK(hipGetLastError());
+    CHECK(hipMemcpyAsync(novelty, s->novelty, sizeof(double) * n, hipMemcpyDeviceToHost, s->stream));
+    CHECK(hipStreamSynchronize(s->stream));
+    return 0;
+}
+
+// Sensors and network for the cars in `mask`: sets their Agent::controls.
+ALTD_API int altd_gpu_sim_infer(Sim* s, ReadMask mask) {
+    if (!s->params) return -1;
+    if (s->n == 0) return 0;
+    int status = altd_gpu_sim_sensors(s, mask, nullptr);
+    if (status) return status;
+    forward_kernel<<<blocks(s->n, CARS_PER_BLOCK), LANES * CARS_PER_BLOCK>>>(s->world.math_profile, s->shape, s->params, s->stride, mask, s->cars, s->n,
+                                                                            s->inputs, s->agents);
+    CHECK(hipGetLastError());
+    return 0;
+}
+
+// Counts the cars still active afterwards into `active` if not null.
+__global__ void stats_kernel(World w, Car* cars, Agent* agents, uint32_t n, uint64_t tick, uint64_t stats_tick,
+                             uint32_t eliminate_when_idle, uint32_t* active) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n) return;
+    uint32_t err = 0;
+    update_stats(w, cars[i], agents[i], tick, stats_tick, eliminate_when_idle != 0, err);
+    cars[i].error |= err;
+    if (active && (cars[i].flags & CAR_ACTIVE)) atomicAdd(active, 1u);
+}
+
+// One physics tick for all cars (see step_kernel). Needs physics shapes
+// (the shapeless resolve_walls path is not ported).
+ALTD_API int altd_gpu_sim_step(Sim* s, uint32_t drive, uint32_t eliminate_on_wall, uint64_t tick) {
+    if (s->world.shape_count == 0) return -2;
+    if (s->n == 0) return 0;
+    if (!split_step()) {
+        step_kernel<<<blocks(s->n, STEP_THREADS), STEP_THREADS>>>(s->world, s->vehicle, s->cars, s->agents, s->n, drive, eliminate_on_wall, tick);
+        CHECK(hipGetLastError());
+        return 0;
+    }
+    CHECK(hipMemset(s->state, 0, sizeof(WindowState)));
+    step_begin_kernel<<<blocks(s->n, STEP_THREADS), STEP_THREADS>>>(s->world, s->vehicle, s->cars, s->agents, s->n, drive, s->carry, s->items, s->state);
+    sat_kernel<<<blocks(s->n, STEP_THREADS), STEP_THREADS>>>(s->world, s->vehicle, s->cars, s->items, s->state, s->pushes);
+    step_end_kernel<<<blocks(s->n, STEP_THREADS), STEP_THREADS>>>(s->world, s->vehicle, s->cars, s->agents, s->n, drive, eliminate_on_wall, tick, s->carry,
+                                              s->pushes, s->state);
+    CHECK(hipGetLastError());
+    return 0;
+}
+
+// Schedule::update_stats for all cars on a statistics tick.
+ALTD_API int altd_gpu_sim_stats(Sim* s, uint64_t tick, uint64_t stats_tick, uint32_t eliminate_when_idle) {
+    if (s->world.path_points < 2) return -2;  // Track::closest_path needs a path
+    if (s->n == 0) return 0;
+    stats_kernel<<<blocks(s->n, 64), 64>>>(s->world, s->cars, s->agents, s->n, tick, stats_tick, eliminate_when_idle, nullptr);
+    CHECK(hipGetLastError());
+    return 0;
+}
+
+// ---- whole windows ----
+//
+// TrainingRunner::advance_window (not paused, no native broadphase), in the
+// tick-major order: per tick the statistics (on statistics ticks, followed by
+// the stop test), then the batch's sensors + forward, then the physics step.
+//
+// The host only enqueues: the stop test runs on the device and every later
+// kernel of the window returns at once. Kernels walk compact work lists,
+// double-buffered and rebuilt on statistics ticks:
+//  - live: the cars that may read sensors or change statistics (active, or
+//    with a pending contact at the window start); after each statistics
+//    update exactly the active cars. Cars deactivated by a wall stay listed
+//    until the next rebuild and are filtered by their active flag. Each live
+//    list has eight segments, retaining the cars' original inference batches.
+//  - step: the cars still stepped. An inactive car whose step leaves every
+//    field but `tick` bitwise unchanged is settled: `car_step` is a pure
+//    function of that state for inactive cars (controls, agent and tick are
+//    not read), so all its later steps repeat it. Settled cars leave the list
+//    and get the skipped `tick` increments when the window ends.
+constexpr uint32_t NOT_SETTLED = 0xffffffffu;
+
+// Appends `value` where `take`, one atomic per wave; every lane must call it.
+__device__ inline void append(bool take, uint32_t value, uint32_t* list, uint32_t* count) {
+    uint64_t mask = altd_ballot(take);
+    if (!mask) return;
+    uint32_t lane = altd_lane_id();
+    uint32_t leader = (uint32_t)__ffsll((unsigned long long)mask) - 1;
+    uint32_t base = 0;
+    if (lane == leader) base = atomicAdd(count, (uint32_t)__popcll(mask));
+    base = altd_shfl(base, leader);
+    if (take) list[base + (uint32_t)__popcll(mask & ((1ull << lane) - 1))] = value;
+}
+
+// The Car state `car_step` reads: everything but `tick`, and the used pairs and contacts.
+__device__ inline void snapshot(const Car& c, Car& s) {
+    altd_memcpy(&s, &c, offsetof(Car, pairs));
+    altd_memcpy(s.pairs, c.pairs, sizeof(uint32_t) * c.pair_count);
+    altd_memcpy(s.axes, c.axes, sizeof(Vec2) * c.pair_count);
+    altd_memcpy(s.contacts, c.contacts, sizeof(Contact) * c.contact_count);
+}
+
+__device__ inline bool same_words(const void* a, const void* b, size_t bytes) {
+    uint32_t differ = 0;
+    for (size_t k = 0; k < bytes; k += 4) {
+        uint32_t x, y;
+        altd_memcpy(&x, (const char*)a + k, 4);
+        altd_memcpy(&y, (const char*)b + k, 4);
+        differ |= x ^ y;
+    }
+    return differ == 0;
+}
+
+__device__ inline bool same_state(const Car& s, const Car& c) {
+    if (s.pair_count != c.pair_count || s.contact_count != c.contact_count) return false;
+    return same_words(&s, &c, offsetof(Car, tick))
+        && same_words((const char*)&s + offsetof(Car, tick) + 8, (const char*)&c + offsetof(Car, tick) + 8,
+                      offsetof(Car, pairs) - offsetof(Car, tick) - 8)
+        && same_words(s.pairs, c.pairs, sizeof(uint32_t) * c.pair_count)
+        && same_words(s.axes, c.axes, sizeof(Vec2) * c.pair_count)
+        && same_words(s.contacts, c.contacts, sizeof(Contact) * c.contact_count);
+}
+
+// Clears HAS_DEACTIVATED and builds the first live and step lists (index 0).
+__global__ void w_start_kernel(Car* cars, Agent* agents, uint32_t n, uint32_t* live, uint32_t* steps, uint32_t* settled_at,
+                               WindowState* st) {
+    uint32_t batch_size = (n + 7) / 8, batch = blockIdx.y;
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x;
+    uint32_t i = batch * batch_size + j;
+    bool valid = j < batch_size && i < n, listed = false;
+    if (valid) {
+        uint32_t flags = agents[i].flags & ~AGENT_HAS_DEACTIVATED;
+        agents[i].flags = flags;
+        settled_at[i] = NOT_SETTLED;
+        listed = (cars[i].flags & CAR_ACTIVE) || (flags & AGENT_PENDING_CONTACT);
+    }
+    append(listed, i, live + batch * batch_size, &st->live_count[0][batch]);
+    append(valid, i, steps, &st->step_count[0]);
+}
+
+// Statistics of the live cars in list p; the still active ones form list 1 - p.
+__global__ void w_stats_kernel(World w, Car* cars, Agent* agents, const uint32_t* in, uint32_t* out, WindowState* st, uint32_t p, uint32_t batch_size,
+                               uint64_t start_tick, uint32_t off, uint64_t first, uint32_t eliminate_when_idle) {
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x;
+    uint32_t batch = blockIdx.y;
+    bool valid = !st->stopped && j < st->live_count[p][batch], keep = false;
+    uint32_t i = valid ? in[batch * batch_size + j] : 0;
+    if (valid) {
+        uint32_t err = 0;
+        uint64_t tick = start_tick + st->base + off;
+        update_stats(w, cars[i], agents[i], tick, tick - first, eliminate_when_idle != 0, err);
+        cars[i].error |= err;
+        keep = cars[i].flags & CAR_ACTIVE;
+    }
+    append(keep, i, out + batch * batch_size, &st->live_count[1 - p][batch]);
+}
+
+// The stop test after the statistics of tick k (live list 1 - p holds the
+// active cars); clears the counts the next rebuilds append to.
+__global__ void w_stop_kernel(WindowState* st, uint32_t p, uint64_t start_tick, uint32_t off, uint64_t first,
+                              uint32_t has_time_limit, double time_limit, uint32_t stop_when_inactive) {
+    if (st->stopped) return;
+    uint64_t k = st->base + off;
+    bool time_stop = has_time_limit && (double)((start_tick + k - first) / 6) * 0.1 >= time_limit;
+    uint32_t live = 0;
+    for (uint32_t b = 0; b < 8; b++) live += st->live_count[1 - p][b];
+    if (time_stop || (stop_when_inactive && live == 0)) {
+        st->stopped = 1;
+        st->executed = k;
+        return;
+    }
+    for (uint32_t b = 0; b < 8; b++) st->live_count[p][b] = 0;
+    st->step_count[1 - p] = 0;
+}
+
+// The live lists retain original batch identity. Each y slice handles one
+// scheduled batch; z slices of the sensor grid handle individual sensors.
+__global__ void w_path_offset_kernel(World w, ReadMask m, Car* cars, const uint32_t* list, const WindowState* st, uint32_t p,
+                                     float* here) {
+    uint32_t batch = (m.batch_index + blockIdx.y) % 8;
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x;
+    if (st->stopped || j >= st->live_count[p][batch]) return;
+    uint32_t i = list[batch * m.batch_size + j];
+    if (!(cars[i].flags & CAR_ACTIVE)) return;
+    here[i] = sensor_path_offset(w, cars[i]);
+}
+
+__global__ void w_sensor_kernel(World w, VehicleDesc v, Sensors s, ReadMask m, Car* cars, const uint32_t* list,
+                                const WindowState* st, uint32_t p, const float* here, double* inputs) {
+    uint32_t batch = (m.batch_index + blockIdx.y) % 8;
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x, k = blockIdx.z;
+    if (st->stopped || j >= st->live_count[p][batch]) return;
+    uint32_t i = list[batch * m.batch_size + j];
+    if (!(cars[i].flags & CAR_ACTIVE)) return;
+    uint32_t err = 0;
+    inputs[(size_t)i * s.count + k] = sensor_value(w, v, cars[i], s.s[k], s.needs_path ? here[i] : 0.0f, err);
+    if (err) atomicOr(&cars[i].error, err);
+}
+
+__global__ void __launch_bounds__(LANES * CARS_PER_BLOCK)
+w_forward_kernel(uint32_t math, NetShape shape, const double* __restrict__ params, size_t stride, ReadMask m, const Car* cars,
+                 const uint32_t* list, const WindowState* st, uint32_t p, const double* __restrict__ inputs, Agent* agents) {
+    uint32_t batch = (m.batch_index + blockIdx.y) % 8;
+    uint32_t count = st->live_count[p][batch];
+    if (st->stopped || blockIdx.x * CARS_PER_BLOCK >= count) return;  // uniform per block
+    uint32_t j = blockIdx.x * CARS_PER_BLOCK + threadIdx.x / LANES;
+    uint32_t car = j < count ? list[batch * m.batch_size + j] : 0;
+    bool live = j < count && (cars[car].flags & CAR_ACTIVE);
+    forward_car(math, shape, params, stride, live, car, inputs, agents);
+}
+
+// Steps the cars of step list q. With `out`, inactive cars are checked for
+// settling and the others form step list 1 - q.
+__global__ void __launch_bounds__(STEP_THREADS) w_step_kernel(World w, VehicleDesc v, Car* cars, Agent* agents, const uint32_t* in, uint32_t* out, WindowState* st,
+                              uint32_t q, uint32_t* settled_at, Car* shadow, uint32_t eliminate_on_wall, uint64_t start_tick,
+                              uint32_t off) {
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x;
+    bool valid = !st->stopped && j < st->step_count[q], keep = valid;
+    uint32_t i = valid ? in[j] : 0;
+    if (valid) {
+        uint64_t k = st->base + off;  // the step index: one step per tick
+        uint64_t tick = start_tick + k;
+        uint32_t step_index = (uint32_t)k;
+        Car& car = cars[i];
+        bool check = out && !(car.flags & CAR_ACTIVE);
+        if (check) snapshot(car, shadow[i]);
+        step_car(w, v, car, agents[i], true, eliminate_on_wall != 0, tick);
+        if (check && same_state(shadow[i], car)) {
+            settled_at[i] = step_index;
+            keep = false;
+        }
+    }
+    if (out) append(keep, i, out, &st->step_count[1 - q]);
+}
+
+// w_step_kernel split (see sat_kernel): begin, then the SAT items, then end.
+__global__ void __launch_bounds__(STEP_THREADS) w_step_begin_kernel(World w, VehicleDesc v, Car* cars, Agent* agents, const uint32_t* in, WindowState* st, uint32_t q,
+                                    uint32_t settle, Car* shadow, StepCarry* carry, uint32_t* items) {
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x;
+    if (st->stopped) return;  // uniform
+    bool valid = j < st->step_count[q];
+    uint32_t i = valid ? in[j] : 0;
+    if (valid && settle && !(cars[i].flags & CAR_ACTIVE)) snapshot(cars[i], shadow[i]);
+    begin_car(w, v, cars, agents, valid, i, true, carry, items, &st->items);
+}
+
+__global__ void __launch_bounds__(STEP_THREADS) w_step_end_kernel(World w, VehicleDesc v, Car* cars, Agent* agents, const uint32_t* in, uint32_t* out, WindowState* st,
+                                  uint32_t q, uint32_t* settled_at, const Car* shadow, uint32_t eliminate_on_wall, uint64_t start_tick,
+                                  uint32_t off, const StepCarry* carry, const Vec2* pushes) {
+    uint32_t j = blockIdx.x * blockDim.x + threadIdx.x;
+    if (j == 0) st->items = 0;  // the SAT kernel is done with them
+    bool valid = !st->stopped && j < st->step_count[q], keep = valid;
+    uint32_t i = valid ? in[j] : 0;
+    if (valid) {
+        uint64_t k = st->base + off;
+        const StepCarry& c = carry[i];
+        bool check = out && !c.was_active;
+        end_car(w, v, cars[i], agents[i], c, pushes, true, eliminate_on_wall != 0, start_tick + k);
+        if (check && same_state(shadow[i], cars[i])) {
+            settled_at[i] = (uint32_t)k;
+            keep = false;
+        }
+    }
+    if (out) append(keep, i, out, &st->step_count[1 - q]);
+}
+
+__global__ void w_advance_kernel(WindowState* st, uint32_t by) { st->base += by; }
+
+// Adds the skipped steps to the settled cars' tick.
+__global__ void w_finish_kernel(Car* cars, uint32_t n, const uint32_t* settled_at, const WindowState* st, uint64_t ticks) {
+    uint32_t i = blockIdx.x * blockDim.x + threadIdx.x;
+    if (i >= n || settled_at[i] == NOT_SETTLED) return;
+    uint64_t steps = st->stopped ? st->executed - 1 : ticks;
+    cars[i].tick += steps - settled_at[i];
+}
+
+ALTD_API int altd_gpu_sim_window(Sim* s, const WindowArgs* a, uint64_t* executed, uint32_t* transition_without_drive) {
+    *executed = 0;
+    *transition_without_drive = 0;
+    if (a->ticks == 0) return 0;
+    if (!s->params || s->world.shape_count == 0 || s->world.path_points < 2) return -2;
+    uint32_t n = s->n;
+    hipStream_t stream = s->stream;
+    // ALTD_GPU_PROFILE=1: GPU time per phase (event pairs around direct launches).
+    // ALTD_GPU_PROFILE=host: only the host thread's CPU time and the wall time.
+    // ALTD_GPU_GRAPH=0: direct launches instead of the period graph.
+    static const char* profile_env = getenv("ALTD_GPU_PROFILE");
+    static const bool profile = profile_env && strcmp(profile_env, "host") != 0;
+    static const char* graph_env = getenv("ALTD_GPU_GRAPH");
+    static const bool use_graph = !profile && !(graph_env && strcmp(graph_env, "0") == 0);
+    const double cpu0 = profile_env ? thread_cpu_seconds() : 0, wall0 = profile_env ? wall_seconds() : 0;
+    double spent[4] = {0, 0, 0, 0};  // stats, sensors, forward, step
+    struct Timed { int slot; uint64_t k; hipEvent_t start, stop; };
+    std::vector<Timed> timed;
+    uint64_t enqueued = 0;  // ticks enqueued so far (profile timeline)
+    auto phase = [&](int slot, auto&& launch) -> int {
+        if (!profile) { launch(); return 0; }
+        Timed t{slot, enqueued, nullptr, nullptr};
+        CHECK(hipEventCreate(&t.start));
+        CHECK(hipEventCreate(&t.stop));
+        CHECK(hipEventRecord(t.start, stream));
+        launch();
+        CHECK(hipEventRecord(t.stop, stream));
+        timed.push_back(t);
+        return 0;
+    };
+    WindowState* st = s->state;
+    CHECK(hipMemsetAsync(st, 0, sizeof(WindowState), stream));
+    if (n) w_start_kernel<<<dim3(blocks((n + 7) / 8, 256), 8), 256, 0, stream>>>(s->cars, s->agents, n, s->live[0], s->steps[0], s->settled_at, st);
+    uint64_t first = a->stats_phase == 0 ? 6 : a->stats_phase;
+    // The time limit stops the window at a known tick; the host runs up to it.
+    uint64_t limit = a->ticks;
+    if (a->has_time_limit)
+        for (uint64_t k = 1; k <= a->ticks; k++) {
+            uint64_t tick = a->start_tick + k;
+            if (tick % 6 == a->stats_phase && (double)((tick - first) / 6) * 0.1 >= a->time_limit) {
+                limit = k;
+                break;
+            }
+        }
+    // Tick k = base + off of a period of PERIOD ticks: the statistics ticks,
+    // read batches and list parity depend only on off, so a period is one graph.
+    constexpr uint32_t PERIOD = 24;  // lcm of the statistics (6) and batch (8) cycles
+    static_assert(PERIOD % 6 == 0 && PERIOD % 8 == 0, "period");
+    auto enqueue_tick = [&](uint32_t off, uint32_t& p) {
+        enqueued++;
+        if (profile && enqueued % 600 == 1) {  // list sizes along the window
+            WindowState now;
+            (void)hipMemcpyAsync(&now, st, sizeof now, hipMemcpyDeviceToHost, stream);  // no CHECK: this lambda returns void
+            (void)hipStreamSynchronize(stream);
+            fprintf(stderr, "  tick %5llu: live %u/%u, steps %u/%u\n", (unsigned long long)enqueued, live_total(now, 0), live_total(now, 1),
+                    now.step_count[0], now.step_count[1]);
+        }
+        uint64_t tick_mod = a->start_tick + off;
+        uint32_t batch_index = (uint32_t)((a->start_batch + ((off - 1) % 8) * a->batches_per_tick) % 8);
+        bool stats = tick_mod % 6 == a->stats_phase;
+        if (stats) {
+            if (n) phase(0, [&] {
+                w_stats_kernel<<<dim3(blocks((n + 7) / 8, 64), 8), 64, 0, stream>>>(s->world, s->cars, s->agents, s->live[p], s->live[1 - p], st, p, (n + 7) / 8,
+                                                                 a->start_tick, off, first, a->eliminate_when_idle);
+                w_stop_kernel<<<1, 1, 0, stream>>>(st, p, a->start_tick, off, first, a->has_time_limit, a->time_limit,
+                                                   a->stop_when_inactive);
+            });
+            else w_stop_kernel<<<1, 1, 0, stream>>>(st, p, a->start_tick, off, first, a->has_time_limit, a->time_limit,
+                                                    a->stop_when_inactive);
+            p = 1 - p;
+        }
+        if (n) {
+            ReadMask mask{(uint32_t)((n + 7) / 8), batch_index, a->batches_per_tick, 1};
+            phase(1, [&] {
+                if (s->sensors.needs_path)
+                    w_path_offset_kernel<<<dim3(blocks(mask.batch_size, 64), mask.batches_per_tick), 64, 0, stream>>>(s->world, mask, s->cars, s->live[p], st, p, s->here);
+                w_sensor_kernel<<<dim3(blocks(mask.batch_size, 64), mask.batches_per_tick, s->sensors.count), 64, 0, stream>>>(s->world, s->vehicle, s->sensors, mask,
+                                                                                           s->cars, s->live[p], st, p, s->here, s->inputs);
+            });
+            phase(2, [&] {
+                w_forward_kernel<<<dim3(blocks(mask.batch_size, CARS_PER_BLOCK), mask.batches_per_tick), LANES * CARS_PER_BLOCK, 0, stream>>>(
+                    s->world.math_profile, s->shape, s->params, s->stride, mask, s->cars, s->live[p], st, p, s->inputs, s->agents);
+            });
+            phase(3, [&] {
+                // On statistics ticks list 1 - p is read and list p rebuilt.
+                uint32_t q = stats ? 1 - p : p;
+                uint32_t* out = stats ? s->steps[p] : nullptr;
+                if (!split_step()) {
+                    w_step_kernel<<<blocks(n, STEP_THREADS), STEP_THREADS, 0, stream>>>(s->world, s->vehicle, s->cars, s->agents, s->steps[q], out, st, q,
+                                                                    s->settled_at, s->shadow, a->eliminate_on_wall, a->start_tick, off);
+                    return;
+                }
+                w_step_begin_kernel<<<blocks(n, STEP_THREADS), STEP_THREADS, 0, stream>>>(s->world, s->vehicle, s->cars, s->agents, s->steps[q], st, q,
+                                                                      out != nullptr, s->shadow, s->carry, s->items);
+                sat_kernel<<<blocks(n, STEP_THREADS), STEP_THREADS, 0, stream>>>(s->world, s->vehicle, s->cars, s->items, st, s->pushes);
+                w_step_end_kernel<<<blocks(n, STEP_THREADS), STEP_THREADS, 0, stream>>>(s->world, s->vehicle, s->cars, s->agents, s->steps[q], out, st, q,
+                                                                    s->settled_at, s->shadow, a->eliminate_on_wall, a->start_tick, off,
+                                                                    s->carry, s->pushes);
+            });
+        }
+    };
+    auto enqueue_period = [&] {
+        uint32_t p = 0;
+        for (uint32_t off = 1; off <= PERIOD; off++) enqueue_tick(off, p);
+        w_advance_kernel<<<1, 1, 0, stream>>>(st, PERIOD);
+    };
+    uint64_t periods = limit / PERIOD, rest = limit % PERIOD;
+    hipGraphExec_t exec = nullptr;
+    if (use_graph && periods > 1) {
+        if (s->graph_exec && (s->graph_n != n || !same_schedule(s->graph_args, *a))) {
+            CHECK(hipGraphExecDestroy(s->graph_exec));
+            s->graph_exec = nullptr;
+        }
+        if (!s->graph_exec) {
+            hipGraph_t graph;
+            CHECK(hipStreamBeginCapture(stream, hipStreamCaptureModeThreadLocal));
+            enqueue_period();
+            CHECK(hipStreamEndCapture(stream, &graph));
+            CHECK(hipGraphInstantiate(&s->graph_exec, graph, nullptr, nullptr, 0));
+            CHECK(hipGraphDestroy(graph));
+            s->graph_n = n;
+            s->graph_args = *a;
+        }
+        exec = s->graph_exec;
+    }
+    // Polls the device stop flag every POLL periods, keeping DEPTH polls queued.
+    constexpr uint64_t POLL = 2;
+    constexpr int DEPTH = 3;
+    uint32_t* seen = s->host_stopped;  // pinned, one slot per queued poll
+    for (int c = 0; c < DEPTH; c++) seen[c] = 0;
+    int polls = 0;
+    bool host_stop = false;
+    double launch_wall = 0, wait_wall = 0;  // host profile: time in launches and in polls
+    for (uint64_t m = 0; m < periods && !host_stop; m++) {
+        double t0 = profile_env ? wall_seconds() : 0;
+        if (exec) CHECK(hipGraphLaunch(exec, stream));
+        else enqueue_period();
+        if (profile_env) launch_wall += wall_seconds() - t0;
+        CHECK(hipGetLastError());
+        if (a->stop_when_inactive && (m + 1) % POLL == 0) {
+            int slot = polls % DEPTH;
+            CHECK(hipMemcpyAsync(&seen[slot], &st->stopped, sizeof(uint32_t), hipMemcpyDeviceToHost, stream));
+            CHECK(hipEventRecord(s->chunk_done[slot], stream));
+            polls++;
+            if (polls >= DEPTH) {  // wait for the oldest queued poll
+                int oldest = polls % DEPTH;
+                double t1 = profile_env ? wall_seconds() : 0;
+                CHECK(hipEventSynchronize(s->chunk_done[oldest]));
+                if (profile_env) wait_wall += wall_seconds() - t1;
+                host_stop = seen[oldest] != 0;
+            }
+        }
+    }
+    if (!host_stop) {
+        uint32_t p = 0;
+        for (uint32_t off = 1; off <= rest; off++) enqueue_tick(off, p);
+    }
+    if (n) w_finish_kernel<<<blocks(n, 256), 256, 0, stream>>>(s->cars, n, s->settled_at, st, a->ticks);
+    CHECK(hipGetLastError());
+    WindowState result;
+    CHECK(hipMemcpyAsync(&result, st, sizeof result, hipMemcpyDeviceToHost, stream));
+    CHECK(hipStreamSynchronize(stream));
+    *executed = result.stopped ? result.executed : limit;
+    *transition_without_drive = result.stopped;
+    constexpr uint64_t SPAN = 600;  // profile timeline bucket, ticks
+    std::vector<double> line(4 * (limit / SPAN + 1), 0.0);
+    for (const Timed& t : timed) {
+        float ms = 0.0f;
+        CHECK(hipEventElapsedTime(&ms, t.start, t.stop));
+        spent[t.slot] += ms * 1e-3;
+        line[4 * ((t.k - 1) / SPAN) + t.slot] += ms * 1e-3;
+        CHECK(hipEventDestroy(t.start));
+        CHECK(hipEventDestroy(t.stop));
+    }
+    if (profile)
+        fprintf(stderr, "altd_gpu window: %llu ticks, %u cars: stats %.3f s, sensors %.3f s, forward %.3f s, step %.3f s\n",
+                (unsigned long long)*executed, n, spent[0], spent[1], spent[2], spent[3]);
+    if (profile)
+        for (size_t b = 0; 4 * b < line.size(); b++)
+            fprintf(stderr, "  ticks %5zu..: stats %.3f sensors %.3f forward %.3f step %.3f\n", b * SPAN + 1, line[4 * b], line[4 * b + 1],
+                    line[4 * b + 2], line[4 * b + 3]);
+#ifdef ALTD_STEP_TIMING
+    {
+        unsigned long long c[16];
+        int rate_khz = 0;
+        CHECK(hipMemcpyFromSymbol(c, HIP_SYMBOL(g_step_cycles), sizeof c));
+        CHECK(altd_wall_clock_khz(&rate_khz));
+        const char* names[6] = {"drive", "validate", "contacts+merge", "active", "solver", "finish"};
+        double us = 1e3 / (double)rate_khz, steps = (double)(c[8] ? c[8] : 1);
+        fprintf(stderr, "altd_gpu step sections (%llu car steps, %llu solving, %llu pair updates, %llu full scans), us per car step:",
+                c[8], c[9], c[7], c[6]);
+        for (int k = 0; k < 6; k++) fprintf(stderr, " %s %.2f", names[k], (double)c[k] * us / steps);
+        fprintf(stderr, " (pairs %.2f, merge %.2f)", (double)c[10] * us / steps, (double)c[11] * us / steps);
+        fprintf(stderr, "; SAT pairs %.2f per step, axes %.2f per pair, separated %.2f, wall points %.2f",
+                (double)c[12] / steps, (double)c[13] / (double)(c[12] ? c[12] : 1), (double)c[14] / (double)(c[12] ? c[12] : 1),
+                (double)c[15] / (double)(c[12] ? c[12] : 1));
+        fprintf(stderr, "\n");
+        unsigned long long zero[16] = {};
+        CHECK(hipMemcpyToSymbol(HIP_SYMBOL(g_step_cycles), zero, sizeof zero));
+    }
+#endif
+    if (profile_env) {
+        double cpu = cpu0 >= 0 ? thread_cpu_seconds() - cpu0 : -1.0, wall = wall_seconds() - wall0;
+        if (cpu >= 0) fprintf(stderr, "altd_gpu window: host thread cpu %.3f s of %.3f s wall", cpu, wall);
+        else fprintf(stderr, "altd_gpu window: %.3f s wall", wall);
+        fprintf(stderr, " (%s): launches %.3f s, polls %.3f s\n", exec ? "graph" : "direct", launch_wall, wait_wall);
+    }
+    return 0;
+}
+
+ALTD_API int altd_gpu_version() { return 10; }
+
+// The runtime the library was built for: "HIP" (AMD) or "CUDA" (NVIDIA).
+ALTD_API const char* altd_gpu_platform() { return ALTD_PLATFORM; }
+
+// Writes the current device's name, NUL-terminated and truncated to `len`
+// bytes; returns the HIP error, so it also tells whether a device is usable.
+ALTD_API int altd_gpu_device_name(char* out, int len) {
+    if (len <= 0) return (int)hipErrorInvalidValue;
+    int device = 0;
+    hipError_t e = hipGetDevice(&device);
+    if (e != hipSuccess) return (int)e;
+    hipDeviceProp_t prop;
+    e = hipGetDeviceProperties(&prop, device);
+    if (e != hipSuccess) return (int)e;
+    snprintf(out, (size_t)len, "%s", prop.name);
+    return 0;
+}
+
+// Whether the library has kernels for the current device, without launching one: ROCm 7.1 crashes
+// in the launch instead of returning an error when the library was built for another GPU_ARCH.
+// Returns the HIP error, hipErrorNoBinaryForGpu when the kernels are missing.
+ALTD_API int altd_gpu_probe() {
+    hipFuncAttributes attributes;
+    hipError_t e = hipFuncGetAttributes(&attributes, (const void*)math_kernel);
+#if !defined(__CUDACC__)
+    if (e == hipErrorInvalidKernelFile) return (int)hipErrorNoBinaryForGpu;  // HIP's answer for a missing code object
+#endif
+    return (int)e;
+}
+
+// Runs one math primitive over `n` host inputs; `err` gets the per-element error bits.
+ALTD_API int altd_gpu_math(int op, int n, const void* in, void* out, uint32_t* err) {
+    void *d_in, *d_out;
+    uint32_t* d_err;
+    CHECK(hipMalloc(&d_in, in_size(op) * n));
+    CHECK(hipMalloc(&d_out, out_size(op) * n));
+    CHECK(hipMalloc(&d_err, 4 * (size_t)n));
+    CHECK(hipMemcpy(d_in, in, in_size(op) * n, hipMemcpyHostToDevice));
+    math_kernel<<<(n + 255) / 256, 256>>>(op, n, d_in, d_out, d_err);
+    CHECK(hipGetLastError());
+    CHECK(hipMemcpy(out, d_out, out_size(op) * n, hipMemcpyDeviceToHost));
+    CHECK(hipMemcpy(err, d_err, 4 * (size_t)n, hipMemcpyDeviceToHost));
+    CHECK(hipFree(d_in));
+    CHECK(hipFree(d_out));
+    CHECK(hipFree(d_err));
+    return 0;
+}
+
+// Raw engine sin/cos for floats with bits first .. first + n - 1.
+ALTD_API int altd_gpu_engine_scan(uint32_t first, uint32_t n, uint32_t* out) {
+    static uint32_t* d_out = nullptr;
+    static uint32_t capacity = 0;
+    if (n > capacity) {
+        if (d_out) CHECK(hipFree(d_out));
+        CHECK(hipMalloc(&d_out, 8 * (size_t)n));
+        capacity = n;
+    }
+    engine_scan_kernel<<<(n + 255) / 256, 256>>>(first, n, d_out);
+    CHECK(hipGetLastError());
+    CHECK(hipMemcpy(out, d_out, 8 * (size_t)n, hipMemcpyDeviceToHost));
+    return 0;
+}
+
+}  // extern "C"

github-simulator/source/gpu/sim/compat.h

@@ -0,0 +1,135 @@
+// One source for AMD (hipcc) and NVIDIA (nvcc -x cu). Under HIP this header only includes the
+// runtime and forwards the warp helpers to the HIP builtins; under CUDA it maps the hip* runtime
+// names the simulator uses to their cuda* equivalents.
+//
+// ALTD_PLATFORM names the compiler the library was built with ("HIP" or "CUDA").
+//
+// Warp helpers: kernels call altd_lane_id/altd_ballot/altd_shfl*. On AMD a wave is warpSize
+// (32 or 64) lanes and __ballot returns a 64-bit mask. On NVIDIA a warp is 32 lanes and the
+// *_sync forms with a full mask are required; callers already have every lane of the wave call them.
+#pragma once
+
+// Marks the C ABI functions of the library. A Windows DLL exports nothing unless told to.
+#if defined(_WIN32)
+#define ALTD_API __declspec(dllexport)
+#else
+#define ALTD_API
+#endif
+
+#if defined(__CUDACC__)
+
+#include <cuda_runtime.h>
+#include <cstdint>
+#include <cstring>
+
+#define ALTD_PLATFORM "CUDA"
+
+#define hipError_t cudaError_t
+#define hipSuccess cudaSuccess
+#define hipErrorInvalidValue cudaErrorInvalidValue
+#define hipGetErrorString cudaGetErrorString
+#define hipGetLastError cudaGetLastError
+#define hipGetDevice cudaGetDevice
+#define hipDeviceSynchronize cudaDeviceSynchronize
+#define hipDeviceProp_t cudaDeviceProp
+#define hipFuncAttributes cudaFuncAttributes
+#define hipFuncGetAttributes cudaFuncGetAttributes
+#define hipGetDeviceProperties cudaGetDeviceProperties
+
+#define hipMalloc cudaMalloc
+#define hipFree cudaFree
+#define hipHostMalloc(ptr, size) cudaMallocHost(ptr, size)
+#define hipHostFree cudaFreeHost
+#define hipMemcpy cudaMemcpy
+#define hipMemcpyAsync cudaMemcpyAsync
+#define hipMemcpyHostToDevice cudaMemcpyHostToDevice
+#define hipMemcpyDeviceToHost cudaMemcpyDeviceToHost
+#define hipMemset cudaMemset
+#define hipMemsetAsync cudaMemsetAsync
+#define hipMemcpyToSymbol cudaMemcpyToSymbol
+#define hipMemcpyFromSymbol cudaMemcpyFromSymbol
+#define HIP_SYMBOL(symbol) (symbol)
+
+#define hipStream_t cudaStream_t
+#define hipStreamCreate cudaStreamCreate
+#define hipStreamDestroy cudaStreamDestroy
+#define hipStreamSynchronize cudaStreamSynchronize
+#define hipStreamBeginCapture cudaStreamBeginCapture
+#define hipStreamEndCapture cudaStreamEndCapture
+#define hipStreamCaptureModeThreadLocal cudaStreamCaptureModeThreadLocal
+
+#define hipEvent_t cudaEvent_t
+#define hipEventCreate cudaEventCreate
+#define hipEventCreateWithFlags cudaEventCreateWithFlags
+#define hipEventDisableTiming cudaEventDisableTiming
+#define hipEventRecord cudaEventRecord
+#define hipEventSynchronize cudaEventSynchronize
+#define hipEventElapsedTime cudaEventElapsedTime
+#define hipEventDestroy cudaEventDestroy
+
+#define hipGraph_t cudaGraph_t
+#define hipGraphExec_t cudaGraphExec_t
+#define hipGraphLaunch cudaGraphLaunch
+#define hipGraphDestroy cudaGraphDestroy
+#define hipGraphExecDestroy cudaGraphExecDestroy
+// HIP's (exec, graph, error node, log buffer, buffer size) form; CUDA 12+ takes flags instead.
+static inline cudaError_t hipGraphInstantiate(cudaGraphExec_t* exec, cudaGraph_t graph, void*, void*, size_t) {
+    return cudaGraphInstantiate(exec, graph, 0ull);
+}
+
+// ALTD_STEP_TIMING: clock64() counts SM cycles at a varying clock, so the step sections read
+// the nanosecond %globaltimer instead (updated about once a microsecond, so only sums are useful).
+__device__ inline uint64_t wall_clock64() {
+    uint64_t t;
+    asm volatile("mov.u64 %0, %%globaltimer;" : "=l"(t));
+    return t;
+}
+inline cudaError_t altd_wall_clock_khz(int* khz) {
+    *khz = 1000000;
+    return cudaSuccess;
+}
+
+// nvcc's front end does not know clang's __builtin_memcpy.
+__device__ inline void altd_memcpy(void* dst, const void* src, size_t bytes) { memcpy(dst, src, bytes); }
+
+__device__ inline uint32_t altd_lane_id() {
+    uint32_t lane;
+    asm volatile("mov.u32 %0, %%laneid;" : "=r"(lane));
+    return lane;
+}
+__device__ inline uint64_t altd_ballot(bool predicate) { return (uint64_t)__ballot_sync(0xffffffffu, predicate); }
+__device__ inline uint32_t altd_shfl(uint32_t value, uint32_t lane) { return __shfl_sync(0xffffffffu, value, lane); }
+__device__ inline uint32_t altd_shfl_up(uint32_t value, uint32_t delta) { return __shfl_up_sync(0xffffffffu, value, delta); }
+
+#else
+
+#include <hip/hip_runtime.h>
+#include <cstdint>
+
+#define ALTD_PLATFORM "HIP"
+
+inline hipError_t altd_wall_clock_khz(int* khz) { return hipDeviceGetAttribute(khz, hipDeviceAttributeWallClockRate, 0); }
+
+// HIP's device memcpy is a byte loop; the builtin lets clang copy whole words.
+__device__ inline void altd_memcpy(void* dst, const void* src, size_t bytes) { __builtin_memcpy(dst, src, bytes); }
+
+__device__ inline uint32_t altd_lane_id() { return __lane_id(); }
+__device__ inline uint64_t altd_ballot(bool predicate) { return __ballot(predicate); }
+__device__ inline uint32_t altd_shfl(uint32_t value, uint32_t lane) { return (uint32_t)__shfl((int)value, (int)lane); }
+__device__ inline uint32_t altd_shfl_up(uint32_t value, uint32_t delta) { return (uint32_t)__shfl_up((int)value, delta); }
+
+#endif
+
+// NaN results with the CPU's bits. x86 SSE returns the first NaN operand with its quiet bit set,
+// and the default NaN 0xffc00000 (0xfff8000000000000) for an invalid operation such as inf - inf.
+// NVIDIA arithmetic instead returns its canonical NaN, and which NaN plain `a + b` returns on AMD
+// depends on the operand order the compiler picks, so both vendors build the bits explicitly.
+// altd_nan_operand(a, b): the result of an add, multiply or divide when a or b is a NaN.
+// altd_invalid(x): the result of x - x for a NaN or infinite x.
+__device__ inline float altd_nan_operand(float a, float b) {
+    return __uint_as_float(__float_as_uint(isnan(a) ? a : b) | 0x00400000u);
+}
+__device__ inline double altd_nan_operand(double a, double b) {
+    return __longlong_as_double(__double_as_longlong(isnan(a) ? a : b) | 0x0008000000000000ll);
+}
+__device__ inline float altd_invalid(float x) { return isnan(x) ? altd_nan_operand(x, x) : __uint_as_float(0xffc00000u); }

github-simulator/source/gpu/sim/double_tables.h

@@ -0,0 +1,691 @@
+// Generated by gpu/gen_tables.py from src/math/double_math_tables.rs. Do not edit.
+#pragma once
+#include <cstdint>
+__device__ constexpr double INV_LN2_N = __builtin_bit_cast(double, (uint64_t)0x40671547652b82feull);
+__device__ constexpr double NEG_LN2_HI_N = __builtin_bit_cast(double, (uint64_t)0xbf762e42fefa0000ull);
+__device__ constexpr double NEG_LN2_LO_N = __builtin_bit_cast(double, (uint64_t)0xbd0cf79abc9e3b3aull);
+__device__ constexpr double EXP_POLY[4] = {
+__builtin_bit_cast(double, (uint64_t)0x3fdffffffffffdbdull),
+__builtin_bit_cast(double, (uint64_t)0x3fc555555555543cull),
+__builtin_bit_cast(double, (uint64_t)0x3fa55555cf172b91ull),
+__builtin_bit_cast(double, (uint64_t)0x3f81111167a4d017ull)
+};
+__device__ constexpr uint64_t EXP_TAB[256] = {
+0x0ull,
+0x3ff0000000000000ull,
+0x3c9b3b4f1a88bf6eull,
+0x3feff63da9fb3335ull,
+0xbc7160139cd8dc5dull,
+0x3fefec9a3e778061ull,
+0xbc905e7a108766d1ull,
+0x3fefe315e86e7f85ull,
+0x3c8cd2523567f613ull,
+0x3fefd9b0d3158574ull,
+0xbc8bce8023f98efaull,
+0x3fefd06b29ddf6deull,
+0x3c60f74e61e6c861ull,
+0x3fefc74518759bc8ull,
+0x3c90a3e45b33d399ull,
+0x3fefbe3ecac6f383ull,
+0x3c979aa65d837b6dull,
+0x3fefb5586cf9890full,
+0x3c8eb51a92fdeffcull,
+0x3fefac922b7247f7ull,
+0x3c3ebe3d702f9cd1ull,
+0x3fefa3ec32d3d1a2ull,
+0xbc6a033489906e0bull,
+0x3fef9b66affed31bull,
+0xbc9556522a2fbd0eull,
+0x3fef9301d0125b51ull,
+0xbc5080ef8c4eea55ull,
+0x3fef8abdc06c31ccull,
+0xbc91c923b9d5f416ull,
+0x3fef829aaea92de0ull,
+0x3c80d3e3e95c55afull,
+0x3fef7a98c8a58e51ull,
+0xbc801b15eaa59348ull,
+0x3fef72b83c7d517bull,
+0xbc8f1ff055de323dull,
+0x3fef6af9388c8deaull,
+0x3c8b898c3f1353bfull,
+0x3fef635beb6fcb75ull,
+0xbc96d99c7611eb26ull,
+0x3fef5be084045cd4ull,
+0x3c9aecf73e3a2f60ull,
+0x3fef54873168b9aaull,
+0xbc8fe782cb86389dull,
+0x3fef4d5022fcd91dull,
+0x3c8a6f4144a6c38dull,
+0x3fef463b88628cd6ull,
+0x3c807a05b0e4047dull,
+0x3fef3f49917ddc96ull,
+0x3c968efde3a8a894ull,
+0x3fef387a6e756238ull,
+0x3c875e18f274487dull,
+0x3fef31ce4fb2a63full,
+0x3c80472b981fe7f2ull,
+0x3fef2b4565e27cddull,
+0xbc96b87b3f71085eull,
+0x3fef24dfe1f56381ull,
+0x3c82f7e16d09ab31ull,
+0x3fef1e9df51fdee1ull,
+0xbc3d219b1a6fbffaull,
+0x3fef187fd0dad990ull,
+0x3c8b3782720c0ab4ull,
+0x3fef1285a6e4030bull,
+0x3c6e149289cecb8full,
+0x3fef0cafa93e2f56ull,
+0x3c834d754db0abb6ull,
+0x3fef06fe0a31b715ull,
+0x3c864201e2ac744cull,
+0x3fef0170fc4cd831ull,
+0x3c8fdd395dd3f84aull,
+0x3feefc08b26416ffull,
+0xbc86a3803b8e5b04ull,
+0x3feef6c55f929ff1ull,
+0xbc924aedcc4b5068ull,
+0x3feef1a7373aa9cbull,
+0xbc9907f81b512d8eull,
+0x3feeecae6d05d866ull,
+0xbc71d1e83e9436d2ull,
+0x3feee7db34e59ff7ull,
+0xbc991919b3ce1b15ull,
+0x3feee32dc313a8e5ull,
+0x3c859f48a72a4c6dull,
+0x3feedea64c123422ull,
+0xbc9312607a28698aull,
+0x3feeda4504ac801cull,
+0xbc58a78f4817895bull,
+0x3feed60a21f72e2aull,
+0xbc7c2c9b67499a1bull,
+0x3feed1f5d950a897ull,
+0x3c4363ed60c2ac11ull,
+0x3feece086061892dull,
+0x3c9666093b0664efull,
+0x3feeca41ed1d0057ull,
+0x3c6ecce1daa10379ull,
+0x3feec6a2b5c13cd0ull,
+0x3c93ff8e3f0f1230ull,
+0x3feec32af0d7d3deull,
+0x3c7690cebb7aafb0ull,
+0x3feebfdad5362a27ull,
+0x3c931dbdeb54e077ull,
+0x3feebcb299fddd0dull,
+0xbc8f94340071a38eull,
+0x3feeb9b2769d2ca7ull,
+0xbc87deccdc93a349ull,
+0x3feeb6daa2cf6642ull,
+0xbc78dec6bd0f385full,
+0x3feeb42b569d4f82ull,
+0xbc861246ec7b5cf6ull,
+0x3feeb1a4ca5d920full,
+0x3c93350518fdd78eull,
+0x3feeaf4736b527daull,
+0x3c7b98b72f8a9b05ull,
+0x3feead12d497c7fdull,
+0x3c9063e1e21c5409ull,
+0x3feeab07dd485429ull,
+0x3c34c7855019c6eaull,
+0x3feea9268a5946b7ull,
+0x3c9432e62b64c035ull,
+0x3feea76f15ad2148ull,
+0xbc8ce44a6199769full,
+0x3feea5e1b976dc09ull,
+0xbc8c33c53bef4da8ull,
+0x3feea47eb03a5585ull,
+0xbc845378892be9aeull,
+0x3feea34634ccc320ull,
+0xbc93cedd78565858ull,
+0x3feea23882552225ull,
+0x3c5710aa807e1964ull,
+0x3feea155d44ca973ull,
+0xbc93b3efbf5e2228ull,
+0x3feea09e667f3bcdull,
+0xbc6a12ad8734b982ull,
+0x3feea012750bdabfull,
+0xbc6367efb86da9eeull,
+0x3fee9fb23c651a2full,
+0xbc80dc3d54e08851ull,
+0x3fee9f7df9519484ull,
+0xbc781f647e5a3ecfull,
+0x3fee9f75e8ec5f74ull,
+0xbc86ee4ac08b7db0ull,
+0x3fee9f9a48a58174ull,
+0xbc8619321e55e68aull,
+0x3fee9feb564267c9ull,
+0x3c909ccb5e09d4d3ull,
+0x3feea0694fde5d3full,
+0xbc7b32dcb94da51dull,
+0x3feea11473eb0187ull,
+0x3c94ecfd5467c06bull,
+0x3feea1ed0130c132ull,
+0x3c65ebe1abd66c55ull,
+0x3feea2f336cf4e62ull,
+0xbc88a1c52fb3cf42ull,
+0x3feea427543e1a12ull,
+0xbc9369b6f13b3734ull,
+0x3feea589994cce13ull,
+0xbc805e843a19ff1eull,
+0x3feea71a4623c7adull,
+0xbc94d450d872576eull,
+0x3feea8d99b4492edull,
+0x3c90ad675b0e8a00ull,
+0x3feeaac7d98a6699ull,
+0x3c8db72fc1f0eab4ull,
+0x3feeace5422aa0dbull,
+0xbc65b6609cc5e7ffull,
+0x3feeaf3216b5448cull,
+0x3c7bf68359f35f44ull,
+0x3feeb1ae99157736ull,
+0xbc93091fa71e3d83ull,
+0x3feeb45b0b91ffc6ull,
+0xbc5da9b88b6c1e29ull,
+0x3feeb737b0cdc5e5ull,
+0xbc6c23f97c90b959ull,
+0x3feeba44cbc8520full,
+0xbc92434322f4f9aaull,
+0x3feebd829fde4e50ull,
+0xbc85ca6cd7668e4bull,
+0x3feec0f170ca07baull,
+0x3c71affc2b91ce27ull,
+0x3feec49182a3f090ull,
+0x3c6dd235e10a73bbull,
+0x3feec86319e32323ull,
+0xbc87c50422622263ull,
+0x3feecc667b5de565ull,
+0x3c8b1c86e3e231d5ull,
+0x3feed09bec4a2d33ull,
+0xbc91bbd1d3bcbb15ull,
+0x3feed503b23e255dull,
+0x3c90cc319cee31d2ull,
+0x3feed99e1330b358ull,
+0x3c8469846e735ab3ull,
+0x3feede6b5579fdbfull,
+0xbc82dfcd978e9db4ull,
+0x3feee36bbfd3f37aull,
+0x3c8c1a7792cb3387ull,
+0x3feee89f995ad3adull,
+0xbc907b8f4ad1d9faull,
+0x3feeee07298db666ull,
+0xbc55c3d956dcaebaull,
+0x3feef3a2b84f15fbull,
+0xbc90a40e3da6f640ull,
+0x3feef9728de5593aull,
+0xbc68d6f438ad9334ull,
+0x3feeff76f2fb5e47ull,
+0xbc91eee26b588a35ull,
+0x3fef05b030a1064aull,
+0x3c74ffd70a5fddcdull,
+0x3fef0c1e904bc1d2ull,
+0xbc91bdfbfa9298acull,
+0x3fef12c25bd71e09ull,
+0x3c736eae30af0cb3ull,
+0x3fef199bdd85529cull,
+0x3c8ee3325c9ffd94ull,
+0x3fef20ab5fffd07aull,
+0x3c84e08fd10959acull,
+0x3fef27f12e57d14bull,
+0x3c63cdaf384e1a67ull,
+0x3fef2f6d9406e7b5ull,
+0x3c676b2c6c921968ull,
+0x3fef3720dcef9069ull,
+0xbc808a1883ccb5d2ull,
+0x3fef3f0b555dc3faull,
+0xbc8fad5d3ffffa6full,
+0x3fef472d4a07897cull,
+0xbc900dae3875a949ull,
+0x3fef4f87080d89f2ull,
+0x3c74a385a63d07a7ull,
+0x3fef5818dcfba487ull,
+0xbc82919e2040220full,
+0x3fef60e316c98398ull,
+0x3c8e5a50d5c192acull,
+0x3fef69e603db3285ull,
+0x3c843a59ac016b4bull,
+0x3fef7321f301b460ull,
+0xbc82d52107b43e1full,
+0x3fef7c97337b9b5full,
+0xbc892ab93b470dc9ull,
+0x3fef864614f5a129ull,
+0x3c74b604603a88d3ull,
+0x3fef902ee78b3ff6ull,
+0x3c83c5ec519d7271ull,
+0x3fef9a51fbc74c83ull,
+0xbc8ff7128fd391f0ull,
+0x3fefa4afa2a490daull,
+0xbc8dae98e223747dull,
+0x3fefaf482d8e67f1ull,
+0x3c8ec3bc41aa2008ull,
+0x3fefba1bee615a27ull,
+0x3c842b94c3a9eb32ull,
+0x3fefc52b376bba97ull,
+0x3c8a64a931d185eeull,
+0x3fefd0765b6e4540ull,
+0xbc8e37bae43be3edull,
+0x3fefdbfdad9cbe14ull,
+0x3c77893b4d91cd9dull,
+0x3fefe7c1819e90d8ull,
+0x3c5305c14160cc89ull,
+0x3feff3c22b8f71f1ull
+};
+__device__ constexpr double LN2_HI = __builtin_bit_cast(double, (uint64_t)0x3fe62e42fefa3800ull);
+__device__ constexpr double LN2_LO = __builtin_bit_cast(double, (uint64_t)0x3d2ef35793c76730ull);
+__device__ constexpr double POW_POLY[7] = {
+__builtin_bit_cast(double, (uint64_t)0xbfe0000000000000ull),
+__builtin_bit_cast(double, (uint64_t)0xbfe5555555555560ull),
+__builtin_bit_cast(double, (uint64_t)0x3fe0000000000006ull),
+__builtin_bit_cast(double, (uint64_t)0x3fe999999959554eull),
+__builtin_bit_cast(double, (uint64_t)0xbfe555555529a47aull),
+__builtin_bit_cast(double, (uint64_t)0xbff2495b9b4845e9ull),
+__builtin_bit_cast(double, (uint64_t)0x3ff0002b8b263fc3ull)
+};
+__device__ constexpr double POW_TAB[128][3] = {
+{__builtin_bit_cast(double, (uint64_t)0x3ff6a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd62c82f2b9c800ull),__builtin_bit_cast(double, (uint64_t)0x3cfab42428375680ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd5d1bdbf580800ull),__builtin_bit_cast(double, (uint64_t)0xbd1ca508d8e0f720ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd5767717455800ull),__builtin_bit_cast(double, (uint64_t)0xbd2362a4d5b6506dull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd51aad872df800ull),__builtin_bit_cast(double, (uint64_t)0xbce684e49eb067d5ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd4be5f95777800ull),__builtin_bit_cast(double, (uint64_t)0xbd041b6993293ee0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd4618bc21c6000ull),__builtin_bit_cast(double, (uint64_t)0x3d13d82f484c84ccull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd404308686a800ull),__builtin_bit_cast(double, (uint64_t)0x3cdc42f3ed820b3aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd3a64c55694800ull),__builtin_bit_cast(double, (uint64_t)0x3d20b1c686519460ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd347dd9a988000ull),__builtin_bit_cast(double, (uint64_t)0x3d25594dd4c58092ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd2e8e2bae12000ull),__builtin_bit_cast(double, (uint64_t)0x3d267b1e99b72bd8ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd2895a13de8800ull),__builtin_bit_cast(double, (uint64_t)0x3d15ca14b6cfb03full)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd2895a13de8800ull),__builtin_bit_cast(double, (uint64_t)0x3d15ca14b6cfb03full)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd22941fbcf7800ull),__builtin_bit_cast(double, (uint64_t)0xbd165a242853da76ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd1c898c1699800ull),__builtin_bit_cast(double, (uint64_t)0xbd1fafbc68e75404ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd1675cababa800ull),__builtin_bit_cast(double, (uint64_t)0x3d1f1fc63382a8f0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd1058bf9ae4800ull),__builtin_bit_cast(double, (uint64_t)0xbd26a8c4fd055a66ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd0a324e2739000ull),__builtin_bit_cast(double, (uint64_t)0xbd0c6bee7ef4030eull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd0402594b4d000ull),__builtin_bit_cast(double, (uint64_t)0xbcf036b89ef42d7full)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfd0402594b4d000ull),__builtin_bit_cast(double, (uint64_t)0xbcf036b89ef42d7full)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcfb9186d5e4000ull),__builtin_bit_cast(double, (uint64_t)0x3d0d572aab993c87ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcef0adcbdc6000ull),__builtin_bit_cast(double, (uint64_t)0x3d2b26b79c86af24ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfce27076e2af000ull),__builtin_bit_cast(double, (uint64_t)0xbd172f4f543fff10ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcd5c216b4fc000ull),__builtin_bit_cast(double, (uint64_t)0x3d21ba91bbca681bull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcc8ff7c79aa000ull),__builtin_bit_cast(double, (uint64_t)0x3d27794f689f8434ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcc8ff7c79aa000ull),__builtin_bit_cast(double, (uint64_t)0x3d27794f689f8434ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcbc286742d9000ull),__builtin_bit_cast(double, (uint64_t)0x3d194eb0318bb78full)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfcaf3c94e80c000ull),__builtin_bit_cast(double, (uint64_t)0x3cba4e633fcd9066ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfca23bc1fe2b000ull),__builtin_bit_cast(double, (uint64_t)0xbd258c64dc46c1eaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfca23bc1fe2b000ull),__builtin_bit_cast(double, (uint64_t)0xbd258c64dc46c1eaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc9525a9cf45000ull),__builtin_bit_cast(double, (uint64_t)0xbd2ad1d904c1d4e3ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc87fa06520d000ull),__builtin_bit_cast(double, (uint64_t)0x3d2bbdbf7fdbfa09ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc7ab890210e000ull),__builtin_bit_cast(double, (uint64_t)0x3d2bdb9072534a58ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc7ab890210e000ull),__builtin_bit_cast(double, (uint64_t)0x3d2bdb9072534a58ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc6d60fe719d000ull),__builtin_bit_cast(double, (uint64_t)0xbd10e46aa3b2e266ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc5ff3070a79000ull),__builtin_bit_cast(double, (uint64_t)0xbd1e9e439f105039ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc5ff3070a79000ull),__builtin_bit_cast(double, (uint64_t)0xbd1e9e439f105039ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc526e5e3a1b000ull),__builtin_bit_cast(double, (uint64_t)0xbd20de8b90075b8full)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc44d2b6ccb8000ull),__builtin_bit_cast(double, (uint64_t)0x3d170cc16135783cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc44d2b6ccb8000ull),__builtin_bit_cast(double, (uint64_t)0x3d170cc16135783cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc371fc201e9000ull),__builtin_bit_cast(double, (uint64_t)0x3cf178864d27543aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc29552f81ff000ull),__builtin_bit_cast(double, (uint64_t)0xbd248d301771c408ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc1b72ad52f6000ull),__builtin_bit_cast(double, (uint64_t)0xbd2e80a41811a396ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc1b72ad52f6000ull),__builtin_bit_cast(double, (uint64_t)0xbd2e80a41811a396ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc0d77e7cd09000ull),__builtin_bit_cast(double, (uint64_t)0x3d0a699688e85bf4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfc0d77e7cd09000ull),__builtin_bit_cast(double, (uint64_t)0x3d0a699688e85bf4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfbfec9131dbe000ull),__builtin_bit_cast(double, (uint64_t)0xbd2575545ca333f2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfbe27076e2b0000ull),__builtin_bit_cast(double, (uint64_t)0x3d2a342c2af0003cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfbe27076e2b0000ull),__builtin_bit_cast(double, (uint64_t)0x3d2a342c2af0003cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfbc5e548f5bc000ull),__builtin_bit_cast(double, (uint64_t)0xbd1d0c57585fbe06ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfba926d3a4ae000ull),__builtin_bit_cast(double, (uint64_t)0x3d253935e85baac8ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfba926d3a4ae000ull),__builtin_bit_cast(double, (uint64_t)0x3d253935e85baac8ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb8c345d631a000ull),__builtin_bit_cast(double, (uint64_t)0x3d137c294d2f5668ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb8c345d631a000ull),__builtin_bit_cast(double, (uint64_t)0x3d137c294d2f5668ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb6f0d28ae56000ull),__builtin_bit_cast(double, (uint64_t)0xbd269737c93373daull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb51b073f062000ull),__builtin_bit_cast(double, (uint64_t)0x3d1f025b61c65e57ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb51b073f062000ull),__builtin_bit_cast(double, (uint64_t)0x3d1f025b61c65e57ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb341d7961be000ull),__builtin_bit_cast(double, (uint64_t)0x3d2c5edaccf913dfull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb341d7961be000ull),__builtin_bit_cast(double, (uint64_t)0x3d2c5edaccf913dfull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfb16536eea38000ull),__builtin_bit_cast(double, (uint64_t)0x3d147c5e768fa309ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfaf0a30c0118000ull),__builtin_bit_cast(double, (uint64_t)0x3d2d599e83368e91ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1000000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfaf0a30c0118000ull),__builtin_bit_cast(double, (uint64_t)0x3d2d599e83368e91ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfab42dd71198000ull),__builtin_bit_cast(double, (uint64_t)0x3d1c827ae5d6704cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0e00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfab42dd71198000ull),__builtin_bit_cast(double, (uint64_t)0x3d1c827ae5d6704cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfa77458f632c000ull),__builtin_bit_cast(double, (uint64_t)0xbd2cfc4634f2a1eeull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0c00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfa77458f632c000ull),__builtin_bit_cast(double, (uint64_t)0xbd2cfc4634f2a1eeull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfa39e87b9fec000ull),__builtin_bit_cast(double, (uint64_t)0x3cf502b7f526feaaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0a00000000000ull),__builtin_bit_cast(double, (uint64_t)0xbfa39e87b9fec000ull),__builtin_bit_cast(double, (uint64_t)0x3cf502b7f526feaaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf9f829b0e780000ull),__builtin_bit_cast(double, (uint64_t)0xbd2980267c7e09e4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0800000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf9f829b0e780000ull),__builtin_bit_cast(double, (uint64_t)0xbd2980267c7e09e4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0600000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf97b91b07d58000ull),__builtin_bit_cast(double, (uint64_t)0xbd288d5493faa639ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf8fc0a8b0fc0000ull),__builtin_bit_cast(double, (uint64_t)0xbcdf1e7cf6d3a69cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0400000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf8fc0a8b0fc0000ull),__builtin_bit_cast(double, (uint64_t)0xbcdf1e7cf6d3a69cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf7fe02a6b100000ull),__builtin_bit_cast(double, (uint64_t)0xbd19e23f0dda40e4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0200000000000ull),__builtin_bit_cast(double, (uint64_t)0xbf7fe02a6b100000ull),__builtin_bit_cast(double, (uint64_t)0xbd19e23f0dda40e4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0000000000000ull),__builtin_bit_cast(double, (uint64_t)0x0000000000000000ull),__builtin_bit_cast(double, (uint64_t)0x0000000000000000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0000000000000ull),__builtin_bit_cast(double, (uint64_t)0x0000000000000000ull),__builtin_bit_cast(double, (uint64_t)0x0000000000000000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fefc00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3f80101575890000ull),__builtin_bit_cast(double, (uint64_t)0xbd10c76b999d2be8ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef800000000000ull),__builtin_bit_cast(double, (uint64_t)0x3f90205658938000ull),__builtin_bit_cast(double, (uint64_t)0xbd23dc5b06e2f7d2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3f98492528c90000ull),__builtin_bit_cast(double, (uint64_t)0xbd2aa0ba325a0c34ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef000000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fa0415d89e74000ull),__builtin_bit_cast(double, (uint64_t)0x3d0111c05cf1d753ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feec00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fa466aed42e0000ull),__builtin_bit_cast(double, (uint64_t)0xbd2c167375bdfd28ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee800000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fa894aa149fc000ull),__builtin_bit_cast(double, (uint64_t)0xbd197995d05a267dull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3faccb73cdddc000ull),__builtin_bit_cast(double, (uint64_t)0xbd1a68f247d82807ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee200000000000ull),__builtin_bit_cast(double, (uint64_t)0x3faeea31c006c000ull),__builtin_bit_cast(double, (uint64_t)0xbd0e113e4fc93b7bull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fede00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fb1973bd1466000ull),__builtin_bit_cast(double, (uint64_t)0xbd25325d560d9e9bull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feda00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fb3bdf5a7d1e000ull),__builtin_bit_cast(double, (uint64_t)0x3d2cc85ea5db4ed7ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed600000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fb5e95a4d97a000ull),__builtin_bit_cast(double, (uint64_t)0xbd2c69063c5d1d1eull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fb700d30aeac000ull),__builtin_bit_cast(double, (uint64_t)0x3cec1e8da99ded32ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed000000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fb9335e5d594000ull),__builtin_bit_cast(double, (uint64_t)0x3d23115c3abd47daull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fecc00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fbb6ac88dad6000ull),__builtin_bit_cast(double, (uint64_t)0xbd1390802bf768e5ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feca00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fbc885801bc4000ull),__builtin_bit_cast(double, (uint64_t)0x3d2646d1c65aacd3ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec600000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fbec739830a2000ull),__builtin_bit_cast(double, (uint64_t)0xbd2dc068afe645e0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fbfe89139dbe000ull),__builtin_bit_cast(double, (uint64_t)0xbd2534d64fa10afdull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec000000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc1178e8227e000ull),__builtin_bit_cast(double, (uint64_t)0x3d21ef78ce2d07f2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3febe00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc1aa2b7e23f000ull),__builtin_bit_cast(double, (uint64_t)0x3d2ca78e44389934ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feba00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc2d1610c868000ull),__builtin_bit_cast(double, (uint64_t)0x3d039d6ccb81b4a1ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb800000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc365fcb0159000ull),__builtin_bit_cast(double, (uint64_t)0x3cc62fa8234b7289ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc4913d8333b000ull),__builtin_bit_cast(double, (uint64_t)0x3d25837954fdb678ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb200000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc527e5e4a1b000ull),__builtin_bit_cast(double, (uint64_t)0x3d2633e8e5697dc7ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feae00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc6574ebe8c1000ull),__builtin_bit_cast(double, (uint64_t)0x3d19cf8b2c3c2e78ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feac00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc6f0128b757000ull),__builtin_bit_cast(double, (uint64_t)0xbd25118de59c21e1ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feaa00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc7898d85445000ull),__builtin_bit_cast(double, (uint64_t)0xbd1c661070914305ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea600000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc8beafeb390000ull),__builtin_bit_cast(double, (uint64_t)0xbd073d54aae92cd1ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fc95a5adcf70000ull),__builtin_bit_cast(double, (uint64_t)0x3d07f22858a0ff6full)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea000000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fca93ed3c8ae000ull),__builtin_bit_cast(double, (uint64_t)0xbd28724350562169ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9e00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fcb31d8575bd000ull),__builtin_bit_cast(double, (uint64_t)0xbd0c358d4eace1aaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9c00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fcbd087383be000ull),__builtin_bit_cast(double, (uint64_t)0xbd2d4bc4595412b6ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9a00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fcc6ffbc6f01000ull),__builtin_bit_cast(double, (uint64_t)0xbcf1ec72c5962bd2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9600000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fcdb13db0d49000ull),__builtin_bit_cast(double, (uint64_t)0xbd2aff2af715b035ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fce530effe71000ull),__builtin_bit_cast(double, (uint64_t)0x3cc212276041f430ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9200000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fcef5ade4dd0000ull),__builtin_bit_cast(double, (uint64_t)0xbcca211565bb8e11ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9000000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fcf991c6cb3b000ull),__builtin_bit_cast(double, (uint64_t)0x3d1bcbecca0cdf30ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8c00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd07138604d5800ull),__builtin_bit_cast(double, (uint64_t)0x3cf89cdb16ed4e91ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8a00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd0c42d67616000ull),__builtin_bit_cast(double, (uint64_t)0x3d27188b163ceae9ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8800000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd1178e8227e800ull),__builtin_bit_cast(double, (uint64_t)0xbd2c210e63a5f01cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8600000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd16b5ccbacf800ull),__builtin_bit_cast(double, (uint64_t)0x3d2b9acdf7a51681ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd1bf99635a6800ull),__builtin_bit_cast(double, (uint64_t)0x3d2ca6ed5147bdb7ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8200000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd214456d0eb800ull),__builtin_bit_cast(double, (uint64_t)0x3d0a87deba46baeaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7e00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd2bef07cdc9000ull),__builtin_bit_cast(double, (uint64_t)0x3d2a9cfa4a5004f4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7c00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd314f1e1d36000ull),__builtin_bit_cast(double, (uint64_t)0xbd28e27ad3213cb8ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7a00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd36b6776be1000ull),__builtin_bit_cast(double, (uint64_t)0x3d116ecdb0f177c8ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7800000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd3c25277333000ull),__builtin_bit_cast(double, (uint64_t)0x3d183b54b606bd5cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7600000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd419b423d5e800ull),__builtin_bit_cast(double, (uint64_t)0x3d08e436ec90e09dull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7400000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd4718dc271c800ull),__builtin_bit_cast(double, (uint64_t)0xbd2f27ce0967d675ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7200000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd4c9e09e173000ull),__builtin_bit_cast(double, (uint64_t)0xbd2e20891b0ad8a4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7000000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd522ae0738a000ull),__builtin_bit_cast(double, (uint64_t)0x3d2ebe708164c759ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe6e00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd57bf753c8d000ull),__builtin_bit_cast(double, (uint64_t)0x3d1fadedee5d40efull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe6c00000000000ull),__builtin_bit_cast(double, (uint64_t)0x3fd5d5bddf596000ull),__builtin_bit_cast(double, (uint64_t)0xbd0a0b2a08a465dcull)}
+};
+__device__ constexpr double LOG_POLY[5] = {
+__builtin_bit_cast(double, (uint64_t)0xbfe0000000000001ull),
+__builtin_bit_cast(double, (uint64_t)0x3fd555555551305bull),
+__builtin_bit_cast(double, (uint64_t)0xbfcfffffffeb4590ull),
+__builtin_bit_cast(double, (uint64_t)0x3fc999b324f10111ull),
+__builtin_bit_cast(double, (uint64_t)0xbfc55575e506c89full)
+};
+__device__ constexpr double LOG_NEAR_POLY[11] = {
+__builtin_bit_cast(double, (uint64_t)0xbfe0000000000000ull),
+__builtin_bit_cast(double, (uint64_t)0x3fd5555555555577ull),
+__builtin_bit_cast(double, (uint64_t)0xbfcffffffffffdcbull),
+__builtin_bit_cast(double, (uint64_t)0x3fc999999995dd0cull),
+__builtin_bit_cast(double, (uint64_t)0xbfc55555556745a7ull),
+__builtin_bit_cast(double, (uint64_t)0x3fc24924a344de30ull),
+__builtin_bit_cast(double, (uint64_t)0xbfbfffffa4423d65ull),
+__builtin_bit_cast(double, (uint64_t)0x3fbc7184282ad6caull),
+__builtin_bit_cast(double, (uint64_t)0xbfb999eb43b068ffull),
+__builtin_bit_cast(double, (uint64_t)0x3fb78182f7afd085ull),
+__builtin_bit_cast(double, (uint64_t)0xbfb5521375d145cdull)
+};
+__device__ constexpr double LOG_TAB[128][2] = {
+{__builtin_bit_cast(double, (uint64_t)0x3ff734f0c3e0de9full),__builtin_bit_cast(double, (uint64_t)0xbfd7cc7f79e69000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff713786a2ce91full),__builtin_bit_cast(double, (uint64_t)0xbfd76feec20d0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6f26008fab5a0ull),__builtin_bit_cast(double, (uint64_t)0xbfd713e31351e000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6d1a61f138c7dull),__builtin_bit_cast(double, (uint64_t)0xbfd6b85b38287800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6b1490bc5b4d1ull),__builtin_bit_cast(double, (uint64_t)0xbfd65d5590807800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff69147332f0cbaull),__builtin_bit_cast(double, (uint64_t)0xbfd602d076180000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6719f18224223ull),__builtin_bit_cast(double, (uint64_t)0xbfd5a8ca86909000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff6524f99a51ed9ull),__builtin_bit_cast(double, (uint64_t)0xbfd54f4356035000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff63356aa8f24c4ull),__builtin_bit_cast(double, (uint64_t)0xbfd4f637c36b4000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff614b36b9ddc14ull),__builtin_bit_cast(double, (uint64_t)0xbfd49da7fda85000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5f66452c65c4cull),__builtin_bit_cast(double, (uint64_t)0xbfd445923989a800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5d867b5912c4full),__builtin_bit_cast(double, (uint64_t)0xbfd3edf439b0b800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5babccb5b90deull),__builtin_bit_cast(double, (uint64_t)0xbfd396ce448f7000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff59d61f2d91a78ull),__builtin_bit_cast(double, (uint64_t)0xbfd3401e17bda000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5805612465687ull),__builtin_bit_cast(double, (uint64_t)0xbfd2e9e2ef468000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff56397cee76bd3ull),__builtin_bit_cast(double, (uint64_t)0xbfd2941b3830e000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff54725e2a77f93ull),__builtin_bit_cast(double, (uint64_t)0xbfd23ec58cda8800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff52aff42064583ull),__builtin_bit_cast(double, (uint64_t)0xbfd1e9e129279000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff50f22dbb2bddfull),__builtin_bit_cast(double, (uint64_t)0xbfd1956d2b48f800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4f38f4734ded7ull),__builtin_bit_cast(double, (uint64_t)0xbfd141679ab9f800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4d843cfde2840ull),__builtin_bit_cast(double, (uint64_t)0xbfd0edd094ef9800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4bd3ec078a3c8ull),__builtin_bit_cast(double, (uint64_t)0xbfd09aa518db1000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4a27fc3e0258aull),__builtin_bit_cast(double, (uint64_t)0xbfd047e65263b800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4880524d48434ull),__builtin_bit_cast(double, (uint64_t)0xbfcfeb224586f000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff46dce1b192d0bull),__builtin_bit_cast(double, (uint64_t)0xbfcf474a7517b000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff453d9d3391854ull),__builtin_bit_cast(double, (uint64_t)0xbfcea4443d103000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff43a2744b4845aull),__builtin_bit_cast(double, (uint64_t)0xbfce020d44e9b000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff420b54115f8fbull),__builtin_bit_cast(double, (uint64_t)0xbfcd60a22977f000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff40782da3ef4b1ull),__builtin_bit_cast(double, (uint64_t)0xbfccc00104959000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3ee8f5d57fe8full),__builtin_bit_cast(double, (uint64_t)0xbfcc202956891000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3d5d9a00b4ce9ull),__builtin_bit_cast(double, (uint64_t)0xbfcb81178d811000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3bd60c010c12bull),__builtin_bit_cast(double, (uint64_t)0xbfcae2c9ccd3d000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3a5242b75dab8ull),__builtin_bit_cast(double, (uint64_t)0xbfca45402e129000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff38d22cd9fd002ull),__builtin_bit_cast(double, (uint64_t)0xbfc9a877681df000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3755bc5847a1cull),__builtin_bit_cast(double, (uint64_t)0xbfc90c6d69483000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff35dce49ad36e2ull),__builtin_bit_cast(double, (uint64_t)0xbfc87120a645c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff34679984dd440ull),__builtin_bit_cast(double, (uint64_t)0xbfc7d68fb4143000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff32f5cceffcb24ull),__builtin_bit_cast(double, (uint64_t)0xbfc73cb83c627000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3187775a10d49ull),__builtin_bit_cast(double, (uint64_t)0xbfc6a39a9b376000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff301c8373e3990ull),__builtin_bit_cast(double, (uint64_t)0xbfc60b3154b7a000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2eb4ebb95f841ull),__builtin_bit_cast(double, (uint64_t)0xbfc5737d76243000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2d50a0219a9d1ull),__builtin_bit_cast(double, (uint64_t)0xbfc4dc7b8fc23000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2bef9a8b7fd2aull),__builtin_bit_cast(double, (uint64_t)0xbfc4462c51d20000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2a91c7a0c1babull),__builtin_bit_cast(double, (uint64_t)0xbfc3b08abc830000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff293726014b530ull),__builtin_bit_cast(double, (uint64_t)0xbfc31b996b490000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff27dfa5757a1f5ull),__builtin_bit_cast(double, (uint64_t)0xbfc2875490a44000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff268b39b1d3bbfull),__builtin_bit_cast(double, (uint64_t)0xbfc1f3b9f879a000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2539d838ff5bdull),__builtin_bit_cast(double, (uint64_t)0xbfc160c8252ca000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff23eb7aac9083bull),__builtin_bit_cast(double, (uint64_t)0xbfc0ce7f57f72000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff22a012ba940b6ull),__builtin_bit_cast(double, (uint64_t)0xbfc03cdc49fea000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2157996cc4132ull),__builtin_bit_cast(double, (uint64_t)0xbfbf57bdbc4b8000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff201201dd2fc9bull),__builtin_bit_cast(double, (uint64_t)0xbfbe370896404000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1ecf4494d480bull),__builtin_bit_cast(double, (uint64_t)0xbfbd17983ef94000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1d8f5528f6569ull),__builtin_bit_cast(double, (uint64_t)0xbfbbf9674ed8a000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1c52311577e7cull),__builtin_bit_cast(double, (uint64_t)0xbfbadc79202f6000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1b17c74cb26e9ull),__builtin_bit_cast(double, (uint64_t)0xbfb9c0c3e7288000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff19e010c2c1ab6ull),__builtin_bit_cast(double, (uint64_t)0xbfb8a646b372c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff18ab07bb670bdull),__builtin_bit_cast(double, (uint64_t)0xbfb78d01b3ac0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1778a25efbcb6ull),__builtin_bit_cast(double, (uint64_t)0xbfb674f145380000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1648d354c31daull),__builtin_bit_cast(double, (uint64_t)0xbfb55e0e6d878000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff151b990275fddull),__builtin_bit_cast(double, (uint64_t)0xbfb4485cdea1e000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff13f0ea432d24cull),__builtin_bit_cast(double, (uint64_t)0xbfb333d94d6aa000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff12c8b7210f9daull),__builtin_bit_cast(double, (uint64_t)0xbfb22079f8c56000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff11a3028ecb531ull),__builtin_bit_cast(double, (uint64_t)0xbfb10e4698622000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff107fbda8434afull),__builtin_bit_cast(double, (uint64_t)0xbfaffa6c6ad20000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0f5ee0f4e6bb3ull),__builtin_bit_cast(double, (uint64_t)0xbfadda8d4a774000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0e4065d2a9fceull),__builtin_bit_cast(double, (uint64_t)0xbfabbcece4850000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0d244632ca521ull),__builtin_bit_cast(double, (uint64_t)0xbfa9a1894012c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0c0a77ce2981aull),__builtin_bit_cast(double, (uint64_t)0xbfa788583302c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0af2f83c636d1ull),__builtin_bit_cast(double, (uint64_t)0xbfa5715e67d68000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff09ddb98a01339ull),__builtin_bit_cast(double, (uint64_t)0xbfa35c8a49658000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff08cabaf52e7dfull),__builtin_bit_cast(double, (uint64_t)0xbfa149e364154000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff07b9f2f4e28fbull),__builtin_bit_cast(double, (uint64_t)0xbf9e72c082eb8000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff06ab58c358f19ull),__builtin_bit_cast(double, (uint64_t)0xbf9a55f152528000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff059eea5ecf92cull),__builtin_bit_cast(double, (uint64_t)0xbf963d62cf818000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff04949cdd12c90ull),__builtin_bit_cast(double, (uint64_t)0xbf9228fb8caa0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff038c6c6f0ada9ull),__builtin_bit_cast(double, (uint64_t)0xbf8c317b20f90000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff02865137932a9ull),__builtin_bit_cast(double, (uint64_t)0xbf8419355daa0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0182427ea7348ull),__builtin_bit_cast(double, (uint64_t)0xbf781203c2ec0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff008040614b195ull),__builtin_bit_cast(double, (uint64_t)0xbf60040979240000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fefe01ff726fa1aull),__builtin_bit_cast(double, (uint64_t)0x3f6feff384900000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fefa11cc261ea74ull),__builtin_bit_cast(double, (uint64_t)0x3f87dc41353d0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef6310b081992eull),__builtin_bit_cast(double, (uint64_t)0x3f93cea3c4c28000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef25f63ceeadcdull),__builtin_bit_cast(double, (uint64_t)0x3f9b9fc114890000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feee9c8039113e7ull),__builtin_bit_cast(double, (uint64_t)0x3fa1b0d8ce110000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feeae8078cbb1abull),__builtin_bit_cast(double, (uint64_t)0x3fa58a5bd001c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee741aa29d0c9bull),__builtin_bit_cast(double, (uint64_t)0x3fa95c8340d88000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee3a91830a99b5ull),__builtin_bit_cast(double, (uint64_t)0x3fad276aef578000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee01e009609a56ull),__builtin_bit_cast(double, (uint64_t)0x3fb07598e598c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fedca01e577bb98ull),__builtin_bit_cast(double, (uint64_t)0x3fb253f5e30d2000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed92f20b7c9103ull),__builtin_bit_cast(double, (uint64_t)0x3fb42edd8b380000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed5cac66fb5cceull),__builtin_bit_cast(double, (uint64_t)0x3fb606598757c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed272caa5ede9dull),__builtin_bit_cast(double, (uint64_t)0x3fb7da76356a0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fecf26e3e6b2ccdull),__builtin_bit_cast(double, (uint64_t)0x3fb9ab434e1c6000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fecbe6da2a77902ull),__builtin_bit_cast(double, (uint64_t)0x3fbb78c7bb0d6000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec8b266d37086dull),__builtin_bit_cast(double, (uint64_t)0x3fbd431332e72000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec5894bd5d5804ull),__builtin_bit_cast(double, (uint64_t)0x3fbf0a3171de6000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec26b533bb9f8cull),__builtin_bit_cast(double, (uint64_t)0x3fc067152b914000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3febf583eeece73full),__builtin_bit_cast(double, (uint64_t)0x3fc147858292b000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3febc4fd75db96c1ull),__builtin_bit_cast(double, (uint64_t)0x3fc2266ecdca3000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb951e0c864a28ull),__builtin_bit_cast(double, (uint64_t)0x3fc303d7a6c55000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb65e2c5ef3e2cull),__builtin_bit_cast(double, (uint64_t)0x3fc3dfc33c331000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb374867c9888bull),__builtin_bit_cast(double, (uint64_t)0x3fc4ba366b7a8000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb094b211d304aull),__builtin_bit_cast(double, (uint64_t)0x3fc5933928d1f000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feadbe885f2ef7eull),__builtin_bit_cast(double, (uint64_t)0x3fc66acd2418f000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feaaf1d31603da2ull),__builtin_bit_cast(double, (uint64_t)0x3fc740f8ec669000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea82e63fd358a7ull),__builtin_bit_cast(double, (uint64_t)0x3fc815c0f51af000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea5740ef09738bull),__builtin_bit_cast(double, (uint64_t)0x3fc8e92954f68000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea2c2a90ab4b27ull),__builtin_bit_cast(double, (uint64_t)0x3fc9bb3602f84000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea01a01393f2d1ull),__builtin_bit_cast(double, (uint64_t)0x3fca8bed1c2c0000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9d79f24db3c1bull),__builtin_bit_cast(double, (uint64_t)0x3fcb5b515c01d000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9ae2505c7b190ull),__builtin_bit_cast(double, (uint64_t)0x3fcc2967ccbcc000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9852ef297ce2full),__builtin_bit_cast(double, (uint64_t)0x3fccf635d5486000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe95cbaeea44b75ull),__builtin_bit_cast(double, (uint64_t)0x3fcdc1bd3446c000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe934c69de74838ull),__builtin_bit_cast(double, (uint64_t)0x3fce8c01b8cfe000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe90d4f2f6752e6ull),__builtin_bit_cast(double, (uint64_t)0x3fcf5509c0179000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8e6528effd79dull),__builtin_bit_cast(double, (uint64_t)0x3fd00e6c121fb800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8bfce9fcc007cull),__builtin_bit_cast(double, (uint64_t)0x3fd071b80e93d000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe899c0dabec30eull),__builtin_bit_cast(double, (uint64_t)0x3fd0d46b9e867000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe87427aa2317fbull),__builtin_bit_cast(double, (uint64_t)0x3fd13687334bd000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe84f00acb39a08ull),__builtin_bit_cast(double, (uint64_t)0x3fd1980d67234800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe82a49e8653e55ull),__builtin_bit_cast(double, (uint64_t)0x3fd1f8ffe0cc8000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8060195f40260ull),__builtin_bit_cast(double, (uint64_t)0x3fd2595fd7636800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7e22563e0a329ull),__builtin_bit_cast(double, (uint64_t)0x3fd2b9300914a800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7beb377dcb5adull),__builtin_bit_cast(double, (uint64_t)0x3fd3187210436000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe79baa679725c2ull),__builtin_bit_cast(double, (uint64_t)0x3fd377266dec1800ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe77907f2170657ull),__builtin_bit_cast(double, (uint64_t)0x3fd3d54ffbaf3000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe756cadbd6130cull),__builtin_bit_cast(double, (uint64_t)0x3fd432eee32fe000ull)}
+};
+__device__ constexpr double LOG_TAB2[128][2] = {
+{__builtin_bit_cast(double, (uint64_t)0x3fe61000014fb66bull),__builtin_bit_cast(double, (uint64_t)0x3c7e026c91425b3cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe63000034db495ull),__builtin_bit_cast(double, (uint64_t)0x3c8dbfea48005d41ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe650000d94d478ull),__builtin_bit_cast(double, (uint64_t)0x3c8e7fa786d6a5b7ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe67000074e6fadull),__builtin_bit_cast(double, (uint64_t)0x3c61fcea6b54254cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe68ffffedf0faeull),__builtin_bit_cast(double, (uint64_t)0xbc7c7e274c590efdull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe6b0000763c5bcull),__builtin_bit_cast(double, (uint64_t)0xbc8ac16848dcda01ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe6d0001e5cc1f6ull),__builtin_bit_cast(double, (uint64_t)0x3c833f1c9d499311ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe6efffeb05f63eull),__builtin_bit_cast(double, (uint64_t)0xbc7e80041ae22d53ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe710000e869780ull),__builtin_bit_cast(double, (uint64_t)0x3c7bff6671097952ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe72ffffc67e912ull),__builtin_bit_cast(double, (uint64_t)0x3c8c00e226bd8724ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe74fffdf81116aull),__builtin_bit_cast(double, (uint64_t)0xbc6e02916ef101d2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe770000f679c90ull),__builtin_bit_cast(double, (uint64_t)0xbc67fc71cd549c74ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe78ffffa7ec835ull),__builtin_bit_cast(double, (uint64_t)0x3c81bec19ef50483ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7affffe20c2e6ull),__builtin_bit_cast(double, (uint64_t)0xbc707e1729cc6465ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7cfffed3fc900ull),__builtin_bit_cast(double, (uint64_t)0xbc808072087b8b1cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe7efffe9261a76ull),__builtin_bit_cast(double, (uint64_t)0x3c8dc0286d9df9aeull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe81000049ca3e8ull),__builtin_bit_cast(double, (uint64_t)0x3c897fd251e54c33ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8300017932c8full),__builtin_bit_cast(double, (uint64_t)0xbc8afee9b630f381ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe850000633739cull),__builtin_bit_cast(double, (uint64_t)0x3c89bfbf6b6535bcull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe87000204289c6ull),__builtin_bit_cast(double, (uint64_t)0xbc8bbf65f3117b75ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe88fffebf57904ull),__builtin_bit_cast(double, (uint64_t)0xbc89006ea23dcb57ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8b00022bc04dfull),__builtin_bit_cast(double, (uint64_t)0xbc7d00df38e04b0aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8cfffe50c1b8aull),__builtin_bit_cast(double, (uint64_t)0xbc88007146ff9f05ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe8effffc918e43ull),__builtin_bit_cast(double, (uint64_t)0x3c83817bd07a7038ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe910001efa5fc7ull),__builtin_bit_cast(double, (uint64_t)0x3c893e9176dfb403ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9300013467bb9ull),__builtin_bit_cast(double, (uint64_t)0x3c7f804e4b980276ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe94fffe6ee076full),__builtin_bit_cast(double, (uint64_t)0xbc8f7ef0d9ff622eull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe96fffde3c12d1ull),__builtin_bit_cast(double, (uint64_t)0xbc7082aa962638baull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe98ffff4458a0dull),__builtin_bit_cast(double, (uint64_t)0xbc87801b9164a8efull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9afffdd982e3eull),__builtin_bit_cast(double, (uint64_t)0xbc8740e08a5a9337ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9cfffed49fb66ull),__builtin_bit_cast(double, (uint64_t)0x3c3fce08c19be000ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fe9f00020f19c51ull),__builtin_bit_cast(double, (uint64_t)0xbc8a3faa27885b0aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea10001145b006ull),__builtin_bit_cast(double, (uint64_t)0x3c74ff489958da56ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea300007bbf6faull),__builtin_bit_cast(double, (uint64_t)0x3c8cbeab8a2b6d18ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea500010971d79ull),__builtin_bit_cast(double, (uint64_t)0x3c88fecadd787930ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea70001df52e48ull),__builtin_bit_cast(double, (uint64_t)0xbc8f41763dd8abdbull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fea90001c593352ull),__builtin_bit_cast(double, (uint64_t)0xbc8ebf0284c27612ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feab0002a4f3e4bull),__builtin_bit_cast(double, (uint64_t)0xbc69fd043cff3f5full)},
+{__builtin_bit_cast(double, (uint64_t)0x3feacfffd7ae1ed1ull),__builtin_bit_cast(double, (uint64_t)0xbc823ee7129070b4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feaefffee510478ull),__builtin_bit_cast(double, (uint64_t)0x3c6a063ee00edea3ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb0fffdb650d5bull),__builtin_bit_cast(double, (uint64_t)0x3c5a06c8381f0ab9ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb2ffffeaaca57ull),__builtin_bit_cast(double, (uint64_t)0xbc79011e74233c1dull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb4fffd995badcull),__builtin_bit_cast(double, (uint64_t)0xbc79ff1068862a9full)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb7000249e659cull),__builtin_bit_cast(double, (uint64_t)0x3c8aff45d0864f3eull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feb8ffff9871640ull),__builtin_bit_cast(double, (uint64_t)0x3c7cfe7796c2c3f9ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3febafffd204cb4full),__builtin_bit_cast(double, (uint64_t)0xbc63ff27eef22bc4ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3febcfffd2415c45ull),__builtin_bit_cast(double, (uint64_t)0xbc6cffb7ee3bea21ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3febeffff86309dfull),__builtin_bit_cast(double, (uint64_t)0xbc814103972e0b5cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec0fffe1b57653ull),__builtin_bit_cast(double, (uint64_t)0x3c8bc16494b76a19ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec2ffff1fa57e3ull),__builtin_bit_cast(double, (uint64_t)0xbc64feef8d30c6edull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec4fffdcbfe424ull),__builtin_bit_cast(double, (uint64_t)0xbc843f68bcec4775ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec6fffed54b9f7ull),__builtin_bit_cast(double, (uint64_t)0x3c847ea3f053e0ecull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fec8fffeb998fd5ull),__builtin_bit_cast(double, (uint64_t)0x3c7383068df992f1ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fecb0002125219aull),__builtin_bit_cast(double, (uint64_t)0xbc68fd8e64180e04ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feccfffdd94469cull),__builtin_bit_cast(double, (uint64_t)0x3c8e7ebe1cc7ea72ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fecefffeafdc476ull),__builtin_bit_cast(double, (uint64_t)0x3c8ebe39ad9f88feull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed1000169af82bull),__builtin_bit_cast(double, (uint64_t)0x3c757d91a8b95a71ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed30000d0ff71dull),__builtin_bit_cast(double, (uint64_t)0x3c89c1906970c7daull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed4fffea790fc4ull),__builtin_bit_cast(double, (uint64_t)0xbc580e37c558fe0cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed70002edc87e5ull),__builtin_bit_cast(double, (uint64_t)0xbc7f80d64dc10f44ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fed900021dc82aaull),__builtin_bit_cast(double, (uint64_t)0xbc747c8f94fd5c5cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fedafffd86b0283ull),__builtin_bit_cast(double, (uint64_t)0x3c8c7f1dc521617eull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fedd000296c4739ull),__builtin_bit_cast(double, (uint64_t)0x3c88019eb2ffb153ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fedefffe54490f5ull),__builtin_bit_cast(double, (uint64_t)0x3c6e00d2c652cc89ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee0fffcdabf694ull),__builtin_bit_cast(double, (uint64_t)0xbc7f8340202d69d2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee2fffdb52c8ddull),__builtin_bit_cast(double, (uint64_t)0x3c7b00c1ca1b0864ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee4ffff24216efull),__builtin_bit_cast(double, (uint64_t)0x3c72ffa8b094ab51ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee6fffe88a5e11ull),__builtin_bit_cast(double, (uint64_t)0xbc57f673b1efbe59ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fee9000119eff0dull),__builtin_bit_cast(double, (uint64_t)0xbc84808d5e0bc801ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feeafffdfa51744ull),__builtin_bit_cast(double, (uint64_t)0x3c780006d54320b5ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feed0001a127fa1ull),__builtin_bit_cast(double, (uint64_t)0xbc5002f860565c92ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3feef00007babcc4ull),__builtin_bit_cast(double, (uint64_t)0xbc8540445d35e611ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef0ffff57a8d02ull),__builtin_bit_cast(double, (uint64_t)0xbc4ffb3139ef9105ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef30001ee58ac7ull),__builtin_bit_cast(double, (uint64_t)0x3c8a81acf2731155ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef4ffff5823494ull),__builtin_bit_cast(double, (uint64_t)0x3c8a3f41d4d7c743ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef6ffffca94c6bull),__builtin_bit_cast(double, (uint64_t)0xbc6202f41c987875ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fef8fffe1f9c441ull),__builtin_bit_cast(double, (uint64_t)0x3c777dd1f477e74bull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fefafffd2e0e37eull),__builtin_bit_cast(double, (uint64_t)0xbc6f01199a7ca331ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fefd0001c77e49eull),__builtin_bit_cast(double, (uint64_t)0x3c7181ee4bceacb1ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3fefeffff7e0c331ull),__builtin_bit_cast(double, (uint64_t)0xbc6e05370170875aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff00ffff465606eull),__builtin_bit_cast(double, (uint64_t)0xbc8a7ead491c0adaull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff02ffff3867a58ull),__builtin_bit_cast(double, (uint64_t)0xbc977f69c3fcb2e0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff04ffffdfc0d17ull),__builtin_bit_cast(double, (uint64_t)0x3c97bffe34cb945bull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0700003cd4d82ull),__builtin_bit_cast(double, (uint64_t)0x3c820083c0e456cbull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff08ffff9f2cbe8ull),__builtin_bit_cast(double, (uint64_t)0xbc6dffdfbe37751aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0b000010cda65ull),__builtin_bit_cast(double, (uint64_t)0xbc913f7faee626ebull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0d00001a4d338ull),__builtin_bit_cast(double, (uint64_t)0x3c807dfa79489ff7ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff0effffadafdfdull),__builtin_bit_cast(double, (uint64_t)0xbc77040570d66bc0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff110000bbafd96ull),__builtin_bit_cast(double, (uint64_t)0x3c8e80d4846d0b62ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff12ffffae5f45dull),__builtin_bit_cast(double, (uint64_t)0x3c9dbffa64fd36efull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff150000dd59ad9ull),__builtin_bit_cast(double, (uint64_t)0x3c9a0077701250aeull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff170000f21559aull),__builtin_bit_cast(double, (uint64_t)0x3c8dfdf9e2e3deeeull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff18ffffc275426ull),__builtin_bit_cast(double, (uint64_t)0x3c910030dc3b7273ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1b000123d3c59ull),__builtin_bit_cast(double, (uint64_t)0x3c997f7980030188ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1cffff8299eb7ull),__builtin_bit_cast(double, (uint64_t)0xbc65f932ab9f8c67ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff1effff48ad400ull),__builtin_bit_cast(double, (uint64_t)0x3c937fbf9da75bebull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff210000c8b86a4ull),__builtin_bit_cast(double, (uint64_t)0x3c9f806b91fd5b22ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2300003854303ull),__builtin_bit_cast(double, (uint64_t)0x3c93ffc2eb9fbf33ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff24fffffbcf684ull),__builtin_bit_cast(double, (uint64_t)0x3c7601e77e2e2e72ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff26ffff52921d9ull),__builtin_bit_cast(double, (uint64_t)0x3c7ffcbb767f0c61ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2900014933a3cull),__builtin_bit_cast(double, (uint64_t)0xbc7202ca3c02412bull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2b00014556313ull),__builtin_bit_cast(double, (uint64_t)0xbc92808233f21f02ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2cfffebfe523bull),__builtin_bit_cast(double, (uint64_t)0xbc88ff7e384fdcf2ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff2f0000bb8ad96ull),__builtin_bit_cast(double, (uint64_t)0xbc85ff51503041c5ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff30ffffb7ae2afull),__builtin_bit_cast(double, (uint64_t)0xbc810071885e289dull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff32ffffeac5f7full),__builtin_bit_cast(double, (uint64_t)0xbc91ff5d3fb7b715ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff350000ca66756ull),__builtin_bit_cast(double, (uint64_t)0x3c957f82228b82bdull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3700011fbf721ull),__builtin_bit_cast(double, (uint64_t)0x3c8000bac40dd5ccull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff38ffff9592fb9ull),__builtin_bit_cast(double, (uint64_t)0xbc943f9d2db2a751ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3b00004ddd242ull),__builtin_bit_cast(double, (uint64_t)0x3c857f6b707638e1ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3cffff5b2c957ull),__builtin_bit_cast(double, (uint64_t)0x3c7a023a10bf1231ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff3efffeab0b418ull),__builtin_bit_cast(double, (uint64_t)0x3c987f6d66b152b0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff410001532aff4ull),__builtin_bit_cast(double, (uint64_t)0x3c67f8375f198524ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4300017478b29ull),__builtin_bit_cast(double, (uint64_t)0x3c8301e672dc5143ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff44fffe795b463ull),__builtin_bit_cast(double, (uint64_t)0x3c89ff69b8b2895aull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff46fffe80475e0ull),__builtin_bit_cast(double, (uint64_t)0xbc95c0b19bc2f254ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff48fffef6fc1e7ull),__builtin_bit_cast(double, (uint64_t)0x3c9b4009f23a2a72ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4afffe5bea704ull),__builtin_bit_cast(double, (uint64_t)0xbc94ffb7bf0d7d45ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4d000171027deull),__builtin_bit_cast(double, (uint64_t)0xbc99c06471dc6a3dull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff4f0000ff03ee2ull),__builtin_bit_cast(double, (uint64_t)0x3c977f890b85531cull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5100012dc4bd1ull),__builtin_bit_cast(double, (uint64_t)0x3c6004657166a436ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff530001605277aull),__builtin_bit_cast(double, (uint64_t)0xbc96bfcece233209ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff54fffecdb704cull),__builtin_bit_cast(double, (uint64_t)0xbc8902720505a1d7ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff56fffef5f54a9ull),__builtin_bit_cast(double, (uint64_t)0x3c9bbfe60ec96412ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5900017e61012ull),__builtin_bit_cast(double, (uint64_t)0x3c887ec581afef90ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5b00003c93e92ull),__builtin_bit_cast(double, (uint64_t)0xbc9f41080abf0cc0ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5d0001d4919bcull),__builtin_bit_cast(double, (uint64_t)0xbc98812afb254729ull)},
+{__builtin_bit_cast(double, (uint64_t)0x3ff5efffe7b87a89ull),__builtin_bit_cast(double, (uint64_t)0xbc947eb780ed6904ull)}
+};

github-simulator/source/gpu/sim/engine_exceptions.h

@@ -0,0 +1,9 @@
+// Generated by examples/gpu_engine_scan.rs: every float with |x| <= 16 whose
+// engine_sin_cos_raw result differs from x87 FSINCOS. Keys: input bits, sorted.
+#pragma once
+#include <cstdint>
+constexpr int ENGINE_EXCEPTION_COUNT = 0;
+constexpr int ENGINE_EXCEPTION_STEP = 0;
+__device__ constexpr uint32_t ENGINE_EXCEPTIONS[1][3] = {
+    {0, 0, 0},
+};

github-simulator/source/gpu/sim/math.h

@@ -0,0 +1,540 @@
+// Bit-exact device ports of the CPU math in src/math/native_math.rs,
+// src/math/godot_math.rs (managed_sin_cos), src/math/double_math.rs and src/nn/network.rs.
+// Build with -ffp-contract=off: a fused multiply-add rounds once and breaks
+// bit equality. Arguments outside the ported domains set an `err` bit instead
+// of taking the rare large-argument paths of the CPU code.
+#pragma once
+#include "compat.h"
+#include <cstdint>
+#include "double_tables.h"
+#include "engine_exceptions.h"
+
+namespace altd {
+
+enum : uint32_t {
+    ERR_MANAGED_LARGE = 1u << 0,  // managed_sin_cos |x| > 10000 (sine_large not ported)
+    ERR_NATIVE_LARGE = 1u << 1,   // musl sinf/cosf |x| >= 0x4dc90fdb (Payne-Hanek not ported)
+    ERR_ENGINE_DOMAIN = 1u << 2,  // engine_sin_cos |x| > ENGINE_DOMAIN (not validated against x87)
+};
+
+__device__ __host__ inline uint32_t fbits(float x) { return __builtin_bit_cast(uint32_t, x); }
+__device__ __host__ inline float ffrom(uint32_t b) { return __builtin_bit_cast(float, b); }
+__device__ __host__ inline uint64_t dbits(double x) { return __builtin_bit_cast(uint64_t, x); }
+__device__ __host__ inline double dfrom(uint64_t b) { return __builtin_bit_cast(double, b); }
+
+// ---- musl sinf/cosf (native_math.rs) ------------------------------------
+
+__device__ inline float sin_kernel(double x) {
+    double z = x * x;
+    const double s1 = -0.16666666666666666;
+    if (x > -7.8175831586122513e-3 && x < 7.8175831586122513e-3) return (float)(x * (1.0 + s1 * z));
+    double w = z * z;
+    double r = -0.0001984126984126984 + z * 2.7557319223985893e-6;
+    double s = z * x;
+    return (float)((x + s * (s1 + z * 0.008333333333333333)) + s * w * r);
+}
+__device__ inline float cos_kernel(double x) {
+    double z = x * x;
+    if (x > -7.816314697265625e-3 && x < 7.816314697265625e-3) return (float)(1.0 - 0.5 * z);
+    return (float)(1.0 + z * (-0.5 + z * (0.041666666666666664 + z * (-0.001388888888888889
+        + z * (2.48015873015873e-5 + z * -2.755731922398589e-7)))));
+}
+// Medium reduction; the large path is flagged.
+__device__ inline int reduce_medium(float x, double& y, uint32_t& err) {
+    if ((fbits(x) & 0x7fffffffu) >= 0x4dc90fdbu) err |= ERR_NATIVE_LARGE;
+    const double toint = 1.5 / 2.220446049250313e-16;
+    double n = ((double)x * 6.36619772367581382433e-1 + toint) - toint;
+    double xd = (double)x;
+    y = xd - n * 1.57079631090164184570 - n * 1.58932547735281966916e-8;
+    const double quarter = (double)0.7853981852531433f;  // f32 FRAC_PI_4
+    if (y < -quarter) { n -= 1.0; y = xd - n * 1.57079631090164184570 - n * 1.58932547735281966916e-8; }
+    else if (y > quarter) { n += 1.0; y = xd - n * 1.57079631090164184570 - n * 1.58932547735281966916e-8; }
+    return (int)n;
+}
+__device__ inline float native_sin(float x, uint32_t& err) {
+    uint32_t bits = fbits(x) & 0x7fffffffu;
+    bool negative = signbit(x);
+    double a = (double)x;
+    const double p = 1.5707963267948966;
+    if (bits <= 0x3f490fdau) return bits < 0x39800000u ? x : sin_kernel(a);
+    if (bits <= 0x407b53d1u) {
+        if (bits <= 0x4016cbe3u) return negative ? -cos_kernel(a + p) : cos_kernel(a - p);
+        return sin_kernel(negative ? -(a + 2.0 * p) : -(a - 2.0 * p));
+    }
+    if (bits <= 0x40e231d5u) {
+        if (bits <= 0x40afeddfu) return negative ? cos_kernel(a + 3.0 * p) : -cos_kernel(a - 3.0 * p);
+        return sin_kernel(negative ? a + 4.0 * p : a - 4.0 * p);
+    }
+    if (!isfinite(x)) return altd_invalid(x);
+    double y;
+    int n = reduce_medium(x, y, err);
+    switch (n & 3) { case 0: return sin_kernel(y); case 1: return cos_kernel(y); case 2: return sin_kernel(-y); default: return -cos_kernel(y); }
+}
+__device__ inline float native_cos(float x, uint32_t& err) {
+    uint32_t bits = fbits(x) & 0x7fffffffu;
+    bool negative = signbit(x);
+    double a = (double)x;
+    const double p = 1.5707963267948966;
+    if (bits <= 0x3f490fdau) return bits < 0x39800000u ? 1.0f : cos_kernel(a);
+    if (bits <= 0x407b53d1u) {
+        if (bits > 0x4016cbe3u) return -cos_kernel(negative ? a + 2.0 * p : a - 2.0 * p);
+        return sin_kernel(negative ? a + p : p - a);
+    }
+    if (bits <= 0x40e231d5u) {
+        if (bits > 0x40afeddfu) return cos_kernel(negative ? a + 4.0 * p : a - 4.0 * p);
+        return sin_kernel(negative ? -a - 3.0 * p : a - 3.0 * p);
+    }
+    if (!isfinite(x)) return altd_invalid(x);
+    double y;
+    int n = reduce_medium(x, y, err);
+    switch (n & 3) { case 0: return cos_kernel(y); case 1: return sin_kernel(-y); case 2: return -cos_kernel(y); default: return sin_kernel(y); }
+}
+
+__device__ inline float native_atan(float x) {
+    bool negative = signbit(x);
+    uint32_t bits = fbits(x) & 0x7fffffffu;
+    const float high[4] = {ffrom(0x3eed6338u), ffrom(0x3f490fdau), ffrom(0x3f7b985eu), ffrom(0x3fc90fdau)};
+    const float low[4] = {ffrom(0x31ac3769u), ffrom(0x33222168u), ffrom(0x33140fb4u), ffrom(0x33a22168u)};
+    if (bits >= 0x4c800000u) return isnan(x) ? x : copysignf(high[3], x);
+    int id;
+    if (bits < 0x3ee00000u) {
+        if (bits < 0x39800000u) return x;
+        id = -1;
+    } else {
+        x = fabsf(x);
+        if (bits < 0x3f980000u) {
+            if (bits < 0x3f300000u) { id = 0; x = (2.0f * x - 1.0f) / (2.0f + x); }
+            else { id = 1; x = (x - 1.0f) / (x + 1.0f); }
+        } else if (bits < 0x401c0000u) { id = 2; x = (x - 1.5f) / (1.0f + 1.5f * x); }
+        else { id = 3; x = -1.0f / x; }
+    }
+    float z = x * x;
+    float w = z * z;
+    float s1 = z * (3.3333328366e-01f + w * (1.4253635705e-01f + w * 6.1687607318e-02f));
+    float s2 = w * (-1.9999158382e-01f + w * -1.0648017377e-01f);
+    if (id < 0) return x - x * (s1 + s2);
+    float r = high[id] - ((x * (s1 + s2) - low[id]) - x);
+    return negative ? -r : r;
+}
+__device__ inline float native_atan2(float y, float x) {
+    const float pi = 3.14159274101257324f;
+    const float pi_lo = ffrom(0xb3bbbd2eu);
+    if (isnan(x) || isnan(y)) return altd_nan_operand(y, x);  // the CPU's `x + y` returns y when both are NaN
+    uint32_t ix = fbits(x), iy = fbits(y);
+    if (ix == 0x3f800000u) return native_atan(y);
+    uint32_t m = ((iy >> 31) & 1u) | ((ix >> 30) & 2u);
+    ix &= 0x7fffffffu; iy &= 0x7fffffffu;
+    if (iy == 0) return m <= 1 ? y : (m == 2 ? pi : -pi);
+    if (ix == 0) return copysignf(pi / 2.0f, y);
+    if (ix == 0x7f800000u) {
+        if (iy == 0x7f800000u) {
+            const float v[4] = {pi / 4.0f, -pi / 4.0f, 3.0f * pi / 4.0f, -3.0f * pi / 4.0f};
+            return v[m];
+        }
+        const float v[4] = {0.0f, -0.0f, pi, -pi};
+        return v[m];
+    }
+    if (ix + (26u << 23) < iy || iy == 0x7f800000u) return copysignf(pi / 2.0f, y);
+    float z = ((m & 2) && iy + (26u << 23) < ix) ? 0.0f : native_atan(fabsf(y / x));
+    switch (m) { case 0: return z; case 1: return -z; case 2: return pi - (z - pi_lo); default: return (z - pi_lo) - pi; }
+}
+
+// ---- .NET MathF.SinCos (godot_math.rs managed_sin_cos) --------------------
+
+// Straight-line for |value| <= 10000; larger arguments are flagged.
+__device__ inline float packed_sine(float value, uint32_t& err) {
+    float a = fabsf(value);
+    if (!(a <= 10000.0f)) err |= ERR_MANAGED_LARGE;
+    float rounded = a * ffrom(0x3ea2f983u) + ffrom(0x4b400000u);
+    float n = rounded - ffrom(0x4b400000u);
+    float r = a - n * ffrom(0x40490000u);
+    r -= n * ffrom(0x3a7da000u);
+    r -= n * ffrom(0x34222000u);
+    r -= n * ffrom(0x2cb4611au);
+    float square = r * r;
+    r = ffrom(fbits(r) ^ (fbits(rounded) << 31));
+    float p = ffrom(0x362edef8u) * square;
+    p += ffrom(0xb94fb7ffu);
+    p *= square;
+    p += ffrom(0x3c088766u);
+    p *= square;
+    p += ffrom(0xbe2aaaa6u);
+    float result = r + (square * p) * r;
+    return ffrom(fbits(result) ^ (fbits(value) & 0x80000000u));
+}
+__device__ inline void managed_sin_cos(float angle, float& s, float& c, uint32_t& err) {
+    if (isnan(angle)) { s = angle; c = ffrom((fbits(angle) & 0x7fffffffu) | 0x00400000u); return; }
+    float a = fabsf(angle);
+    if (!(a >= ffrom(0x39000000u))) { s = angle; c = 1.0f - a * a * 0.5f; return; }
+    s = packed_sine(angle, err);
+    c = packed_sine(a + 1.57079637050628662f, err);
+}
+
+// ---- x87 FSINCOS (native_math.rs engine_sin_cos) --------------------------
+// fdlibm kernels in f64 after a Cody-Waite reduction; for float inputs up to
+// ENGINE_DOMAIN the product n * PIO2_1 and the first subtraction are exact.
+// The rounded float results equal x87 except for the inputs in
+// engine_exceptions.h, found by an exhaustive scan (examples/gpu_engine_scan.rs).
+
+__device__ inline void engine_sin_cos_raw(float xf, float& s, float& c) {
+    double x = (double)xf;
+    double n = rint(x * 6.36619772367581382433e-01);
+    double y = (x - n * 1.57079632673412561417e+00) - n * 6.07710050650619224932e-11;
+    y = n == 0.0 ? x : y;  // keeps -0
+    double z = y * y, w = z * z;
+    double r = 8.33333333332248946124e-03 + z * (-1.98412698298579493134e-04 + z * 2.75573137070700676789e-06)
+        + z * w * (-2.50507602534068634195e-08 + z * 1.58969099521155010221e-10);
+    // fdlibm returns tiny arguments unchanged, which also keeps the sign of -0.
+    double sy = fabs(y) < 0x1p-27 ? y : y + z * y * (-1.66666666666666324348e-01 + z * r);
+    double rc = z * (4.16666666666666019037e-02 + z * (-1.38888888888741095749e-03 + z * 2.48015872894767294178e-05))
+        + w * w * (-2.75573143513906633035e-07 + z * (2.08757232129817482790e-09 + z * -1.13596475577881948265e-11));
+    double hz = 0.5 * z, one_minus = 1.0 - hz;
+    double cy = one_minus + (((1.0 - one_minus) - hz) + z * rc);
+    int q = (int)n & 3;
+    double sv = (q & 1) ? cy : sy, cv = (q & 1) ? sy : cy;
+    sv = (q & 2) ? -sv : sv;
+    cv = ((q + 1) & 2) ? -cv : cv;
+    s = (float)sv;
+    c = (float)cv;
+}
+
+constexpr float ENGINE_DOMAIN = 16.0f;
+
+// Branch-free binary search over the sorted exception keys.
+__device__ inline void engine_sin_cos(float x, float& s, float& c, uint32_t& err) {
+    if (!(fabsf(x) <= ENGINE_DOMAIN)) err |= ERR_ENGINE_DOMAIN;
+    engine_sin_cos_raw(x, s, c);
+    if (ENGINE_EXCEPTION_COUNT == 0) return;
+    uint32_t key = fbits(x);
+    int lo = 0;
+    for (int step = ENGINE_EXCEPTION_STEP; step > 0; step >>= 1) {
+        int probe = lo + step;
+        lo = (probe < ENGINE_EXCEPTION_COUNT && ENGINE_EXCEPTIONS[probe][0] <= key) ? probe : lo;
+    }
+    bool hit = ENGINE_EXCEPTIONS[lo][0] == key;
+    s = hit ? ffrom(ENGINE_EXCEPTIONS[lo][1]) : s;
+    c = hit ? ffrom(ENGINE_EXCEPTIONS[lo][2]) : c;
+}
+
+// ---- musl/Arm double exp and pow (double_math.rs) -------------------------
+
+__device__ inline double exp_special(double tmp, uint64_t bits, uint64_t k) {
+    if ((k & 0x80000000ull) == 0) {
+        bits -= 1009ull << 52;
+        double scale = dfrom(bits);
+        return dfrom(2032ull << 52) * (scale + scale * tmp);
+    }
+    bits += 1022ull << 52;
+    double scale = dfrom(bits);
+    double y = scale + scale * tmp;
+    if (fabs(y) < 1.0) {
+        double one = y < 0.0 ? -1.0 : 1.0;
+        double lo = scale - y + scale * tmp;
+        double hi = one + y;
+        lo = one - hi + y + lo;
+        y = (hi + lo) - one;
+        if (y == 0.0) y = dfrom(bits & (1ull << 63));
+    }
+    return 2.2250738585072014e-308 * y;
+}
+__device__ inline double exp_inner(double x, double xtail, bool negative) {
+    uint64_t exponent = (dbits(x) >> 52) & 0x7ff;
+    if (exponent < 969) return negative ? -(1.0 + x) : 1.0 + x;
+    if (exponent >= 1033) {
+        double y = signbit(x) ? 0.0 : INFINITY;
+        return negative ? -y : y;
+    }
+    double kd = round(INV_LN2_N * x);
+    uint64_t ki = (uint64_t)(int64_t)kd;
+    double r = (x + kd * NEG_LN2_HI_N + kd * NEG_LN2_LO_N) + xtail;
+    int idx = 2 * (int)(ki % 128);
+    uint64_t bias = negative ? (0x800ull << 7) : 0;
+    uint64_t top = (ki + bias) << 45;
+    double tail = dfrom(EXP_TAB[idx]);
+    uint64_t bits = EXP_TAB[idx + 1] + top;
+    double r2 = r * r;
+    double tmp = tail + r + r2 * (EXP_POLY[0] + r * EXP_POLY[1]) + r2 * r2 * (EXP_POLY[2] + r * EXP_POLY[3]);
+    if (exponent >= 1032) return exp_special(tmp, bits, ki);
+    double scale = dfrom(bits);
+    return scale + scale * tmp;
+}
+__device__ inline double dexp(double x) {
+    if (isnan(x)) return x;
+    return exp_inner(x, 0.0, false);
+}
+__device__ inline void pow_log(uint64_t ix, double& out_hi, double& out_lo) {
+    uint64_t tmp = ix - 0x3fe6955500000000ull;
+    int i = (int)((tmp >> 45) % 128);
+    double kd = (double)((int64_t)tmp >> 52);
+    uint64_t iz = ix - (tmp & (0xfffull << 52));
+    double z = dfrom(iz);
+    double invc = POW_TAB[i][0], logc = POW_TAB[i][1], logctail = POW_TAB[i][2];
+    double zhi = dfrom((iz + (1ull << 31)) & (~0ull << 32));
+    double zlo = z - zhi;
+    double rhi = zhi * invc - 1.0;
+    double rlo = zlo * invc;
+    double r = rhi + rlo;
+    double t1 = kd * LN2_HI + logc;
+    double t2 = t1 + r;
+    double lo1 = kd * LN2_LO + logctail;
+    double lo2 = t1 - t2 + r;
+    const double* a = POW_POLY;
+    double ar = a[0] * r;
+    double ar2 = r * ar;
+    double ar3 = r * ar2;
+    double arhi = a[0] * rhi;
+    double arhi2 = rhi * arhi;
+    double hi = t2 + arhi2;
+    double lo3 = rlo * (ar + arhi);
+    double lo4 = t2 - hi + arhi2;
+    double p = ar3 * (a[1] + r * a[2] + ar2 * (a[3] + r * a[4] + ar2 * (a[5] + r * a[6])));
+    double lo = lo1 + lo2 + lo3 + lo4 + p;
+    double y = hi + lo;
+    out_hi = y;
+    out_lo = hi - y + lo;
+}
+__device__ inline uint32_t integer_kind(uint64_t bits) {
+    uint64_t e = (bits >> 52) & 0x7ff;
+    if (e < 1023) return 0;
+    if (e > 1075) return 2;
+    uint64_t bit = 1ull << (1075 - e);
+    return (bits & (bit - 1)) ? 0 : ((bits & bit) ? 1 : 2);
+}
+__device__ inline double dpow(double x, double y) {
+    // pow(1, y) is 1 for every y, NaN included, as the paths below also give;
+    // answering first skips the logarithm, e.g. for godot_ease(0, curve).
+    if (dbits(x) == dbits(1.0)) return 1.0;
+    const uint64_t SIGN = 1ull << 63;
+    uint64_t ix = dbits(x), iy = dbits(y);
+    uint32_t topx = (uint32_t)(ix >> 52), topy = (uint32_t)(iy >> 52);
+    bool negative = false;
+    if (topx - 1u >= 0x7feu || (topy & 0x7ffu) - 0x3beu >= 0x80u) {
+        if (y == 0.0 || !isfinite(y)) {
+            if (y == 0.0) return 1.0;
+            if (x == 1.0) return 1.0;
+            if (isnan(x) || isnan(y)) return altd_nan_operand(x, y);
+            if (fabs(x) == 1.0) return 1.0;
+            if ((fabs(x) < 1.0) == !signbit(y)) return 0.0;
+            return y * y;
+        }
+        if (x == 0.0 || !isfinite(x)) {
+            double x2 = isnan(x) ? altd_nan_operand(x, x) : x * x;
+            if (signbit(x) && integer_kind(iy) == 1) x2 = dfrom(dbits(x2) ^ (1ull << 63));  // -x2, NaN included
+            return signbit(y) && !isnan(x2) ? 1.0 / x2 : x2;
+        }
+        if (signbit(x)) {
+            uint32_t kind = integer_kind(iy);
+            if (kind == 0) return dfrom(0xfff8000000000000ull);
+            negative = kind == 1;
+            ix &= ~SIGN; topx &= 0x7ff;
+        }
+        if ((topy & 0x7ffu) - 0x3beu >= 0x80u) {
+            if (ix == dbits(1.0)) return 1.0;
+            if ((topy & 0x7ffu) < 0x3beu) return ix > dbits(1.0) ? 1.0 + y : 1.0 - y;
+            return (ix > dbits(1.0)) == (topy < 0x800u) ? INFINITY : 0.0;
+        }
+        if (topx == 0) ix = (dbits(x * 4503599627370496.0) & ~SIGN) - (52ull << 52);
+    }
+    double hi, lo;
+    pow_log(ix, hi, lo);
+    double yhi = dfrom(iy & (~0ull << 27));
+    double ylo = y - yhi;
+    double lhi = dfrom(dbits(hi) & (~0ull << 27));
+    double llo = hi - lhi + lo;
+    double ehi = yhi * lhi;
+    double elo = ylo * lhi + y * llo;
+    return exp_inner(ehi, elo, negative);
+}
+
+// ---- Network activation (network.rs game_expm1 / game_tanh) ---------------
+
+__device__ inline double game_expm1(double x) {
+    uint32_t high = (uint32_t)(dbits(x) >> 32) & 0x7fffffffu;
+    bool negative = signbit(x);
+    if (high >= 0x4043687au) {
+        if (isnan(x)) return x;
+        if (isinf(x)) return negative ? -1.0 : x;
+        if (negative) return -1.0;
+        if (x > 7.09782712893383973096e2) return INFINITY;
+    }
+    int k; double c;
+    if (high > 0x3fd62e42u) {
+        double hi, lo;
+        if (high < 0x3ff0a2b2u) {
+            if (!negative) { hi = x - 6.93147180369123816490e-1; lo = 1.90821492927058770002e-10; k = 1; }
+            else { hi = x + 6.93147180369123816490e-1; lo = -1.90821492927058770002e-10; k = -1; }
+        } else {
+            k = (int)(1.44269504088896338700 * x + (negative ? -0.5 : 0.5));
+            hi = x - (double)k * 6.93147180369123816490e-1;
+            lo = (double)k * 1.90821492927058770002e-10;
+        }
+        x = hi - lo; c = (hi - x) - lo;
+    } else if (high < 0x3c900000u) {
+        return x;
+    } else { k = 0; c = 0.0; }
+    double hfx = 0.5 * x;
+    double hxs = x * hfx;
+    double r1 = 1.0 + hxs * (-3.33333333333331316428e-2 + hxs * (1.58730158725481460165e-3 + hxs * (-7.93650757867487942473e-5
+        + hxs * (4.00821782732936239552e-6 + hxs * (-2.01099218183624371326e-7)))));
+    double t = 3.0 - r1 * hfx;
+    double e = hxs * ((r1 - t) / (6.0 - x * t));
+    if (k == 0) return x - (x * e - hxs);
+    e = x * (e - c) - c;
+    e -= hxs;
+    if (k == -1) return 0.5 * (x - e) - 0.5;
+    if (k == 1) return x < -0.25 ? -2.0 * (e - (x + 0.5)) : 1.0 + 2.0 * (x - e);
+    double twopk = dfrom((uint64_t)(0x3ff + k) << 52);
+    if (k < 0 || k > 56) {
+        double y = x - e + 1.0;
+        return (k == 1024 ? y * 2.0 * dfrom(0x7fe0000000000000ull) : y * twopk) - 1.0;
+    }
+    double inverse = dfrom((uint64_t)(0x3ff - k) << 52);
+    return k < 20 ? (x - e + (1.0 - inverse)) * twopk : (x - (e + inverse) + 1.0) * twopk;
+}
+// The scalar tanh, one branch per range. A wave whose lanes fall in different
+// ranges executes every taken branch in turn, and the three expm1 call sites
+// are inlined separately, so the double-precision work (1/32 rate on RDNA3)
+// runs up to three times per layer. Kept for comparison: -DALTD_TANH_BRANCHY.
+__device__ inline double game_tanh_branchy(double value) {
+    double x = fabs(value);
+    uint32_t high = (uint32_t)(dbits(x) >> 32);
+    double t;
+    if (high > 0x3fe193eau) {
+        if (high > 0x40340000u) t = 1.0 - 0.0 / x;
+        else { double u = game_expm1(2.0 * x); t = 1.0 - 2.0 / (u + 2.0); }
+    } else if (high > 0x3fd058aeu) {
+        double u = game_expm1(2.0 * x); t = u / (u + 2.0);
+    } else if (high >= 0x00100000u) {
+        double u = game_expm1(-2.0 * x); t = -u / (u + 2.0);
+    } else t = x;
+    return signbit(value) ? -t : t;
+}
+
+// ---- branch-free game_tanh ------------------------------------------------
+// One expm1 evaluation per lane on a selected argument, then selects, so the
+// lanes of a wave never serialize the tanh ranges or the expm1 cases. Each
+// lane's selected expression is exactly what the scalar code evaluates on
+// that path; unselected values are computed and dropped. This is the scalar
+// form of `tanh4`/`expm1_tanh` in src/nn/network_simd.rs, whose CPU tests
+// compare it with the scalar functions bit for bit over every branch,
+// threshold and special value.
+
+// 2^k by exponent-field arithmetic, as the scalar code.
+__device__ inline double pow2_of(int32_t k) {
+    return dfrom((uint64_t)(int64_t)(k + 0x3ff) << 52);
+}
+
+// `game_expm1` for the arguments `game_tanh` selects: finite, below 709.78
+// when positive, so the overflow block of the scalar code never returns early.
+// The integer k is kept as an integer for its comparisons and powers of two
+// (the scalar code's `k as f64` only enters the two reduction products).
+__device__ inline double expm1_lane(double x) {
+    uint32_t h = (uint32_t)(dbits(x) >> 32) & 0x7fffffffu;
+    bool negative = signbit(x);
+    bool reduce = h > 0x3fd62e42u, tiny = h < 0x3c900000u, near = h < 0x3ff0a2b2u;
+    // k = +-1 near ln 2, else trunc(x / ln 2 +- 0.5); 0 without reduction.
+    double rounded = 1.44269504088896338700 * x + (negative ? -0.5 : 0.5);
+    int32_t ki = reduce ? (near ? (negative ? -1 : 1) : __double2int_rz(rounded)) : 0;
+    double k = (double)ki;
+    // For k = +-1, x - k*ln2_hi and k*ln2_lo equal the scalar x -+ ln2_hi, +-ln2_lo exactly.
+    double hi = x - k * 6.93147180369123816490e-1;
+    double lo = k * 1.90821492927058770002e-10;
+    double xr = reduce ? hi - lo : x;
+    double c = reduce ? (hi - xr) - lo : 0.0;
+    double hfx = 0.5 * xr;
+    double hxs = xr * hfx;
+    double p = hxs * -2.01099218183624371326e-7;
+    p = hxs * (4.00821782732936239552e-6 + p);
+    p = hxs * (-7.93650757867487942473e-5 + p);
+    p = hxs * (1.58730158725481460165e-3 + p);
+    p = hxs * (-3.33333333333331316428e-2 + p);
+    double r1 = 1.0 + p;
+    double t = 3.0 - r1 * hfx;
+    double e = hxs * ((r1 - t) / (6.0 - xr * t));
+    double k0 = xr - (xr * e - hxs);
+    e = (xr * (e - c) - c) - hxs;
+    double xme = xr - e;
+    double km1 = 0.5 * xme - 0.5;
+    double k1 = xr < -0.25 ? -2.0 * (e - (xr + 0.5)) : 1.0 + 2.0 * xme;
+    double twopk = pow2_of(ki), inverse = pow2_of(-ki);
+    // k < 0 || k > 56 (k == 1024 needs x > 709, outside the domain).
+    bool far = ki < 0 || ki > 56;
+    double far_value = (xme + 1.0) * twopk - 1.0;
+    double below20 = (xme + (1.0 - inverse)) * twopk;
+    double from20 = ((xr - (e + inverse)) + 1.0) * twopk;
+    double general = far ? far_value : (ki < 20 ? below20 : from20);
+    double result = ki == 0 ? k0 : (ki == -1 ? km1 : (ki == 1 ? k1 : general));
+    return tiny ? x : result;
+}
+
+__device__ inline double game_tanh(double value) {
+#ifdef ALTD_TANH_BRANCHY
+    return game_tanh_branchy(value);
+#else
+    double x = fabs(value);
+    uint32_t h = (uint32_t)(dbits(x) >> 32);
+    // Above 0x40340000 (|x| > 20, infinities, NaN) the scalar path stays a
+    // branch: NaN must keep its payload, and a NaN routed through the selects
+    // below can lose it on this hardware (fabs folded into the 32-bit select
+    // as a float source modifier, which quiets or canonicalizes under IEEE
+    // mode). Finite lanes never take it during inference.
+    if (h > 0x40340000u) {
+        double t = 1.0 - 0.0 / x;
+        return signbit(value) ? -t : t;
+    }
+    bool big = h > 0x3fe193eau, mid = h > 0x3fd058aeu, normal = h > 0x000fffffu;
+    double t = expm1_lane(mid ? 2.0 * x : -2.0 * x);
+    double d = t + 2.0;
+    // The range's own division: 2 / (t + 2) for the large range, t / (t + 2)
+    // otherwise; the small range's (-t) / (t + 2) is the exact negation.
+    double q = (big ? 2.0 : t) / d;
+    double result = big ? 1.0 - q : (mid ? q : (normal ? -q : x));
+    return signbit(value) ? -result : result;
+#endif
+}
+
+// ---- math profiles (crate::math::profile) ----------------------------------
+// The Windows UCRT functions of math/kernels/ucrt.h. World::math_profile picks a
+// profile for the whole simulation, so the branches below never diverge.
+
+#define ALTD_MATH_FN __device__ inline
+#define ALTD_MATH_TABLE __device__ constexpr
+#define ALTD_MATH_CONST constexpr
+#include "../../math/kernels/ucrt.h"
+
+// MathProfile::index.
+enum : uint32_t { MATH_PROTON = 0, MATH_WIN10_FMA3 = 1, MATH_WIN11_FMA3 = 2 };
+
+// sinf and cosf are musl's with the Windows exceptions. Inputs beyond
+// WIN_TRIG_LIMIT are flagged by the musl reduction already.
+__device__ inline float profile_sin(uint32_t math, float x, uint32_t& err) {
+    float musl = native_sin(x, err);
+    return math == MATH_PROTON ? musl : win_sinf_fix(x, musl);
+}
+__device__ inline float profile_cos(uint32_t math, float x, uint32_t& err) {
+    float musl = native_cos(x, err);
+    return math == MATH_PROTON ? musl : win_cosf_fix(x, musl);
+}
+// The profile is uniform, so these branch rather than select (WGSL's select
+// evaluates both operands).
+__device__ inline float profile_atan2(uint32_t math, float y, float x) {
+    if (math == MATH_PROTON) return native_atan2(y, x);
+    return win_atan2f(y, x);
+}
+__device__ inline double profile_exp(uint32_t math, double x) {
+    if (math == MATH_PROTON) return dexp(x);
+    if (math == MATH_WIN10_FMA3) return win10_exp(x);
+    return win11_exp(x);
+}
+__device__ inline double profile_pow(uint32_t math, double x, double y) {
+    if (math == MATH_PROTON) return dpow(x, y);
+    if (math == MATH_WIN10_FMA3) return win10_pow(x, y);
+    return win11_pow(x, y);
+}
+__device__ inline double profile_tanh(uint32_t math, double x) {
+    if (math == MATH_PROTON) return game_tanh(x);
+    if (math == MATH_WIN10_FMA3) return win10_tanh(x);
+    return win11_tanh(x);
+}
+
+}  // namespace altd

github-simulator/source/gpu/sim/rays.h

@@ -0,0 +1,118 @@
+// BSP queries of src/track/bsp.rs with explicit stacks instead of recursion:
+// RayTree::raycast and Node::closest, which share the RayTree arena.
+#pragma once
+#include "world.h"
+#include "math.h"
+
+namespace altd {
+
+// `Bounds::beside`: box (cx, cy, hx, hy) lies beyond `margin` on one side of the ray's line.
+__device__ inline bool beside(float4 box, float2 start, float2 b, float margin) {
+    float cross = b.x * (box.y - start.y) - b.y * (box.x - start.x);
+    return fabsf(cross) > fabsf(b.x) * (box.w + margin) + fabsf(b.y) * (box.z + margin);
+}
+
+// `classify`: side of p relative to the wall (origin, direction).
+__device__ inline int classify(float4 wall, float2 p) {
+    float cross = wall.z * (p.y - wall.y) - wall.w * (p.x - wall.x);
+    return cross > 0.0001f ? 1 : (cross < -0.0001f ? -1 : 0);
+}
+
+// `godot_math::ray_wall_hit`
+__device__ inline bool ray_wall_hit(float2 start, float2 b, float4 wall, float2& hit) {
+    float denominator = wall.z * b.y - b.x * wall.w;
+    float dx = wall.x - start.x, dy = wall.y - start.y;
+    float ray_fraction = ((0.0f - wall.w) * dx + wall.z * dy) / denominator;
+    float wall_fraction = (b.x * dy - b.y * dx) / denominator;
+    hit = make_float2(wall.x + wall.z * wall_fraction, wall.y + wall.w * wall_fraction);
+    return !(fabsf(denominator) < 1e-6f) && ray_fraction >= 0.0f && ray_fraction <= 1.0f
+        && wall_fraction >= 0.0f && wall_fraction <= 1.0f;
+}
+
+// `RayTree::raycast`. The recursion "near subtree, else own walls, else the
+// far subtree if the ray crosses the partition" becomes a descent loop that
+// pushes each entered node, and a pop that tests the node's own walls and
+// then continues into its far child.
+__device__ inline bool raycast(const World& w, float2 start, float2 end, float2& hit) {
+    float2 b = make_float2(end.x - start.x, end.y - start.y);
+    float scale = w.ray_magnitude + fabsf(start.x) + fabsf(start.y);
+    float margin = fabsf(b.x) + fabsf(b.y) > 1e-10f ? 1e-3f + 2e-5f * scale : INFINITY;
+    uint32_t stack[MAX_RAY_DEPTH];
+    int depth = 0;
+    uint32_t current = w.ray_node_count ? 0 : NONE;
+    for (;;) {
+        while (current != NONE) {
+            const RayNode& node = w.ray_nodes[current];
+            if (beside(node.subtree, start, b, margin)) break;
+            float4 partition = w.ray_walls[node.first];
+            int a = classify(partition, start), e = classify(partition, end);
+            bool front_first = a == 1 || (a == 0 && e == 1);
+            // Low bit: the ray crosses the partition, so the far side follows.
+            stack[depth++] = current << 1 | (a != e);
+            current = front_first ? node.front : node.back;
+        }
+        if (depth == 0) return false;
+        uint32_t entry = stack[--depth];
+        const RayNode& node = w.ray_nodes[entry >> 1];
+        if (!beside(node.own, start, b, margin)) {
+            float distance = 3.40282347e38f;
+            bool found = false;
+            for (uint32_t i = node.first; i < node.last; i++) {
+                float2 p;
+                bool ok = ray_wall_hit(start, b, w.ray_walls[i], p);
+                float dx = p.x - start.x, dy = p.y - start.y;
+                float d2 = dx * dx + dy * dy;
+                bool better = ok && d2 < distance;
+                distance = better ? d2 : distance;
+                hit = better ? p : hit;
+                found |= better;
+            }
+            if (found) return true;
+        }
+        float4 partition = w.ray_walls[node.first];
+        bool front_first = classify(partition, start) == 1
+            || (classify(partition, start) == 0 && classify(partition, end) == 1);
+        current = (entry & 1) ? (front_first ? node.back : node.front) : NONE;
+    }
+}
+
+// `Node::closest`: own walls, then the near subtree, then the far subtree
+// when the partition line is closer than the best wall so far.
+__device__ inline float2 closest_wall_point(const World& w, float2 p) {
+    float distance = INFINITY;
+    float2 closest = make_float2(0.0f, 0.0f);
+    uint32_t stack[MAX_RAY_DEPTH];
+    int depth = 0;
+    uint32_t current = w.ray_node_count ? 0 : NONE;
+    for (;;) {
+        while (current != NONE) {
+            const RayNode& node = w.ray_nodes[current];
+            for (uint32_t i = node.first; i < node.last; i++) {
+                float4 wall = w.ray_walls[i];
+                float len2 = wall.z * wall.z + wall.w * wall.w;
+                float t = (p.x * wall.z + p.y * wall.w) - (wall.x * wall.z + wall.y * wall.w);
+                t = t < 0.0f ? 0.0f : (t > len2 ? len2 : t);  // f32::clamp
+                t = t / len2;
+                float2 candidate = len2 == 0.0f ? make_float2(wall.x, wall.y)
+                                                : make_float2(wall.x + wall.z * t, wall.y + wall.w * t);
+                float dx = p.x - candidate.x, dy = p.y - candidate.y;
+                float d2 = dx * dx + dy * dy;
+                bool better = d2 < distance;
+                distance = better ? d2 : distance;
+                closest = better ? candidate : closest;
+            }
+            stack[depth++] = current;
+            current = classify(w.ray_walls[node.first], p) >= 0 ? node.front : node.back;
+        }
+        if (depth == 0) return closest;
+        const RayNode& node = w.ray_nodes[stack[--depth]];
+        float4 partition = w.ray_walls[node.first];
+        float t = ((p.x - partition.x) * partition.z + (p.y - partition.y) * partition.w)
+            / (partition.z * partition.z + partition.w * partition.w);
+        float dx = p.x - (partition.x + partition.z * t), dy = p.y - (partition.y + partition.w * t);
+        bool far = dx * dx + dy * dy < distance;
+        current = far ? (classify(partition, p) >= 0 ? node.back : node.front) : NONE;
+    }
+}
+
+}  // namespace altd

github-simulator/source/gpu/sim/sensors.h

@@ -0,0 +1,98 @@
+// `Car::sensor` (src/physics/car.rs) for every sensor kind, reading the GPU car state.
+#pragma once
+#include "rays.h"
+#include "track.h"
+
+namespace altd {
+
+constexpr float PI_F = 3.14159265358979323846f;
+
+struct Sensors {
+    uint32_t count, needs_path;  // needs_path: some sensor reads the path offset
+    SensorDesc s[MAX_SENSORS];
+};
+
+// Cars whose controls update this tick (Schedule::update_controls).
+struct ReadMask {
+    uint32_t batch_size, batch_index, batches_per_tick, require_active;
+};
+
+__device__ inline bool reads(const ReadMask& m, const Car& car, uint32_t index) {
+    uint32_t batch = index / m.batch_size;
+    return (batch + 8 - m.batch_index) % 8 < m.batches_per_tick && (!m.require_active || (car.flags & CAR_ACTIVE));
+}
+
+__device__ inline Vec2 actual_velocity(const Car& c) { return (c.flags & CAR_PENDING_VELOCITY) ? Vec2{0.0f, 0.0f} : c.velocity; }
+__device__ inline float actual_angular(const Car& c) { return (c.flags & CAR_PENDING_VELOCITY) ? 0.0f : c.angular_velocity; }
+__device__ inline Vec2 actual_acceleration(const Car& c) { return (c.flags & CAR_PENDING_VELOCITY) ? c.reset_acceleration : c.acceleration; }
+__device__ inline Vec2 cached_right(const Car& c) { return (c.flags & CAR_RESET_RIGHT) ? Vec2{0.0f, 0.0f} : normalized(c.basis_x); }
+// `Car::cached_front`: cached_right rotated by -PI/2, whose managed sine and
+// cosine are constant (godot_math::QUARTER_TURN_BACK).
+__device__ inline Vec2 cached_front(const Car& c) {
+    Vec2 r = cached_right(c);
+    float s = ffrom(0xbf7fffffu), co = ffrom(0xb3bbbd2eu);
+    return Vec2{r.x * co - r.y * s, r.x * s + r.y * co};
+}
+
+// `Car::sensor_path_offset` (actual position equals position: no transform reset is pending).
+__device__ inline float sensor_path_offset(const World& w, const Car& car) {
+    return curve_closest_offset(w, path_sensor_point(w, car.position));
+}
+
+// `Car::sensor`. `here` is sensor_path_offset for the path sensors.
+__device__ inline double sensor_value(const World& w, const VehicleDesc& v, const Car& car, const SensorDesc& s,
+                                      float here, uint32_t& err) {
+    switch (s.kind) {
+        case S_RAYCAST: {
+            Vec2 local = s.offset;  // `Car::ray_local`, precomputed on the host (with_ray_offset)
+            Vec2 end = transform_point(car.position, car.basis_x, car.basis_y, local);
+            float2 hit;
+            if (!raycast(w, make_float2(car.position.x, car.position.y), make_float2(end.x, end.y), hit)) return 0.0;
+            if (hit.x == end.x && hit.y == end.y) return 0.0;
+            return (double)(1.0f - length(Vec2{hit.x, hit.y} - car.position) / s.b);
+        }
+        case S_DISTANCE_FROM_WALL: {
+            float2 wall = closest_wall_point(w, make_float2(car.position.x, car.position.y));
+            return (double)rclamp(length(car.position - Vec2{wall.x, wall.y}) / s.a, 0.0f, 1.0f);
+        }
+        case S_SPEED: return (double)rclamp(length(car.velocity) / v.max_velocity_f, 0.0f, 1.0f);
+        case S_VELOCITY_FRONT:
+            return signed_sensor(dot(actual_velocity(car), cached_front(car)), v.max_velocity_f);
+        case S_VELOCITY_SIDE:
+            return signed_sensor(dot(actual_velocity(car), cached_right(car)), v.max_velocity_f / 2.0f);
+        case S_ACCELERATION_FRONT:
+            return signed_sensor(dot(actual_acceleration(car), cached_front(car)), s.a);
+        case S_ACCELERATION_SIDE:
+            return signed_sensor(dot(actual_acceleration(car), cached_right(car)), s.a);
+        case S_ANGULAR_VELOCITY: return signed_sensor(actual_angular(car), 2.0f);
+        case S_WHEEL_ANGLE: {
+            uint32_t i = 0;
+            while (i + 1 < v.wheel_count && !v.wheels[i].steering) i++;
+            return signed_sensor(car.wheel_angle[i], 45.0f);
+        }
+        case S_BOOST_CAPACITY: return py_clamp((double)car.boost_energy, 0.0, 1.0);
+        case S_GRIP: {
+            Vec2 p = car.position + rotated(s.offset, car.rotation, err);
+            return (double)w.surfaces[vehicle_surface(w, p)].grip;
+        }
+        case S_CORRECT_DIRECTION: {
+            if (w.path_points < 2) return 0.0;
+            Vec2 tangent = normalized(curve_direction(w, here, err));
+            Vec2 forward = normalized(cached_front(car));
+            return (double)rclamp(dot(forward, tangent), -1.0f, 1.0f);
+        }
+        case S_TRACK_CURVATURE: {
+            if (w.path_points < 2) return 0.0;
+            Vec2 tangent = normalized(curve_direction(w, here, err));
+            if (w.curve_length <= 0.0f) return 0.0;
+            float speed = rclamp(length(actual_velocity(car)) / v.max_velocity_f, 0.0f, 1.0f);
+            float lo = rmax(s.a, 0.0f), hi = rmax(s.b, lo);
+            float offset = fmodf(here + (lo + (hi - lo) * speed), w.curve_length);
+            Vec2 ahead = normalized(curve_direction(w, offset, err));
+            return (double)rclamp(fabsf(profile_atan2(w.math_profile, cross(tangent, ahead), dot(tangent, ahead))) / PI_F, 0.0f, 1.0f);
+        }
+    }
+    return 0.0;
+}
+
+}  // namespace altd