Bannerlator 3.1.2

     

Bannerlator 3.1.2

Run Windows apps and games on Android — no PC and no root required.

3.1.2 brings Wayland to everyone as an experiment. Instead of drawing through the Java X server, a game can draw through an embedded Wayland compositor that Bannerlator runs itself — a second display backend, chosen per container. It can do things X11 cannot: HDR10 on HDR screens, launching a game on your TV, zero-copy presentation, eight bundled game drivers to pick from per game, real mouse-look, and frame generation in HDR.

🧪 Wayland is EXPERIMENTAL. Please read this before you switch anything.

• It is very new and it has bugs. It has been in tester hands for a few months and a lot works, but you will find rough edges — some games will run worse than on X11, some will not run at all, and some features are still missing. The honest list is under What it can and cannot do right now below.
• It is NOT a replacement for X11 and is not meant to be one. X11 remains the default, remains fully supported, and is still the right choice for anything you actually want to play. Treat Wayland as something to try on a spare container, not as an upgrade to move your games onto.
• It only works on the new versionCode 8 arm64ec Proton 11 layers — the ones labelled (v8) in the catalog. On any other layer the Wayland option is greyed out and a launch falls back to X11 with a notice. It does not work on the x86_64 (box64) layers, and it does not work on the Proton 10 layers (10.0-4 and GE 10.0-34), which stay on v7.
• It needs an Adreno GPU. The bundled drivers are Turnip, so Mali, Xclipse and PowerVR phones cannot use Wayland at all and stay on X11, which is unchanged for them.
• Nothing changes unless you change it. Every existing container keeps using X11 and behaves exactly as before. Wayland is off until you turn it on, per container.

If a game misbehaves on Wayland, switch that container back to X11 — it is one setting — and please report it with the session log from Download/Wayland-logs/.

🖥️ The X11 vs Wayland deck: the412banner.github.io/Bannerlator/wayland-deck.html — where a frame goes on each backend, the measured frame rates, the root causes fixed, and what Wayland can do that X11 never could.

📘 New to LSFG Native? Read the plain-language guide: LSFG Native Made Simple — why Max FPS × multiplier has to fit your screen's refresh rate, why a steady base matters, a live checker, a cheat sheet and real-world fixes. The same rule applies to Win-FG Native, which always runs at 2×.

What's New — everything since 3.1.1

📺 Play on your TV, a faster Wayland, GPU spoof, and HDR for more games

The Wayland work now lives in the normal compatibility layers. The pre-releases needed a separate test layer; 3.1.2 ships it in the versionCode 8 layers from the catalog (see New compatibility layers below), so Wayland is available on whichever layer your container uses. Those layers carry everything the last test layer had:

• compressed (UBWC) buffers for zero-copy;

• Windows' HDR monitor answer;

• Wine's own AMD AGS library.

• 📺 Launch a game on your TV.

  • TV tab: a new TV tab in a game's settings (and the XMB game settings) appears while an external screen is connected. It reads the screen's resolutions and whether it supports HDR10, and HDR is chosen automatically.
  • Launch this game on the TV starts the whole session on the external screen. The handheld shows a companion screen: the game's name, "Playing on screen", Send input back to the TV and End the game.
  • No freeze: touching the handheld no longer freezes the game on the TV, and the controller stays on the TV.
  • Unplugging: pull the cable and the game pauses and moves back to the handheld, where it carries on with sound.
  • HDR readouts in the HUD and drawer follow the screen the game is actually on.
  • ✅ Proven on the Pocket FIT with an HDR TV and an HDMI screen: launch from the Games tab, HDR on the TV, no freeze when touching the handheld, End the game, unplug and resume.
  • ⚠️ Not tested yet: pressing Home during a TV game and reopening the app (it should come back to the companion screen and hand input back to the TV), the match-resolution option and the output-mode picker. Android gives input to one screen at a time; if the controller stops reaching the game, use Send input back to the TV.
  • The old X11 Play on TV is unchanged.

• ⚡ Wayland performance, phase 1.

  • Compositor: it keeps a pool of five layer buffers, releases them with GPU-side waits and asks for compressed (UBWC) buffers. It clears only the letterbox bars, and keeps the black base under a zero-copy layer.
  • CPU: CPU affinity now works on Wayland, and Prefer big cores means every core at 70% or more of the fastest core's peak.
  • ✅ Measured on the Pocket FIT with AIO Graphics Test, copy path, against the previous Wayland build: Vulkan +9%, D3D12 +12%, DirectDraw +20%, D3D11 +3.5%, and higher 1% lows on every API.
  • UBWC: the versionCode 8 layers' Turnips ask for compressed (UBWC) buffers for zero-copy, and the device reports compressed buffers in use. The frame-rate effect of that part is not measured yet.

• 🎭 Wayland driver settings: GPU spoof and more. A ⚙️ gear next to Wayland game driver, in the container and game settings:

  • GPU Name (spoof): games see the GPU you pick, from the same list as X11.
    • It is written into a generated DXVK config file, so it works on DXVK versions that ignore the environment variable, and card names with spaces survive.
    • The Fusion HUD names the spoofed card with a spoof marker.
    • ✅ Proven with God of War on DXVK 2.4.1: all six spoof settings reached DXVK and the game showed the fake card.
  • Also in the gear: the DXVK memory cap (dxgi.maxDeviceMemory), the present mode (mailbox / FIFO) and the OneUI / HyperOS Fix (UBWC flag hint). ⚠️ Not device-tested yet.

