Bannerlator 3.1.3 — pre-release 2

       

Bannerlator 3.1.3 — pre-release 2

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

⬆️ Upgrading from pre-release 1? Install this APK over your current install. That is all: your sign-in, your games, Valve's ARM64 Proton and your settings are kept, and nothing is re-downloaded.

Coming from the September 21 test build instead? The same two steps as pre-release 1: install over, then open Contents → Linux Runtime once so the Steam (Linux) entry moves out of its old Wine container. The full walkthrough is under Setup below.

In-app updates: stable users are never offered a pre-release. Testers who turn on Settings → Include pre-releases are offered this one (versionCode 88).

Pre-release 2 of 3.1.3 puts the Steam client's interface back on the GPU. Chromium's GPU process — the part of Steam that draws its interface — was dying on its way up every time the client started, and after a few tries Chromium gave up and drew the whole interface on the CPU instead. That is why Big Picture felt slow on every device. It now stays on the GPU.

• A much faster Steam interface. Measured in a controlled A/B (same device, same install, same scroll through the library): about 44 fps before, 85 after, with the GPU-process crashes gone from twelve to none. On an AYANEO Pocket FIT the interface now reads 117–138 fps.
• Warnings before the download when Android is set to kill the session's processes, or when the phone's GPU is not an Adreno — the two failures that used to end a session with nothing on screen and nothing in the log.
• Scaling mode and scaling filter in the Steam (Linux) settings, including FSR, NIS and SGSR.
• A crash fix for sessions that fall back to the app's own proot, plus faster proot memory handling.
• Only your real controllers are listed to Steam.
• Steam Deck mode is in the settings as an experiment — it breaks game controllers, so it is off by default and only turns on through a warning.

Everything from pre-release 1 and 3.1.2 is here too.

⚠️ Read before testing. This is a tester build of something very new.

• Adreno only. The runtime draws with Turnip. Mali, Xclipse and PowerVR phones get sound over a black screen. Contents → Linux Runtime now says so before the download, so please do not install it on one of those to "see what happens".
• Turn on "Disable child process restrictions" in Android's Developer options before your first launch. The Steam client is dozens of processes; without that switch Android kills them at random and the session dies for no visible reason. Contents → Linux Runtime now tells you when it is still on, with a button to Developer options. Some phones (Android 12, some vendor skins, some Thor units) do not show the switch at all — the card gives the adb line for those, and the app still cannot flip it for you.
• Leave Steam Deck mode off. It is in the Steam (Linux) settings as an experiment, and on device it breaks game controllers: Steam's own menus still work, but in a game the pad does nothing. It also shows a Steam Client update under System that cannot install — do not press Apply on it.
• FlatOut shrinks to a strip in the top-left corner after Guide → Resume game. FlatOut 2 does not. The fix is not found yet.
• One device. Everything below was proven on one AYANEO Pocket FIT. Reports from anything else — with the session folder from Download/Bannerlator-LinuxSteam/ — are the most useful thing a tester can send.
• Team Fortress 2 reports "insecure" on this client. The cause is not found yet; it is not something the runtime sets. Do not expect VAC-secured servers to work until it is.
• It is experimental. Games can crash, the client can crash, and a game installed while the compatibility layer is still downloading pulls in ~1.7 GB of Valve's own tools it never uses. Your Wine containers and games are untouched by any of it.

📘 New to LSFG Native? Read the plain-language guide: LSFG Native Made Simple — why Max FPS × multiplier has to fit your panel, and what the numbers on the HUD mean.

What is in this release (all three flavours)

File	What it is
Bannerlator-3.1.3-pre2-standard.apk	the normal app (com.winlator.banner)
Bannerlator-3.1.3-pre2-pubg.apk	the "pubg" package name flavour (com.tencent.ig)
Bannerlator-3.1.3-pre2-ludashi.apk	the Ludashi package name flavour

