gfn-electron wraps the GeForce NOW web app for Linux

It is a wrapper, and the README says so

gfn-electron is an unofficial desktop client for Nvidia's GeForce NOW game streaming service on Linux, and the Disclaimers section is the first substantive part of the README.

The affiliation note is unambiguous: this project and its contributors are not affiliated with Nvidia, nor with the GeForce NOW product, and this repository does not include Nvidia or GeForce NOW software. It provides an Electron wrapper that loads the official GeForce NOW web application.

That single sentence defines both the value and the risk. The value is that you get the service the way Nvidia intends it to behave, in a window that respects your compositor, your keyboard and your desktop conventions. The risk is that everything the web app does, the wrapper does, and when Nvidia changes the web app the wrapper changes with it.

The expectations note adds the maintenance caveat: this is a free and open-source project maintained by volunteers, and contributions occur as contributor availability permits.

So the project is a small compatibility layer maintained by volunteers in their spare time, and it is honest about that. That framing belongs in any evaluation of it, because the cost of owning this wrapper is inheriting the maintenance of somebody else's web application.

The licence is GPL-3.0, the author is Horațiu Mlendea, the releases are v3.0.5 from 2026-10-16, v3.0.4 from 2026-10-09 and v3.0.3 from 2026-09-08, and the last push was on 2026-10-16 with the repository not archived.

What the wrapper adds over a browser

The capabilities list is the argument for using this rather than opening the site in a browser, and each item maps to something a browser tab cannot do.

Native Wayland support with compositor-aware behaviour is the first, and on a modern Linux desktop it is the difference between a window that behaves like a window and one that flickers or mis-renders. Steam Deck integration comes next, with automatic fullscreen and a virtual keyboard overlay, which is the feature that makes the client usable on a handheld where the screen is small and the input methods are limited.

The video pipeline is the third item and the one that matters for a streaming service. Hardware accelerated video uses VA-API and GPU rendering flags, and there is a GPU crash fallback strategy for rendering stability. For a client whose whole purpose is decoding a video stream, using the hardware decoder rather than a software path is the difference between a smooth stream and a hot CPU.

The experimental flags deserve a note. GFN_ENABLE_EXPERIMENTAL_GPU_FLAGS=1 re-enables aggressive GPU flags for experimentation, which suggests the defaults are conservative. The fallback strategy and the conservative default point the same way: a streamed video client that crashes the GPU is worse than one that runs slightly slower, and the defaults are chosen accordingly.

The rest are conveniences. Discord rich presence integration is optional, there are keyboard shortcuts for fullscreen, navigation and developer tooling, direct game launch via CMS identifier, and a stream quality override for resolution and refresh rate reporting. The resolution and refresh overrides are worth understanding: they change what the stream reports to the service, not what your monitor is set to.

Installing it three ways

There are three distribution channels, and the README recommends one of them over the others.

The Flatpak is the primary route:

flatpak install flathub io.github.hmlendea.geforcenow-electron

For Arch Linux users the AUR package is available, and the README gives both helpers:

paru -S geforcenow-electron

and:

yay -S geforcenow-electron

Manual packages are on the GitHub releases page, and the known limitations section says plainly that manual installation packages receive less maintainer support than the Flatpak distribution. That is a good reason to prefer the Flatpak even when it is not your usual habit, since the Flatpak carries the sandboxing and the update path that a manually downloaded artefact does not.

The system requirements are short: Linux, Node.js 20 or later as the runtime, and GPU drivers with WebGL and hardware video decode support are recommended.

For the Flatpak the Node.js requirement applies to running the source, and for the packaged builds the runtime is bundled by the packaging format. The recommended drivers are the part to check first, because a streaming client without a hardware video decoder falls back to software decode and the experience collapses.

Running it from source, and the project layout

The development section gives the three commands you need.

The setup is:

npm install

The build is:

npm run build

And the run is:

npm start

The package.json confirms what those do. The start script is electron ., and the build script is electron-builder --publish never, with asar set to false and linux targets of zip and AppImage for the x64 architecture.

That asar setting is a detail with a reason behind it. ASAR is Electron's archive format, a single file that bundles the application code. Leaving it off means the application runs from an unpacked directory, which is what a Linux distribution wants when it wants to patch or inspect the files, and it is also why the build produces an AppImage, where the sandbox and the mount namespace do the containment work instead.

The runtime dependencies are three and each is named for its job: discord-rich-presence for the Discord RPC integration, electron-localshortcut for the application-local keyboard shortcuts, and find-process for process discovery in the integration logic.