• 🌈 HDR for more games.

  • RE Engine games (Resident Evil 2, 3, 4, Village…) only offer HDR when they see an AMD GPU.
    • On a versionCode 8 layer, Wine's own AMD AGS library answers for your screen instead of the copy the game ships with.
    • Set GPU Name (spoof) to an AMD card, e.g. Radeon RX 6800/6800 XT / 6900 XT, and turn on HDR output (HDR10).
    • ✅ Proven on the Pocket FIT with Resident Evil 3: the game asks "Enable HDR?" and AGS reports an HDR10 display. Without an AMD spoof the game never asks.
    • ⚠️ Not yet seen on an HDR screen with the game's HDR switched on. Resident Evil 2, 4 and Village are not tested.
  • Unreal Engine HDR in the game's settings: Off / DirectX 12 fix (DXVK_ENABLE_NVAPI=1) / DirectX 11 (experimental). The DirectX 11 option adds the bundled dxvk-nvapi v0.9.2 while it is on and removes it when you turn it off.
    • ✅ Proven with Tetris Effect: Connected: HDR10 on a TV in DirectX 12 and DirectX 11, and on the Galaxy Z Fold 8 Ultra in DirectX 11.
    • ⚠️ Tetris needed HDR forced in its ini files (bUseHDRDisplayOutput=True, r.HDR.EnableHDROutput=1); the game's own menu didn't switch it on.
    • The setting also shows on X11, where it doesn't help yet.
  • More HDR answers for Windows: the layer now also reports your monitor as HDR through Windows' display-configuration API, and answers two more of its HDR queries (SDR white level and advanced colour state).

• 🧪 AIO Graphics Test with the HDR card is built into new containers, with a Start menu entry AIO Graphics Test (HDR) that opens straight on the HDR card.

• Fusion HUD: in the pill, a GPU name wider than the stats (a spoofed card) gets its own line across the top instead of stretching the pill. ⚠️ Not device-tested yet.

🆕 Pre-release 8 — real HDR on Wayland (tap to expand)

This release comes with the v11 Proton layer (proton-11.0-2.1-arm64ec-wayland-v11.wcp, installs as Proton-11.0-2.1-arm64ec-11). It carries everything from v9 plus your screen's HDR description for Windows.

• HDR10 for games, on HDR screens.

  • Setting: a new HDR output (HDR10) setting in the container, game shortcut and XMB settings. It only shows on screens that report HDR10, and a shortcut's choice wins over the container's.
  • Path to the screen: with it on, a game's own 10-bit HDR frames go straight to the display tagged as HDR10 (BT.2020 PQ), with the game's brightness information attached.
  • ✅ Proven on a Galaxy Z Fold 8 Ultra with God of War and the AIO HDR card: highlights up to about 3.6 times brighter than normal white, zero washed-out frames.

• HDR stays on with the rest of the app.

  • Screen effects, a windowed game, a window on top of the game and Zero-copy presentation off all keep HDR: the compositor composes one 10-bit HDR picture and puts it on the game's display layer.
  • The in-game drawer has a live HDR output switch (Graphics tab). Off shows the same picture tone-mapped to normal brightness, straight away, with the game's own setting untouched.

• Frame generation keeps HDR.

  • LSFG Native and Win-FG Native run on the HDR picture in 16-bit and present it through a 10-bit HDR10 swapchain, so interpolated frames are HDR too and smooth gradients don't band.
  • ✅ Proven on the Fold: 60 fps shown at 120 fps, every frame HDR.
  • On a screen that offers no HDR10 swapchain, frame-generated frames are tone-mapped to normal brightness instead: correct colours, never washed out.

• Games see your real screen.

  • The v11 layer describes your screen to Windows: peak and full-screen brightness, black level and colours, as Android reports them. DXGI now reports your display instead of DXVK's made-up 1499-nit screen, so games aim their highlights at what your screen can show. It took two fixes: v10 built the description, and v11 fixed Wine's virtual desktop, which had handed games a monitor with a blank description.
  • ✅ Proven: 1345 nits on the Fold, 1207 on an ASUS ROG Phone 9 Pro, 892 on an Adreno 735 phone.

• Asking Android for the HDR boost.

  • On Android 15 and later the app now asks for HDR headroom for the game's picture, because some phones only brighten HDR when an app asks.
  • ⚠️ Not proven yet. It changes nothing on the Fold, which boosts anyway; whether it helps phones like the ROG Phone 9 Pro is still being tested.

• The HUD shows the HDR state on its own line under <latency> · Wayland:

  • HDR
  • HDR (no headroom): HDR frames, but the phone gives them no extra brightness right now
  • HDR off: the drawer switch
  • HDR tone-mapped
  • HDR ready: HDR is open, the game is in SDR right now

  Sessions without HDR look exactly as before.

• The session log explains HDR:

  • what your screen can do;
  • every HDR frame and the path it took;
  • the live HDR/SDR headroom, and when it drops, the phone's heat level and brightness beside it.

  Worth knowing: Android turns the HDR boost off while a screenshot or screen recording is being taken, and when the phone gets hot.

• Fusion HUD:

  • it starts in the top-right corner and grows to the left when you tap it to a bigger size;
  • a HUD you dragged keeps its place;
  • new containers get the Fusion pill at 75% with every metric on and the lock off. Existing containers keep their own HUD settings.

• The frame generation picker works on Wayland in the container, game shortcut and XMB settings. It was greyed out with an old "not available on Wayland yet" note. The LSFG Vulkan 1.1 compatibility switch stays off on Wayland, where it isn't needed.

