bazzite.gg

Bazzite is built to run across five device categories: handhelds, home theater PCs (HTPCs), laptops, tablets, and desktop PCs. If you want to confirm whether your specific machine is supported before installing, the site's "View Compatible Hardware" list is the intended starting point. The rest of this article explains what each device category means in practice, how the shared MicroSD library works, and what to check before committing.

The five supported device categories

Bazzite's own framing is that it works "whether you prefer to game on your handheld, chill on the couch with your home theater PC, lug your laptop to the LAN party, surf the subway with your tablet, or pretend you're getting work done on your desktop."

The site also lists three experience modes that map onto these devices: a handheld experience, a couch gaming setup, and a desktop environment. In other words, the same operating system adapts its interface depending on the form factor you install it on, rather than shipping separate editions per device type.

How to check whether your hardware is compatible

1. Go to bazzite.gg and find the View Compatible Hardware link.
2. Compare your device model against that list before downloading an image.
3. If your device appears, proceed with the install image that matches your form factor.
4. If it doesn't appear, treat compatibility as unconfirmed — the site does not claim universal hardware support, and its stated goal is to "work with your hardware, not for it."

The compatibility list is the authoritative reference here. Because Bazzite is image-based and ships with specific drivers and tweaks, a machine that isn't listed may still work but isn't covered by the project's own guidance.

Sharing one game library across devices

If you install Bazzite on more than one device, your MicroSD card game library can be shared between multiple Bazzite installs regardless of which devices you're using. This is useful if, for example, you keep a card for a handheld and also want the same library available on a laptop or desktop install.

The practical requirement is that each device runs Bazzite — the sharing is described as working between Bazzite installs, not between Bazzite and other operating systems.

What you get on every device

Two features apply across all supported hardware and are worth knowing before you choose a device:

• Steam pre-installed, with HDR and VRR support, improved CPU schedulers for responsive gameplay, and community-developed tools for gaming and streaming.
• Non-Steam launchers — Lutris comes pre-installed, and other launchers can run games from most stores and integrate them into Steam Gaming Mode. The site names Xbox Game Pass (via battle.net), EA App, Epic Games Store, GOG.com, itch.io, Rockstar Games Launcher, and Ubisoft Connect.

If your main question is whether a particular store's games will run, that's a software question rather than a device one — the launcher support is the same across the supported hardware list.

Common sticking points

• "My device isn't on the list." The site points to a compatibility list rather than promising broad support. Check it first; don't assume an unlisted device is fine.
• "Can I share my library with a non-Bazzite machine?" The shared MicroSD library is described as working between Bazzite installs, so a Windows or other-Linux machine isn't covered by that claim.
• "Which experience will I get?" The handheld, couch gaming, and desktop modes correspond to your device type, so the same install adapts rather than requiring you to pick an edition.

If you're still deciding whether Bazzite fits your situation at all, the device list above is the fastest filter: match your hardware to a category, confirm it on the compatibility page, then pick the image for that form factor.

Bazzite is an image-based operating system, which means each update replaces the whole system image rather than patching files in place. The practical result: after every update, the previous version of the OS is still on your machine, and you can boot into it if something breaks. Images stay in Bazzite's repositories for ninety days, so you have a long window to roll back — including switching to an older image from the terminal, or rebasing to a last-known-good release and pinning it if a driver update (Nvidia, for example) causes problems.

Why image-based updates change the rollback story

On a traditional Linux distribution, an update modifies packages on top of your existing install. If a new kernel or driver misbehaves, recovery often means chrooting in from a live USB and manually downgrading packages.

Bazzite's image model works differently. The OS ships as a single image, and updating means moving to a newer image. The one you were running before is retained locally. That's the mechanism behind the site's "Upgrade fearlessly" framing — the safety net is structural, not something you configure after the fact.

How to roll back at boot

The most direct recovery path requires no terminal:

1. Reboot the machine.
2. At the boot menu, select the previous image entry instead of the default.
3. The system starts on the older version, with your data and home directory intact.

