February 2026 - Wine-GitLab

[PATCH v5 0/7] MR6911: ntdll: Add WaitCompletionPacket.
by Zhiyi Zhang (＠zhiyi) March 6, 2026

March 6, 2026

WaitCompletionPacket is a kernel object that, when associated with a target object and a completion object and when the target object is signaled, adds the completion information stored in itself to the completion object. For React Native. -- v5: ntdll: Implement NtCancelWaitCompletionPacket(). ntdll: Implement NtAssociateWaitCompletionPacket(). ntdll: Implement NtCreateWaitCompletionPacket(). ntdll/tests: Add NtCancelWaitCompletionPacket() tests. ntdll/tests: Add NtAssociateWaitCompletionPacket() tests. https://gitlab.winehq.org/wine/wine/-/merge_requests/6911

3 10

[PATCH v18 0/1] MR10191: comctl32: Implement Tile view style
by Huw Campbell (＠HuwCampbell) March 6, 2026

March 6, 2026

The Tile View in common controls offers a compact and pretty nice way to show some additional context within the list view, without resorting to the full reports mode. It's used a lot in explorer like programs where things like the disk size and file type are shown. But, it's been sitting unimplemented in wine for a long time. I've just spent a few days implementing this by: - Building a small test program in windows to get a feel for how it works - Hacking just enough to get something displaying - Writing a test suite to try and understand the ownership model, getting, and setting, and the various messages passed by windows. - Fixing up the implementation. - Adjusting my program to use I_COLUMNCALLBACK in windows and testing that. - Fixing my implementation to match the behaviour observed. Full disclosure, I originally started this implementation within the ReactOS build system as I had that compiling installed on my Windows box (my Mac is an M1 so doesn't play very nicely with Wine). I've since spun up a Linux VM and continued the work there. All bugs and misunderstandings are my own; I used clean room techniques (read MSDN, write a test program, write tests, compare results, iterate). Interesting things: - I initially wrote layout code for tiling mode as well, but a few rounds of playing with my test program and various layouts and settings (things like `LVS_ALIGNTOP`, `LVS_AUTOARRANGE` and `LVS_ALIGNLEFT`) for both tile mode and icon mode, convinced me that they use same layout logic (or close enough to). - I noticed some differences in Wine's Icon mode layout as compared to Windows 10. - I didn't fix these, one thing at a time. - I noticed and fixed a bug in SetView, where `UpdateItemSize` was called _after_ `Arrange`; that doesn't work. - The Text colours are really odd, if set to black the sub items show up gray, but any other colour and they're the same as the main. - Layout is tricky, in windows it looks like the first item (file name for example) can flow to 2 lines, and subitems are restricted to 1 - But this is really subtle, using GetItemMetrics kind of assumes there's no 'interference' from other items. - If we're on subitem 2, I don't want to have to fetch 0 and 1 to render their sizes before calculating my own, it seems like an `O(N^2)` situation off the bat. - I used a sidechannel from DrawItems, I'm open to other ideas here. - I haven't tested message passing, many of the test failures for listview at the moment look like sequencing errors for messages. I didn't look into it. - The auto mode on Windows 10 looks quite sophisticated, in that it examines many (all) items before deciding the best size. I haven't done anything interesting for auto size mode. - Not really interesting, but the tabs vs spaces situation in this file is a mess. Next Steps ========== - ~~Test with image lists loaded as well~~ - Hope for feedback here (particularly for messages) - Think about auto sizing. - Think about vertical centering within the space. Windows seems to have this as an option, though I haven't discovered how that works just yet. If Merged ========= Now that I have a pretty good grasp of how this component works and lays things out, once this is merged I'll see if I can do Groups as well. Pictures: ======== Windows ListView with Tile mode active. The first entry uses a Callback for the text and the columns layout, while the second is static. ![image](/uploads/8c9d1eb4c362a07c74291b49989c4fd7/image.png){width=300} Wine (with an image list as well) ![image](/uploads/81392817be792c2b95c962be83145a72/image.png){width=300} And Explorer++ ![image](/uploads/877966fc2ded1901cbb000c75f932719/image.png){width=400} Known Issues: ============= - Some highlighting seems a bit janky, I've a quick fix for this, but I think it would be best handled along with: - Hit testing when sub items are touched seems janky too. Test Program =========== ```C #include <windows.h> #include <commctrl.h> HINSTANCE g_hInst; HWND g_hLV; static void AddItems(HWND hLV) { static UINT puColumns[2] = {1,2}; LVITEMW it = {0}; it.mask = LVIF_TEXT | LVIF_COLUMNS; it.cColumns = I_COLUMNSCALLBACK; it.iItem = 0; it.iSubItem = 0; it.pszText = LPSTR_TEXTCALLBACK; ListView_InsertItem(hLV, &it); ListView_SetItemText(hLV, 0, 1, L"Static"); ListView_SetItemText(hLV, 0, 2, L"1 KB"); ListView_SetItemText(hLV, 0, 3, L"2026-02-23 12:00"); it.cColumns = 2; it.puColumns = puColumns; it.iItem = 1; it.iSubItem = 0; it.pszText = L"bravo.txt"; ListView_InsertItem(hLV, &it); ListView_SetItemText(hLV, 1, 1, L"Text"); ListView_SetItemText(hLV, 1, 2, L"12 KB"); ListView_SetItemText(hLV, 1, 3, L"2026-02-22 09:30"); } static void AddColumns(HWND hLV) { LVCOLUMNW col = {0}; col.mask = LVCF_TEXT | LVCF_WIDTH; col.cx = 160; col.pszText = L"Name"; ListView_InsertColumn(hLV, 0, &col); col.cx = 140; col.pszText = L"Type"; ListView_InsertColumn(hLV, 1, &col); col.cx = 100; col.pszText = L"Size"; ListView_InsertColumn(hLV, 2, &col); col.cx = 180; col.pszText = L"Modified"; ListView_InsertColumn(hLV, 3, &col); } static void EnableTileView(HWND hLV) { SIZE size = { 100, 70 }; LVTILEVIEWINFO tileViewInfo = {0}; tileViewInfo.cbSize = sizeof(tileViewInfo); tileViewInfo.dwFlags = LVTVIF_FIXEDSIZE; tileViewInfo.dwMask = LVTVIM_COLUMNS | LVTVIM_TILESIZE; tileViewInfo.cLines = 3; tileViewInfo.sizeTile = size; ListView_SetTileViewInfo(hLV, &tileViewInfo); ListView_SetView(hLV, LV_VIEW_TILE); } static void OnGetDispInfo(NMLVDISPINFO* pnmv) { if (pnmv->item.iItem < 0) { return; } if (pnmv->item.mask & LVIF_TEXT) { // Demonstrates that Windows is passing us a size 20 buffer to write to. pnmv->item.pszText = pnmv->item.cColumns == 20 ? L"Yes" : L"No"; } if (pnmv->item.mask & LVIF_IMAGE) { pnmv->item.iImage = -1; } if (pnmv->item.mask & LVIF_STATE) { pnmv->item.state = 0; } if (pnmv->item.mask & LVIF_COLUMNS) { pnmv->item.cColumns = 2; pnmv->item.puColumns[0] = 1; pnmv->item.puColumns[1] = 2; } } static LRESULT OnNotify(WPARAM wParam, LPARAM lParam) { switch (((LPNMHDR)lParam)->code) { case LVN_GETDISPINFO: OnGetDispInfo((NMLVDISPINFO*) lParam); break; } return TRUE; } static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_CREATE: { g_hLV = CreateWindowExW(WS_EX_CLIENTEDGE, WC_LISTVIEWW, L"", WS_CHILD | WS_VISIBLE | LVS_REPORT | LVS_ALIGNTOP | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_AUTOARRANGE, 0, 0, 0, 0, hWnd, (HMENU)1, g_hInst, NULL); ListView_SetExtendedListViewStyle(g_hLV, LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP); AddColumns(g_hLV); AddItems(g_hLV); EnableTileView(g_hLV); return 0; } case WM_SIZE: if (g_hLV) MoveWindow(g_hLV, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE); return 0; case WM_DESTROY: PostQuitMessage(0); return 0; case WM_NOTIFY: OnNotify(wParam, lParam); return 0; } return DefWindowProcW(hWnd, msg, wParam, lParam); } int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) { INITCOMMONCONTROLSEX iccx; g_hInst = hInstance; /* Initialize common controls */ iccx.dwSize = sizeof(iccx); iccx.dwICC = ICC_STANDARD_CLASSES | ICC_WIN95_CLASSES; InitCommonControlsEx(&iccx); WNDCLASSW wc = {0}; wc.lpfnWndProc = WndProc; wc.hInstance = hInstance; wc.lpszClassName = L"WineLvTileSmoke"; wc.hCursor = LoadCursor(NULL, IDC_ARROW); RegisterClassW(&wc); HWND hWnd = CreateWindowExW(0, wc.lpszClassName, L"ListView Tile puColumns Smoke Test", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 700, 450, NULL, NULL, hInstance, NULL); ShowWindow(hWnd, nCmdShow); MSG msg; while (GetMessageW(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessageW(&msg); } return (int)msg.wParam; } ``` -- v18: comctl32: Implement Tile view style https://gitlab.winehq.org/wine/wine/-/merge_requests/10191