• Smaller:

  • the session log says when a phone with no display device takes the OpenGL fallback path;
  • BANNER_WAYLAND_NO_RENDER_NODE=1 reproduces that path on any phone.

🆕 Pre-release 7 — setting up Wayland just works, and OpenGL games stay up (tap to expand)

This release comes with the v9 Proton layer (proton-11.0-2.1-arm64ec-wayland-v9.wcp, installs as Proton-11.0-2.1-arm64ec-9). Containers on -7 or -8 show an Update layer button that moves them to -9 in place: it backs up the registry first and can be reverted. Most of what is new is in the app, and most of it is about a tester's first five minutes.

• A new container keeps what you chose. Picking Wayland on the create screen used to be thrown away: the container was born on X11, and its Wayland game driver was lost with it, so a tester could be testing X11 without knowing. Creating, editing and the New Container Defaults now all save through one writer, so every field on the screen reaches the container: the display backend, the Wayland game driver, the drivers, the DXVK and VKD3D versions, and an environment variable you deleted stays deleted. ✅ Proven by creating a container through the real screen and reading its saved file back, before and after its first launch.
• No more blank Compositor driver. A Wayland container used to start with an empty Compositor driver, which means the phone's own driver, and that shows a black screen. It now fills in a Turnip that can do the job: the one in your New Container Defaults if it qualifies, otherwise the newest installed Turnip that can import the game's frames (the app checks each driver for the four extensions the compositor needs, rather than trusting its name). Your own choice is never replaced. With no usable Turnip installed, the field says so and offers a download. ✅ A new container rendered its first boot without the field being touched.
• No more Wine Mono download prompt. Wine offered to download Mono on the first boot of every new container, and again after a layer update, on every layer, not just Wayland. The app now runs Wine's prefix update as its own step with that one check switched off, so the prompt never comes up. Your game's own session is untouched, so a game that needs .NET still loads it. ✅ Proven on a new Wayland container, a real -7 → -8 layer update and a new GE 11.0-6 container on X11. ⚠️ x86_64 layers are covered by the same code but were not run on a device.
• OpenGL safe mode, on by default. OpenGL games could vanish a few seconds in, with no error box, no log and no crash dump: Mesa's threaded-driver helper faults on this build, and because Wine owns crash handling, the process simply disappears. Pre-release 6 asked you to type GALLIUM_THREAD=0 into Env Vars. Now the app does it for OpenGL games on Wayland, and the drawer's Graphics tab has an OpenGL safe mode switch (it applies at the next launch, because Mesa reads it when the game starts). ✅ Wizardry: 30 fps for minutes with it on, gone 0.3 seconds after its first frame with it off, steady again with it back on. It only affects OpenGL games on Wayland; DirectX, Vulkan and X11 never see it.
• Control Panel works in the XP desktop again (since the v8 layer). Since the v7 layers, Start → Control Panel did nothing: the XP menu asked Wine to open the Control Panel folder, and Wine's explorer mangled the folder's special name and quit without a window. The entry now opens Wine's Control Panel with its proper icon, and Add/Remove Programs is reachable from it. ✅ Proven on the v8 layer.
• OpenGL games draw on phones that hide their display device (v9 layer, added 14 September). On many retail phones, seen on Adreno 830/840, an OpenGL game stayed black with sound: Mesa's OpenGL setup insisted on opening the phone's display device, and when the phone refused, it fell back to a software renderer this layer does not contain. It now starts OpenGL on the Vulkan driver directly in that case, and the session log says plainly when it happens. ✅ Wizardry renders on a retail Adreno 840 phone, and still renders the usual way on the Pocket FIT, with a DirectX game unchanged.
• The HUD and the cards say what is really running. On Wayland the HUD used to print the container's settings as the renderer, so a native OpenGL game read "DXVK". It now starts at what is true of every Wayland session and upgrades only on evidence from the game's own process: Wizardry reads OpenGL, Insane 2 still reads D3D9 · DXVK. Cards now name the display backend on both sides: Vulkan (Wayland), and on X11 Vulkan (X11) or OpenGL (X11).
• A window above a game no longer costs hardware composition for the rest of the session on a screen that rotates and scales the game (handhelds like the Pocket FIT). Pre-release 5 put such a window on its own display layer, and on this panel the display then gave up composing in hardware until you left the app. The second layer is now only raised when the display does not have to both rotate and scale the game layer; otherwise the window is drawn over the game the old way. Same picture, same frame rate, and the session never leaves hardware composition. A tablet or TV running a game at native orientation and size still gets the second layer.
• Every session log now opens with what the screen can do for HDR (formats, brightness, headroom), re-read if the game moves to another display. Task Manager shows it too. This device reports none, 500 nits, SDR only.

🆕 Pre-release 6 — native OpenGL games render (tap to expand)

Pre-release 6 introduced the v7 layer (the v9 layer here carries it): the fix is half in the app and half in the layer's graphics libraries.

• Games that use OpenGL directly now draw on Wayland. Until now every one of them was a black window with working sound, and nobody had noticed because DirectX games go down a different path. Two things were wrong. The compositor described its buffer sharing with an older version of the protocol than Mesa's OpenGL needs to find the graphics device, so OpenGL gave up on the hardware; and our own driver build then steered it into a software renderer that this layer does not contain, which is why the window came out blank rather than slow. Both are fixed, and a game's OpenGL now runs on the real GPU through Zink.
• Games that use DirectX or Vulkan are unaffected: they never used that path, and they were re-measured on the new layer to be sure.
• The compositor's buffer sharing moved to version 4 with full feedback. Programs that speak the older versions still see exactly what they saw before, checked against the running compositor rather than assumed.