This is the fastest fix when an update leaves you with a black screen, a broken desktop session, or a driver that won't initialize. Because the old image is already on disk, you don't need network access or a recovery USB.

Rolling back from the terminal, and the 90-day window

Booting the previous image is a temporary state — you're running the old version, but the system still considers the new one the default. To make a rollback stick, or to reach further back than the locally retained image, you use terminal commands to switch images.

Bazzite's documentation notes that OS images are kept in the project's repositories for ninety days and can be switched to via the terminal. Two consequences worth planning around:

• If a problem only shows up weeks after an update, you can still move to a known-good image from within that window.
• Past ninety days, that specific image may no longer be available to pull, so the practical rollback horizon is roughly a quarter.

Rebasing and pinning when a driver breaks

The site gives a concrete example: an Nvidia driver update breaks something you depend on. The recommended response is to rebase to the last known good release and pin it, so that version is retained as long as you need it.

Rebasing means changing which image your system tracks — useful when you want to stay on a specific release rather than follow the default stream. Pinning keeps that choice from being overwritten by the next update. The trade-off is straightforward: you keep a working driver, but you stop receiving newer updates until you unpin.

What this means in practice

Limits and things to check

Rollback restores the operating system image — it is not a general backup. Files you created or changed in your home directory are not reverted by switching images, and neither are changes inside containers or Flatpak app data. If an update corrupted user-level data, an image rollback won't recover it.

Also note that the ninety-day figure applies to images retained in Bazzite's repositories. The previous image kept locally on your machine is a separate, shorter-lived safety net — it's the one you reach from the boot menu, and it's replaced as you move forward through further updates.

For current specifics on commands and available images, check Bazzite's own documentation, since the exact terminal syntax and repository layout can change between releases.

Bazzite is a Linux-based operating system built primarily for gaming, aimed at both Linux newcomers and experienced users. It comes with Steam pre-installed and is designed to run across desktop PCs, handhelds, tablets, and home theater PCs (HTPCs). If you want a console-like or Steam Deck-like gaming experience on your own hardware—or you're curious about Linux gaming but don't want to configure everything from scratch—Bazzite is aimed at you.

What makes Bazzite different from a standard Linux distro?

Bazzite isn't a general-purpose Linux distribution that happens to run games. Its defaults and tooling are oriented around gaming and streaming:

• Steam is pre-installed, so you don't have to set it up yourself.
• HDR and VRR support are included for compatible displays.
• Improved CPU schedulers are tuned for more responsive gameplay.
• Community-developed tools and tweaks are bundled to streamline gaming and streaming.

It also targets a range of form factors rather than just the desktop. According to the project, Bazzite works whether you game on a handheld, relax on the couch with a home theater PC, bring a laptop to a LAN party, use a tablet, or sit at a desktop.

Can it run games outside of Steam?

Yes. Lutris is pre-installed, and other launchers can run games from most game stores while integrating them into Steam Gaming Mode. The project lists support for:

• Xbox Game Pass (via Battle.net)
• EA App
• Epic Games Store
• GOG.com
• itch.io
• Rockstar Games Launcher
• Ubisoft Connect
• Older physical media, such as game CDs

If you're new to gaming on Linux, Bazzite points users to its own Gaming Guide, plus community-maintained compatibility resources like ProtonDB and GamingOnLinux to check whether specific titles work.

How do updates and rollbacks work?

Bazzite is an image-based operating system. That means after every update, the previous version of the operating system is retained on your machine. If an update causes problems, you can select the previous image at boot time.

Images are kept in the project's repositories for ninety days and can be switched to via the terminal. If, for example, an Nvidia driver update breaks something you rely on, you can rebase to the last known good release and pin it so it's retained as long as you need.

This is the main practical difference from a traditional rolling or point-release distro: you get a built-in safety net for failed updates.

What about security?

Bazzite describes its security posture as enterprise-class and enabled out of the box, including:

• SELinux
• Secure Boot support
• Signed container images with SBOMs and attested build provenance
• LUKS full disk encryption with optional automatic TPM unlocking

It also uses Flathub for applications, which provides attestation, sandboxing, and officially verified apps.

Who should consider Bazzite?

Bazzite fits you if:

• You want to play games on Linux with minimal setup.
• You use a handheld, HTPC, tablet, or desktop and want one consistent gaming-oriented system.
• You want the ability to roll back a bad update without reinstalling.
• You're a Linux newcomer who wants sensible gaming defaults, or an enthusiast who wants a gaming-focused base to build on.

It may be less suitable if you need a general-purpose workstation distro with a specific non-gaming configuration, or if your hardware or favorite games aren't covered by the compatibility lists. Before installing, check Bazzite's compatible hardware page and verify your key titles on ProtonDB or GamingOnLinux.

Yes. Bazzite ships with Lutris pre-installed, and Lutris can run games from most third-party stores. Bazzite also states that these launchers integrate cleanly into Steam Gaming Mode, so non-Steam titles can appear alongside your Steam library in a controller-friendly interface. The officially named examples are Xbox Game Pass (via Battle.net), EA App, Epic Games Store, GOG.com, itch.io, Rockstar Games Launcher, and Ubisoft Connect.

What "non-Steam" support actually covers

Bazzite's own description draws a line between two things:

• Running the game — handled by Lutris and other launchers, which can execute titles from most game stores.
• Presenting the game — handled by integration into Steam Gaming Mode, so the launcher and its games are reachable without dropping to a desktop.

That second point matters most on handhelds and home theater PCs, where you may never want to touch a keyboard. If a launcher only runs games but doesn't surface them in Gaming Mode, the experience degrades quickly on those devices.

Supported launchers and stores

Bazzite's page also mentions "your dad's old CDs" as a half-joking catch-all for physical media and other odd sources — a signal that the intent is broad compatibility rather than a fixed list.

How the integration works in practice

The mechanism Bazzite describes is: a launcher runs the game, and that game is then integrated into Steam Gaming Mode. From the user's side the flow is roughly:

1. Install or launch the third-party store through its launcher (Lutris is already there).
2. Add or let the launcher register the game.
3. The title becomes reachable from Steam Gaming Mode rather than only from a desktop session.

The expected result is a single, controller-navigable library instead of switching between desktop windows. Bazzite does not document the exact menu path for each launcher on its landing page, so treat per-launcher setup as something you confirm in Bazzite's own Gaming Guide.

Before you commit: check compatibility first

Running a launcher is not the same as running a specific game well. Bazzite points to two community-maintained resources for that question:

• ProtonDB — community compatibility reports, primarily for Steam/Proton titles.
• GamingOnLinux — broader Linux gaming coverage.

For a non-Steam title, the practical check is whether the game itself works under Proton or Wine, not merely whether the store launches. A store can open fine while a specific anti-cheat-protected multiplayer game still refuses to run.

Who this fits

• Good fit: you have libraries spread across Epic, GOG, itch.io, or Ubisoft and want them in one Gaming Mode interface on a handheld or TV.
• Check first: your main game uses kernel-level anti-cheat, or you rely on a store not named above.
• New to Linux gaming: Bazzite explicitly targets Linux newcomers and points to its Gaming Guide for current tips, so start there rather than assuming a launcher will behave exactly as it does on Windows.

One more note from the source: Bazzite is image-based, so if a launcher or driver update breaks something, you can boot the previous image or rebase to a last-known-good release and pin it. That rollback path is the main safety net when experimenting with third-party launchers.

Bazzite ships with four security layers enabled or available out of the box: SELinux, Secure Boot support, signed container images with SBOMs and attested build provenance, and LUKS full disk encryption with optional automatic TPM unlocking. Application-level security comes from Flathub, which provides attestation, sandboxing, and verified applications. If you want a gaming-focused Linux system where you don't have to assemble these protections yourself, this is the relevant set — and most of it is on by default rather than opt-in.

