Player guide

Everything a player needs: how a game night works, what each game plays like, and help for the things that can go sideways — known issues, browser quirks, and their fixes. This guide is player-facing; developer docs live in the developer guide.

The basics

Everything stays in the room

LibreBash is offline-first. No accounts, no ads, no analytics, and no servers out on the internet — the only server involved is the host's own device, and it only talks to the phones in the room. Pass-the-phone games never touch the network at all. Play Together rooms run over your existing Wi-Fi, or over a local-only hotspot the host's phone creates when there's no shared network — so a night works just as well in a forest cabin as in a living room. Nothing anyone types, draws, or votes ever leaves the room's devices.

Two ways to play

Pass the phone — one device, handed around the circle. Between turns the app pauses behind a "Pass the device to Maya — I am Maya" gate so secrets stay secret, and on Android it offers once to pin itself to the screen so a borrowed phone stays in the game (the switch lives in Settings).
Play Together — one device hosts a room and everyone else plays from their own phone, or straight from a browser with no install at all. Every game on the shelf can run in a room; four of them — Draw What Now?, Buildboard, Dreamweavers, and Sketchy Sources — are room-only, because every seat acts at the same moment and one passed phone can't be in four hands at once.

Pick a game and its setup screen adapts: with no room open it asks for the roster to pass around; while hosting, it lists the room's phones with a deal-in switch per seat. The same settings — scoring, the turn timer, round options — apply either way, and the shelf's Pass the phone filter chip (under Play style) splits the shelf by which games can do without a room.

Rooms, hosts, and displays

Hosting is a shelf button away: Play together → Host → name the room and hit Open the room. The lobby shows a QR ticket and a four-letter session code; two switches shape who can get in — Require a session code (on by default) and Hide this room, which keeps it off network discovery so only QR/manual joiners find it.

Friends join from Play together → Join:

With the app — pick the room off the Rooms on this Wi-Fi list (discovery handles the address), scan the host's QR with the camera, or under Advanced type address:port plus the session code — the fallback for networks that block discovery.
Without the app — any phone camera scans the same QR and lands on a web page the host serves itself; typing the address works too. Browser players get the same seats, secrets, votes, and scores — nothing is watered down.
No shared Wi-Fi? The host taps Provide the Wi-Fi and the phone spins up its own local network — app users join it and the room in one scan; everyone else joins the Wi-Fi first, then the room (the lobby's code flips between Room and Wi-Fi for exactly this).

Once inside, everyone gets a seat: a name, an emoji, and a color — names are unique per room, and returning players get their identity back from the "played before" chips. The host then calls games off the shelf: setup shows the room's phones instead of a typed roster, the host can bench a seat from the toolbox (or the setup screen's deal-in switches), and anyone who joins mid-game waits for the next call. Between calls the room stays open — seats can even tap a game card to mark it as their pick for the next one — until the host ends the room or a client leaves.

Dropping is a stalled seat, not a dead one: the phone retries quietly in the background, the home screen keeps a Reconnect card up while a room is remembered, and rejoining lands the seat back mid-call — unfiled drafts and all. A seat that never comes back stops holding up the table: its pending writings get ghostwritten, its votes stop being waited on, and its turns get skipped.

The host runs all of it and can deal their own phone in or out per call — a host who stays out becomes the presenter, pacing the game and reading the room's screens. Displays are the other role: observer screens that only ever see the public view — the board, the ballots, the standings, never a secret card. A TV browser at http://<host>:<port>/d is a display; so is a spare phone joined with Present this room. While a display is attached it also owns the room's soundtrack and read-aloud voice — player phones stay quiet. The full display story (wireless casting included) is in Putting the room on a TV.

The floating Host tools bubble — bottom-right on touch screens, or Start/F1 from a controller — holds the room's controls: Pause the room (freezes every screen and timer), Wrap it up (a countdown on every screen that even takes over a running turn's clock), the invite QR and share link, bench/remove per seat, the known-players list, and Quit the app. A kicked player rejoins as a fresh seat — nothing carries over — while a benched one stays warm and can be dealt back in.