4 7

[PATCH v2 0/2] MR9857: ntdll/unix: Reimplement fill_vm_counters() for macOS.
by Jactry Zeng (＠jactry) March 6, 2026

March 6, 2026

On Windows, PagefileUsage represents the total private memory committed by a process, includes both resident memory in RAM and pages swapped to the disk. On macOS, virtual_size is misleading as it represents the total reserved address space, which is often vastly larger than actual usage; for example, it can be 40+GB when a program was alloced about 4GB memory on a machine with 16GB RAM (tested on Intel macOS 15.7.2 and Apple Silicon macOS 26.2). In order to make it closer to the Windows metric, using the sum of TASK_VM_INFO.internal (resident private memory in RAM) and swapped pages (includes both compressed memory in RAM and pages that were swapped to the disk) from mach_vm_region_recurse() is more correct. I also use the sum of TASK_VM_INFO.internal and TASK_VM_INFO.compressed (compressed memory, and still in RAM) as a fallback when mach_vm_region_recurse() fails; however, this doesn't include that the memory has been compressed and swapped to the disk[0], but it is still correct relatively to the current implementation. [0] https://github.com/apple-oss-distributions/xnu/blob/f6217f/osfmk/kern/task.… -- v2: ntdll/tests: Test PagefileUsage with a large memory reservation. ntdll/unix: Reimplement fill_vm_counters() for macOS. https://gitlab.winehq.org/wine/wine/-/merge_requests/9857