System-level protections

SELinux

Bazzite enables SELinux out of the box, which the project describes as "enterprise class security." SELinux is a mandatory access control system: instead of trusting that every process only touches what it should, the kernel enforces rules about which processes can access which files, devices, and network resources. A compromised game launcher or browser process is confined to what its policy allows rather than inheriting your full user permissions.

The practical trade-off is that SELinux can block legitimate software that wasn't written with it in mind. On Bazzite this is mitigated by the fact that most desktop applications arrive as Flatpaks (see below), which are sandboxed separately, so you're less likely to hit policy denials during normal gaming and desktop use.

Secure Boot support

Bazzite supports Secure Boot, the UEFI firmware feature that verifies the bootloader and kernel are signed by a trusted key before handing control to the operating system. This closes the gap where malware or an unauthorized OS could be loaded before your disk encryption prompt even appears.

Support here means Bazzite is built to work with Secure Boot rather than requiring you to disable it — a common friction point on Linux distributions, especially for gaming setups that also need out-of-tree drivers.

Signed images, SBOMs, and build provenance

Bazzite is an image-based operating system, and those images are signed and shipped with:

• SBOMs (software bills of materials) — a machine-readable inventory of every component inside the image, so you can check whether a given library or package is present and at what version.
• Attested build provenance — a verifiable record of how and from what source the image was built.

Together these let you confirm that the image you installed is the one the project actually produced, and audit its contents without reverse-engineering it. This matters more on an image-based distro than a traditional one, because you're consuming a whole prebuilt system rather than assembling packages locally.

LUKS full disk encryption with optional TPM unlock

Bazzite supports LUKS full disk encryption, so the contents of your drive are unreadable without your passphrase. Optionally, you can set up automatic unlocking via a TPM (Trusted Platform Module), which releases the decryption key when the boot measurements match an expected state.

The trade-off is worth stating plainly: TPM auto-unlock removes the need to type a passphrase at every boot, but it also means the disk unlocks automatically on that machine. It protects against someone pulling the drive out and reading it elsewhere; it protects less against someone with physical access to the running, booted machine. If that distinction matters to you, keep the passphrase prompt instead of enabling auto-unlock.

Application-level security: Flathub

Bazzite's desktop applications come through Flathub, which the project notes provides "attestation, sandboxing, and the most officially verified applications of any Linux application repository."

• Sandboxing confines each app to the permissions it declares, so a game launcher or utility can't freely read your entire home directory unless you grant it.
• Attestation lets Flathub confirm that a published build came from the claimed source.
• Verified applications are those where the upstream developer has confirmed ownership of the Flathub listing, so you're installing from the actual vendor rather than a repackager.

For a gaming system this is the layer that matters most day to day, since launchers for Epic, GOG, Xbox Game Pass (via Battle.net), EA App, Ubisoft Connect, and similar stores are exactly the kind of third-party software you'd otherwise install with broad system access.

How this compares to a typical desktop Linux setup

The pattern is that Bazzite makes these choices for you and turns them on, at the cost of some flexibility — you're working within an image-based, Flatpak-first model rather than configuring each layer yourself.

What to check before relying on these

• Confirm Secure Boot is actually active in your firmware after install, not just supported by the OS. A supported-but-disabled setup gives you none of the boot-chain protection.
• Decide on TPM auto-unlock deliberately. It's a convenience/security trade, not a strict upgrade.
• Check whether your specific hardware needs Secure Boot disabled. Some configurations, particularly certain GPU or peripheral setups, may push you toward turning it off — in which case budget for that in your threat model.
• Verify a Flatpak's permissions before granting it broad filesystem or device access, since sandboxing only helps if you don't widen it.

If your priority is a gaming system where SELinux, Secure Boot, signed images, and disk encryption are handled for you rather than assembled by hand, Bazzite's defaults cover that. If you need to tune each security layer individually or run unsigned kernel modules freely, the image-based model will feel restrictive.