Bot players

Five games offer a seatable bot — the app's own player, persona emoji and all, moving in and out of the roster like a friend would. Bottle-O-Bot writes opening lines in Desert Island Poetry, Bard-O-Bot answers a share of blanks in Infinite Monkeys, and Board-O-Bot sneaks a real dictionary entry into Dictionairheads — the only bot that banks points. Research-O-Bot (Unfocused Group) and Troll-O-Bot (Acquired Taste) throw a comparison guess into every reveal for show. The bot seat is one global switch — seat it once and it travels to every game that has a persona.

The same neighborhood holds inspiration: the "stuck?" helpers some games offer — Ask the Muse, Ask the Focus Group, Ask Bard-O-Bot, and Doctor Maroon's field-guide clue angles. App-assisted entries are marked on the ballot and score half when scoring is on.

Settings worth knowing

A few toggles shape every game night, all under Settings:

Scoring — most games can run unscored (cozy mode) and a few — Unfocused Group, the drawing games, Buildboard — score by design and skip the switch entirely. This or That? never scores at all. Every scoring game also has a floor (usually three players): below it the vote still runs for fun but nobody banks.
Inspiration — the "stuck?" helpers above; off means no hints and no bot-authored material.
Typos — app-filed ballot entries arrive with plausible typos so perfect spelling can't out them; turn it off for cleaner reads.
Turn timer — off, or quick/standard/extended countdowns.
Read aloud — most text on screen can be spoken, in a voice and at a speed you pick (or rolled randomly each round, the default). On Linux the app uses the bundled piper voices or any desktop engine it finds, and Settings can download more piper voices.
Music and sound effects — a theme per game plus a full cue vocabulary, each with its own volume slider and off switch. While a display is attached, the room's sound plays there instead of on the phones.
TV mode — couch-distance presentation for a TV host (see Hosting from a TV); Start fullscreen and window-size memory do the same on a Linux PC.