3 4

[PATCH v3 0/3] MR10114: msi: Handle unusual installer files (padding, malformed strrefs)
by Theodoros Chatzigiannakis (＠TChatzigiannakis) March 5, 2026

March 5, 2026

This PR addresses two issues that I observed preventing the Native Instruments Kontakt Player MSI (and other MSI files from the same vendor) from successfully finishing: 1. Some installers contain padding for 4-byte alignment of table streams. * Proposed fix: We relax Wine's parsing to allow for such padding. 2. Some installers declare that they have 3-byte strrefs, but the data actually contains 2-byte strrefs. This looks like a malformed MSI to me, and Wine correctly rejects them currently. The regression tests in this PR indicate that Windows in CI (test-win10-21h2-\*) is reading garbage as well. However, NI ships these MSI files, which implies that somehow the installation successfully completes on Windows machines nevertheless. * Proposed fix: We explicitly detect and correct this particular mismatch at load time of the MSI, in order to be able to complete the installation under Wine as well. --- The above are technically separate issues, but they affect the same software in similar ways, so I opted for one PR. Please me know if I should split them. --- Quick repro hint: Native Instruments offers a program called Native Access (which acts as an installation hub on the user's machine). On user request, NA downloads and launches the affected MSI files in the background. If you try to repro, a couple of things to watch out for: 1. NA seems to always report a successful installation, even when the underlying MSI fails to complete (and therefore nothing is installed). This PR does nothing to address this false positive, as it is most likely a logic bug in the hub or installation orchestration. 2. To observe/examine the underlying MSI files (including the fix presented here), you'll need to grab them after NA downloads and extracts them on your machine (or find manual/direct downloads on the NI website, where applicable) --- _Disclaimers for reviewers:_ * _AI was used while tracking down the issues and coming up with fixes._ * _I am not affiliated with Native Instruments, I'm just a user._ -- v3: msi/tests: Add regression tests for table stream padding and mismatched string refs. https://gitlab.winehq.org/wine/wine/-/merge_requests/10114

3 5

[PATCH 0/5] MR10217: dsound: Speed up resampling, part 3
by Anton Baskanov (＠baskanov) March 5, 2026

