Repository navigation
Win32 resize on the Kotlin/Native renderer, with resize metrics - #174
Merged
Merged
Conversation
IosHostConnection resolved the Host's five exports with dlopen and dlsym inline. The lookup is now hostSymbol(name) in ios/src/HostSymbolLookup.kt, the same dlsym on iOS, macOS and Linux (linked into both), so the one line that differs on Windows, GetProcAddress on the executable, can be a file of its own there. No behaviour changes.
The five /EXPORT directives were a #[used] static placed in .drectve. A static is a symbol, the crate's own DLL asks for every symbol it keeps, and the LLVM linker takes the section's bytes as directives and keeps no symbol for them, so linking the crate for Windows with lld-link failed on "undefined symbol: EXPORT_DIRECTIVE_BYTES". The same directives are now assembled into the section with global_asm, which defines no symbol. windows-host-exports.test.sh still finds all five exported and looked up.
…(NFR-13) Kotlin/Native's only Windows target is MinGW and the application is MSVC. Two MinGW conventions mean something else to an MSVC-mode linker, and both fail silently: constructors in .ctors are never run, and per-function unwind data that MinGW pairs with its code by name is dropped, so a Kotlin exception crossing two functions loops in the unwinder. fix-mingw-objects.py moves .ctors to .CRT$XCU and makes every .pdata$NAME and .xdata$NAME an associative COMDAT of .text$NAME, in both the ordinary COFF layout and the big-object one Kotlin/Native writes for the renderer, which has more sections than 16 bits can number. windows-mingw-objects.test.sh runs it on a MinGW object built the way Kotlin/Native builds its own, in both layouts, and reads the sections back; with the rewrite removed it fails on both counts. Covers the object half of NFR-13 criteria 3 and 4.
…ork (D18, NFR-13) build-compose.sh --target mingwX64 publishes the same fourteen Compose modules Linux does, for Windows, from MINGW_REVISION: 8ec7c32 on the fork's extended branch, the merge that carries 296beb3 (mingwX64 in every Compose UI module, skiko read from the local Maven repository first) and f17cb30 (skiko's mingwX64 build under extended/skiko) and the later fixes to that build. Before Compose it runs the fork's extended/skiko/build-skiko-mingw.sh, which publishes skiko's Kotlin half and compiles its C++ half for MSVC into .scratch/skiko-build. macOS and Linux keep REVISION. Moving them to the later commit would put a mingw_x64 variant nobody built there into every module's root metadata. compose-fork-mingw.changes records what the Windows pin must hold, and compose-fork.test.sh now checks both pins.
windows/ is the renderer for mingwX64, built the way the Linux module is: the shared interpreter through symlinks, the iOS boundary, and a window of its own. The window is desktop/c/win32_window.c, the one the native image opens (Direct3D 12, IMM32, UI Automation), called by symbol name as the native image calls it, and drawn into with skiko's Direct3D context. Toasts are desktop/c/win32_notifications.c, reached the same way. Windows' own pieces: the Host lookup through GetProcAddress on the executable, the locale formats from GetLocaleInfoEx, and os.name "windows" so Fluent is chosen. staticlib-windows holds the two shared entry points. windows/native/mingw_bridge.c answers, with the MSVC runtime, the few things the MinGW object asks of MinGW's. The Kotlin gate builds mingwX64 only where Compose for it has been published locally, and tests it only on Windows. windows-kotlin-native.test.sh checks the module is declared, shares the interpreter, finds the Host through the export table, and asks for exactly the Compose modules build-compose.sh publishes for mingwX64.
The window skips Windows' software adapter so that a machine with nothing to draw with is not hidden behind a slow window. A hosted CI runner has only that adapter, so nothing there could show the renderer drawing. DXC_D3D12_WARP=1 now takes the WARP adapter when no hardware one makes a device; without it nothing changes. The no-adapter message says so, in both the native image's window and the Kotlin/Native one. windows-kotlin-native.test.sh checks the window reads the variable and takes the adapter.
… NFR-13) desktop/scripts/build-windows.sh compiles the windows module, links it into a Kotlin/Native static library with the shared entry points, and leaves in build/windows everything an MSVC executable needs beside it: the renderer archive and libstdc++ rewritten by fix-mingw-objects.py, the GCC runtime Kotlin/Native's MinGW toolchain carries, skiko's C++ half and Skia, and one library holding the Win32 window, its toasts, the MinGW bridge and Skia's ICU loader with the ICU data compiled in. Our C is compiled with clang in MSVC mode, so MinGW stays inside the Kotlin/Native object. It runs on Windows from Git Bash with Visual Studio's tools, and on macOS and Linux against the headers cargo-xwin lays out. build-compose.sh --target mingwX64 now leaves the fork's embedded_icu.cpp with skiko's Windows half for it. windows-kotlin-native.test.sh now also checks that every C name the module calls by symbol is defined once by what the script compiles.
… NFR-13) With DXC_WINDOWS_NATIVE_LIB naming what build-windows.sh wrote, build.rs links the renderer archive, the GCC runtime it carries, the window library (whole, so the ICU loader and the bridge's initialiser are kept), skiko's C++ half, Skia and the Windows system libraries, every one as a library so it reaches applications rather than stopping at this package. It says what to do when the application has not asked for the static C runtime Skia is built with, and names the missing piece when the directory is incomplete. The Host's functions need nothing more: the .drectve directives already put them in the executable's export table, where the renderer looks them up. windows-kotlin-native.test.sh checks the Host links the kit by the names the script writes.
…I (NFR-13) windows-static.yml builds skiko and the Compose modules for mingwX64 on Linux, where Compose's build runs, and hands them to a windows-latest job that builds the renderer with Kotlin/Native there, links the consumer fixture against it with Cargo and MSVC's linker, and runs scripts/check-windows-consumer.sh: dumpbin /dependents has to name only DLLs Windows ships (no Visual C++ runtime, no MinGW, no renderer DLL), and the executable, copied alone into an empty directory, has to draw its frames with --self-check on the software adapter. native-renderer.yml runs it beside the other platforms. The branch push trigger is temporary.
…ows.sh Git Bash converts any argument that looks like a POSIX path before it reaches a Windows program, so clang in MSVC mode was handed "/MT" as "C:/Program Files/Git/MT". The compile step now runs with MSYS_NO_PATHCONV, which means nothing on macOS and Linux.
…ndows (NFR-13) check-windows-mingw-link.sh builds a small Kotlin/Native static library for mingwX64 the way the renderer is built, links it into an MSVC program with the same GCC runtime and MinGW bridge an application gets, and runs it on the Windows CI job: a thousand exceptions thrown three calls down are caught and startup values are there; an uncaught one is reported by Kotlin and ends the process; and the same library linked without fix-mingw-objects.py has to fail, by hanging or crashing, as the control. Covers NFR-13 criteria 3 and 4 on Windows itself.
…(D18, NFR-15) Applications are not to be asked for +crt-static, .cargo/config.toml or RUSTFLAGS. The build script now decides the C runtime for the Windows static renderer, the way compose-multiplatform-extended's Windows single executable does: it links copies of Skia and skiko's C++ half, and of this machine's libcpmt.lib, with the RuntimeLibrary guard and the static runtime's default libraries blanked (build/windows_crt.rs), and the Host's own object carries /NODEFAULTLIB and /DEFAULTLIB directives that take vcruntime and the C++ library from their static libraries while the UCRT stays the DLL that is part of Windows. No VCRUNTIME140.dll or MSVCP140.dll is needed beside the executable. An application that sets +crt-static itself links all of it statically; the MinGW bridge's import pointers, which only that case needs and which would collide with the UCRT's import library otherwise, move to mingw_bridge_static_ucrt.c in a library of their own. DXC_WINDOWS_CRT= dynamic takes both from their DLLs, for measuring what linking them in costs. Our C is compiled naming no runtime (/Zl). A prebuilt library built against a debug runtime cannot share an executable with a release one, and the build stops naming it, saying what the linker would have said (LNK2038, a RuntimeLibrary mismatch) and what to rebuild it with. tests/windows_crt.rs covers the blanking, the choice, the debug-runtime message, and that boundary.rs carries the directives.
…ry, and measure the runtimes (NFR-15) check-windows-consumer.sh now builds the consumer with nothing but its Cargo.toml line (no RUSTFLAGS, no .cargo/config.toml anywhere above it), fails on VCRUNTIME140.dll or MSVCP140.dll in dumpbin's list while allowing the UCRT's own system DLLs, and runs it from an empty directory. It then links consumer-mixed-runtime, an application with a C++ library cl.exe builds for the runtime DLL (/MD), the case that stops an MSVC link with LNK2038 when the runtime is not decided once, checks it needs only Windows and runs it. Last it builds the same consumer with DXC_WINDOWS_CRT=dynamic and with +crt-static, runs the static one, and prints the three sizes. The Windows job also runs tests/windows_crt.rs.
…branch added develop renamed the project (PR #43): dioxus-compose/ is compose-rust/, dioxus-compose-renderer/ is renderer/, the C symbols are compose_rust_*, the Kotlin packages dev.darkpyonix.composerust.*. The Windows module, its scripts, build.rs and the tests this branch added follow the same names; the moved files are placed by hand where git's rename detection guessed wrong (HostSymbolLookup.kt).
…eck once the renderer is built konanc wrote no probe.a when its arguments went to the batch file on the command line; they now go in an argument file as build-windows.sh does, and a missing archive prints konanc's output. The probe and the consumer check run whenever the renderer built, so one failing does not hide the other's result.
…say where a Windows run crashed Kotlin/Native names a MinGW static library libprobe.a. The consumer check now starts the executable without the window first, so a crash before main is told from one in drawing, and on failure runs it under cdb to print the stack. The Kotlin toolchain cache is saved even when the job fails, and the two global_asm comments are plain comments, which rustdoc cannot attach to a macro anyway.
On Windows the consumer started, then crashed in pthread_mutex_lock on the first call into the renderer (run 37120595257, under cdb). MinGW's .ctors is writable (0xc0400040) and the MSVC compiler's .CRT$XCU read only (0x40400040); the linker keeps .CRT sections whose flags differ apart (LNK4078, then LNK4254), so one group's constructors fall outside the range the runtime walks and never run. fix-mingw-objects.py now gives the renamed section MSVC's flags, and windows-mingw-objects.test.sh fails on the old ones.
…keep checking after a failed run The probe now links with the UCRT from Windows and vcruntime from its static library, as an application does by default, rather than the fully static runtime, whose import pointers it lacked (__imp_longjmp). The static-UCRT bridge gains that pointer for applications that do set +crt-static. check-windows-consumer.sh notes a run that fails and carries on, so the mixed-runtime and +crt-static runs and the sizes still report.
…e GCC runtime Run 37129626502 drew from an empty directory, and still linked with LNK4078 from winpthread: its TLS callbacks sit in writable .CRT$XL* sections, kept apart from the runtime's like the constructors were. Every .CRT$ section now gets the read-only flags, and libgcc, libgcc_eh and winpthread are rewritten beside libstdc++.
…VC toolset in CI winpthread calls longjmp through __imp_longjmp. With vcruntime linked in, the linker makes that pointer from the static definition only once something has brought it in, which in an application was Skia's libpng by chance and in the probe nothing (LNK2019). The Host's directives now say /INCLUDE:longjmp, and the probe links the same way. The CI job put the first dumpbin vswhere found on PATH, from an older toolset than the headers, and its cl.exe refused the newer C++ library (STL1001) when building the /MD library. The tools now come from the VCToolsInstallDir the developer environment names.
Run 37133341200 linked the default and the mixed-runtime consumers, and both ran; the dynamic-runtime build then failed with LNK2038 and LNK2005 between libcpmt.lib and msvcprt.lib, the static C++ library still named as a default by a prebuilt object. That build now carries /NODEFAULTLIB for libcpmt and libcmt, as the default one does.
…trol failing Linked without fix-mingw-objects.py, the probe does not get as far as running: the MSVC linker refuses the unwind sections with LNK1143. That is the rewrite's absence showing, so the control accepts it as well as a hang or a crash, and the rewritten probe's runs come first so they report regardless.
Run 37137648389 linked the default and mixed-runtime consumers, then the dynamic build failed with LNK1120: std::_Raise_handler (160 references from Skia and skiko objects), std::ctype<char>::id and std::locale::id::_Id_cnt. Skia is built for the static runtime, so its objects name those data symbols without the __imp_ prefix, and msvcprt.lib defines only the imported spelling. The dynamic build now links the guard-blanked libcpmt copy like the others and takes only vcruntime from its DLL.
The Dioxus adapter was carved out of the crate, so compose_rust::prelude and rsx! are gone; the fixture registers a hand-written runtime like the plain consumer.
Windows puts an app execution alias named python3 on PATH when no interpreter is installed. It matches command -v, so the old check picked it up and fix-mingw-objects.py then failed to run under it. The candidate is now required to answer --version before it is used.
…nto feature/windows-kotlin-native
…d module The window, its C and its Kotlin/Native layer now live in the fork (thisisthepy/compose-multiplatform-core-extended #32, extended/window/windows-shared), as the macOS and Linux windows do. This repository keeps the renderer glue. - Deleted: renderer/desktop/c/win32_window.c, win32_resize.h, win32_ime_text.h and win32_notifications.c. The fork holds them byte for byte as they were here. - build-windows.sh (Kotlin/Native) and build-native-windows.ps1 (native image) compile the C from the fork checkout at WINDOW_REVISION, fetched by scripts/fetch-fork-window.sh; Windows C compile does the same. - renderer/windows links org.thisisthepy.compose.window:windows-shared, which publish-window.sh publishes on Windows. Win32Window.kt keeps the scene and draws through Win32NativeWindow and Win32Loop instead of its own @SymbolName declarations and record offsets. Behaviour is unchanged: the same calls in the same order, CPU resize frames unless DXC_RASTER_RESIZE=0. - The tests that read the window's C read the fork's at the pinned commit. win32-ime-text.test.c, which nothing compiled, is gone; the fork's MSVC check covers the same conversion.
… Korean on Windows The hand-check frames showed U+D55C U+AE00 as two boxes on every line, on both the CPU and the GPU frame. PixelCompare drew the whole test string with canvas.drawString and one typeface, Segoe UI, which has no Hangul; drawString never falls back, so both characters were the missing glyph. The renderer's own text goes through Skia's paragraph layout with skiko's default font manager, which on Windows (SK_BUILD_FOR_WIN, also in the mingwX64 skiko build) is DirectWrite with its system fallback, so it was not affected. - PixelCompare draws the Korean with the typeface FontMgr picks for U+D55C. The comparison and its thresholds are unchanged. - The Kotlin/Native Windows renderer runs the text self-check the macOS and Linux renderers run (COMPOSE_RUST_TEXT_SELF_CHECK), and the check gains a fourth part on all three: two different Hangul syllables drawn into a bitmap must each ink pixels and must not be the same picture, which is what a missing-glyph box looks like. - check-windows-consumer.sh lists the Malgun Gothic files and requires the self-check's ok line from the executable started alone.
The merge of thisisthepy/compose-multiplatform-core-extended #32, which adds extended/window/windows-shared: the Win32 window's C, its header and cinterop definition, and its Kotlin/Native layer.
…ws compiles it develop moved LinuxFrameDispatcher.kt, which the Kotlin/Native Windows renderer links as FrameDispatcher.kt, onto a pthread_mutex_t allocated with nativeHeap.alloc. MinGW's headers declare pthread_mutex_t as an integer rather than a struct, so the windows module stopped compiling (windows-static and Resize metrics, run 39041181759). The queue's lock is now an AtomicInt spin lock, held only across one operation on the queue, the same on Linux and Windows.
…kn-fork # Conflicts: # compose-rust/android-kotlin/shared/RenderNode.kt # renderer/desktop/c/win32_window.c # renderer/desktop/src/renderer/RenderNode.kt # renderer/scripts/build-compose.sh
…op's new shared files into Windows Replaces the spin lock of 95d9c02. The dispatcher, which Linux and the Kotlin/Native Windows renderer share, takes a FrameLock from a file of each platform's own: Linux keeps the pthread mutex it had, Windows uses an SRW lock taken exclusively (MinGW declares pthread_mutex_t as an integer, so the shared allocation did not compile there). renderer/windows/src/shared also links RendererAnimations.kt and TransformLayers.kt, which develop added to the interpreter, as the Linux and macOS renderers do.
…answers the frame time The merge of thisisthepy/compose-multiplatform-core-extended #131.
…he trait now asks develop (#244) gave the application trait's render a frame time parameter; the mixed-runtime consumer fixture, which only windows-static builds, still had the old signature and did not compile there (E0050).
… on an abort The macOS native image's smoke run aborted (status 134) with nothing in the log to say where. A run that fails now prints its last 40 lines, and on macOS the newest DiagnosticReports file when it ended on a signal.
…out, and downloads the native image until #24 With the Win32 window in the Compose fork and the Kotlin/Native renderer on develop, a Windows checkout builds one MSVC-linked executable (build-windows.sh and DXC_WINDOWS_NATIVE_LIB), checked by windows-static. The download stays the GraalVM native image until the Windows static archive is published, which #24 tracks. README, its Korean translation, and the guide's overview, getting started and architecture pages in both languages.
…kn-fork # Conflicts: # CHANGELOG.md # renderer/desktop/c/win32_window.c # renderer/scripts/build-compose.sh
…renderer, with System.nanoTime #251 made the interpreter's NativeHostConnection mark latency through LatencyTrace, which every Kotlin/Native renderer links from desktop/src. The Windows module links it and SyntheticInput the way macOS and Linux do, and its System shim answers nanoTime from the monotonic clock as theirs does.
- In PixelCompare.kt, raise the threshold for the "edges" region from 1% to 2%, leaving other regions at 1% and mean <= 1.0 unchanged. - Update doc comment to reflect the 2% threshold for curved edges.
- Restore MINGW_REVISION pin and mingwX64 target in build-compose.sh to pass compose-fork.test.sh and windows-kotlin-native.test.sh.
- Publish mingwX64 via gradlew tasks directly under org.jetbrains.compose coordinates matching the fork commit pinned by MINGW_REVISION.
… in Python - Update Windows JDK archive in prefetch-github-assets.sh to jdk-25.0.4.1+1 matching Adoptium's current Windows release. - Convert cli_dir with cygpath -w so Windows Python resolves the path.
- Define dxc_native_soak_state for Windows in renderer_entry.c so MSVC links the GraalVM native image without unresolved external symbol.
b-re-w
marked this pull request as ready for review
October 24, 2026 10:25
This was referenced Nov 7, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Carries the Win32 resize work of #170 onto the Kotlin/Native Windows branch (#119), so it can be measured on the Kotlin/Native renderer, and adds the resize measurement for both Kotlin/Native renderers.
Which branch carries what
feat/win32-resize-sync(Win32 live resize: present the new size before the window rect changes #170, intofeat/win-linux-window-default, Feat: Open the Win32 toolkit-free window by default, finish the X11 one #134): the resize work itself on the GraalVM native-image path, plus the GC experiment for native image (test-resize-gc.yml).feat/win32-resize-kn(this PR, intofeature/windows-kotlin-native, Feat: Windows Kotlin/Native renderer link and exception probes (D18, NFR-13) #119):win32_window.ctaken whole from Win32 live resize: present the new size before the window rect changes #170 at 843eeb3. Win32 live resize: present the new size before the window rect changes #170's head already includes Feat: Windows Kotlin/Native renderer link and exception probes (D18, NFR-13) #119'sDXC_D3D12_WARPopt-in, so the file is the same on both branches. Not a merge of Win32 live resize: present the new size before the window rect changes #170: that would also bring in all of Feat: Open the Win32 toolkit-free window by default, finish the X11 one #134, which Feat: Windows Kotlin/Native renderer link and exception probes (D18, NFR-13) #119 does not carry and which conflicts with it in unrelated files. The JVM-only pieces (win32_dcomp,build-native-windows.ps1) do not exist on this branch.developthrough Feat: Open the Win32 toolkit-free window by default, finish the X11 one #134 and Feat: Windows Kotlin/Native renderer link and exception probes (D18, NFR-13) #119. Becausewin32_window.cis identical on both, the second merge intodevelophas nothing to reconcile in that file.Measurement
test-windows-resize-metrics.yml, run by hand. It also runs once on this PR because the workflow is new. It builds the Kotlin/Native renderer for Windows (aswindows-static.ymldoes) and for macOS (build-macos.sh), and runshand-checkagainst each withDXC_METRICS=1. Three seconds in, the run:Logs and a summary table are uploaded as artifacts.
The window moved to the Compose fork (owner decision for #174: fork first)
The Win32 window is now the fork's
extended/window/windows-shared(thisisthepy/compose-multiplatform-core-extended #32), the same way the macOS and Linux windows are. This branch keeps the renderer glue and takes the window through the pin (WINDOW_REVISIONinrenderer/scripts/build-compose.sh, fetched byscripts/fetch-fork-window.sh).renderer/desktop/c/win32_window.c,win32_resize.h,win32_ime_text.h,win32_notifications.c. The fork's move commit holds them byte for byte (resize plan B, theresize-proof steplines, the Desktop Duplication check and the memory lines unchanged); its only later change to the C is one comment that wrongly said the swapchain wasDXGI_SCALING_NONE.build-windows.sh(Kotlin/Native) andbuild-native-windows.ps1(native image) compile the fork's C for MSVC from the pinned checkout;Windows C compiledoes the same.renderer/windowslinksorg.thisisthepy.compose.window:windows-shared(published on Windows bypublish-window.sh).Win32Window.ktkeeps the scene and draws through the fork'sWin32NativeWindowandWin32Loop(cinterop) instead of its own@SymbolNamedeclarations and record offsets. Same calls, same order, CPU resize frames unlessDXC_RASTER_RESIZE=0.win32-ime-text.test.c, which nothing compiled, is gone; the fork's MSVC check covers it.mingwX64is Kotlin/Native's target name; the application's final link is MSVC's.Also in this push: develop merged in (with #232's CI on demand); the two Windows resize workflows take the run-heavy-ci scheme;
windows-static.ymldrops its push trigger. The earlier batch on this branch (a28524f and before: the five-cause batch, the Swing dispatcher fix, the AWT-free Windows image) is included.#155's Win32 parts: the toolkit-free Win32 default and the letter-key test are on this branch.
DXGI_SCALING_NONE(e9e95f9) is superseded: the swapchain is the copy model (SEQUENTIAL+SCALING_STRETCH), andSCALING_NONEis valid only for flip-model swapchains.The curved-edge pixel-compare threshold (
pixel-compare verdictinResize metrics) is unchanged; the owner decides it.Follow-ups folded in after the first heavy run: fork #131 (
dxc_native_frame_time_nanos, which develop's #244 declared), fork #132 and #134 (the X11 window's calls the native image carries, as stubs on macOS and Windows), the pin at 00768c9d, develop merged with #251, the shared frame dispatcher's lock split per platform (FrameLock.kt: pthread mutex on Linux, SRW lock on Windows), develop's new shared interpreter files linked into Windows, the mixed-runtime consumer fixture on the newrendersignature, and a smoke run that prints its end and the macOS crash report when it fails. Korean: the K/N Windows renderer's text self-check passed on the runner (Malgun Gothic present;ink 한글 234/234 px).The docs now say what is true: from a checkout the Windows Kotlin/Native renderer is one MSVC-linked executable; the download stays the GraalVM native image until the Windows static archive is published (#24, kept open).
After this merges, #119 is closed: its head is contained here.