SolarFlare

A game-streaming host for Moonlight.

A Linux game-streaming host for Moonlight, built for local networks.

Website | Install | Interface | Architecture | Configuration | Build | Changelog

---

Overview

SolarFlare is a self-hosted game-streaming server for Moonlight clients. It combines low-latency Linux capture and transport with a Web UI for pairing devices, managing applications, changing host settings, and checking logs.

Primary use	High-quality game and desktop streaming across a trusted local network
Host focus	Linux x86-64, with build and runtime tuning for modern AMD and Intel CPUs
Client protocol	Moonlight / NVIDIA GameStream-compatible transport
Control plane	Responsive HTTPS interface at https://localhost:47990
Current release	v1.1.0
Build tag	v2026.804.1-solarflare

Important

SolarFlare preserves the executable name, service identifier, ports, state format, and configuration directory used by Sunshine so existing Moonlight pairings remain compatible. User-facing product identity is SolarFlare; compatibility identifiers such as sunshine, SUNSHINE_CLIENT_*, and ~/.config/sunshine intentionally remain unchanged.

Fork additions

System	SolarFlare approach
Host control	A responsive Web UI with command search, host status, and troubleshooting tools
Network path	Link-aware pacing, optional busy polling, expanded ENet buffers, DSCP tagging, and adaptive bitrate controls
Scheduling	Capture-thread affinity, controlled real-time scheduling, native CPU tuning, and optional boot-time performance services
Video	NVENC tuning profiles, per-application encoder overrides, headless display paths, and hardware-aware capture selection
Audio	Low-latency PipeWire hints plus optional AGC, voice activity detection, ducking, noise gating, and Opus controls
Operations	Scoped API tokens, trusted-subnet pairing, a local client catalog, and structured logs

SolarFlare exposes these as individual controls. Defaults stay compatible with upstream, and each tuning path can be disabled when comparing hosts.

Web interface

The Web UI covers routine host setup and troubleshooting. Animation is limited to interactions and state changes.

Pair a client Focused PIN entry with clear host state.	Manage applications Launch definitions, artwork, and import tools.
Discover clients A local Moonlight client catalog with no third-party runtime fetch.	Tune the host Search or browse settings by category.
Inspect the pipeline Logs, diagnostics, and recovery actions in one place.	Monitor the host Connection state, release status, and direct actions.

Performance architecture

flowchart TD
  UI["Web UI"] --> CFG["Host configuration"]
  CAP["Display capture"] --> ENC["Hardware or software encoder"]
  ENC --> NET["SolarFlare network path"]
  AUD["Audio capture and optional FX"] --> NET
  NET --> ML["Moonlight client"]
  CFG --> CAP
  CFG --> ENC
  CFG --> AUD
  CFG --> NET

Loading

The fork-specific path sits in four areas:

1. Capture: X11, KMS, PipeWire/portal, headless compositor, and optional Hermes-KMS paths are selected according to the build and host environment.
2. Encode: NVENC presets and per-application overrides tune latency, lookahead, adaptive quantization, and frame structure without changing the Moonlight protocol.
3. Transport: Link-speed detection, pacing, socket buffers, busy polling, QoS marking, and adaptive bitrate respond to local-network conditions.
4. Control: The HTTPS UI, API scopes, pairing rules, and diagnostics expose host state. No cloud services sit in the streaming path.

See SolarFlare configuration for fork controls and the complete configuration reference for inherited host options.

Install

Supported release profile

SolarFlare v1.1.0 publishes three Linux x86-64 files:

Asset	Purpose
sunshine-x86_64	Stripped executable for updating an existing SolarFlare install
solarflare-linux-x86_64.tar.gz	Executable plus matching runtime and Web UI assets for existing installs
SHA256SUMS	SHA-256 checksums for both downloads

Caution

New users should always build fresh with ./scripts/linux-install.sh. The release binaries are only for people updating an already working SolarFlare install. Prefer Update now in the Web UI when that path is available.

Build from source for Web UI changes, desktop files and icons, shaders, udev rules, the systemd user service unit, and installer helpers such as solarflare-update-apply. The bare sunshine-x86_64 file is the executable only.

The sunshine-x86_64 compatibility filename is intentional. SolarFlare keeps the executable and service names expected by existing Sunshine installations and Moonlight pairings.

The source tree retains inherited cross-platform code, but the SolarFlare release and performance profile documented here are maintained for Linux.

Fresh source installation

git clone --recursive https://github.com/vindeckyy/Solar-Flare.git
cd Solar-Flare
./scripts/linux-install.sh
systemctl --user enable --now app-dev.lizardbyte.app.Sunshine.service

The installer detects Arch/CachyOS, Debian/Ubuntu, Fedora-family, openSUSE, Bazzite, and NixOS hosts. On NixOS it enters the repository's reproducible Nix shell and installs into ~/.local. Read the porting guide for the required declarative host settings or before using an unsupported distribution.