March 5, 2026

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/10217

4 11

[PATCH 0/2] MR3067: mf: Shutdown handling of activate objects in session.
by Bernhard Kölbl March 4, 2026

March 4, 2026

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/3067

4 12

[PATCH v5 0/2] MR9997: shell32: ShellExecute uses SW_SHOWDEFAULT by default
by Fan Zhou (＠zhoufan_uniontech) March 4, 2026

March 4, 2026

This patch applies to applications that launch processes via ShellDispatch specified as VT_EMPTY type (such as WPS PDF Editor).\ It prevents the conversion of VT_EMPTY type to the INT_4 value of 0 (i.e., SW_HIDE), which would otherwise cause the main program window not to be displayed. -- v5: shell32: ShellExecute uses SW_SHOWDEFAULT by default https://gitlab.winehq.org/wine/wine/-/merge_requests/9997

3 4

[PATCH 0/5] MR10045: jscript/mshtml: Implement mshtml cycle collection for jscript objects.
by Gabriel Ivăncescu March 3, 2026

March 3, 2026

This implements mshtml's cycle collection for JS objects so that they can be part of gecko's CC graph and have circular refs dealt with. It only does this during a Full CC, not incremental phases as we can't be part of gecko's "purple buffer" without replacing the entire refcounting logic to gecko's (which doesn't seem desirable as it will be too slow, nor possible, since we still need the current one for normal jscript without gecko). Full CC is forced when doing jscript garbage collection, and otherwise we are ignoring reporting jscript objects during incremental collection. The way it does it now is to fakingly report the current wine-specific-refcount to gecko only when traversing. This is fine when we are doing Full CC without being part of a purple buffer, to integrate existing jscript objects' refcounting into the gecko CC. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/10045

2 16

[PATCH v6 0/3] MR9874: wineandroid.drv: experimental bring-up fixes for Android 7.1.x
by Twaik Yont (＠twaik) March 3, 2026

March 3, 2026

Requires #10067, fixup/followup to e0d3683d8947cd9a3cb20acdf69091b183a90861 and 4b5311c7e02aa7ab2409f8fdcd22233f116dc4bc. #### Note on authorship and language This text was translated into English and structured with the assistance of ChatGPT. The author is not a native English speaker and may struggle with written technical English; any wording issues are unintentional. #### Description This merge request is an experimental attempt to bring wineandroid.drv back to a minimally functional state on Android 7.1.x. The current Android support appears to have bit-rotted over time, likely due to a combination of internal contract changes in Wine, toolchain and NDK evolution, and the absence of continuous Android testing. The changes proposed here aim to re-establish a working baseline and make the regressions more concrete and easier to reason about. #### Test environment and context All testing so far was performed on Android 7.1.2 x86 images from the Android-x86 project, published on osboxes.org ([link](https://www.osboxes.org/android-x86/)) The primary target is i386 Wine running on x86 Android userspace. Because no up-to-date official Android build scripts were available, Wine was built using Termux as an unsupported but convenient environment for rapid testing. The Java part (WineActivity and related glue code) was built with `sharedUserId = com.termux` purely for convenience (filesystem access and faster prototyping). **Termux is explicitly not considered a supported environment and is mentioned only to provide context for the testing setup.** The build uses Android NDK r29. Since the last known functional Android Wine builds, the NDK and linker behavior have changed multiple times, including symbol visibility and relocation handling. These changes appear to have directly affected several failure modes described below. There is also a known issue with wine-preloader producing excessively large binaries under recent toolchains; a workaround exists but is not included here and is mentioned only as additional context. #### Scope of changes This merge request currently modifies only Android-specific code: - `wineandroid.drv` (native code and Java glue, including WineActivity) - android-only paths in `dlls/ntdll/unix/loader.c` No non-Android platforms are affected. #### Summary of resolved issues 1) Desktop initialization ordering regression After recent `CreateDesktopW`-related changes, `ANDROID_CreateDesktop` started running before the DESKTOP window was created. The Java glue assumed the opposite order. The fix splits desktop initialization into two phases (view setup first, desktop window attachment later via an explicit is_desktop flag) and corrects the `ANDROID_CreateDesktop` success return value. 2) Rendering stalls and `USER lock assertion` Occasional crashes with: ``` err:system:user_check_not_lock BUG: holding USER lock ``` A full memory barrier was added in the dequeue path to avoid a likely memory ordering issue. Additionally, a guard was added for a `NULL` buffer returned on successful dequeue. 3) Early startup failure in `virtual_alloc_first_teb` Wine frequently failed with: ``` err:virtual:virtual_alloc_first_teb wine: failed to map the shared user data: c0000018 ``` `virtual_init()` is now called from `JNI_OnLoad()` to reduce the likelihood of the JVM reserving the required address range before Wine initializes its virtual memory subsystem. #### Remaining issues - Window focus handling is partially broken: windows receive focus on click, but are not always raised to the front. - Despite the available desktop area being larger (e.g. 1024x696), Wine consistently reports a display resolution of 800x600. #### Limitations Wine on Android stopped functioning entirely starting with Android 8. As a result, all testing so far has been limited to Android 7.1.x. No claims are made about behavior on newer Android versions. #### Out of scope This merge request intentionally does not attempt to: - redesign IPC mechanisms - introduce new Android integration models - address Android 8+ compatibility The sole goal is to re-establish a minimally working baseline on Android 7.1.x and enable informed discussion about what regressed and how to proceed. **This is my first contribution to Wine, and I am aware that some parts of this analysis or implementation may be flawed. I would be grateful for any review comments or suggestions.** <details> <summary>Also, the screenshot of the working prototype.</summary> ![1](/uploads/666d78a712edce531a25521a2615ea9f/1.png){width=756 height=600} </details> -- v6: ntdll: call virtual_init from JNI_OnLoad to avoid early virtual_alloc_first_teb failure Wineandroid: Sanitize dequeueBuffer result and reject missing buffers. wineandroid: fix desktop init ordering after CreateDesktopW changes https://gitlab.winehq.org/wine/wine/-/merge_requests/9874