Every gameplay setting also exists per game — the setup screen's Common settings tile overrides the globals for just that game, and each game's Round settings tile holds its own knobs (line counts, round counts, timers, and the game's signature options).

The scorekeeper

Finished calls feed the Statistics screen — an overall totals card (games played, players seen, hours logged), per-player cards (wins, win rate, streaks), a per-game split, head-to-head records, and a leaderboard per room name — so a recurring room keeps its standings across sessions. It counts real play, not app opens: a call you bailed on mid-game files as abandoned rather than padding the numbers.

The games

Twelve games live on the shelf. The line under each name gives the roster size and how it plays — "pass the phone" games also run in a room, while "Play Together only" needs every seat on its own screen.

Acquired Taste

2 or more players · pass the phone or Play Together · optional teams · scoring optional (needs 3+ to bank points)

A foodie influencer never posts a plain number — they post calibrations. Each turn one player is the influencer: dealt a secret 1–10 rating for a silly dish at an even sillier venue, they type the pick they'd place at their number on each of their personal scales — "on the scale of vegetables I'd use for toothpaste flavors, this lands right on rutabaga." The followers secretly decode the rating behind the post. Exact decodes pay 100, close ones 50, and the influencer banks the best read — cryptic but legible is the whole skill. Teams mode splits the roster into fandoms: the influencer's own side huddles openly (they keep a straight face) and locks one shared decode; Troll-O-Bot throws a comment-section dart into every reveal for comparison, never scoring.

Buildboard

4–8 players · Play Together only · scoring built in

Two client companies sent over nothing but a name — so the painting crew makes the rest up. Each round half the crew writes taglines for one client while the other half paints its billboard art, then everyone flips clients; taglines and canvases get filed until the clock or quota runs out. Then the yard deals: every client's submissions are shuffled and dealt back out, and each painter assembles a billboard per client from whatever landed in their hand — possibly a rival's words under their own paint. The room votes a favorite per client: a star pays the hanger 100 and each contributor 50 — but you can never star a board you hung, and your own vote never pays you for your piece of it.

Desert Island Poetry

2 or more players · pass the phone or Play Together · optional scoring (needs 3+)

A plane full of the world's best poets crashed into an archipelago, and now they write the most epic poem ever — one line at a time, passed in a bottle that leaks. Each poet sees only the drips the bottle lets through of the lines before theirs (how many lines back and how many words each is a setup knob); everything else stays sealed until the finished epic washes ashore. Bottle-O-Bot can write the opening lines, and a stuck poet can Ask the Muse — Muse-touched lines are marked and score half. With scoring on, the group votes a favorite line (100) and emojis the rest (10 each).

Dictionairheads

2 or more players · pass the phone or Play Together · optional scoring (needs 3+)

Nobody buys dictionaries anymore, so the company's last lexicographers invent tomorrow's words. Every round deals the same made-up word to the whole table — word size is your call, snappy to sesquipedalian — and each writer secretly authors a convincing entry for it. Board-O-Bot's app-written definition sneaks into the vote (and banks real points); a stuck writer can Ask the Focus Group for a half-price suggestion. All entries are read out together, then the table votes: star the most convincing for 100, emoji the rest for 10. Tallies carry across however many words you set.

Draw What Now?

3–8 players · Play Together only · scoring built in

There is no AI — when a customer types a ridiculous image prompt, it lands on your phone and you draw it. Every artist gets a secret order and a random four-color palette; pen down to pen up is one line, a held stroke splits at seven seconds, and the bucket floods a region. When every canvas ships, each piece goes up for review: everyone but the artist writes what they think the order was, and those cover stories join the real prompt on the ballot. A correct pick pays the guesser and the artist 100; a fooled vote pays the fake's author 50. Rounds and the undo budget are setup knobs.

Dreamweavers

3–8 players · Play Together only · scoring built in

The night shift: each weaver slips into a sleeping mind to scribble its dream — but dream ink won't hold. You only ever see the line under your pen; lift it and it dissolves over five seconds. Each weaver draws a secret dream dealt to a specific dreamer (nobody weaves their own), then every piece goes up for interpretation with the dreamer named but the weaver secret. Everyone else writes what they think the dream was — those readings join the real dream on the ballot — and whatever the dreamer picks pays its target double.

Infinite Monkeys

1 or more players · pass the phone or Play Together · optional scoring (needs 3+)

An infinite number of monkeys on an infinite number of typewriters, tonight staffed by your friends: a real Shakespeare excerpt is dealt out as word requests — a noun, a past-tense verb, a part of the body — and every monkey answers without ever seeing the scene. Then the mangled excerpt is revealed and performed in per-character voices. Excerpt length is a setup knob (Aside, Soliloquy, Full scene, or Surprise me), as is whether the play is named while filling. Bard-O-Bot can seat a robotic quill for a share of the blanks — and doubles as the inspire-me — and the troupe votes on the best substitutions. It even runs solo — a one-monkey troupe argues both sides of the stage.

The Island of Doctor Maroon

2 or more players · pass the phone or Play Together · optional teams · optional scoring (needs 3+)

The evil Doctor Maroon has an island of mismatched animal monstrosities, and you've infiltrated his lair to radio the Collective exactly what you see — a skateboarding snake, a poker-playing duck — without ever saying the animal, its quirk, or the card's banned words (3–8 per word, your call). Agents take turns holding the radio while the room shouts guesses; a banned word means the room can hit Buzzed — the card burns, the describer pays 50, and the turn ends on the spot. Two turn styles: Blitz races the clock through a stack of creatures, One creature deals a single card per call. Skips are a setup knob (limited ones cost 25 each; aborting the call is always free), and the field guide deals a clue angle — "tell them what it eats" — at the cost of a halved rescue. In teams mode only the describer's own side shouts, banking the whole card for 150 while the other sides watch for fouls.

Off by One

4 or more players · pass the phone or Play Together · optional scoring (needs 4+)

Two nearly-identical conventions share the hotel — Kayak Kon one floor, Canoe Con the other — and a few seats got off the elevator early. Everyone holds a con program, and nobody is told whether theirs is the wrong floor's. Mingle: each seat asks a dealt prompt ("would you cosplay as it?") of a shuffled target, who answers about their program — answers that don't quite fit are the evidence, but a wrong program can feel exactly right, so suspect yourself first. Then the secret accusation: point at who's off by one — yes, you may point at yourself. Out seats score 100 per voter they deceived, a correct point scores 100, and the outed get one steal guess back: name the room's real fandom for 50 more.

Sketchy Sources

3–8 players · Play Together only · optional scoring (needs 3+)

Breaking news, broken telephone. Every source draws a secret wire headline and posts it to Dubious Art; each sketch then lands on Sharedit, where a freshly-matched writer captions it into a brand-new headline — which a different artist draws again, on and on until everyone has touched every thread. Assignments reshuffle every post, so no one simply follows the same player around. The reveal walks each chain from original post to whatever it became, bylines and all, and the room stars its favorite link in each chain — a drawing plus the headline it connects to — paying both its authors 100 (and 10 per reaction). A setup option decides whether an even crew ends where it lands or closes the loop so the original poster draws the last headline.

This or That?

1 or more players · pass the phone or Play Together · never scored

The shelf's palate cleanser: one phone, a deck of impossible either/or questions. The named asker reads the dilemma aloud, everyone picks a side and defends their take, then the phone moves to the next asker — a take you cannot defend is the only losing move. Endless by default, or set a dilemma count for a built-in finish line; with three or more players some cards name names (never the asker's own). Works solo too — argue with yourself; you might lose.

