A URL written to $BL_LAUNCH_DIR/steam-url goes to the running client, as
the stop request does: a game can be started (steam://rungameid/...)
without touching the screen, for either client.
With FEX's host thunks installed, the client runs with a ThunksDB of GL
and Vulkan (FEX_THUNKCONFIG): its Vulkan and GL calls go to the runtime's
own Turnip and Mesa with the session's settings for them, and it gets the
arm64 client's Chromium flags (-cef-force-gpu, ANGLE on Vulkan). Without
the thunks, or with BL_X64_SOFTWARE=1, software rendering as before.
'bannerlator-steam-x64 --gpu' answers for the session.
libblfastpath broke FEX's 32-bit mode (SIGILL at start), so the x86-64
client ran with PROOT_FP_OFF=1 and every one of its syscalls went the
slow ptrace way. In a FEX process it now reads the program FEX is about
to run and stays on for a 64-bit ELF only. bannerlator-steam-x64 drops the
blanket switch (BL_X64_FP_OFF=1 brings it back).
- DroidDeck direct: a compatibility tool the x86 client gets in its own
compatibilitytools.d, running a native Linux game with Valve's scout
library runtime under FEX instead of the Steam Linux Runtime container
(pressure-vessel, which needs bwrap). Left 4 Dead 2 (BL_X64_DIRECT_APPS)
is mapped to it in the x86 config while that client is not running.
- The session shim and the controller reader are also built for i386 and
preloaded through glibc's $LIB, so 32-bit games get them too.
- The runtime's bin/ on the client's PATH (steam-runtime-launch-client).
- No -steamdeck -steamos3 for the x86 client yet: its SteamOS audio
manager aborts on the runtime's PulseAudio 13 (pa_operation_get_state).
A Steam setting (Client > Steam client: ARM64, the default, or x86-64
under FEX, experimental) sent as BL_STEAM_CLIENT_ARCH. With x86_64 the
session starts Valve's x86-64 client through bannerlator-steam-x64 in its
own home instead of steamrtarm64/steam, so the Play button gets every fix
the session has (system bus and NetworkManager stand-in, gamescope, Deck
and Big Picture UI, stale locks, branch sync, restart loop, stop watcher,
logs, core pinning); what is only for the arm64 client (ARM64 Proton and
its mapping, redist seeding, Decky, the steamclient.so probes) is skipped.
bannerlator-steam-x64 gains --prepare and --exec for that; its own library
replaces the shared steamapps link.
The client ran on FEX's defaults (half-barrier TSO, full-precision x87).
Use the app's default game preset, PERFORMANCE_TSO (WinNative's), as the
FEX_* variables both FEX builds read; values already set win.
From an audit of bannerlator-session against bannerlator-steam-x64:
- a system bus and the NetworkManager stand-in when none is up, stopped
with the client: the client showed no connection on the desktop
- stale .crash/steam.pid/htmlcache Singleton* cleared before a start
- package/beta matched to -clientbeta before every start (rc=42 loop)
- BL_CLIENT_CPUS re-pinning of the client and its web helper every 5 s
- pathcache.c and perms.c also recognise steamrt64 (the path cache saved
most of the arm64 client's start-up; the write override covers its
self-update)
The session's pads exist for a guest program only through libfakeinput
(the FAKE_EVDEV_* rings), which was built for arm64 alone, so the x86
client saw no controller. Build it natively for x86-64 too, stage it, and
preload it through the FEX rootfs next to the session shim.
Traced per process through FEXServer: every x86 web helper read
/proc/self/status (the string sits in libtier0_s.so) and died of SIGTRAP
right after. proot is a tracer, so tier0 believes a debugger is attached
and breaks into it with int3 on the first failed assertion. The arm64
build only issues a stray svc there, which is why the session shim leaves
the arm64 web helper reading the real TracerPid. BL_WEBHELPER_HIDE_TRACER=1,
set by bannerlator-steam-x64, serves the x86 one TracerPid 0 as well.
A diagnostic: FEX's file log is opened without O_APPEND, so each process
overwrites the last. Through a foreground FEXServer every line carries
the pid and tid it came from.
On X11 Chromium sets up GBM on the render node Xwayland hands out over
DRI3 even with the GPU disabled, loops on KMS dumb-buffer ioctls against
the KGSL device, and never creates the SteamUI browser; the client
restarted it every 10 s. Without a GPU, Chromium's Wayland backend draws
to shared-memory buffers.
Hiding /dev/dri was not enough: Xwayland hands the render node out over
DRI3, and llvmpipe then loops on KMS dumb-buffer ioctls against the KGSL
device. LIBGL_DRI3_DISABLE=1 presents through plain X.
x86 Mesa and the Vulkan loader still enumerated /dev/dri, found the
session's KGSL node and looped on it (KMS dumb-buffer ioctls), and the
webhelper never brought a browser up; the client restarted it every
10 s. FEX resolves paths in the rootfs first, so an empty /dev/dri there
leaves llvmpipe and lavapipe.
The desktop exports zink over the arm64 Turnip ICD (GALLIUM_DRIVER,
MESA_LOADER_DRIVER_OVERRIDE, VK_ICD_FILENAMES); x86 Mesa found no driver
and the client died on glXChooseVisual. Clear them and use llvmpipe.
LD_LIBRARY_PATH beats the system folders regardless of order, so the
platform's own older libc.so.6 shadowed the rootfs's (GLIBC_2.38 not
found). Keep only the libraries the rootfs lacks.
Valve's platform runtime files carry each library under its full version
only; pressure-vessel makes the soname links when it builds a container.
Link them into a folder of our own and run the rootfs's ldconfig -n there,
so libgtk-x11-2.0.so.0 and the rest resolve.
steamui.so needs GTK 2 (libgtk-x11-2.0.so.0), which the SteamRT container
provides and FEX's Ubuntu 24.04 rootfs does not. Append Valve's own
steamrt3c platform library directories to the client's library path,
after the rootfs.
After its self-update the x86 client re-executes itself in the SteamRT
container through pressure-vessel-wrap, which needs bwrap. The FEX rootfs
with the client's steamrt64 libraries is the container here, as proot is
for the arm64 client: set the client's recursion guard. Restart on exit
code 42 the way steam.sh does.
The x86 client stops at start on a tier0 assertion: semget answers ENOSYS,
as Android kernels have no System V IPC (traced with a DEBUG_STRACE FEX).
The session shim that gives the arm64 client its semaphores is now also
built as native x86-64 and preloaded through the FEX rootfs's own
ld.so.preload. SessionFiles stages it and bannerlator-steam-x64 into
installed runtimes.
The x86 client carries pressure-vessel and will not start when
steam-runtime-check-requirements cannot create a user namespace; no
Android app can, and proot is the container here as it is for the arm64
client, which has no such probe. STEAM_RUNTIME_STEAMRT points it at
Valve's runtime linked file by file, with only that probe replaced.
Through steam.sh, steam-runtime-check-requirements' bwrap probe needs user
namespaces, which proot does not have. Run the SteamRT3 client directly
with STEAM_RUNTIME=1 and its own library folders, after the ~/.steam
links steam.sh would make, as bannerlator-session does for steamrtarm64.
The legacy ubuntu12_32 path in steam.sh refuses to start without user
namespaces (steam-runtime-check-requirements, exit 71). On the beta branch
STEAM_FORCE_CLIENT=steamrt64 makes steam.sh run steamrt64/steam directly,
the x86 twin of the arm64 client the session already runs.
With libblfastpath loaded into FEX, every i386 program died with SIGILL
(FEX's fatal trap) before logging was up, and steam.sh reported the
32-bit libc.so.6 missing. Bisected on device: the session's other two
preloads are harmless; PROOT_FP_OFF=1 lets i386 ld.so run.
Our proot answers openat2 with ENOSYS. FEX opened every rootfs path with
openat2(RESOLVE_IN_ROOT) and only fell back on EXDEV, so in a session
every x86 file lookup missed the rootfs and hit the arm64 guest: bash
under FEX could not find libtinfo. GetEmulatedFDPath already follows
absolute symlinks inside the rootfs, so a plain openat relative to the
rootfs fd is the same lookup. The rootfs also gets an empty
ld.so.preload, so the guest's arm64 preloads are not tried.
FEX processes take the rootfs from FEXServer. The version probe started
one before FEX_ROOTFS was set, and later clients inherited its empty
rootfs. Still not enough on its own on the device: under investigation.
The arm64 Linux client never runs VAC: TF2 and L4D2 are refused by VAC
servers and no client log mentions VAC, because VAC modules are x86 code.
bannerlator-steam-x64 installs Valve's x86-64 client, FEX and FEX's
Ubuntu 24.04 x86 rootfs, and runs the client unchanged under FEX in a
home of its own, sharing only steamapps with the arm64 client. The arm64
client stays the default; the desktop menu gets an experimental entry.
The client reads config.vdf once, as it starts. A title installed during a
session got its per-app ARM64 Proton entry from the compat beat, but the
running client kept its own pick: native for a Linux build, which then sat
on "Downloading content (0%)" waiting for Steam Linux Runtime 2.0 and FEX
it can never run here (Left 4 Dead 2), or proton-stable for a Windows one.
The beat now runs the compat pass with --live, which notes titles it maps
while the client runs. Once each has finished installing and no game is
running, the session restarts the client through the existing restart-once
marker. Once per title and three times per session at most. The mapping is
re-applied before the client starts again, since it writes config.vdf back
from memory as it exits.
A Source-engine game says whether it started VAC-secure only in its own
console, which reaches a file only with -condebug. With the new Setup
toggle on (off by default), the launch wrapper adds -condebug to Source
and Source 2 titles and notes each launch; at the end of the session each
console.log written during it is copied, scrubbed, into vac/ and vac.txt
quotes the game's secure/insecure lines, any VAC lines in the client's
logs and which client builds are on disk. No connection to a server is
reported as inconclusive rather than guessed.
* Add your own apps to the Desktop page
An Add tile on Desktop takes a .sh script, an AppImage, a GitHub repo
(newest ARM64 AppImage release) or a Flatpak ID, with an optional name
and icon. Script folders are linked into the session, or copied when
they hold Linux programs (shared storage is noexec); folders outside
internal storage are bound at their own path.
Each app's page opens it under gamescope, edits its name and icon (with
icons suggested from its GitHub repo), checks a GitHub app for a newer
release and updates it in place, or removes it. Replaces the beta
AppImages section.
* Put Add at the end of the installable emulators
Installed emulators and added apps keep the top section, shown once there is one. Add closes the installable grid, or the installed one when nothing is left to install.
* Import DwarFS AppImages and their SVG icons
uruntime images built with sharun keep one program under several names
as hard links, which Android denies apps, so dwarfsextract aborted. The
extraction runs with proot's link2symlink, and each linked name becomes
a file of its own afterwards; their AppDir is followed through the
squashfs-root link.
An image's icon is a PNG of at least 128 px from the name its entry
gives, else its SVG (drawn with AndroidSVG), else the largest PNG, else
.DirIcon.
* Give AppImages the session's pads
sharun images start the app through their own ld.so, patched not to read
/etc/ld.so.preload, and drop LD_PRELOAD unless allowed, so the app never
loaded libfakeinput and saw no controller. The launcher now hands the
preload list over in LD_PRELOAD with SHARUN_ALLOW_LD_PRELOAD set.
Pad defaults also put Player 1 on the controller for yuzu-family
emulators, once, while it is still on the keyboard.
* Redesign the Add and Edit app dialogs
Source and appearance sit in two panels side by side, with a live
preview of the Desktop tile. A disabled primary button keeps an outline
so it still reads as a button.
* fix: carry the installed Steam build into imported games so Steam stops re-verifying them
A second-library game downloaded by WinNative was registered with a bare
manifest (no buildid or InstalledDepots), so Steam treated it as build 0 and
verified all ~92 GB of Final Fantasy XV through proot. Reuse WinNative's
.winnative-steam manifest, or a completed .DepotDownloader/depot.config, so
Steam only fetches what changed since the recorded build.
* fix: give queued Steam fresh installs of imported games the recorded build
Steam rewrites a bare import manifest into a fresh install at build 0
before downloading anything. While nothing is downloaded or staged, the
WinNative build is still safe to carry over, so Steam skips the full
re-download (FF7 Remake was queued for 98 GB this way).
* fix: mount the game storage at /mnt/droiddeck-sd
The second library was bound at /mnt/bannerlator-sd, a name left from the
Bannerlator port, which is what Steam shows in its paths and errors. Bind
it at /mnt/droiddeck-sd, keep the old path as an alias for links and
prefixes that still name it, move Steam's library entry in place, re-point
import links, read ownership snapshots taken under the old path, and key
added-game shortcut ids by the old path so their prefixes stay put.
* fix: restart Steam once when owned added games are confirmed
On a fresh install the importer runs before any ownership snapshot exists,
so every added game became a non-Steam shortcut and stayed one until the
client happened to restart. Once the watcher confirms owned titles that are
not imported, it asks the session for one restart, while no game runs and
no download is in progress, and the importer turns them into Steam entries.
* perf: answer Turnip's zero-timeout KGSL timestamp polls without blocking
Turnip polls a timeline point with IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID
and a timeout of 0, which KGSL reads as wait forever; Mesa does it under
a lock on every signalling submit, so vkd3d-proton, DXVK, gamescope and
Zink ran in lock-step with the GPU. The session preload now answers
those polls from the context's retired timestamp and passes everything
else to the kernel. Bannerlator measured a D3D12 demo at 614 -> 4335 fps
with the same answer in its Vulkan adapter. BL_NO_KGSL_POLL_FIX=1 turns
it off.
* perf: frame limiter, live panel refresh, opt-in GPU clock pin, cheaper cursor sync
- A per-mode frame limit (Steam and desktop settings, off by default):
gamescope's -r, the compositor's buffer-release pacer, the display
layer's frame-rate vote and a panel mode the cap divides evenly, as
WinNative's per-shortcut limit does. BL_FPS was always 0 and the
pacer's limit was never set.
- The compositor follows the panel's refresh rate when it changes
mid-session instead of reporting the rate read at start. (WinNative.)
- Performance > GPU: hold the Adreno clock at its top through KGSL's
power-control property, no root (Bannerlator's PerfGpuTurbo). Off by
default; cleared when the session stops and at the next app start if
a killed process left it set.
- The cursor image is copied across JNI only when its serial changes,
not on every pointer move.
* perf: stop re-seeding every prefix every 5 s, and run the library helpers only on change
- bannerlator-seed-redists stamped its change check from a block that
carried the current time, so it never matched: every prefix had ~32
keys appended to system.reg on every beat. The stamp now comes from
the names; Proton's prefix template is seeded too (date kept), with
WinNative's built-in list until the client has the install scripts.
- The library beat runs the seeder every 15 s and steam-compat only
when a directory it reads has changed, or once a minute.
- The client-core pin reads /proc itself and runs taskset -a only for
new processes or ones that grew threads.
- The games watcher backs off after a failed ownership probe and does
not probe while a game runs.
- The Proton launcher runs the newest ARM64 depot by build number, and
PROTON_USE_PIPEWIRE defaults to 0. (WinNative.)
* perf: Mesa's database shader cache, and proot's tracer above the guest
- MESA_DISK_CACHE_DATABASE=1 for the session: the file cache opens a
file per lookup and opens and renames one per store, each a proot
stop; the database is opened once and used with pread/pwrite.
- proot's single tracer thread is raised to nice -6 (under the
compositor's -8) two seconds after it starts, so the first guest
process it forks keeps nice 0. setpriority() directly, not
Process.setThreadPriority, which would also move its cgroup.
* feat(lsfg): take Lossless Scaling from Steam by itself, import it once owned, rebuild on update
- Lossless.kt owns the DLL and its shader cache. The copy the Steam
client installs (runtime library or the card's) is taken by itself
and taken again when the client updates it (size/mtime stamp). The
DLL is copied in and built into a cache named after its SHA-256, so
a new DLL hands the compositor a new path; a build that fails keeps
the working cache. Builds are serialized.
- The Steam session asks the signed-in client once per session whether
the account owns app 993090 until the answer is yes, then records it
and the app stops asking (BL_LOSSLESS_OWNED). Once owned, the frame
generation menu offers "Import Lossless.dll…", on the main screen and
in the session drawer; an import stays until Steam's copy changes.
- The compositor restarts the LSFG engine when its cache path changes,
and a new engine selection clears an earlier start failure, so an
updated DLL or a retry no longer needs the app restarted.
- The HUD says when LSFG is waiting on Lossless Scaling instead of
"starting"; frame generation strings are resources.
- Removed LsfgNative's unused DLL variant and cache-match calls.
* Find Lossless.dll in added Games libraries too
* LSFG: 120, 90 and 60 fps targets alongside 2x-4x
The pacer's target-rate mode picks 0-3 generations per game frame. While it
is warm the input ring and shared chain follow every frame, so frames that
generate nothing don't leave the next one without history.
* Credit LSFG: Camille LaVey / Eden, ported to WinNative and DroidDeck by @maxjivi05
* LSFG: aim 0.1 fps under the target so output never passes the refresh rate
* feat: run Flatpak apps through a proot bwrap stand-in and add a Flathub store
* feat: give Flatpak apps the KGSL GPU, the controllers and a CPU LLVM can target
* feat: Flatpak games on the desktop, Store apps on the Desktop page, safer remove
* test: cover the sandbox planner and store helpers; docs: explain Flatpak on DroidDeck
* fix: keep controller focus through Store tabs and app pages; show progress per Flatpak step
* fix: let Chromium, Electron and Firefox Flatpaks start without their own sandboxes
* fix: fetch Flatpak's supporting libraries when the runtime lacks them
* fix: add Flathub without a download, log store commands, keep Electron apps on X11 under gamescope
* feat: import ARM64 AppImages from storage and run them from the Desktop page
* fix: report failed Flatpak installs as failures and deploy runtimes that ship a resolv.conf link
* fix: let Flatpak create its repo where Android denies hard links
* fix: point store commands at the current network's DNS
* fix: keep failed Flatpak extensions non-fatal, give Electron AppImages a bus, X11 and time to relaunch
* docs: AppImage import and what x86 apps would take
* feat: put the Flathub Store and AppImage import behind beta toggles in Setup
---------
Co-authored-by: MaxsTechReview <maxjividen@gmail.com>
The Steam menu is an overlay that takes input without changing gamescope's focus
window. A fullscreen wine game minimizes itself when it loses input, and gamescope
only takes a window out of iconic when the focus window changes, so after Resume
the game stayed minimized: a black screen with its caption in the top-left corner
(Titanfall 2 on GE-Proton 11, proven on device).
gamescope patch 0112 remembers the iconify request and puts the window back to
NormalState before input returns to it, then hands focus over again so wine
restores and activates it. The session script also asks gamescope to restore the
game once input comes back from the client (GAMESCOPE_RESTORE_FOCUS_WINDOW);
BL_RESTORE_ON_RESUME=0 turns that off.
* perf: cache pinned downloads, skip unchanged proot rebuilds, and wait out a Docker Desktop restart in the local build
* perf: skip xalia and gamescope realtime queues by default, add a realtime toggle, default the mic off
* fix: show the saved Steam Deck mode on the Steam page before Performance has been opened
The session's watchers slept with sleep(1) and read files with cat, an
exec each under proot; they now wait in bash itself. steam-compat
writes its tool, the adopted wrappers and config.vdf only when they
change, the games watcher probes ownership when its matches change or
every five minutes instead of every 30 s, and Proton no longer inherits
the client's steamrtarm64 library path.