3 6

[PATCH v4 0/3] MR10067: wineandroid: fix Android NDK/ARM build issues (resubmission with expanded rationale)
by Twaik Yont (＠twaik) March 3, 2026

March 3, 2026

This series addresses several Android-specific build failures and toolchain interactions observed when building Wine with recent Android NDK versions. Some of these changes were previously proposed but not accepted due to insufficient explanation of the underlying behavior. This submission reintroduces those fixes with more detailed technical justification and adds a few additional related corrections discovered during further testing. The changes include: - Replace `ffs()` with `__builtin_ffs()` in ntdll. Android builds fail due to ffs() being used without `<strings.h>`, which Wine does not include. Using `__builtin_ffs()` avoids implicit declaration errors under C99 and matches existing usage elsewhere in the tree while preserving semantics. - Avoid pthread mutex attributes in winepulse on Android. `pthread_mutexattr_setprotocol()` may be exposed at configure time depending on the selected API level, but actual availability depends on the device's bionic libc. Robust mutex support is not provided by bionic. Configure-time detection can therefore select a code path that is not reliably supported at runtime. Use plain `pthread_mutex_init()` on Android and retain the existing attribute-based initialization on other platforms. - Force `--rosegment` for `wine-preloader` on Android (API < 29, NDK r22+). Since NDK r22, clang implicitly passes `-Wl,--no-rosegment` when targeting API levels below 29 ([NDK changelog](https://github.com/android/ndk/wiki/Changelog-r22) Issue 1196). Because wine-preloader links with `-Wl,-Ttext=0x7d400000`, this results in a `PT_LOAD` segment with a very large file offset to preserve the VMA-to-file-offset relationship, creating a sparse gap (`~0x7d400000`) and inflating the apparent ELF size to `~2GB`. `wine-preloader` is a static binary and does not depend on unwind/backtrace correctness, so inheriting `--no-rosegment` provides no benefit. Force `-Wl,--rosegment` when supported to keep the segment layout reasonable, without affecting other binaries. Overall, this series improves Android NDK compatibility, prevents false feature detection based on header exposure or API-level-dependent behavior, and fixes ARM assembler incompatibilities, while keeping the changes restricted to Android-specific paths. -- v4: wineandroid: force --rosegment for wine-preloader on Android (API < 29, NDK r22+) winepulse: avoid pthread mutex attributes on Android due to unreliable availability ntdll/unix: use __builtin_ffs instead of ffs in ldt_alloc_entry https://gitlab.winehq.org/wine/wine/-/merge_requests/10067

2 6