scripts/linux-install.sh is the maintained SolarFlare path. scripts/linux_build.sh is the inherited upstream Docker/CI builder and is not required for normal installs. scripts/cachyos-build.sh remains as a compatibility wrapper that forwards to linux-install.sh.

Update an existing installation

Use Update now on the outdated Web UI banner. Open the chevron to watch the command log. That path downloads solarflare-linux-x86_64.tar.gz, checks SHA256SUMS, installs the binary and assets, then restarts. An active stream blocks apply until the session ends.

If the install lives under /usr/local, you need the solarflare-update-apply helper from ./scripts/linux-install.sh or cmake --install.

Manual binary-only fallback:

systemctl --user stop app-dev.lizardbyte.app.Sunshine.service
sudo curl --fail --location \
  --output /usr/local/bin/sunshine \
  https://github.com/vindeckyy/Solar-Flare/releases/latest/download/sunshine-x86_64
sudo chmod 0755 /usr/local/bin/sunshine
sudo setcap 'cap_sys_admin,cap_sys_nice+p' /usr/local/bin/sunshine
systemctl --user start app-dev.lizardbyte.app.Sunshine.service

Verify the host

systemctl --user --no-pager status app-dev.lizardbyte.app.Sunshine.service
getcap /usr/local/bin/sunshine
journalctl --user -u app-dev.lizardbyte.app.Sunshine.service -n 50 --no-pager
curl --insecure --output /dev/null --write-out '%{http_code}\n' \
  https://localhost:47990/

An unauthenticated curl request should return 401; the browser login page becomes available after credentials are configured.

Configuration

Configuration remains at ~/.config/sunshine/sunshine.conf, with application definitions in ~/.config/sunshine/apps.json.

Area	Representative controls	Documentation
Network	busy_poll_us, rate_cap_pct, enet_4mib_buffer, dscp_qos	Fork controls
Scheduling	cpu_pinning, gpu_governor	Scheduling behavior
Capture	headless_virtual_display, skip_wayland_correlation	Capture controls
Latency	latency_mode (safe / aggressive)	Latency mode
Video	nvenc_tuning_preset, adaptive bitrate, codec and quality controls	Complete reference
Audio	pipewire_latency_ms, sf_audio_*, sf_opus_*	Audio FX
Access	Scoped API tokens, trusted subnets, pairing, origin policy	API / Security

For a minimal per-application encoder override:

{
  "name": "Competitive profile",
  "cmd": "steam steam://rungameid/730",
  "encoder-preset": 0
}

Preset values are -1 for the host default, 0 for latency, 1 for balanced, and 2 for quality.

Build and test

The project uses CMake, Ninja, Vite, and GoogleTest. Keep build directories under the cmake-build- prefix.

git submodule update --init --recursive

cmake -S . -B cmake-build-release -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_DOCS=OFF \
  -DBUILD_TESTS=OFF
cmake --build cmake-build-release --target sunshine web-ui -j2

To run the test suite:

cmake -S . -B cmake-build-tests -G Ninja \
  -DCMAKE_BUILD_TYPE=Debug \
  -DBUILD_TESTS=ON \
  -DBUILD_DOCS=OFF
cmake --build cmake-build-tests --target test_sunshine -j2
./cmake-build-tests/tests/test_sunshine --gtest_brief=1

Platform-specific dependencies and compiler requirements are documented in Building and Porting SolarFlare.

Repository map

Path	Purpose
src/	Streaming host, transport, capture, encode, audio, and configuration
src_assets/common/assets/web/	SolarFlare Web UI
tests/	Unit, integration, regression, and documentation contracts
packaging/	Platform packaging and optional Linux performance services
scripts/	Linux installer, release, screenshot, and maintenance tooling
docs/	User, operator, developer, and inherited configuration references

Documentation

Document	Use it for
Getting started	Inherited platform background and client prerequisites
SolarFlare configuration	Fork-specific network, scheduling, audio, and capture controls
Complete configuration	Every inherited host option
Porting	Distribution packages, toolchains, and manual builds
Troubleshooting	Capture, encoder, audio, networking, and input diagnostics
API	Automation and scoped host access
Security	Supported versions and private vulnerability reporting
SolarFlare changelog	Fork release and implementation history

Project policy

• Security: report SolarFlare-specific vulnerabilities privately through GitHub Security Advisories.
• Contributions: read CONTRIBUTING.md and the development guide before opening changes.
• License: SolarFlare is distributed under GPL-3.0-only.
• Upstream: the GameStream foundation and inherited platform work come from LizardByte/Sunshine. Internal compatibility names are retained where changing them would break clients, configuration, packaging, or update paths.
• Acknowledgment: SolarFlare's Linux capture, compositor, and stream-health design was informed by reviewing papi-ux/polaris. Thanks to its contributors. SolarFlare remains a Sunshine-derived project; that review was design inspiration, not incorporated source.

---

SolarFlare
_{Self-hosted streaming on your LAN. No cloud in the path.}