Unfocused Group

2 or more players · pass the phone or Play Together · optional teams · scoring built in

Megacorp's research department is too big to focus, so it surveys everyone about everything. The survey question is public — the speaker can read it aloud — while the consumer alone secretly rates it from 1 to 10. The researchers then lock secret guesses (in teams mode, the consumer's own side huddles openly and locks one shared guess while they keep a straight face). Exact reads pay 100, reads within the tolerance pay 50, and the consumer banks the best read of the turn — honesty helps, but being legible pays. Research-O-Bot throws a random guess into every reveal for comparison — it never scores and never counts toward the consumer's banked read.

Getting around the game shelf

The home screen lists every game as a card. Two buttons above the card grid change what the shelf shows:

Sort (the up-and-down arrows icon) chooses the card order: Shuffle — the default — deals the cards a fresh random order every time you open the app, My order reveals Arrange games, where you drag rows into your own arrangement, plus A to Z, Newest games, Recently played, and Most played. The pick is remembered between launches; the play-based orders count only games you actually finished.
Filter (the funnel icon) narrows the shelf: set a headcount under Group size, keep only Pass the phone games under Play style, or pick a Game type (writing, guessing, drawing…). A counter on the button shows how many filters are on. If nothing matches, Clear all brings the full shelf back. Filters reset when you reopen the app.

Hosting from a TV

The host device can be a television instead of a phone — the app runs on Android TV / Google TV boxes and on a Linux PC plugged into a TV, and the whole host path drives without a touchscreen. The TV opens the room, presents the shared screen, and runs the games; players still join from their phones.

Turn it on: open Settings and set TV mode — Auto turns on by itself on Android TV, On is the manual pick for a Linux PC on a TV (which can't announce itself), Off keeps the phone layout. TV mode enlarges text (on shorter, ~720p-class screens it skips the bump — they're already tight), keeps content inside the screen edges, shows a clear focus outline, and starts a hosted room in presenting mode — the host runs the show instead of holding a seat.

Controls — every screen a host sees works the same on a gamepad, a TV remote, or a keyboard:

What	Gamepad	TV remote	Keyboard
Move between controls	D-pad or left stick	D-pad	Arrow keys or Tab
Select	A / cross	OK / center	Enter or Space
Back / close a dialog	B / circle	Back	Escape
Details on the focused item	X / square	—	I
Host tools	Start	—	F1

