Sunshine Control Panel: a Tauri desktop manager for Sunshine game streaming

What Sunshine Control Panel adds to a Sunshine install

Sunshine is the host side of Moonlight game streaming. Once it is running, the usual way to configure it is a web UI served by the Sunshine process itself. This project is a separate Windows desktop application that puts a native window over the same configuration surface and adds things the web UI does not have: a game library with grid and list views, a launcher with pre-launch and post-launch scripts, process memory charts, and a manager for the virtual display driver.

The README is explicit that the Tauri GUI is an optional component and that it does not affect Sunshine core functionality. That framing matters. This is not a fork of Sunshine and it is not a replacement for the streaming host. It is a front end that talks to a Sunshine instance over HTTPS and to a handful of external services, and it is aimed at Windows users who already have Sunshine running and want a desktop-shaped interface for it rather than a browser tab.

The feature list is broad for a companion app: update management with pre-release channel switching, a service mode versus user mode toggle, Sunshine start, stop and restart, paired device management, encoder selection for H.264, H.265 and AV1, bitrate adjustment, HDR switching, Moonlight Web service management, a bilingual interface in Chinese and English, and an AI assistant the project calls 米塔 AI that configures multiple models and adds a desktop pet.

The Axum proxy on port 48081 and how requests reach Sunshine

The architecture diagram in the README shows three layers. A WebView2 client runs the Vue 3 and Vite front end with composables such as useApps, useTauri and useTheme. That front end calls into the Tauri 2 Rust core through the IPC bridge using invoke and events. The Rust side then splits into three paths: an Axum proxy listening on port 48081, system access through WMI COM and winreg, and an AI proxy built on reqwest.

The proxy is the interesting part. It forwards HTTPS requests to the Sunshine service, which the diagram places on port 47990, and it also fronts the Steam Store API and handles CORS. That means the cover search feature, which lets you right-click an app and pull candidate artwork from Steam, does not require the webview to talk to Steam directly. The Rust side does it and returns the results. The same proxy pattern covers GitHub Releases for the update checker and the LLM API for the AI assistant.

System access is split from network access. WMI queries and Windows registry reads go through a separate Rust module, and the README lists the source files that own each concern: proxy_server.rs for the Axum proxy, sunshine.rs for process management and path utilities, system.rs for WMI process queries and memory statistics, fs_utils.rs for the game scan and Steam cover upload, vdd.rs for the virtual display driver, and windows.rs for registry and autostart. The memory monitoring feature is built on Win32 API calls rather than WMI, which the tech stack section states directly.

One detail worth flagging: the diagram shows the VDD driver access as a dotted line from the system module to the driver, meaning registry-based configuration rather than a live API. The README does not describe how the driver install itself is performed, only that install, configuration and EDID management are features.

Installing Sunshine Control Panel and building it from source

There is no published installer described in the README. The project documents a development and build workflow, and the package.json confirms it: the scripts are npm and Tauri commands, and the version field is 0.0.0-dev. The prerequisites listed are Node.js and npm, Rust and Cargo for Tauri, and the Windows SDK.

Start by installing dependencies in the project root. The README gives this as the first step.

npm install

For a development run that proxies to a Sunshine service, the README gives npm run dev. Note that the package.json version of this script first builds native plugins through a PowerShell script before starting Tauri, so the first run does more than launch a dev server.

npm run dev

If you only want the front end without the Tauri shell, the README documents a renderer-only mode.

npm run dev:renderer

When you want to work on the Sunshine web UI and this GUI at the same time, the README describes a dev-webui mode. You start the WebUI dev server in the Sunshine root on port 3000, then start Tauri with the WEBUI_DEV_TARGET environment variable pointing at https://localhost:3000. The Tauri proxy forwards to that dev server, hot module replacement works, and API requests are still proxied to the Sunshine service at https://localhost:47990.

npm run dev-webui

For a production build, the README lists three commands. build:renderer compiles the renderer, build produces the full application, and build:win runs the Windows installer script.

npm run build:win

The README warns that the first build downloads and compiles Rust dependencies and takes a long time. After a successful build, the compiled GUI is installed into the Sunshine tree at assets/gui/sunshine-gui.exe. There is also a beta path, npm run build:beta, which sets BETA=true and builds the Tauri app with a beta feature flag.

Where the project is thin, and the cases it does not cover

The README does not document a rollback path for the update manager. It lists automatic update checks, download progress, one-click install and a Beta and pre-release channel toggle, but nothing about reverting to a previous version after an update. If you switch to the beta channel and a build misbehaves, the documentation is silent on how to go back. Recent releases include a test build tagged dpi-freeze-test-1 described as verification for a display configuration freeze fix, which suggests display configuration changes have been a source of panel freezes. That is a build label, not a documented workaround.