🆕 Pre-release 5 — two display layers, and the panel rate on Wayland (tap to expand)

Pre-release 5 used the v6 layer; the changes below are app-side.

• Screen effects keep the game on its own display layer. Until now, turning on a Look, a scaling mode or any filter dropped the whole session back to the compositor's copy path. The effects chain now draws its result straight into the game's display layer, so the picture still reaches the screen through the display hardware. Proven with the Retro CRT look over Half-Life 2 at about 123 fps against 122 to 126 on the old path, with the display hardware composing the result.
• A window above a game gets its own layer. Open a second window over a fullscreen game, a launcher or Wine's Task Manager, and the game keeps presenting its own frames copy-free while the window is composed on a second layer above it. Before, any window on top dropped the game off the layer entirely.
• Two layers is a deliberate cap. Android's display hardware only composes a few layers before it quietly hands the whole frame back to the GPU, which would throw the gain away. The compositor never uses more than a game layer and one overlay, and says so in the session log.
• Input and the drawer are unchanged. Display layers carry no input at all, so touches and the mouse keep reaching the game exactly as before, and the in-game drawer still draws above everything.
• Refresh-rate matching now reaches Wayland properly. The rate request used to ride on a surface that never presents a frame in a Wayland session, and the game's own display layer carried no request at all. Both are fixed: with a 60 cap the panel runs at 60 even with zero-copy on, clearing the cap returns it to the panel's maximum, a manual lock is honoured, and frame generation still asks for cap times multiplier. If you have never switched it on, it is Match refresh rate in the container's display settings.

🆕 Pre-release 4 — the zero-copy switch is live (tap to expand)

Pre-release 4 introduced the v6 layer (installs as Proton-11.0-2.1-arm64ec-6; the v9 layer here carries it): the switch is a conversation between the compositor and the game's driver, and the driver lives inside the layer.

• Turn zero-copy on and off while the game runs. The toggle sits in the drawer's Graphics tab, under Native Rendering. Flip it and the compositor tells the game's driver to rebuild its swapchain; within a few frames the game is presenting on its own Android display layer, with no copy anywhere between the game and the screen. Flip it back and it returns to the compositor's normal path. The picture never goes black and the frame rate does not change.
• The drawer shows what is actually happening, not what was asked for: "On: N zero-copy frames in the last 10 s", or "Off". The setting is still saved to the shortcut or container, so the next launch starts the way you left it.
• It steps aside for frame generation, and resumes afterwards, live, with no relaunch. Since pre-release 5 screen effects no longer make it step aside at all.
• Proven on Half-Life 2 on the Adreno 750: launched with zero-copy off, switched on mid-game (every presented frame zero-copy within one stats window), switched off, switched on again, with the frame rate flat at about 1,435 game frames per ten seconds throughout. The AIO Graphics Test also switched Vulkan → D3D12 → D3D9 → Vulkan with zero-copy on, rebuilding its buffers each time.
• Mixed versions are safe. A new app on the old v5 layer runs exactly as before (the driver simply keeps deciding at launch); an older app on the v6 layer is unaffected. Only the two new halves together give you the live switch.
• Two latent compositor bugs fixed on the way: after a live switch-off the display layer could have been left up holding a frozen frame, and a buffer could have been handed back to the game while the display was still reading it.

🆕 Pre-release 3 — the in-game drawer on Wayland (tap to expand)