A slim button legend sits at the bottom of every screen while TV mode is on — D-pad moves, A selects, B backs out — so nobody has to guess which face button does what. Two hints come and go with the screen: X details shows while the highlighted control can actually answer it (a game card can; a settings row can't), and Start host tools shows only while you're hosting a room with nothing modal open.

The host tools sheet (pause, kick, invite link, wrap-it-up timer) opens from the Host tools button on the room banner and inside a game, or straight from Start/F1. Navigate to the highlighted control and press select — the focus ring shows where you are. On the home shelf the content scrolls under your selection instead: steering toward a card pulls it to the middle of the screen, steering back to the top row brings the room banner and app header home. While a room's banner is scrolled away, a slim room bar stays pinned under the top buttons — name, code, invite, host tools, end — so you can never strand the room.

On Linux, wired and wireless gamepads work — the D-pad or left stick moves focus (hold to keep stepping), A selects, B goes back, X shows a game's details, Start opens host tools. If a pad does nothing in a sandboxed install, the sandbox is missing the input-device permission: for the Flatpak that means Flatpak 1.15.6 or newer (the build's --device=input needs it), and for the Snap run snap connect librebash:joystick. Running under Steam's game mode? Its input layer mirrors your pad onto a virtual device — the app spots the twin (same connect burst, presses landing in the same instant), keeps the Steam-named one so your Steam button mappings apply, and mutes the echo. If a second real controller ever arrives in the same burst, it unmutes itself the first time it presses something its twin didn't.

For the couch-console setup on Linux, the app can also open straight into fullscreen: turn on Settings → Start fullscreen (Linux only) once, or pass --fullscreen on the command line to fullscreen a single launch — handy for a desktop entry or a launcher script. Otherwise the app remembers its window size and position and restores them next launch; on the first run (or under Steam's game mode, where windowed sizes don't apply) it opens maximized.

Quitting: TV mode and fullscreen hide the window's own close button, so the app carries one — an exit icon sits on the home screen's top-right button row (with stats/settings/about), a Quit the app row lives at the bottom of the host tools sheet, and pressing B / Back / Escape on the topmost screen asks to exit. Every path opens the same confirm first, so a stray button press can't end the room.

Putting the room on a TV

The host's phone doesn't have to be the screen everyone stares at — the room can appear on a TV while everyone plays from their own phones, Jackbox-style. The display only ever sees the public view of the game: the board, the ballots, the standings — never a player's secret cards or answers, even while the host keeps playing on the same phone that runs the room.

All of it lives behind the invite: open the room's QR code (room banner) or Put it on a TV (host tools), and the dialog's Players / TV display toggle picks which half you see.

A TV with a browser — type the display address it shows, which is deliberately short for a remote: http://<host>:<port>/d on an open room, http://<host>:<port>/d/CODE on a locked one (the code rides the address itself — no question marks to hunt on an on-screen keyboard). Works on Fire TV's Silk, Samsung and LG's built-in browsers, a TV browser installed on an Android/Google TV box, or a laptop or Raspberry Pi plugged into HDMI.

A spare phone or tablet — scan the same screen's QR with any camera and that device becomes the room's display; prop it wherever the room can see it.