The platform constraint is the harder one. The prerequisites name the Windows SDK, the system layer uses WMI COM, winreg and Win32 API calls, and the driver management is for IddCx virtual display drivers. Nothing in the README suggests a Linux or macOS path. If your Sunshine host runs on Linux, this project is not the tool for you, and the Sunshine web UI remains the supported interface.

The install story is the other limitation. A user who wants a GUI for Sunshine and does not have a Rust toolchain cannot use this without setting one up. The README's note that the Tauri GUI is optional is accurate, but it also means there is no supported lightweight route in: you either build it or you do not run it. There is no mention of a prebuilt binary download in the README, and the repository does not describe one.

Finally, the AI assistant is the least specified part. The README says it provides large model capability for Sunshine and clients, with multi-model configuration and a desktop pet, and the architecture shows an AI proxy using reqwest to an OpenAI-style LLM API. It does not document which models are supported, how credentials are stored, or what the assistant can actually change in the Sunshine configuration.

Sunshine Control Panel versus the Sunshine web UI and LizardByte's Sunshine

The obvious alternative is the Sunshine web UI that ships with Sunshine itself. Both configure the same host. The difference is in shape and in scope. The web UI is served by the Sunshine process and is reachable from any browser on the network. This project is a local Windows desktop application with a native window, a floating toolbar and a log console, and it adds a game library, a launcher with pre and post scripts, process memory charts and driver management that the web UI does not provide. If you only need to set encoder, bitrate and paired clients, the web UI does the job and requires nothing installed on the client machine.

The other reference point is LizardByte/Sunshine, the upstream project this GUI is built around. This repository is not a fork of it in the sense of replacing its streaming code. The README states the GUI installs into Sunshine's assets/gui directory and is optional. Upstream Sunshine is where the streaming protocol, the encoder pipeline and the host service live. This project depends on that, and its release notes use the name Sunshine GUI, which is consistent with it being a component rather than a separate streaming stack. Choosing between them is not really a choice: you run Sunshine, and then you decide whether to add this panel on top.

A third comparison worth making is against doing the same work with scripts. The launcher's pre and post script feature, which the README describes as configuring scripts for things like virtual display and resolution switching, is the kind of thing people already do with batch files. The panel's value there is that the scripts are attached to library entries and triggered from the same UI that starts the game, rather than being a separate manual step.

Maintenance, licensing and the cost of keeping it current

The repository is not archived and the last push was on 2026-09-14, one day before this assessment. Release cadence in the repository is tight: v0.4.46 and v0.4.47 both landed on 2026-09-09, and a test build followed on 2026-09-10. That pattern means upgrade work is real work. The update manager exists precisely because builds move quickly.

The upgrade cost has two parts. The first is the build itself. Because the GUI is compiled into Sunshine's assets/gui directory, updating either Sunshine or the GUI means rebuilding the Tauri application, and the README warns that a first build compiles Rust dependencies and takes a long time. The second is the beta channel. The build:beta script sets BETA=true and builds with a beta feature flag, and the update manager can switch to pre-release versions. Pre-release builds are where the display configuration freeze work was being verified, so the beta channel is not a low-risk track.

On licensing, the repository is MIT. That is permissive and compatible with the kind of redistribution the install layout implies, but it says nothing about the licences of Sunshine itself, the virtual display driver, or the LLM API you point the AI assistant at. Sunshine is a separate project with its own licence, and the README does not state which one. If you plan to ship a build to other people, check the licence of every component you bundle, including the native plugins that the build scripts compile. This is a description of what the repository states, not legal advice.

Reading the update and service controls before you rely on them

Two operational details in the README deserve attention before you depend on this panel for day-to-day streaming. The first is the port mismatch between the two documented values. The architecture diagram places the Sunshine service on HTTPS port 47990, and the Axum proxy on port 48081. The dev-webui section repeats 47990 as the Sunshine service address. If your Sunshine instance is configured on a different port, the proxy configuration is the place that would need to change, and the README does not document a setting for it.

The second is the service mode toggle. The README lists switching between service mode and user mode as a one-click action, alongside start, stop and restart of the Sunshine service. Those operations touch a Windows service, and the panel runs them from the Tauri side. The README does not describe what happens to an active stream if you toggle the mode mid-session. Given that the app also has an anti-sleep feature that keeps the screen and system awake during streaming, the intended use is clearly to leave the panel running while you stream, which makes the absence of a documented safeguard around service restarts a gap worth testing on a non-critical session first.

Editorial conclusion

Adopt it if you run Sunshine on Windows and want the game library, VDD driver controls and service toggles in one desktop window, and you accept that the GUI is an optional component you build yourself with Rust and Node. Skip it if you are on Linux, if you want the plain Sunshine web UI that LizardByte ships, or if you are not prepared to build a Tauri app from source. Before installing, verify that your Sunshine install has an assets/gui directory for the compiled sunshine-gui.exe, and confirm which port your Sunshine service actually listens on, because the README documents 47990 while the proxy listens on 48081.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. qiin2333/sunshine-control-panel on GitHub
4. README
5. Releases