• Every scaling mode and screen effect works on Wayland, live from the drawer exactly as on X11: Linear, Nearest, SGSR, SGSR HQ, FSR, FSR Fit, Sharpen and NIS scaling, CAS, HDR, Debanding, the Looks, brightness / contrast / gamma / saturation, FXAA, CRT, Toon and NTSC. They run as a 13-pass Vulkan chain inside the compositor's present pass, in the same order X11 applies them. Proven: the Retro CRT look applied live over Half-Life 2.
• Frame generation works on Wayland: LSFG Native and Win-FG Native. Arm them from the drawer as on X11 (a launch never auto-arms). Proven: Half-Life 2 running at 30 fps shown at 60.0 / 90.0 / 120.0 fps with LSFG Native 2x / 3x / 4x, the session log counting 300 GPU frames from games | 600 generated frames per ten seconds at 3x.
• Task Manager → Container shows the display backend (X11 or Wayland). On Wayland the Renderer row reads "Vulkan (Wayland compositor)" and the Graphics driver row names both drivers: the compositor's Android Turnip and the game's bundled pick.
• Zero-copy toggle in the Graphics tab, under Native Rendering (which is greyed on Wayland because it is X11's own direct-scanout path). It writes BANNER_WAYLAND_ZERO_COPY=1 to the shortcut or container and shows the live zero-copy frame count. In pre-release 4 it also switches live, see above.
• Effects or frame generation on means the copy path: zero-copy pauses for as long as either is active (the log says so and the stats line shows generated frames instead of zero-copy frames) and resumes when both are off.
• HUD FPS no longer reads 0.0 under zero-copy on GPUs whose gralloc frames the compositor cannot import for its own copy path (reported by a tester on a Samsung Adreno 8xx: game ran at full speed, HUD said 0.0). The frame counter now ticks on the frames the display layer shows.
• The session log now names the frame-gen engine, multiplier and each multiplier change.

🆕 Pre-release 2 — eight drivers, zero-copy, compressed buffers (tap to expand)

• Eight Wayland game drivers built into the Proton (was four): plain, Vauzi a7xx, WinNative Balanced and Performance, and four more Adreno 8xx builds — Banners-Turnip's own gen8 recipe, StevenMXZ's Gen8 V36, whitebelyash's Mainline v31, and pure upstream Mesa main. Table below.
• Zero-copy presentation (experimental, off by default). BANNER_WAYLAND_ZERO_COPY=1 in Env Vars makes a fullscreen game's own frames go straight to the display hardware: the game's driver builds its swapchain on Android gralloc buffers and the compositor hands them to SurfaceFlinger without a copy. The session log counts them (… | N zero-copy frames). Proven with Half-Life 2 on the Adreno 750: 1239 of 1240 presented frames without a copy, correct picture, same 144 fps cap.
• Compressed game buffers. The compositor now accepts Qualcomm-compressed buffers, so the game no longer resolves every frame to a linear copy first. Default on; BANNER_WAYLAND_UBWC=0 forces linear if a GPU shows a scrambled picture.
• Two launch bugs fixed: the first launch after installing a Wayland Proton no longer opens at 1024x768 (Wine's prefix update now runs before the session), and Wine's desktop no longer closes a second into a 32-bit game's startup (the Proton tree's zero-second desktop-close grace is restored to 1 second, and every session process is started on the game desktop).
• Keyboard layouts by name: xkb data is bundled in the Proton, so layouts are no longer forced to US.
• Shortcut executables without a folder or without .exe no longer crash the launch.

🌊 Pre-release 1 — the Wayland backend itself: per-container backend, pointer lock, keyboard, fullscreen modes, the bundled drivers (tap to expand)

🌊 Wayland display backend

• Per container, with a per-game override (Use container default / Force X11 / Force Wayland) in the container editor, the game shortcut editor and the XMB view.
• Gated on a capable layer. Wayland is only offered when the selected Proton ships winewayland and its Wayland Turnip; anything else falls back to X11 with a notice, so a wrong setting can never hide a game.
• The settings tell the truth on Wayland. Renderer reads "Vulkan (Wayland compositor)"; Render scale is greyed with the reason; Fullscreen Mode, Screen Alignment, FPS limiter, Frame Generation (LSFG Native / Win-FG Native), DX wrapper, audio, emulator and refresh rate all work.
• Every graphics API switches fluidly in one session: Vulkan, OpenGL (through Zink), D3D12, D3D11, D3D10, D3D9, D3D8 and DirectDraw, proven with the AIO Graphics Test switching between all of them in one launch without a crash.

🎯 Pointer lock and mouse-look

• The compositor implements pointer constraints and relative motion, the two Wayland protocols Wine uses for games that grab the mouse. Touch drags, a captured mouse and stick-as-mouse all reach the game as relative motion.
• Proven: Half-Life 2 at 144 fps with touch mouse-look, including a full turn-around.
• The in-game Relative Mouse chip and Mouse Warp Override are live on Wayland.

⌨️ Keyboard, clipboard and the soft keyboard

• Keyboard input works on Wayland — it never did in the earlier test kits. Two causes were fixed: winewayland gave up its keyboard when it could not read xkb registry data, and the compositor handed keys to Wine's desktop instead of the window you clicked.
• Clipboard both ways: copy in a Windows program and paste on Android, copy on Android and paste in the program.
• The soft keyboard opens by itself when a Windows text field takes focus (tap into the field first) and closes when it loses it.

🖥️ Fullscreen modes, alignment and the compositor

• Fullscreen Mode (Off / Fit / Stretch / Fill / Integer) and Screen Alignment (Center / Top / Bottom) now apply on Wayland, live from the in-game drawer too, with touch input mapped to match.
• Compositor fixes: no black frame or window churn when a game rebuilds its swapchain, HOME and back brings the picture back, the FPS cap stays exact, HUD sampling no longer stalls the compositor thread, and the swapchain recovers when the screen surface is lost.

🧩 Per-game Wayland driver choice — eight Turnips built into the Proton

On Wayland the game renders on a Vulkan driver bundled inside the Proton layer, chosen under Wayland game driver (Auto picks by your GPU):

Choice	Built from	Adreno target
Bundled	upstream Mesa 7cda7850, no device patches, Banners-Turnip wayland branch	6xx, 730, 740, 750
Bundled a7xx	Vauzi-17 "710" v3.6 recipe, Mesa 7631b525	710, 720, 722
Bundled a8xx	WinNative WN-Turnip 1.15 Balanced recipe, Mesa 12b7b819 — Auto's pick on an 8xx	830, 840 (+ 810 / 825 / 829)
Bundled a8xx Performance	WinNative WN-Turnip 1.15 Performance recipe (GPU held at PWR_MAX), Mesa 12b7b819	same
Bundled a8xx gen8	Banners-Turnip's own Android a8xx recipe (gen8 patch set + shared-memory script), Mesa 12b7b819	same
Bundled a8xx SMXZ	StevenMXZ Turnip Gen8 V36 recipe, Mesa c501e1d1	same
Bundled a8xx WHITE	whitebelyash Mainline Turnip v31 recipe (mesa-unified turnip/gen8 9c475fc3)	same
Bundled a8xx upstream	pure Mesa main bbc7792f (2026-09-13), no patches	same

All eight are rebuilt from those sources as Wayland/Linux drivers (KGSL backend, Wayland WSI) — the Android zips those projects publish cannot be used inside Proton. You can also import your own Wayland-built driver as a zip under Contents → Wayland game drivers (Linux ICD). Vauzi recommends TU_DEBUG=sysmem on 710/720/722 if you see artifacts (set it in the container's Env Vars).

🧪 Experimental: the game on its own Android layer

Turn on Zero-copy presentation in the in-game drawer (Graphics tab), live, or put BANNER_WAYLAND_ZERO_COPY=1 in a container's or shortcut's Env Vars to start that way, and a fullscreen game is presented on its own Android hardware layer, composed by the display hardware instead of the app. Proven with Half-Life 2 (hardware composition at 144 Hz). It does not save a copy yet — it is the first half of the zero-copy work below. Leave it unset for normal play.

🔧 Smaller

• A shortcut whose executable has no folder or no .exe no longer crashes the launch.
• The wcp's Zink / EGL libraries now come from the same build as its Turnips.

🎮 A physical controller stick can move the mouse

Binding a stick to mouse movement on a physical controller now moves the cursor with the on-screen controls switched off. It previously needed an on-screen profile to be showing before the binding did anything. Device-proven.

📦 New compatibility layers — versionCode 8: Wayland and HDR10 on every 11.x layer

All the Proton / GE-Proton 11.x layers were rebuilt as versionCode 8 (proton-wine release build-bionic-layers-20260917-wayland-v8) and are the in-app catalog default. They install into a new <version>-arm64ec-8 slot beside v7's -7, so nothing is overwritten; a container already on a -7 layer is offered this as an Update layer → v8 on its container card, keeping games, saves and settings, with a revert snapshot.

• Wayland and HDR10, on every layer. Each layer carries Wine's own winewayland.drv plus eight bundled Wayland Turnip drivers you can pick per game — plain (Adreno 6xx/730/740/750), a7xx, a8xx, a8xx-perf, a8xx-gen8, a8xx-smxz, a8xx-white and a8xx-upstream — and reports HDR10 screens to Windows through a built EDID, DXGI and DisplayConfig. This is what makes the Wayland backend available whatever layer a container is on, instead of only the test layer the pre-releases needed.
• Proton-CachyOS joins the layer list — the wine-cachyos build, previously a standalone test, is now a normal catalog layer with the same Wayland and HDR10 work.
• More x86_64 layers — GE-Proton 11.0-7, 11.0-7.1 and CachyOS now ship an x86_64 (box64) build as well as arm64ec. The x86_64 layers do not have Wayland (it is arm64ec-only) but carry everything else at versionCode 8.
• Carried over from v7 — the Wine XP desktop (Luna taskbar, start menu, XP window frames and visual style, dark mode) and its Start-menu Control Panel fix, the XInput update-thread fix, RtlIsEcCode, DirectAudio v1.3.2, the EA networking fixes and the rest of the v7 set.
• Proton 10.0-4 and GE-Proton 10.0-34 stay at versionCode 7. Their Wine 10 base uses an older graphics-driver interface that this work does not apply to, so they keep the v7 build and Wayland is not offered on them.

ℹ️ Wayland itself has been running for months with a few dozen testers across Snapdragon devices. The versionCode 8 layers specifically are a fresh rebuild — they were binary-verified (every layer unpacked and checked for the Wayland driver, the eight drivers and the right identity) but they are newer than the community testing behind the backend.

What it can and cannot do right now

Can:

• Graphics: run DXVK / VKD3D / Zink games on Wayland with the same drivers and settings you use on X11, and switch graphics APIs freely.
• Input: mouse-look, keyboard, clipboard and the soft keyboard.
• Display: fullscreen modes, the FPS cap, every scaling mode and screen effect live, and HDR10 on HDR screens.
• TV: launch a game on an external screen (in HDR when it supports it) and pull the cable to carry on on the handheld.
• Frame generation: LSFG Native and Win-FG Native, in HDR too.
• Also: background and resume, a GPU name spoof, and picking a bundled driver per game.

Cannot yet, or not proven:

• HDR in games needs a helper, per engine.
  • RE Engine games only offer HDR with an AMD GPU spoof. The prompt and the HDR answer are proven on Resident Evil 3; the game's HDR on an HDR screen is not seen yet.
  • Tetris Effect (Unreal Engine) needed HDR forced in its ini files; the Unreal Engine HDR setting does not write them yet.
  • Other games may need their own tricks. Reports with the Wayland session log are very welcome.
• TV launch: Home and reopen during a TV game, match resolution and the output-mode picker are not tested yet. Android gives input to one screen at a time, so touching the handheld can take the controller away until you tap Send input back to the TV.
• The HDR boost depends on the phone.
  • On the Galaxy Z Fold 8 Ultra, HDR highlights got about 3.6 times brighter than normal white.
  • An ASUS ROG Phone 9 Pro received the same correct HDR picture, but Android gave it no extra brightness. 3.1.2 asks Android for the boost; whether that helps on that phone is not proven yet.
  • On every phone, a screenshot, a screen recording or a hot phone switches the boost off while it lasts. The HUD then reads HDR (no headroom).
• scRGB is not supported yet. That's the other HDR format some games use. With DXVK 2.4.1 such a game shows in normal brightness, because the compositor offers HDR10 only.
• HDR is proven on one phone (the Fold) with one game (God of War) and the attached HDR test card. Reports from other HDR phones are the most useful thing an HDR tester can send: the AIO HDR card's report plus the Wayland session log.
• Measured: zero-copy saves GPU work, not frames, on the Pocket FIT.
  • Setup: Half-Life 2 uncapped (+fps_max 0 +mat_vsync 0), the same scripted scene, two 60-second passes each, alternating.
  • Zero-copy vs copy path: 185 vs 187 fps (no change; the game is CPU-bound under FEX here), GPU busy 79% vs 83%, GPU clock 944 vs 1000 MHz, power 16.3 W vs 16.8 W.
  • The compositor copy is gone; a frame-rate gain needs a GPU-bound game or a large panel.
• OpenGL is working, but not broadly tested. Safe mode (on by default) avoids the vanishing-game crash; it does not fix it.
• The bundled a7xx drivers are unproven on real hardware. The 710/720/722 builds have only run on an Adreno 750. The a8xx drivers now run on real Adreno 830 and 840 phones; which a8xx build is best is still open.
• Clipboard and window decorations: drag-and-drop and image clipboard are not bridged (text only), and window icons and title-bar decorations are missing.
• Frame generation pauses zero-copy. It still needs the compositor pass, so zero-copy is off while it runs; in HDR the frames go through the HDR10 swapchain.
• New Container Defaults do not fully reach a new arm64ec container. The Mono fix covers x86_64 layers with the same code, but was only run on arm64ec layers.
• Leaving the app pauses the whole container; come back and it resumes. That is by design.

What is left — fixes and performance

1. HDR:
   • see RE Engine HDR on an HDR screen;
   • have Unreal Engine HDR write the game's HDR ini lines itself;
   • an automatic HDR preset per engine;
   • scRGB support;
   • prove the HDR boost request on phones that don't brighten HDR on their own.
2. TV: prove Home and reopen, match resolution and the output-mode picker; bring back input focus by itself.
3. Performance: measure UBWC and zero-copy where they can show (an uncapped game, a large panel), then make zero-copy the default once more GPUs have run it.
4. Real 710/720/722 testing of the bundled drivers, and reports on which a8xx build runs best.
5. Screen effects on GPUs whose buffers the compositor cannot import.
6. Later: presentation feedback for even frame pacing, tearing control, native multi-touch, window decorations.

Logs, if something goes wrong

• Download/Wayland-logs/wayland-<date>_<time>.log: the compositor's session log. It covers windows, frames on screen per 10 s, pointer lock, clipboard, text input and screen mode. It also has every color line for HDR: what the screen can do, the path each HDR frame took, the live headroom and the verdict at the end.
• Download/bannerlator/<game name>/wine_debug.log and the DXVK / VKD3D logs next to it (turn on Wine debug logging in Settings → Log Manager).
• The HDR test card writes AIO Results\HDR\AIO-Graphics-Test_hdr.txt next to where it runs.

⚠️ Carried over — still open

• Everything listed as open in 3.1.1 is unchanged here:
  • Win-FG Native's limited device testing;
  • the untested Steam Controller puck;
  • cancelling a store download;
  • Origin-era EA sign-ins;
  • Need for Speed (2015);
  • Rockstar Games Launcher titles;
  • 64-bit titles launched directly by Steam;
  • the Java Steam engine fallback.

📦 Where to get Proton 9 (tap to expand)

The APK does not bundle Proton 9 — Wine installs from the in-app catalog on first run. The Wayland layer attached to this release is Proton 11.0-2 and is not in the catalog: install it from the file above.

Proton 9.0 arm64ec — not bundled, download it if you want it:

https://github.com/The412Banner/Nightlies/releases/download/Proton/wine/proton-9.0-arm64ec.wcp

66.7 MB · sha256 f8a99fed387f1b097009129dc49368c8f500927640a9d4c7a192d850b1b2068c
Install it via Containers → download icon → install the .wcp. It also appears in the in-app catalog. (Compiled as a wcp by Xnick417x.)

📜 Every change since 3.1.1 — 55 merged, oldest first

• Mali-report 2026-09-12T22-26-30-d7e7e9: data · f0b20569
• Mali-report 2026-09-12T22-26-30-d7e7e9: page · 335ab874
• Mali-report 2026-09-12T22-26-30-d7e7e9: index · 20f1110b
• 3.1.1 notes carry the v7 Wine XP compatibility layers · 11b670b2
• Mali-report 2026-09-13T01-40-28-941e27: log PSPIME8M.jpg · fa60756e
• Mali-report 2026-09-13T01-40-28-941e27: log 0MNwvchD.jpg · 87c642ba
• Mali-report 2026-09-13T01-40-28-941e27: log _2lD-k8K.jpg · 68cc2d76
• Mali-report 2026-09-13T01-40-28-941e27: log XzlaznEi.jpg · 14abda48
• Mali-report 2026-09-13T01-40-28-941e27: data · 8952808e
• Mali-report 2026-09-13T01-40-28-941e27: page · 66d0fc5b
• Mali-report 2026-09-13T01-40-28-941e27: index · e44c94b9
• Embedded Wayland compositor as a per-container display backend — feat/wayland-runtime · bd75d20c
• X11 vs Wayland deck for the 3.1.2 Wayland pre-release (GitHub Pages) · 4d8fccb0
• X11 vs Wayland deck updated for pre-release 2 (eight drivers, measured zero-copy, launch fixes) · b95bd13b
• Mali-report 2026-09-13T21-26-49-0ccf80: data · c555e8d6
• Mali-report 2026-09-13T21-26-49-0ccf80: page · ca2fb461
• Mali-report 2026-09-13T21-26-49-0ccf80: index · 3bf89d3c
• Wayland deck updated for pre-release 3 (effects + frame generation live on Wayland) · 939fde40
• Wayland deck updated for pre-release 4 (live zero-copy switch) · 6ca04365
• Wayland game driver: per-container/shortcut choice resolved into BANNER_WAYLAND_VK_VARIANT / _ICD at launch · 3e98053c
• Wayland deck updated for pre-release 5 (two display layers, effects on the game layer) · c5652ade
• Wayland: route the VRR refresh-rate vote to the surface that actually presents · 8fc2f5ce
• Wayland phase 5: OpenGL safe mode, HDR capability reporting, display-layer composition recovery · c518c7af
• X11 cards name their backend on the renderer chip — fix/renderer-chip-backend · 161225a2
• A Wayland container never starts with a blank or System compositor driver — fix/wayland-compositor-driver-default · 23ab7dcf
• The prefix update runs as its own step with mscoree disabled, so Wine never offers to download Mono — fix/wine-mono-prompt · 3ab2f306
• Wayland pre-release 7 notes, kit README and deck · 1fbb720c
• Pre-release 7 notes - older pre-releases collapsed into tap-to-expand sections · f8e045a5
• Drop bionic-fg from the Wayland pre-release 7 notes, kit README and deck (no longer in the app) · f1cf9f94
• Pre-release 7 - v9 test layer attached next to v8 · 531b9220
• Pre-release 7 - v9 is the layer, v8 removed · c408dc55
• The Frame Generation picker is live on Wayland in the container, shortcut and XMB editors — fix/wayland-framegen-settings · 49248c3e
• Log when a phone exposes no display device or OpenGL falls back to software, plus a switch to reproduce it — fix/wayland-gl-no-drm-node · cd553d8c
• Wayland deck adds real HDR (in testing) and a plain-words "what Wayland can do that X11 can't" slide · f4f76afa
• Wayland HDR10 round 1 (native, WIP): wp_color_manager_v1 v1 subset, 10-bit dma-buf formats and BT2020_PQ on the game layer behind an opt-in gate · 4938f357
• Pre-release 8 notes and kit README; the Wayland deck says HDR shipped in pre-release 8 with the v11 layer · d1a002be
• Start menu: AIO Graphics Test (HDR) opens straight on the HDR test card (--hdr) · abb98231
• Bake AIO Graphics Test 2.1.0 into the container pattern (drive_c/AIO Graphics Test v2) · 69ec7ca5
• Wayland compositor: perf line, black base kept under the layers, letterbox-only clears, layer pool of 5 · 0255dfea
• CPU affinity on Wayland + Prefer big cores = the whole performance tier · 3c4b8983
• Wayland driver settings (GPU name spoof) + Unreal Engine HDR (DX12 fix / DX11 with bundled dxvk-nvapi) · a399d749
• TV tab: launch a game's session on the external display, pause on unplug · a1206106
• TV tab UI: the per-game rows, live display watch, and the TV launch path · c6310b8c
• TV tab: trust the display the window landed on, not the launch request · 80226e30
• TV sessions: don't freeze a game that is still playing on the TV · 9388c2a0
• TV tab: a companion screen on the handheld while the game plays on the TV · 7c421557
• HDR readouts follow the screen the game is on, not the gate · c97c9a7c
• Wayland GPU spoof: deliver the name in a generated dxvk.conf · 5814f59c
• Re-opening the app during a TV game lands on the companion, not the games list · 29c8c5f0
• Fusion HUD pill: a GPU name wider than the stats gets its own line across the top · be893205
• Wayland pre-release 9 notes and kit README; PROGRESS_LOG · 7796b13c
• The Wayland deck for pre-release 9 (TV launch, GPU spoof, phase 1 numbers, engine HDR helpers, v16) · 64ce8936
• Physical pad: a stick bound to mouse movement moves the cursor with the on-screen controls off · 2f4cb5e2
• 3.1.2 stable release notes · 1a96ca1d
• 3.1.2 notes — two remaining v16 test-layer references in the visible text · 334fcc53

---

🙏 Credits (tap to expand)

The bundled Wayland drivers are rebuilt from community work, all on top of Mesa / Turnip by the Freedreno and Mesa teams:

• the 710/720/722 recipe by Vauzi-17 (release 3.6);
• the Adreno 8xx Balanced and Performance recipes by the WinNative development team (WN-Turnip 1.15);
• the Gen8 V36 recipe by StevenMXZ;
• the Mainline v31 recipe and the gen8 patch stack by whitebelyash.

The plain driver, the Wayland WSI builds and the Proton integration are from The412Banner's Banners-Turnip and proton-wine forks.

The412Banner's original work:

• the embedded Wayland compositor, with its pointer-lock, clipboard and text-input support;
• its HDR path;
• the Android-layer prototype;
• the AIO Graphics Test.

Built on the work of many open-source projects and their communities:

• Display — Wayland (the freedesktop.org community) and Wine's winewayland.drv (WineHQ).
• Graphics — DXVK (Philip Rebohle & contributors), VKD3D-Proton (Hans-Kristian Arntzen & contributors), Mesa / Turnip / Zink (the Freedreno & Mesa teams).
• Containers, launch & runtime — Wine (WineHQ) and Proton / GE-Proton (Valve & GloriousEggroll); box64 (ptitSeb) and FEXCore (the FEX-Emu team).
• Native Steam engine & SteamLite agent — derived from WinNative's GPL wnsteam client and wn-steam-launcher; protocol groundwork from SteamKit2.
• Audio — Android AAudio, driven by our own DirectAudio endpoint.