Wireless display (Android) — where the TV is Miracast-capable (Samsung Smart View, LG Screen Share, Roku screen mirroring, a Windows PC's "Project to this PC", most Wi-Fi display dongles), pair it once from the phone's own settings, and the Wireless display switch projects the room straight onto it — the phone keeps running the room and stays your controller. If no display is paired yet the switch says so and offers an Open display settings button that jumps straight to the pairing page — no hunting through settings. One honest catch: the phone must support Miracast too — Google Pixels and other stock-Android phones only ship Google Cast, so their settings never show a Miracast TV. On those phones the switch greys out and says exactly that — this device doesn't support Miracast — leaving the TV-browser address above as the way in, or a friend's phone that does support it: whoever projects, the casted page just joins the room as its display — the room and every control stay with the host. A USB-C-to-HDMI cable counts as a wired display and works on any phone that outputs video. The switch is a real switch: flipping it off — or ending the room — drops the whole cast, not just the room page, so the TV goes back to its own home screen instead of silently mirroring the phone. And because a casted display shares the phone's own sound, the room automatically dedupes read-aloud: while that projection is the only display attached, the host's Read it on the display hides — say it already speaks through the same speakers. Attach a real browser display alongside it and the button comes straight back for the display that can't hear the phone.

An Android/Google TV running the app itself — sideload the APK onto the box and its join screen's Present this room switch joins the TV as the room's display natively — the smoothest option on that hardware (see Hosting from a TV for the full TV-mode controls).

A locked room still asks for the code once — the display page's own code prompt posts back to the display address, so the TV never wanders into a player seat.

The display owns the sound — and nobody else plays it. While a display is connected, the room's soundtrack, fanfares, and read-aloud voices move to it — the host's phone drops to the same quiet menu player phones get (taps and the turn ping stay local), so there's no echo of every cue playing on two devices a beat apart. And player phones never carry the soundtrack at all: a phone that joined as a player stays silent from the room lobby onward, in the app and the browser alike — only the host and a display ever play music. The voice is the host's. Most TV browsers have no usable speech engine of their own, so the display doesn't try: the host renders every read-aloud line with its own voice setting and the display just plays the audio — a say-it pressed on the display asks the host for the clip the same way. A second screen with a good local engine (a Linux laptop, say) can flip Use this display's own voice on its lobby screen instead — the choice sticks across reloads — but the switch locks off the moment a second display joins, since a room speaks with one voice. Two small buttons in the top corner of the web client's join and lobby screens help late-night sessions (they're on every browser client, display or phone): a night mode toggle that dims the page (it remembers the choice across reloads), and a fullscreen toggle that hides the TV browser's own chrome. A cast or remote-typed display isn't easy to tap, though — so while a display is attached the host's Host tools carry remote versions of both: Toggle display night mode and Fullscreen the display reach across the room and flip them there (some TV browsers insist on a local press before they'll go fullscreen — if it doesn't take, that's the browser being a browser). Browser autoplay rules mean a page that never gets touched may stay muted until the first tap — press any remote key once and the sound joins.

What the Android app asks for

The app keeps its permission list short, and Android only ever pops a prompt at the moment a feature needs it:

Camera — when you join a room by scanning the host's QR ticket.
Nearby devices (Android 13+) or location (older phones) — when a room runs on the host's own hotspot. Android bundles starting a hotspot under these; the app never reads your position.
Notifications (Android 13+) — so the room can keep itself alive in the background and warn you when your turn lands.

