* 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>
* feat: stand in for /dev/uinput so Steam Input's virtual pads reach games
* feat: present the pad to the Steam client as a Steam Deck controller over hidraw
* docs: log the uinput stand-in and the Steam Deck controller
* feat: feed the handheld's gyro and accelerometer to the Steam Deck controller
* feat: let the Steam page choose between the Steam Deck controller and the Xbox 360 pad
* feat: Deck back grips and trackpads on the second screen
* fix: serialize ring teardown with its writers, fall back to the Xbox pad when the Deck cannot be set up, and read motion only for a Deck
* fix: keep the second screen's choice through sleep and bring it back on wake
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.
* Add ownership-aware Steam game folder imports
* Fix Steam title lookup and installed game manifests
---------
Co-authored-by: MaxsTechReview <6025299+maxjivi05@users.noreply.github.com>
The desktop forced a software cursor (WLR_NO_HARDWARE_CURSORS=1) because
labwc's cursor never showed when handed to the app's compositor. With a
software cursor wlroots never scans out: every frame of a full-screen game
was composited by labwc first ("Direct scan-out disabled by software
cursor", 2284 times in one Adreno 825 report).
Why the cursor never showed: wlroots' Wayland backend attaches and commits
its cursor surface before wl_pointer.set_cursor gives it the cursor role,
and sets it again with nothing new committed each time the pointer enters.
The compositor released a role-less surface's buffer on commit, so the
cursor surface had no image by the time it became the cursor.
- A role-less surface's last buffer (cursor-sized only) is held until the
next commit; set_cursor publishes it, and a repeat set_cursor of the
surface already shown unhides its last image.
- A dma-buf cursor is read back after the client's implicit render fence,
as the zero-copy path waits for it.
- The desktop no longer forces a software cursor.
Device-tested on the AYN Thor (Adreno 740, 1920x1080): labwc's own cursor
is drawn, with its shapes (I-beam over a terminal); wlroots logs "Direct
scan-out enabled" for a full-screen glxgears. At the same 60 fps on screen
the GPU is 3.0 % busy against 4.6 % with the software cursor, both at
550 MHz.
mangoapp's VRAM figure on a Qualcomm driver comes only from the gpu_mem_total
trace event. The tracefs stand-in's event list now declares that event as
Android kernels do, and reading the stand-in's events answers with one
record carrying the total KGSL reports in /sys/class/kgsl/kgsl/page_alloc,
which every Adreno under Android has and the app can read.
Three things kept Valve's mangoapp from drawing the overlay in a session:
- GLFW 3.4 takes XDG_SESSION_TYPE=wayland with WAYLAND_DISPLAY set as
Wayland-only, and mangoapp needs gamescope's X server; the wrapper sets
XDG_SESSION_TYPE=x11.
- On a Qualcomm display driver it opens a tracefs instance for the GPU memory
total and aborts when that fails, which it always does for an Android app.
The session preload now places the instance in an empty directory of its own
when the real one cannot be made.
- gamescope sends it each frame's timings through a System V message queue,
and Android kernels have no System V IPC. sysv.c now emulates the queue
operations gamescope and mangoapp use, beside its semaphores and shared
memory.
The Quick Access menu's performance overlay toggle and level slider stayed
greyed out: the client exposes SteamClient.System.Perf only with -steamos3,
which SteamOS and Armada pass alongside -steamdeck. Deck mode now launches the
client with both. The session already puts package/beta back to the forced
branch before every start, which keeps -steamos3's own branch switch from
turning into an update loop.
The Deck mode switch moves from the Performance page to the Steam page's
Client settings, next to the client branch it selects by default.
Twice today a session's Xwayland aborted from one thread ("The futex
facility returned an unexpected error code"), proot lost the tracee, and
the process lived on reparented to init: proot's seccomp filter, with no
tracer left, answers ENOSYS, so Xwayland's main loop logged
"WaitForSomething(): poll: Function not implemented" until something killed
it - 9 GB after Dolphin, 13 GB after PPSSPP. --kill-on-exit and the tree
sweep only reach what proot still traces, and the straggler sweep ran only
at the next session's start.
Now a session stop also kills every process of ours whose executable lives
in the Linux runtime, and bannerlator-session keeps only the first
BL_LOG_CAP bytes (256 MB) of session.log, draining the rest so a writer
that filled it is not killed by SIGPIPE.
Cemu never showed a frame on DroidDeck: its Getting Started dialog blocked
every first launch (the folder picker cannot reach ROMs), the session's
controller helper aborted it, and the desktop's Vulkan renderer drew no
cursor. With the Turnip KGSL fix in the driver and the haptic-optional
Cemu in the catalog, this makes the app side complete:
- bannerlator-pad-defaults seeds Cemu's settings.xml once: the Wii U games
folder, Vulkan, and Cubeb audio on the default device for both the TV
and the GamePad speaker at full volume (Wipeout 3 plays through the
GamePad; Cemu's own default is 20 %).
- The Cemu tile launches full screen (-f).
- libfakeinput.so is preloaded into every session process and exported its
static C++ runtime (~7000 symbols); programs unwound through it and
aborted (shadPS4 in pthread_exit, Cemu's controller thread). Link with
--exclude-libs,ALL, and fail the build if the runtime leaks out again.
- On the Vulkan and GLES desktops the pointer worked but no cursor was
drawn: wlroots hands the cursor to the app's compositor, which draws
none. WLR_NO_HARDWARE_CURSORS=1 makes labwc composite it itself.
Device-tested on the FIT: Super Mario 3D World in-game at 35-37 fps with
sound, Deus Ex HR DC and Wipeout 3 launch with sound; RPCS3, Dolphin and a
Steam session (FlatOut) unchanged on the same driver.
The session's proot runs with -i <app uid>, and the rootfs names that uid
root, so the client calls itself root while geteuid() returns the app's
uid. The read-only retry required geteuid() == 0 and never ran: the
Proton Experimental (ARM64) update still failed with Missing file
permissions on wineopenxr.dll (2026-09-26 16:07, 2,471 read-only files).
Also recognise the client by the path it was started by: the kernel's
/proc/self/exe names proot's loader for every process in the session.
The client runs as proot's root, which the kernel does not see, and
leaves many content files read-only; an update that rewrites one was
refused (EACCES) and cancelled with "Missing file permissions"
(Proton Experimental (ARM64), wineopenxr.dll). For the client's own
processes, a refused write-open of a file the app owns now gets the
owner's write bit - on the file, or on the directory a new file goes
into - and one more try. Games and Wine keep ordinary permissions.
With Steam publicbeta 1790380355 the client spent 27 s in its post-logon
compat phase and dropped the install request the session sent 15 s after
sign-in, so a clean install never offered Proton Experimental (ARM64).
Wait for the console log's "Waiting for compat in post-logon took" (90 s
at most), then ask, up to three times a minute apart until the install
starts.
With the check reached from the client's own runs right after login, the Steam client segfaulted
within seconds, four sessions out of four; the same build without the check (test/bisect-no-launch-check)
and the last build before it both reach Big Picture. Now every run that is not a game launch -
the client's probes, app id 0 - is left exactly as before. Each check logs one line.
Steam runs its graphics probe through every registered Proton at once after login, all in
compatdata/0. Prefix system32 links point into the Proton that set it up last, and the other
Protons' Wines, running outside Proton's pfx.lock, wrote their builtin DLLs through them into that
Proton's tree (device: GE's FEX DLLs became Proton Experimental's at session start).
- bannerlator-steam-compat: both wrappers (Valve's depot launcher and the third-party
bannerlator-proton-wrap) give a tool-0 run STEAM_COMPAT_DATA_PATH=.../compatdata/0-<tool>, and
before every other launch check the Proton's files against the app's desired.tsv and put back
anything that differs (same Proton build only), logging to reapplied.log.
- ComponentsManager writes desired.tsv plus unpacked copies of the packages in use into the
runtime after every change; the page and the drawer show 're-applied at launch'.
Tried on device: with a session bus the client still sat on "Switching to Desktop..." and
never reached its legacy path (no "No SteamOSManager support" line, steamos-session-select not
called), so the bus was not what it waited on. Sign-in was unaffected.
This reverts commit 40fc5463f3.
Big Picture's Switch to Desktop asks SteamOS Manager over the session bus before falling back to
steamos-session-select (steamui.so). The Steam session had no session bus, the ask never
finished, and the client sat on "Switching to Desktop..."; the new stub was never called. A
bus with nothing on it answers at once, and the client takes its legacy path.
- The front end's "Steam Desktop UI" started a Steam session without -gamepadui, and the client
put itself into Big Picture under gamescope anyway. It now opens the desktop with Steam's
desktop client started in it (BL_DESKTOP_STEAM, the desktop's autostart, the same
bannerlator-steam-launch the menu's Steam entry uses).
- Big Picture's power menu "Switch to Desktop" runs steamos-session-select, which did not exist,
so it sat on "Switching to Desktop..." for ever. The new stub leaves the app a request
(session=desktop in the steam-launch file); the app ends the Steam session and starts the
desktop with Steam's desktop client open.
AutoPlace on its own left the resized window in the top-left corner; with policy="center" it
opens in the middle of the desktop. Tried in a running desktop (labwc --reconfigure).
melonDS remembers a 1x window for the front end's full-screen toggle, too small on a desktop.
A labwc window rule (only the desktop reads rc.xml) resizes it to 800x600 on open and places
it again by the desktop's centre policy.
The desktop set QT_QPA_PLATFORM=wayland for every program. The melonDS AppImage bundles only
Qt's xcb plugin, so from the desktop it exited at once: "Could not find the Qt platform plugin
wayland ... Available platform plugins are: xcb" (exit 127). "wayland;xcb" keeps LXQt on
Wayland and lets such an AppImage use Xwayland. Proven in a running desktop: labwc mapped
"melonDS 1.1".
The guide button's toggle returns to melonDS's saved window size. A 512x288 window (1x wide,
16:9) is stretched by gamescope to fill the panel, menu bar and cursor with it; at 2x and up
the menus stay at their real size, tiny on a handheld. Written once, with the layout.
Hybrid repeats the big screen, small, above the bottom one. Horizontal with the top screen
emphasised fills the panel's height with the top screen and centres the bottom screen in the
rest. Installs set up with Hybrid (or still on melonDS's defaults) move once.
- bannerlator-pad-defaults: new installs start on the Hybrid layout with sharp pixels; an
existing install is moved once, only where still on melonDS's defaults (marker keeps later
choices). Guide = HK_FullscreenToggle. The user's DS/DSi BIOS, firmware and NAND are found in
ROMs/nds/{bios,firmware} and filled in only where melonDS has no path.
- Front end starts melonDS with -f, at the panel's own resolution unless the user chose one.
- From the rail: -batch -bigpicture -fullscreen (the same flags as PCSX2's,
src/duckstation-qt/qthost.cpp) - straight into the game, gone when it is quit.
- bannerlator-pad-defaults: a new player starts on DuckStation's first-time setup
with the BIOS folder in the ROMs folder (psx/bios, created, or an existing one),
psx as the game list, Vulkan, the controller on Player 1 and the guide button
on the pause menu (not the analog toggle). An existing install gets the guide
and game-list changes, and once, its own empty BIOS folder moved to the ROMs
folder and Automatic made Vulkan; later choices are kept. Users bring their own
BIOS and games.
Quake III Arena, Team Arena, Return to Castle Wolfenstein and Jedi Academy set their own
resolution and switch the display to it. Under gamescope with the ARM64 Proton that switch is
refused ("calling CDS: failed, bad mode") and the game never gets OpenGL - device-seen on a
Retroid Pocket 5 on Proton Experimental build 25406135 - and a window left at the game's own size
draws small in a corner. Both wrappers (Valve's depot and an adopted GE or CachyOS) now add
+set r_fullscreen 0 +set r_mode -1 +set r_customwidth/height at BL_WIDTH x BL_HEIGHT for those
app ids, unless the user's launch options already set the video mode; the choice is logged.
MaxsTechReview