The project structure table lists the files that matter. scripts/main.js holds the Electron main-process lifecycle, window initialisation and runtime flags, scripts/preload.js is the safe bridge between the renderer and the Electron APIs, scripts/renderer.js handles the renderer-side interactions and UI behaviour, scripts/rpc.js is the Discord rich presence integration, and scripts/windowManager.js does window creation and management. There is also a desktop entry file, com.github.hmlendea.geforcenow-electron.desktop, and an ARCHITECTURE.md with a structural synopsis of the components and how they interact.

Shortcuts, arguments and environment variables

The keyboard shortcut table is small and deliberately includes one developer-oriented binding.

F11 or Super+F toggles fullscreen, Alt+Home goes to the home page, Alt+F4 exits the application, Ctrl+Shift+I toggles the developer tools, and Ctrl+Shift+P creates a desktop shortcut for the active game.

That last one is a native client feature rather than a web one: a wrapper can write a .desktop entry that launches the service directly into a title, which is what a Steam Deck library entry wants.

The command line arguments and environment variables table is where the direct game launch and the quality overrides live.

--direct-start <cmsId> and its environment equivalent GFN_DIRECT_START_ID=<cmsId> launch directly into a game by CMS identifier. --disable-rpc and GFN_DISABLE_RPC=1 turn off the Discord rich presence, which is the setting to use if you would rather the wrapper did not report what you are playing to a third party service.

The stream quality overrides are GFN_RESOLUTION_WIDTH=<px>, GFN_RESOLUTION_HEIGHT=<px> and GFN_REFRESH_RATE=<hz>, which override the reported stream width, height and refresh rate.

The wording matters here: these override what is reported to the service, not what your display is set to. A user who sets GFN_RESOLUTION_HEIGHT=144 on a 1080p panel is telling the service to send a taller stream, which the panel will then scale or crop. The README does not spell out the consequences, so treat the override as a request to the service rather than a display setting.

Further documentation lives in the project wiki, with pages for basic usage, integrations and troubleshooting.

Where gfn-electron fits, and where it stops

The comparison worth making is with a plain browser, and with Nvidia's own clients for other platforms.

Against a browser, the difference is the container. A browser tab has no fullscreen integration with a compositor that behaves, no way to launch straight into a game, no way to write a desktop entry, and no hardware decode path you control. The wrapper supplies all of those, and the Steam Deck integration is the clearest case where the wrapper earns its keep, because a browser on a handheld is an awkward experience in a way the wrapper is not.

Against Nvidia's own clients for other platforms, the difference is status. This project is the Linux answer that a volunteer maintains, unlicensed by Nvidia and built on the web app rather than a native protocol implementation.

The limits follow from that. The first is the one the README states: application behaviour depends on the current GeForce NOW web interface and can change when upstream web functionality changes. This is a wrapper whose target moves, and the maintenance burden lands on whoever maintains the wrapper. The second is the volunteer nature of the project, where contributions occur as contributor availability permits, which is the honest way of saying the response time to a GeForce NOW change is unpredictable.

The third is the privacy surface. The wrapper loads the official web application and adds Discord rich presence, which is an extra channel that reports your activity to a third party service, though it can be disabled with --disable-rpc or GFN_DISABLE_RPC=1. The README also points at PRIVACY.md and SECURITY.md for how personal data is handled and how vulnerabilities are reported.

On maintenance, the release cadence is weekly: three releases in five weeks across September and October 2026, which is fast for a volunteer project and consistent with the web app changing often. The last push was on 2026-10-16 and the repository is not archived.

For a Linux user without a native client, or a Steam Deck owner, this is the practical answer. For anyone who needs a real streaming client, it is a wrapper around a website, and that is what you are installing.

Editorial conclusion

gfn-electron suits a Linux user who wants GeForce NOW in a native window with a Steam Deck friendly layout and does not mind that the service is delivered as a web application inside Electron. It is the wrong tool if you need a client that speaks to Nvidia's own streaming protocol, since this one loads the official web app and inherits whatever the web app does. Before installing, read the known limitations, because the README states that behaviour depends on the current GeForce NOW web interface and can change when upstream web functionality changes, and prefer the Flatpak over a manual package since manual installation receives less maintainer support.

Frequently asked questions

Official sources

1. hmlendea/gfn-electron on GitHub
2. Issues
3. License: GPL-3.0
4. README
5. Releases