The Linux runtime itself (about 755 MB) is not in the APK — the app downloads it once, see Setup. Valve's ARM64 Proton (about 2 GB) is downloaded by the Steam client on your first sign-in.

Setup

1. Install the APK for your flavour over your current install (data is kept), or fresh.
2. Android Settings → Developer options → Disable child process restrictions → on. (If you do not see Developer options, tap Build number seven times in About phone.)
3. In the app: Contents → Linux Runtime → Download. One download, about 755 MB. When it finishes, a Steam (Linux) entry appears in your games list.
4. Launch Steam (Linux). The first run shows a loading screen while the client downloads itself and updates (a few minutes; the clock on the screen tells you it is alive). Sign in with your Steam account (the QR code and the Steam mobile app work).
5. Wait here — do not install a game yet. The client fetches Valve's ARM64 Proton by itself, but it may not start on its own: watch for the Proton Experimental (ARM64) install box (about 2 GB) and, if the phone has an SD card, choose internal storage or the card and tap Install. If nothing appears, look in Downloads — it may be waiting on that choice.
6. Let it restart itself. When that download finishes the client restarts on its own — the loading screen comes back with "Steam is restarting once…" and goes away when Steam is back, still signed in. A game installed before that restart gets Steam's own tool chain (~1.7 GB it cannot use) and fails to launch with no error, so wait it out.
7. After the restart: install a game from your library and play it. That's it — nothing to pick.

Optional:

