Platform Evidence¶
The dated runs and measurements behind each platform's status. The user pages state what works, and Requirements and Platform Status gives each platform one status word; this page records how that was established, so a later change can be checked against it. The runs themselves are described in Device and Browser Runs.
A status is claimed only after the matching smoke path passes on that target, and it never moves to a new Godot baseline before the matching smoke and device runs pass there (Godot Upgrade Runbook).
Godot Baseline Changes¶
main moved from 4.7.2 to 4.8 beta 2 on 2026-11-07
(4.8.beta2.official.cafc17a19). It is a prerelease pin: no release is cut on it,
and the statuses on Requirements and Platform Status stay those of release 0.4.0
on 4.7.2 until their runs pass on 4.8. scripts/upgrade_godot.sh --prerelease
classified the bump as an API change: 33 classes added and adopted, 15 source
breaks and 4 compatible changes on the public surface, gdextension_interface.h
with no new deprecation Kanama binds. Run on macOS arm64 the same day:
scripts/local_ci.sh (runtime, @Tool, editor-probe and hot-reload smokes
included), every red run (gate_red_runs.py --slow --strict, 334 cases), the
demos desktop_smoke_all.sh nine-demo matrix, the Web pr set in Chrome 156
(4/4, protocol 39), the iOS device xcframeworks (172.2 / 113.4 MB), an Android
debug export of dodge and an R8-minified release export of Match3 without a
device, and the store addon with a headless Android export from it.
Not run on 4.8 yet: every Android and iOS device gate, the Web corpus beyond
the pr set, Firefox and Safari, and Windows and Linux. The ledger entries for
them carry a dated waiver to 2026-12-31.
Kanama re-pinned from 4.7.0 to 4.7.2 stable on 2026-09-08.
scripts/upgrade_godot.sh classified the bump as metadata-only: only the
extension_api.json header changed (version_patch 0 → 2); the API body and
gdextension_interface.h are byte-identical, so wrappers, name constants, and
struct layouts are unchanged and the regen churn was version strings plus a
KDoc re-sync from the 4.7.2 doc/classes. Desktop gates re-ran on the 4.7.2
binary the same day: scripts/local_ci.sh passed end to end on macOS arm64
(runtime, @Tool, hot-reload, and in-process hot-reload smokes included), and
the demos desktop_smoke_all.sh nine-demo matrix passed. Not re-run on 4.7.2
templates: the Android and iOS device gates and the Web browser matrix; the
mobile and Web evidence below stays dated on the 4.7.0 templates until they
are. Godot's Android export-template toolchain (config.gradle) is identical
between the two tags, so the Android toolchain table holds for 4.7.2.
The 4.7 rc 2 → 4.7 stable bump was also metadata-only: the dumped
extension_api.json (excluding the version_status header field) and
gdextension_interface.h are byte-identical between the two builds, so the
generated wrappers, Panama bindings, name constants, and struct layouts are
unchanged and the rc 2 validation carries over. scripts/runtime_smoke.sh
passed against the macOS arm64 4.7 stable binary
(4.7.stable.official.5b4e0cb0f) on 2026-06-21. iOS (iPhone 12 self-test) and
Android (android_smoke.sh on the API 36 emulator, Starter-Kit-Match3) also
re-passed against 4.7 stable templates the same day. The Pixel 7 hardware
device gate (debug demo matrix + R8-minified Match3 release APK) passed on
2026-06-26. Windows x86_64 completed its full local 4.7-stable revalidation on
2026-07-13; Linux x86_64 and arm64 both re-passed the full local CI, demo,
TPS, package, and native-artifact gates against Godot 4.7 stable (x86_64 on
2026-07-13/14, arm64 on 2026-07-14 on a native AArch64 Ubuntu 26.04 host).
Desktop¶
Validation Runs¶
- macOS arm64 is the primary runtime and package target. API and header
inputs, generated wrappers, KDoc, local CI and the desktop demo smokes target
this baseline;
runtime_smoke.shpassed against the 4.7 stable binary on 2026-06-21. The exported-game run is under Exported Games. - Linux arm64: full local CI, native bootstrap preflight, strict docs, all
11 demo builds, the nine-demo desktop smoke matrix, the TPS checked smoke,
distribution packaging, and the desktop-kit and store-addon install smokes
passed on Ubuntu 26.04 with Godot
4.7.stable.official.5b4e0cb0fand OpenJDK 25.0.3 (native AArch64, 2026-07-14). The resource-loader/saver teardown fix is required. - Linux x86_64: the same set passed on Ubuntu 25.04 with Godot
4.7.stable.official.5b4e0cb0fand OpenJDK 25.0.2 (2026-07-13/14). The resource-loader/saver teardown fix is required. - Windows x86_64: full local revalidation on the 4.7 stable console binary
(2026-07-13): demo audits, script builds, imports, the nine-demo desktop
runtime smoke, the TPS smoke, and the packaged desktop-kit and store-addon
install smokes all passed. The commands that build the native bootstrap run
from a VS 2022 developer environment (
VsDevCmd); Git Bash runs the smoke scripts (Local Validation).
Exported Games¶
The decided end state is unpack-and-play: exported desktop games ship a bundled, jlink-trimmed JVM runtime that the native bootstrap finds app-relative, so players never install a JDK. The system JDK stays the developer path — like C# development needs the .NET SDK while Godot/.NET exports bundle the .NET runtime.
Status: implemented for Windows, Linux, and macOS, and cross-target — a developer on any desktop host can produce the runtime for any other.
Evidence, so you can judge how far it has been taken:
- Windows — a game exported with a runtime cross-built on macOS arm64
was run on real Windows hardware (2026-08-10) and booted from its own bundled
runtime. That machine had a JDK installed and the app-relative probe still
won (
[kanama] using libjvm: <export>\runtime\bin\server\jvm.dll, nochecked JAVA_HOMEline), so this is not a case of a system JVM standing in. Real GPU path (Vulkan 1.2.175 - Forward+, NVIDIA GTX 670), no VC++/CRT redistributable needed, and a clean teardown (22/22 scripts and 221/221 StringNames released, script language unregistered withError=0). - Linux — the same cross-built-on-macOS proof runs on the CI runner with
JAVA_HOMEunset. No dedicated real-hardware pass yet. - macOS — validated on macOS arm64 (2026-09-10, Godot
4.7.2.stable, Temurin 25.0.4.1+1): the exported.appboots headless withJAVA_HOMEunset andPATHstripped, from<app>/Contents/Resources/runtime/lib/server/libjvm.dylib. Proven twice — once against a host-jlinked image and once against one linked from the pinnedmacos-arm64Temurin jmods, 31.7 MB either way. The path in that line is the proof, not the fact that the game ran: with the bundledruntime/deleted the same.appstill starts on a developer Mac, because the bootstrap's last resort is a hardcoded/Library/Java/…/temurin-25.jdkfallback. The run constructed a script (SelfSmoke self_class=Node3D same_object=true) and tore down clean (23/23 tracked objects destroyed, 6 extension classes unregistered). No pass yet on a second Mac with no JDK installed. Distribution-grade signing and notarization of the bundled runtime is a separate track and is not done — see macOS Entitlements and Signing. That caveat is macOS-specific — it does not gate the Windows or Linux path.
Cross-Target Runtime Images¶
A Temurin JDK install no longer contains jmods at all — since JDK 24's JEP 493
the JDK links from its own run-time image, which only ever produces an image
for the platform it is running on — so jlinkGameRuntimeCross fetches the
target platform's jmods from Adoptium's separate per-platform download
(about 80 MB compressed, SHA-256 pinned in build.gradle.kts).
kanamaTargetJdkRelease in gradle.properties pins which Temurin release is
fetched; the jmods must be the same JDK feature version as the JDK doing
the linking (patch levels may differ), and the task fails with a clear message
if they do not match. jlinkGameRuntime links the pinned module set
(java.base, java.instrument, jdk.unsupported) — one recipe for every
Kanama game.
Runtime Image Size¶
The bundled runtime is the whole download cost of unpack-and-play. Measured with the pinned module set, cross-built from macOS arm64 against Temurin 25.0.4+7:
| Target | Runtime image |
|---|---|
windows-x64 |
31 MB |
linux-x64 |
42 MB |
macos-arm64 |
31 MB |
linux-arm64 |
40 MB |
(Sum of file sizes; du reports 1-2 MB more from block rounding.)
In a finished bundle the runtime is not the biggest item. The macOS validation
export of the example project (universal binary) measured 206 MB in total:
162 MB of Godot's own universal executable, 31.7 MB of runtime/, 12 MB of
kanama.jar, and under 1 MB of scripts jar plus .pck.
Plus kanama.jar and the project's kanama-scripts.jar. That is the accepted
trade: every shipped commercial Java game bundles its runtime, and a smaller
download that asks players to install Java is effectively fatal for a game.
Module stripping and compression are later tuning knobs, not blockers.
Exported Game Layout¶
export_game_assemble.sh anchors on the exported bootstrap library and
places the payload where the bootstrap probes before JAVA_HOME:
next to the library on Windows/Linux, and inside Contents/Resources/ for a
macOS .app (the bundle location that survives re-signing). On macOS it also
re-seals the bundle ad-hoc, because adding files after Godot's export breaks
the code signature.
Windows keeps the server JVM at runtime\bin\server\jvm.dll, not
runtime/lib/server as macOS and Linux do, and jvm.dll's CRT dependencies sit
one level up in runtime\bin. The bootstrap registers that directory with the
loader before loading the JVM, so a bundled Windows runtime works on a machine
with no Visual C++ redistributable installed.
The bootstrap anchors on its own dylib (dladdr) and walks up two parent levels,
probing a Resources/ subdirectory at each level, so a library in
Contents/Frameworks/ finds Contents/Resources/runtime. Resources/ is the
only location that works: when codesign seals the bundle it rejects jars and
loose runtime files under Contents/ or Contents/Frameworks/ as unsigned
nested code, while everything under Resources/ is sealed by hash as a plain
resource.
The macOS validation export reports flags=0x10002(adhoc,runtime) with exactly
the three JVM entitlements, and codesign --verify --deep --strict passes on
the assembled bundle. Without com.apple.security.cs.allow-jit,
JNI_CreateJavaVM dies (SIGTRAP in pthread_jit_write_protect_np) before the
VM exists, because HotSpot's code cache is MAP_JIT memory. A Temurin-derived
image carries Developer ID Application: Eclipse Foundation, Inc. signatures,
which library validation would refuse. The pinned module set produces 16 Mach-O
files inside runtime/ (13 dylibs, including lib/server/libjvm.dylib and
lib/server/libjsig.dylib, plus bin/java, bin/keytool and
lib/jspawnhelper); files under Resources/ are only hashed into
CodeResources and keep whatever signature the JDK vendor shipped. Notarizing
the bundled runtime is an explicit non-goal of the exported-game work.
Young-Generation Sizing after a Large Spawn¶
The user pages recommend -XX:MaxNewSize=128m for games that spawn many
objects at once. This is the measurement behind it.
After a game creates many script objects at once (a level load, 10,000 Bunnymark sprites), frames that walk those objects can run ~20–30 % slower until the next young garbage collection, and with HotSpot's defaults that collection can be seconds away. The cause is memory layout: the new objects sit in eden interleaved with the garbage the spawn produced (~2–6 KB per Bunnymark bunny), and G1, seeing a small live set and short pauses, grows eden to ~450–600 MiB, so it fills slowly. The first young collection copies the survivors together and the frames recover at once. Measured on Bunnymark V1 Sprites (100-frame windows after the spawn): the phase lasts ~900 frames at ~2,250 µs per frame instead of ~1,750 µs; forcing a young collection right after the spawn removes it; adding 4 KB of garbage per bunny makes it ~15 % worse.
Recommendation for games that spawn many objects at once:
-XX:MaxNewSize=128m (in kanama/jvm/options or KANAMA_JVM_OPTIONS). Capping
the young generation makes that collection come after at most 128 MiB of
allocation (~200 frames in Bunnymark). It is not the default because it costs
steady-state frame time, and the cost grows with how much the game allocates and
with how loaded the machine is: ~5× more, shorter young pauses (~1.1 ms instead
of ~2.6 ms each). On Bunnymark V3, which allocates ~0.9 GB/s, four interleaved
runs of 10–12 rounds each measured +0.4 % and +0.9 % (load average 4–7) and
+4.6 % and +7.6 % (load 4–6 with other builds running, one spike to 103): plan
for ~5–8 % on a busy machine in a game that allocates like V3. V2 (~0.5 GB/s)
measured −1 % to +3.5 %, V1 Sprites +1.5 % to +3.5 %. A game that allocates less
pays less — and, without the cap, waits longer for that first collection.
-Xmn64m ends the phase as well, but measured head to head with the 128m cap
(10 interleaved rounds, load 4–7) it costs as much or more in steady state (V3
+1.4 %, V2 +1.4 %, V1 Sprites −1 % against the cap), runs twice the collections
and has the worse p99 frames, so the cap is the one recommended.
| Young generation (Bunnymark, 10,000 bunnies) | Frames 100–800 after the spawn vs steady state (V1 Sprites) | Steady state vs G1 default, V3 / V2 / V1 Sprites | Young GCs per second (V3) | Rounds |
|---|---|---|---|---|
| G1 default | +22–30 % | — | ~1.4 | — |
-XX:MaxNewSize=128m (recommended for spawn-heavy games) |
+1 % | +0.4…+7.6 % / −1…+3.5 % / +1.5…+3.5 % | ~7 | 4 runs of 10–12 |
-Xmn64m |
−1 % | +1 % / +2 % / +3 % | ~14 | 10 |
-XX:MaxNewSize=256m |
+17–24 % | +2.5 % / +1 % / −1 % | ~3.3 | 12 |
-XX:MaxNewSize=64m |
0 % | +3 % / −5 % / +1.5 % | ~15 | 4 |
-Xms64m |
+1 % | +3 % / −2 % / +3 % | ~6 (falling as the heap grows) | 4 |
Apple M1 Max, editor binary, median frame time after a 1,500–3,000-frame
warm-up, each option interleaved with the default in the same rounds on a
machine shared with other builds; at 4 rounds ±3 % is noise. -Xms64m ends the
phase only while the heap is small: G1 grows the heap (and eden with it, to
~300 MiB in V3) as the game runs, so a later spawn is slow again. ZGC and
generational Shenandoah were dropped after one screening run each (Shenandoah:
V3 frames ~2× slower; ZGC: the slow phase lasted ~2,000 frames and V3 had 70 ms
p99 frames).
Multiplayer Smoke¶
One desktop smoke (kanama-demos tpsBuildAndMultiplayerSmokeGodot, run
locally, not in CI) starts a headless host and a headless client of the TPS
demo over localhost ENet. It checks that the lobby RPCs work in both directions
and that, after a real-bullet robot kill on the host, the server's part
destroy RPC reaches the client. The demo sends each RPC its GDScript original
sends through the generated *Rpcs senders (lobby in Menu.kt; jump,
land, shoot, hit, explode, play_shoot and destroy in gameplay).
Not covered: Android or iOS peers, more than two peers, client input RPCs
during gameplay, latency or packet loss, and a clean shutdown with a peer still
connected (the smoke kills both processes).
Debugger Attach¶
JDWP attach was verified by hand on 2026-10-18 by attaching a JDWP client
(jdb, the JDK's debugger) to a headless starter project started with the
kanama/debug/jdwp_enabled project setting and with KANAMA_JDWP_PORT.
IntelliJ itself is not driven by any automated check, and the CI stage only
greps that the settings are wired through bootstrap.c and the editor
plugins.
Global Classes in the Editor¶
@GlobalClass registration (the class in Create New Resource, its .tres
instances matching typed export slots) was validated by hand in the editor GUI
(issue #39).
String Method Cost¶
Each generated String method from net.multigesture.kanama.builtins makes one
engine call and converts the text both ways: getExtension() measured about
0.24 µs on desktop where GDScript's takes 0.08 µs. That is why
API Conventions
points per-frame loops over many strings at Kotlin's own functions.
Android¶
Android was promoted from Experimental to Supported on 2026-07-14, when it
met the mobile promotion bar (B1 to B4). The Android path uses the Godot 4.7.2
stable Android export, a Godot Android plugin AAR, Android ART,
PanamaPort, emulator smoke tests, and
device smoke and playability checks for the Android-enabled demos.
scripts/android_smoke.sh passes on the API 36 emulator.
Device-validated across four models: Pixel 7 (Android 16; Android 17 on
2026-09-15; the September Android 17 update on 2026-10-01 with PanamaPort fork
0.1.5-kanama-r8.1) and Moto g 5G 2023 (Android 14) pass the full gate
(nine-demo debug matrix + R8-minified Match3 release); Galaxy S10+
(Android 12) and Pixel 3 XL (Android 9, Vulkan/Mobile) added debug breadth
before Android 13 became the minimum.
The R8/release path is tied to the PanamaPort fork
com.github.falcon4ever.PanamaPort:Core:0.1.5-kanama-r8.1 (Android 17 needs
it), not upstream. Kits and the store addon carry the runtime as the debug AAR
kanama-android and compile a project's scripts with the Kanama Gradle
plugin's buildAndroidScripts; package.yml's android-export job exports
an APK from the Linux kit and from the store addon, with no device.
Android Demo Matrix¶
The nine public demo exports (the eight below plus Bunnymark) are the Android
smoke targets. On 2026-06-26 the full Godot 4.7 stable matrix passed on a
Pixel 7 using debug APK exports, logcat startup checks, and screenshot smoke
checks. The R8-minified Match3 release APK also passed on Pixel 7 when built
against Kanama's PanamaPort fork
(com.github.falcon4ever.PanamaPort:Core:0.1.3-kanama-r8.4 at the time); the
minified-release claim is tied to the forked dependency, not upstream
PanamaPort. On 2026-10-01 the nine-demo debug matrix and the R8-minified Match3
release passed again on the Pixel 7 after its September Android 17 update
(API 37, build CP3A.260905.009), on fork 0.1.5-kanama-r8.1; the earlier
fork aborts in the FFI bootstrap on that build (it had passed on the phone's
earlier Android 17 build on 2026-09-15). The Android 14 (Moto g 5G 2023)
results are carried from the 0.1.3-kanama-* fork era and were not re-run on
0.1.5-kanama-r8.1 (no such device at hand).
| Demo | Result |
|---|---|
godot-demo-2d-dodge-the-creeps |
APK exports, launches, initializes Kanama, and handles D-pad input. |
Starter-Kit-3D-Platformer |
APK exports, launches, loads seven Kotlin scripts, reaches the main loop, renders the 3D scene, and runs gameplay logic with mobile controls. |
Starter-Kit-Match3 |
APK exports, launches, initializes Kanama, and passes startup/screenshot smoke checks. |
godot-demo-3d-squash-the-creeps |
APK exports, launches, initializes Kanama, and passes startup/screenshot smoke checks. |
Starter-Kit-FPS |
APK exports, launches, initializes Kanama, reaches the main loop, and passes screenshot smoke checks with touch-control coverage. |
Starter-Kit-Racing |
APK exports, launches, initializes Kanama, reaches the main loop, and passes screenshot smoke checks with mobile steering controls. |
godot-4-3d-character-controller-tutorial |
APK exports, launches, initializes Kanama, reaches the main loop, and passes screenshot smoke checks with virtual joystick controls. |
godot-4-3d-third-person-controller |
APK exports, launches, initializes Kanama, reaches the main loop, and passes screenshot smoke checks with virtual joystick controls. |
On 2026-07-10 the same nine-demo matrix also passed under Godot's
Vulkan/Mobile renderer on the Pixel 7 (Mali-G710, Android 16): each demo
was exported with rendering_method.mobile="mobile", and the smoke asserted
the renderer actually initialized (Vulkan 1.4.305 - Forward Mobile in logcat;
a silent OpenGL fallback fails the check) alongside the normal Kanama
startup and screenshot checks. The demo corpus ships OpenGL Compatibility as
its default mobile renderer; both renderers are smoke-validated on Pixel 7,
while gameplay and visual parity under Vulkan beyond the smoke bar remains
per-demo validation. These passes are the evidence behind the Supported
claim; they are not a claim of per-demo mobile polish, and broader input
coverage would still strengthen the claim.
Validated Android Versions¶
Android 13 (API 33) is the minimum, for debug and release builds alike. The
plugin declares minSdk 33, and the Kanama Tools export guard stops an
Android Gradle export whose preset sets Min SDK below 33 or leaves it
empty. Debug and release builds are validated on Android 14 (Moto g 5G 2023)
and Android 16 and 17 (Pixel 7).
The minimum comes from release builds. On Android 12 and below, release-mode
(android:debuggable=false) builds crash during PanamaPort's upcall-stub
generation into the system libLLVM_android.so (argument marshalling lands
shifted under release-mode ART's invocation of PanamaPort's runtime-bound
native methods; debug-mode ART invokes them compatibly). Android 13 replaced
that code path. Characterized with a full tombstone 2026-07-13.
Until 2026-10-21 the plugin declared minSdk 26 and the floor was per build
type (2026-07-13 four-model matrix: Pixel 3 XL, Galaxy S10+, Moto g 5G 2023
and Pixel 7, on Android 9, 12, 14 and 16): debug builds were validated down to
Android 9 (the dodge smoke on the Vulkan/Mobile renderer; the factory OpenGL
driver on that device crashes before Kanama runs, see
Other Android Findings) and Android 12 (the
nine-demo matrix), while release builds already needed Android 13. A game
therefore installed on phones it could not run on as a release build, so one
floor replaced the two. The Android 8-12 code paths went with it: the
reachability-fence probe (API 28) and the java.lang.ref.Cleaner probe
(API 33) that turned the garbage-collector release off on older phones.
Pre-16 devices additionally require fork 0.1.3-kanama-r8.3+ (the
SDK_INT_FULL bootstrap guard); older fork versions and upstream PanamaPort
fail the FFI bootstrap on every device below Android 16. Android 17 from the
September 2026 update requires fork 0.1.5-kanama-r8.1+ (upstream v0.1.5's
Android 17 QPR fixes); every earlier fork aborts in the bootstrap there.
Other Android Findings¶
- Old vendor OpenGL drivers. A Pixel 3 XL on its factory Android 9 image
(2018 Adreno 630) segfaults inside the vendor shader compiler
(
libllvm-glnext.so) while linking Godot 4.7 Compatibility-renderer shaders, before any Kanama code runs. The same device runs the demo smoke with the Mobile (Vulkan) renderer (rendering_method.mobile = "mobile"; Vulkan 1.1.66 initialized, 2026-07-13). This is an engine-vs-driver constraint: the renderer is chosen by Godot from project settings before scripts run, so it cannot be switched from Kanama at runtime. - Android 17. The FFI bootstrap abort with
Check failed: IsExceptionPending()inMethodHandles.reflectAswas seen from the September 2026 update, buildCP3A.260905.009; PanamaPort fork0.1.5-kanama-r8.1(upstreamv0.1.4/v0.1.5carry the Android 17 QPR fixes) is required, and the earlier0.1.3-kanama-*forks predate them. Fork0.1.3-kanama-r8.3(included in every0.1.5-kanama-*fork) added theSDK_INT_FULLbootstrap guard every device below Android 16 needs. - Export guard. The command-line stop is verified on a macOS host (exit 137); Linux and Windows hosts are not tested.
- Plugin minimum. The Kanama plugin declares
minSdk33 (Android 13); see Validated Android Versions.
iOS¶
iOS was promoted from Experimental to Supported on 2026-07-14, when it met
the mobile promotion bar (B1 to B4). The backend runs full Kanama project
scripts through a C shim and a Kotlin/Native static .xcframework, using the
same wrapper generator as desktop and Android, with no JVM on the device.
Physical-device export and launch are the validation target; simulator runs
are optional compile and link checks and not a frame-rate signal.
The evidence is the full ten-step device gate (scripts/ios_device_gate.sh:
the fresh-project install path plus the nine-demo matrix; each demo step also
streams the device console for 30 s after launch and fails on a crash
signature), validated on two physical models: iPhone 12 (iOS 26.5,
2026-06-25; 0 guardrail hits, per-frame Kanama script and binding overhead
about 0.63 ms/frame measured there) and iPhone 15 Pro (iOS 26.5,
2026-07-10, on the full-breadth generated-wrapper runtime), both on 4.7 stable
iOS templates. The claim names those two models; it is not a device-family
("recent iPhones") claim. The playable demo set matches the Android-enabled
public demo set plus Bunnymark, and the heavy tps-demo-kanama also runs on
device (the audited type set and KSP registration path cover the whole
corpus).
Tracked as non-blocking: the TPS demo's mobile touch and multiplayer UI
polish, and an intermittent Audio autoload follow-up in the FPS demo. There is
no mobile hot reload. A project made from the macOS kit or
the store addon builds its iOS libraries itself (buildIosScripts);
package.yml exports and builds one with Xcode from both packages, without a
device.
iOS Library Size¶
The size in Requirements and Platform Status was measured on 2026-10-17 with Kotlin 2.4.21 on a clean link without incremental caches:
./gradlew linkDebugStaticIosArm64 --rerun -Pkotlin.native.cacheKind=none -Pkotlin.incremental.native=false
./gradlew linkReleaseStaticIosArm64 --rerun -Pkotlin.native.cacheKind=none -Pkotlin.incremental.native=false
then the size of build/bin/iosArm64/{debug,release}Static/libkanama_ios_runtime.a.
check_doc_claims.py reads the measured sentence on that page and holds every
other stated size to it.
Web¶
Web is Experimental (Kotlin/Wasm preview) on the Godot 4.7 stable baseline. It is not a Supported target: it exports from a release kit, the store addon or a source checkout, runs the single-thread Compatibility renderer only, and makes no support claim. The twelve-demo corpus passes the automated production export smoke in Chrome, Firefox, and Safari.
Unlike desktop, Android and iOS, the Web backend does not use a JVM or an
FFM/PanamaPort path. It is a Kotlin/Wasm backend: project gameplay compiles
to WebAssembly and talks to the Godot 4.7 Web export (Emscripten/Wasm) through a
generated per-call proxy and a versioned JavaScript bridge
(web-runtime/src/webSpikeGodot/assets/kanama-web-bridge.js, currently
protocol 39). The typed backend seam is shared with the other platforms through
scripts/platform_backend_calls.json, and
scripts/generate_web_gameplay_coverage.py fails loudly if a call the demo
executes has no admitted backend family. See
Web Internals for the architecture.
Validated Web Evidence¶
Twelve production Godot Web exports (Bunnymark, Starter-Kit-Match3, dodge,
web3d, 3D-Platformer, squash, FPS, character-controller, third-person, Racing,
City-Builder and tps-demo) each pass an automated, assertion-driven play
sequence, not a page-load check. Every run asserts gameplay deltas, crossing
budgets, and handle/callback/scheduler teardown to baseline, and rejects stale
handles. Gameplay coverage reports zero blocking calls; the families a demo
calls that the backend does not model (getters of write-only properties, for
example) stay listed as explicit nonblocking unsupported entries rather than
being pattern-hidden. A thirteenth cell, starter, exports a fresh
createStarterProject the way a game developer exports their own project
(-PkanamaWebProjectDir, the generic stageWebProject) and passes in Chrome
and Firefox (2026-10-21, macOS arm64; part of the per-PR Web matrix). It has
not been run in Safari: the Safari evidence below is the demo corpus.
Browser Floors¶
Browser floors and the versions the corpus is driven on (protocol 39). The
floors are declared once, machine-readably, in scripts/web/browser_floors.json,
and web_export_smoke.sh fails any run below them:
| Browser | Floor | Basis | Corpus validated at | Notes |
|---|---|---|---|---|
| Chrome | 130 | tested (2026-07-28) | 150 (headless) | CI cell |
| Firefox | 141 | tested (2026-07-28) | 152–153 (headless) | CI cell |
| Safari | 26.5 | validated-at (2026-08-20) | 26.5 / WebKit 605.1.15, macOS 26.5.1: 13 of 13 cells on 2026-08-20 (the twelve-demo corpus plus the spike cell), zero console errors corpus-wide, at protocol 20 | spot-checked, not gated; no headless mode, needs a logged-in GUI session, and cannot run two at once |
"Tested" and "validated-at" are different claims. Tested means the gate was run on the floor version and on the one below it (2026-07-28, macOS arm64, on a protocol-15 export): Chrome 129 never boots the Kotlin/Wasm module and 130 does; that is where WebAssembly JS String Builtins shipped. Firefox's number is a limit of the harness rather than of the engine: 141, 143 and 145 all pass, while 140 ESR and older never expose a reachable WebDriver BiDi endpoint to the driver, so they are untestable, not known-bad. Safari cannot be installed side by side with itself, so its number is only the oldest version ever driven.
Safari Spot Checks¶
Safari is spot-checked, deliberately. It has no headless mode, needs a
logged-in GUI session with an unoccluded window, and cannot run two gates
concurrently, so a CI cell would cost more than it returns (maintainer
decision, 2026-08-14). The trade is explicit: between spot checks, the Safari
claim can go stale without anything noticing. It did: the corpus was 12/12
on 2026-07-27 and 11/12 when next run on 2026-08-14, with match3 failing
on the swap path. It is 13/13 as of 2026-08-20, re-measured after the fix.
That was not a regression in Kanama or in the demo. Root-caused
2026-08-15: the harness dispatched the swap gesture while the Safari window was
not focused, and Safari delivers synthesized pointer input to the key
window only, so the gesture was discarded outright. The board was healthy, the
coordinates were right, and Godot simply never received any input. It
reproduced about 1 run in 8. Fixed by retrying the focus recovery and by
proving the engine accepts input before playing the real gesture; match3 then
passed 12 consecutive runs.
Two things are worth carrying from it. A locked screen voids a Safari run
entirely: Safari suspends requestAnimationFrame for a non-visible page, so
the engine advances a few frames and stops, and the run fails inside a demo
assertion with nothing naming the cause; the driver now refuses to start in
that state. And quote the date a Safari result was last measured, not the
best result ever recorded.
Safari on iPhone and iPad¶
iOS and iPadOS are hand-checked, not gated, and no mobile-WebKit floor is claimed. A device pass (2026-08-03, iPhone 15 Pro, Safari/WebKit 26.5.2/605.1.15, served over HTTPS, since Godot Web exports require a secure context) had 11 of the 12 corpus demos boot and render with zero console errors; dodge and match3 were hand-played with working audio and lock/unlock resume, and tps-demo exceeds the per-tab memory budget during load. How to drive Safari on a device is in Device and Browser Runs; no automated iOS gate exists, so mobile WebKit stays outside the validated claim.
Web Gaps¶
- No editor-side runtime: a project's Kotlin is compiled ahead of time into the
Wasm payload at export (
./gradlew exportWebin a kit or store-addon project, or-PkanamaWebProjectDirfrom a source checkout), so a change needs a new export. - Godot Compatibility renderer, single-thread only.
- No Web editor, no hot reload, no threads, no Kotlin/JS path.
- Safari has no headless mode, so the Safari gate is a local GUI gate rather than a CI cell; iOS/iPadOS WebKit is hand-checked only, not gated.
- One defect is tracked openly rather than solved: on one Linux CI host,
spawned mobs never receive
VisibleOnScreenNotifier2D.screen_exited, so they are not freed off screen; the next round'squeue_freestill frees them (issue #370; thedodge:firefoxcell is quarantined, not hidden). Nothing measured implicates the Kanama backend, but it has not been ruled out; see Quarantined Cells.
Other Web Findings¶
- Secure context on a LAN address. Serving an export over plain HTTP on a
LAN address never starts the engine on the device. Measured: a fatal error in
audio-worklet init right after "starting Godot…";
serve_export.pynow refuses--lanwithout--httpsup front. - tps-demo payload. tps-demo serves ~638 MB (570 MB of upstream demo assets
in
index.pck) and exceeds the itch.io defaults;packageWebExportfails it by name rather than producing an artifact nobody could upload. This is the same known exception recorded inscripts/web/budgets.json— shrinking it is asset work in the demo, not a packaging concern. Its online lobby is deliberately inert on the Web, because Web builds are single-player.