Granted silently at install time: network and Wi-Fi access (the host runs a small server on your local network or hotspot and joining phones talk to it), foreground service (keeps the room's connection alive while the app is backgrounded or the screen is off), and vibration (the turn ping).

No microphone, no contacts, no file or media access. The gallery button in the QR scanner goes through Android's own photo picker, which hands the app only the one picture you choose.

Reporting a problem

The app keeps a local diagnostic log — one file per day, kept for a week, written only to your device. It exists so a "the room dropped" or "the sound cut out" report comes with evidence instead of guesswork. To share it:

Open Settings and scroll to Troubleshooting.
Tap View logs, pick the day the problem happened from the Day selector, then use the toolbar: copy puts the day's entries on the clipboard, share sends the file itself, and delete clears everything after a confirm.
Attach it to your bug report. If the problem is subtle, set Log level to Debug first and reproduce it — debug captures screen-to-screen navigation and network chatter the default Info level skips.

The log can contain app internals — screen names, network events, file paths — but never your answers or drawings. It never leaves the device unless you copy or share a day yourself.

Known issues

Friends can't get onto the host's Wi-Fi

Symptom: the host tapped Provide the Wi-Fi, friends scanned the big code — and their phone just sits on a page that never loads, or never finds the network.

Cause: there are two hops, and the big code only covers the second one. The room code is a web address that only works after the phone is on the host's Wi-Fi; a phone that isn't attached yet opens it into a dead page. Phones running the app handle both hops in one scan — everyone else (iPhones, laptops) joins the Wi-Fi first, then the room.

Fix: while the hotspot runs, the lobby's code toggles between Room and Wi-Fi:

Friends open their camera and scan the Wi-Fi code — iOS and Android both answer with a "join this network" prompt. Typing works too: the network's name and password print right under the code.
Once the phone is on the Wi-Fi, flip back to the Room code and have them scan that — the page loads and they're in.

If the Wi-Fi code's join prompt doesn't take, check the printed credentials on the host screen — they always show what the network actually answers to (older Androids mint a random name and password; Android 16.1+ phones get the friendlier LibreBash-… name and a speakable password).

Drawing feels jagged or laggy in the browser (Vanadium)

Symptom: when drawing on the web client — Buildboard, Draw What Now?, Dreamweavers, Sketchy Sources — fast strokes stutter or look polygonal even though you're moving smoothly, while other players' browsers draw fine.

Cause: Vanadium (the GrapheneOS browser) disables the JavaScript JIT compiler by default as a security hardening measure. The whole game client then runs interpreter-slow: pen strokes arrive in sparse bursts and painting stutters, no matter how fast your phone is. Chrome and Firefox run with JIT enabled and are unaffected.

Fix: allow JIT for the site — it's a per-site toggle:

Tap the permission icon on the left of the address bar.
Enable JavaScript JIT for the site.
Reload the page and rejoin the session.

Or simply play in a different browser. The drawing board shows a "this browser is feeding strokes slowly" hint — at most once per session, and only after the slow feed persists well past your first stroke — so players know the lag isn't their phone.

The app is crazy slow on a Linux desktop — check display scaling

Symptom: the app feels unusable and burns a whole CPU core, but only when its window is large or fullscreen on a HiDPI monitor. The same build idles perfectly at smaller sizes.

Cause: the monitor's display scale is set to a fraction (125%, 150%, …) on a Wayland desktop — seen on KDE Plasma, worst with several monitors at different scales. It's a bug in Flutter's Linux rendering engine, not the app: the engine and the desktop disagree about the window's pixel size, every frame times out waiting, and the engine redraws non-stop. Integer scales (100%, 200%) are unaffected, and so are gaming environments that never scale — SteamOS game mode included.

Fix: set that monitor's scale to 100% or 200% in the desktop's display settings (KDE: System Settings → Display Configuration). There is no in-app switch — the fix has to come from the Flutter engine — but real TV setups (a single display at normal scale) never hit it.

The AppImage won't start when launched through Steam

Symptom: the AppImage runs fine from a terminal, but added to Steam as a non-Steam game the Play button flips to Cancel for a moment and falls back to Play — no window ever appears.

Cause: Steam runs non-Steam Linux shortcuts inside its Steam Linux Runtime container (pressure-vessel). The sandbox ships no working fusermount, so the AppImage can't mount itself and exits before the app starts — you'll find Cannot mount AppImage if you capture the shortcut's output.

Fix: either of these works —

Open the shortcut's Properties → Compatibility and uncheck Force the use of a specific Steam Play compatibility tool, so the game runs on the host system where FUSE works. (If you deliberately want the runtime container, use option 2.)
Or keep the container and make the AppImage extract-and-run instead of mounting. Point the Steam target at a two-line wrapper:

#!/bin/sh
APPIMAGE_EXTRACT_AND_RUN=1 exec /path/to/librebash-linux.AppImage

Extracting adds a moment to each launch, and it's the right choice for game mode, where the runtime is part of the setup. If the game then launches but crashes opening its window, add unset LD_PRELOAD to the wrapper — that only drops the Steam overlay popup, not controller input.