• The ⚙️ next to the Steam (Linux) entry has its settings: resolution (720p by default — the client's interface is the most expensive thing a session draws), the draw driver (the Turnip that draws the client and its games) and the display driver (the one that puts frames on your screen), core lists for the client and for games, DirectAudio, frame generation and the HUD.
• Other Turnips for drawing: Contents → Drivers → import one of the -Linux.zip builds from Banners-Turnip (there are plain, A8xx and 710/720 builds). The runtime ships one already; import only if you want to compare.
• GE-Proton and proton-cachyos (ARM64 builds) can be downloaded in Contents → Linux Runtime and chosen per game in the client's own Compatibility page. A game's per-game choice follows Steam's rules, not the app's.

📖 Step-by-step in plain English — a brand-new install, or upgrading from pre-release 1 or the September 21 test build (tap to expand)

🆕 New here? Installing for the first time

Before you start — check two things:

• Your phone needs an Adreno GPU (Snapdragon). Mali, Xclipse and PowerVR phones will get sound over a black screen. There is no warning for this yet, so please do not install it to "see what happens".
• Turn on one Android setting first: go to Settings → Developer options → Disable child process restrictions and switch it on. Do not see Developer options? Go to Settings → About phone and tap Build number seven times, then it appears.
  Without this switch, Android randomly kills the Steam client and your session just dies for no visible reason. Some phones do not have the switch at all — on those, this build will not work yet.

Then:

1. Download and install the APK. There are three — just take standard unless you specifically use the pubg or ludashi build already.

2. Open the app and go to Contents → Linux Runtime → Download. This is about 755 MB, once. It is not in the APK, so this step is required.

3. When it finishes, a Steam (Linux) entry appears in your games list. Tap it.

4. First launch takes a few minutes. You will see a loading screen — Steam is downloading and updating itself. There is a clock on screen so you know it is alive. It may restart itself once; that is normal.

5. Sign in with your Steam account. Password, or the QR code with the Steam mobile app — both work.

6. ⏳ Now wait. Do not install a game yet — this is the part people get wrong.

   Steam fetches Valve's ARM64 Proton by itself. It may not start downloading on its own — watch for an install box for Proton Experimental (ARM64) (about 2 GB). If your phone has an SD card, Steam will ask where to put it: internal storage or the SD card. Pick one and tap Install. If nothing appears, check the Downloads page — it may be sitting there waiting on that choice.

   When the download finishes, still do not touch anything. The loading screen comes back saying "Steam is restarting once…" — the client restarts itself automatically. That restart is what makes every game you install run properly. Let it happen; Steam reopens on its own, still signed in.

   ⚠️ Installing a game before that restart breaks it. Steam grabs the wrong set of tools — about 1.7 GB you will never use — and the game just fails to launch with no error message. Wait for the restart. It is a minute or two.

7. Once Steam has come back on its own — now install a game from your library and play it. Nothing to configure, nothing to pick.

That's it. Your existing Wine containers and games are completely untouched by any of this.

Optional tweaks — the ⚙️ next to the Steam (Linux) entry has resolution (720p by default, because Steam's own interface is expensive to draw), drivers, audio, frame generation and the HUD.

⬆️ Already running the Linux Steam client?

From pre-release 1: install this APK over your current install. That is all — nothing to re-download, and you stay signed in.

From the September 21 test build: two steps. Nothing to re-download.

1. Install this APK over your current install. Your data is kept — do not uninstall first.
2. Open Contents → Linux Runtime once.
   In the old build, Steam (Linux) lived inside a Wine container. It now stands on its own with its own settings. Just opening that tab moves your entry out of the container and carries your settings over (HUD, LSFG, audio, drivers).

Then launch Steam (Linux) from your games list as usual.

• ✅ You stay signed in. Your games, Valve's ARM64 Proton and your downloads are all still there.
• ❌ Do not remove or re-download the Linux Runtime.
• 🗑️ If you made a container only for Steam and nothing else lives in it, you can delete it afterwards. (The Linux Desktop entry stays in the container — leave that one alone if you use it.)
• If you skip step 2 it still launches, but it will keep using the old container's settings until you open that tab.

In-app updates: you will not be offered this automatically unless you turn on Settings → Include pre-releases. Stable users are never offered pre-releases.

🐞 If something goes wrong (both groups)

Post the whole session folder from Download/Bannerlator-LinuxSteam/session-<date>-<time>/. It is already scrubbed — tokens, Steam IDs and login files are masked or never copied, so it is safe to post.

Known and already on the list, no need to report: Steam Deck mode breaks game controllers, FlatOut shrinks to the corner after Guide → Resume, TF2 says "insecure", GTA V Enhanced does not run, Serious Sam Shatterverse is killed for memory, NFS Hot Pursuit Remastered faults. Everything was proven on one AYANEO Pocket FIT — reports from any other device are the single most useful thing right now.

What's New in pre-release 2

🚀 The Steam client's interface is back on the GPU

The Steam client draws its interface with Chromium, and Chromium names the video card through a small library called libpci. libpci decides how to read the PCI bus by checking whether it can see the /proc/bus/pci folder — which an Android app can — and then opens the device list inside it, which Android does not allow. When that fails, libpci does not return an error: it ends the whole process. So Chromium's GPU process died on its way up, every time, and after a few tries Chromium gave up on the GPU and drew the rest of the session on the CPU.

• ✅ An empty device list now answers that question truthfully from inside the runtime — nothing the app can see is on a PCI bus — and the GPU process stays up.
• ✅ Measured A/B (OnePlus 15, same install, same d-pad scroll through the Big Picture library): ~44 fps before, ~85 after, against a gamescope asked for 90; GPU-process crashes 12 → 0. On an AYANEO Pocket FIT the interface reads 117–138 fps.
• ✅ It takes effect at session start, so an installed runtime is fixed with no re-download. It only steps in when the real file is unreadable, so it can never hide real hardware.
• Found and fixed by maxjivi05 in WinNative (deff1ac6); ported here with thanks.

⚠️ Warnings before the download

Two failures used to end a session with nothing on screen and nothing in any log. Contents → Linux Runtime now checks for both before the 755 MB download:

• ✅ Android's child-process limit. A Linux session is dozens of processes, and Android 12 and later kill an app's extra child processes. The card says when that limit is still on; on Android 14 and later it has a button that opens Developer options, and on older versions it gives the one-line adb command, because there is no switch in the settings there. The app cannot change this setting itself — Android only lets the system do that. (Detection follows maxjivi05's in WinNative, e86cc2fc.)
• ✅ A GPU that is not an Adreno. The runtime draws with Turnip, an Adreno driver. On Mali, Xclipse and PowerVR a session comes up as sound over a black screen, so the card names your GPU and says so first.

🖥️ Scaling mode and scaling filter

Two new rows in the Steam (Linux) settings, handed straight to gamescope:

• ✅ Scaling mode: Auto, Integer, Fit, Fill or Stretch.
• ✅ Scaling filter: Linear, Nearest, Pixel, FSR, NIS or SGSR. SGSR is Qualcomm's own upscaler, made for Adreno.
• They only change anything when a game renders below the session's resolution. Only values this gamescope accepts are ever passed, because an unknown one would stop the session from starting.
• For a frame cap, use the in-game drawer's FPS limit.

🎮 Controllers

• ✅ Only the controllers you actually have are listed to Steam. Four were always listed, with one real pad behind them and three that never moved. Now it is one node per connected pad, plus one for the on-screen controls; a pad plugged in mid-session still appears.

🐧 proot

• ✅ A crash fix. If the runtime's own proot is missing — a download cut short, or an older runtime — the app falls back to the proot built into the APK. It was handing that copy an option it does not have, which is fatal before anything starts: the session died instantly, with no window and nothing in the log. The option now only goes to the binary that takes it. (The same fault was found independently in WinNative, b6b2fce8.)
• ✅ Faster memory handling. proot copies data between itself and the programs it runs — every file path, for a start. It did that eight bytes at a time; it now moves each piece in one call, and it no longer trips over the tagged pointers Android puts on memory. (From maxjivi05's WinNative, 290c5314 and 0c71304a.) This only affects the APK's own proot, which the runtime's usually replaces.

🎛️ Steam Deck mode — experimental, and off by default

A Steam Deck mode switch in the Steam (Linux) settings runs the client the way it runs on a Steam Deck. That brings Steam's Quick Access Menu, with its performance page — the frame limiter and scaling controls.

• ⚠️ On device, it breaks game controllers. Steam takes the pad over through Steam Input, the way a real Deck always does, and hands the game a virtual controller that never arrives here. Steam's menus keep working; the game gets nothing. Turning Deck mode off brings the controls back.
• ⚠️ It shows a Steam Client update under System → Software Updates that cannot install. Do not press Apply. The ARM64 client is only published on the beta channel, and Deck mode switches the client to the Deck's stable channel, where there is no ARM64 build.
• ⚠️ The Quick Access Menu's performance overlay cannot be turned on: on a Deck it is drawn by a program the runtime does not ship.
• So it only turns on through a warning that lists all of this, with a red line under the switch while it is on.
• ✅ Deck mode no longer throws the client into a restart loop. It used to also claim to be SteamOS, which changed the client's update channel on disk and left it restarting to install an update that could never land. That flag is gone, the update channel is put back before every start, and any client update that keeps asking for a restart is stopped after three tries.

🧪 Three experimental rendering switches

The Performance (experimental) part of the Steam (Linux) settings also has three switches that make the chain drawing Steam's interface cheaper: Threaded GL (mesa_glthread), Lazy descriptors (ZINK_DESCRIPTORS=lazy) and Skip GL error checks (MESA_NO_ERROR). All three are on by default. None is measured on this device yet — if you try them, change one at a time. Whatever is in effect is written into the session's device.txt.

📝 Logs

• ✅ Session logs now keep the first 600 lines of a big log as well as the last 3000. The GPU-process fault above only ever wrote its reason while starting up, and a log trimmed to its end could not show it.

🐧 Pre-release 1 — everything since 3.1.2: the Linux Steam client (tap to expand)

🐧 The Linux Steam client

Valve ships a native ARM64 Linux Steam client. Bannerlator now runs it, inside a small Arch Linux ARM root filesystem, under Valve's gamescope compositor, on top of the same embedded Wayland compositor 3.1.2 introduced. What that means in practice:

• ✅ It is the real client: sign-in (password, QR, Steam Guard), the library, the store, downloads with Steam's own resume and verification, cloud saves, the overlay, friends and chat, Big Picture and the desktop UI, controller configuration, the shader pre-cache.
• ✅ Games run through Valve's ARM64 Proton (the depot the client downloads, wrapped as a Bannerlator Proton (ARM64) compatibility tool that runs it without the Linux runtime container Android cannot provide). Wine, DXVK, VKD3D and FEX are Valve's own, matched to each other. Only the Turnip driver is ours.
• ✅ No container. The client has its own settings entry; no Wine prefix is created or touched. Your existing containers, games and shortcuts behave exactly as before.
• ✅ Your games in one place: the app's own game folders (phone and card) are the client's library folders, so a game the app installed shows up installed in the client, a game the client installs lands where the app would have put it, and nothing is ever copied. Uninstalling in the client releases it in the app.
• ✅ The account's owned games and the anti-cheat runtimes (BattlEye, EAC) are mapped to the ARM64 tool before the client can reach for anything x86.
• ⚠️ First-run window: a game installed in the couple of minutes while Valve's ARM64 Proton is still downloading gets Steam's own tool chain assigned for that session (about 1.7 GB of downloads it then cannot use). The automatic restart when the layer lands fixes the assignment; the extra download stays. Launching a game in that window fails quietly. After the restart there is no window.

🧭 A first run that takes care of itself

Tested from a clean install, start to finish, and each of these was a real problem on the way:

• ✅ Loading screen until the client draws its first frame: the runtime's milestone, the client's own download percentage, a clock, and a rotating hint. It comes back for the client's self-update restart and for the compatibility-layer restart, and leaves on the first frame — the picture arrives with Steam's start-up chime, not five seconds after it.
• ✅ The compatibility layer is fetched after you sign in, not before (a signed-out client silently drops the request). When it lands, the client restarts itself once so everything installed before or after that point runs through it.
• ✅ A fresh install starts on Turnip. The old default was the proprietary driver, which cannot share frames with the compositor: sound over a black screen for every new user.
• ✅ Opening the Steam (Linux) settings no longer crashes on a fresh install (its entry has no Wine, Box64 or FEX to speak of, and the editor assumed it did).
• ✅ A session that dies before the client ever draws shows its exit status and log folder for a moment instead of a flash of black.

🔊 DirectAudio, and a microphone

• ✅ Games in the client use DirectAudio (the same low-latency Android path Wine games use), chosen in the entry's settings.
• ✅ The Steam client gets an input device — DirectAudioMic — with a working voice slider, proven in Steam's own voice tester. Five separate faults sat behind "no input device"; they are all gone.
• ⚠️ In-game voice chat with real people has not been tested yet.

🎮 Controllers and input

• ✅ The client sees a real Xbox 360 controller (an evdev device the app feeds), including the Steam button, so Big Picture, the overlay and Steam Input work as on a PC. The on-screen pad appears when no controller is connected.
• ✅ The client has its own input interposer instead of sharing Wine's.
• ✅ Wayland: real multi-touch (wl_touch) instead of a synthesised mouse; the guest's real cursor and its hide requests are honoured; the overlay pointer hides when idle or when a controller is driving; the soft keyboard types capitals and shifted symbols.
• ⚠️ The Steam Controller puck is still untested (carried over).

🖼️ Drivers

• ✅ Three kinds of Turnip now, and the app knows which is which. The regular Android driver puts frames on the screen; the -Wayland builds draw Wine games on Wayland; the new -Linux builds (glibc) draw the Steam client and its games. Banners-Turnip builds all three, and the importer sends each zip to the list that can actually load it — no more "imported, but not offered".
• ✅ The Steam (Linux) entry has a draw driver row (the Linux Turnip) beside the display driver (the Android Turnip), each explained in place.
• ✅ Turnip stops advertising present timing without calibrated timestamps (a crash source on the client's path).

⚙️ Cores, refresh, resolution

• ✅ The client gets all eight cores; Steam pins its own interface renderer to five by default, which is right on a PC with a game running and wrong when the client is all there is. Games get their own core list, separately.
• ✅ Sessions run at the screen's highest refresh rate, never the frame cap.
• ✅ 720p by default for the client (its interface is the most expensive thing a session draws); change it in the entry's settings.

📚 Library, storage, downloads

• ✅ Two libraries — internal storage and the card — presented to the client as its own library folders; downloads land on the card when you choose it; free space is the library's, not the phone's.
• ✅ Installs the client made are adopted by the app's store database (size from the manifest, the build the client put there); an uninstall in the client releases the game; a stale prefix link is recovered instead of hiding a game.
• ✅ Shared redistributables are marked as already run in every prefix, including one the client creates mid-session — no x86 installers starting under emulation and hanging a first launch.

📝 Logs

• ✅ One folder per session in Download/Bannerlator-LinuxSteam/session-<date>/: the session log (proot, gamescope, the client's own output), a device report, a network report, controller diagnostics, the audio daemon's log, Android's crash buffer as it stood when the session ended, and the client's own logs.
• ✅ The client's logs are scrubbed before they are copied: session tokens, GUIDs, Web API keys and Steam IDs are masked; loginusers.vdf, config.vdf and the ssfn files are never copied. A log bundle is safe to post.
• ✅ Collection happens on the close path, cheap pieces first, so it finishes before the session is torn down.

🛠️ Smaller

• ✅ The in-game drawer and the HUD describe a Linux session as what it is (its own graphics API, not the container's leftovers).
• ✅ A NetworkManager stand-in answers the client's connection questions (Settings → Internet no longer breaks).
• ✅ GStreamer plugin libraries Proton needs are shipped; a competing Steam client on the device is named before the session starts and stopped, since it takes the account's session.
• ✅ The seccomp probe that could kill a session for its own reasons is gone.
• ✅ CI bounds the informational unit-test step (it hung a build for 25 minutes once).
• ✅ Three session fixes ported from WinNative (maxjivi05, feature/wayland-gamescope): sessions that never started, black ones, and the network stand-in.

What it can and cannot do right now

Can:

• Steam: sign in, browse, install, update, verify, cloud-sync and play games from your library, with the overlay, Big Picture or the desktop UI, on a controller or on the touch screen.
• Games: the Source titles, GTA V (Legacy), NFS Most Wanted and Payback, FlatOut 1 and 2, Brawlhalla, DiRT Showdown — playing, on one device.
• Sound: DirectAudio for games, a microphone for the client.
• Drivers: pick the drawing Turnip per entry; import Linux builds from Banners-Turnip.
• Scaling: gamescope's scaling mode and filter per entry, FSR, NIS and SGSR included.
• Also: frame generation, screen effects and the HUD on the client's sessions, session log bundles you can post.

Cannot yet, or not proven:

• Mali, Xclipse and PowerVR: nothing. The runtime's driver is Turnip. The app now says so before the download.
• Phones without the "Disable child process restrictions" switch: the session is killed at random. The app now detects the limit and warns before the download; a one-tap fix with root or Shizuku is still to come.
• Steam Deck mode: breaks game controllers — Steam's menus work, games get no pad. Off by default, behind a warning.
• Steam Input for games (per-game layouts, remapping, gyro): the virtual controller Steam Input hands a game does not reach it yet. Games read your pad directly instead, which works.
• FlatOut shrinks to the top-left corner after Guide → Resume game. FlatOut 2 does not.
• GTA V Enhanced does not run (a null call in x86 code under FEX, ~2 minutes in). Serious Sam Shatterverse is killed by Android for memory during its shader burst. NFS Hot Pursuit Remastered faults inside FEX.
• TF2 "insecure" — open, see above.
• Voice chat with people — untested. Remote Play, streaming, family sharing — untested.
• Join-a-friend / invites — built, not proven.
• Steam Controller — untested.
• The client's desktop session (the Linux Desktop entry) has had far less testing than Big Picture.
• Leaving the app pauses the session; come back and it resumes. That is by design.

Coming in later pre-releases — your other games inside the Steam client

None of this is in pre-release 2 yet; it is the next line of work, in this order:

1. Custom games in the client's library. The games Bannerlator already runs in its Wine containers — your own installs and shortcuts — added to the Linux Steam client's library as non-Steam games, with their artwork, so the client is one place to launch everything. Launching one hands it to the app's container, not to Valve's Proton.
2. GOG, Epic and Amazon games in the same list. The titles the app's store pages installed from GOG, the Epic Games Store and Amazon Games appear in the client as custom games too, launched through the app the same way, with their store's own sign-in and cloud saves staying with the app.
3. The other way round: a game installed by the Linux client showing up in the app's library with the same artwork and per-game settings it has today (the library sync already covers Steam installs; the store pages will follow).
4. Client updates from the app, a logs manager for the session folders, and touch tap accuracy in Big Picture.

What is left — fixes and performance

1. The process-limit switch: the app now detects it and warns. Still to do: flip it with root or Shizuku where the phone allows.
2. Steam Input's virtual controller: make it reach games, which is what Steam Deck mode needs and what per-game controller layouts need.
3. FlatOut's shrink after Resume: work out what sizes the game's picture down when it comes back from the Steam menu.
4. The first-run window: keep Steam's own tool chain from being pulled in when a game is installed before the layer lands.
5. TF2 secure status: connect to a real secure server with -condebug and let the game say why.
6. A tester matrix beyond one device: Adreno 830/840 phones, Thor, and the phones that reported black screens.
7. Performance: measure the three experimental rendering switches now that the interface is on the GPU, and trim what the client costs while a game runs.
8. The list above: custom games, then GOG / Epic / Amazon titles, in the client's library.

Logs, if something goes wrong

• Download/Bannerlator-LinuxSteam/session-<date>-<time>/ — the whole session: session.log (proot, gamescope, the client's output), device.txt, network.txt, fake-input.txt (controllers), audio.log, crash.log (Android's crash buffer), and steam/ with the client's own scrubbed logs.
• Download/Wayland-logs/wayland-<date>_<time>.log — the compositor: the driver it loaded, windows, frames on screen per 10 s.
• device.txt lists the Steam (Linux) settings in effect — Deck mode, the rendering switches, scaling — so a report says what was set.
• Post the whole session folder; it is scrubbed for that purpose.

⚠️ Carried over — still open

• Everything listed as open in 3.1.2 is unchanged here:
  • HDR helpers per engine, scRGB, the HDR boost on phones that don't brighten on their own;
  • TV launch: Home and reopen, match resolution, the output-mode picker;
  • real 710/720/722 testing of the bundled Wayland drivers; which a8xx build is best;
  • 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 Linux Steam client does not use these layers at all: its games run through Valve's own ARM64 Proton, which the client downloads.

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.)

---

🙏 Credits (tap to expand)

The Linux Steam client runtime is built on:

• Valve — the Steam client, gamescope, Proton and the ARM64 Proton depot, the Steam Linux Runtime;
• WinNative (maxjivi05, feature/wayland-gamescope) — the session fixes ported here: the seccomp lesson, the NetworkManager stand-in, the fake-evdev controller layer, and the library and library-folder work the runtime grew from;
• Termux's fork of proot (the unprivileged root the runtime runs in), Arch Linux ARM (the root filesystem), FEX-Emu (Valve's x86 translation on ARM64);
• Mesa / Turnip (the Freedreno and Mesa teams) — the glibc builds are from The412Banner's Banners-Turnip.

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 Linux runtime's integration: the container-free session, the compatibility tool, the two libraries, DirectAudio and the microphone, the loading screen, the log bundles;
• the embedded Wayland compositor, with its pointer-lock, clipboard, text-input and multi-touch 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.