How SjslTech Streams PC Games to R36S with ZimaBoard 2

Thank you to SjslTech for documenting and sharing this real-world build. His full video guide demonstrates how ZimaBoard 2, Sunshine, Tailscale, Moonlight, and an R36S handheld can work together as a portable PC game-streaming setup. This article reorganizes that build into a clear system overview and adds the network conditions, headless-server details, and limitations worth understanding before you reproduce it.

Collaboration disclosure: This article was created in collaboration with SjslTech and is based on the setup and tests shown in his video. The video description identifies his ZimaBoard 2 link as an affiliate link and includes the coupon code SjslTech. Streaming results will vary with the game, host configuration, handheld firmware, and network route.

Quick answer: the R36S does not run the Windows game itself. The host runs and renders the game, Sunshine encodes the video, Tailscale provides a private path between networks, and Moonlight displays the stream on the handheld while sending controller input back to the host.

The Build at a Glance

The useful idea behind SjslTech's build is separation of work. A budget handheld may not have the hardware or operating system needed to run a PC game locally, but it can still act as a streaming client. The heavier work remains on the Windows host, while the R36S handles video decoding, networking, and input.

In the video, the server is configured on Windows 11; SjslTech notes that the process is also applicable to Windows 10. The compact host is a ZimaBoard 2 single-board server. The complete data path looks like this:

PC game on ZimaBoard 2 → Sunshine → Tailscale network path → Moonlight on R36S → controller input returned to the host

Why Add Tailscale to Moonlight Game Streaming?

Moonlight and Sunshine work naturally when the host and client are on the same local network. The challenge begins when the handheld leaves home. The host is now behind one router, the R36S is behind another, and exposing a streaming service directly to the public internet introduces both setup friction and unnecessary risk.

Tailscale addresses the connectivity layer. Both devices join the same encrypted private network and receive identities that remain useful even when their local IP addresses change. In this workflow, Moonlight connects to the host through its Tailscale address or name instead of relying on public port forwarding.

That does not mean every remote session will have the same latency. Tailscale attempts to establish a direct peer-to-peer path. When a direct path is not possible, traffic can use a relay, which generally adds latency and reduces available throughput. The route, the host's upload connection, and the handheld's current network all matter.

What You Need Before Starting

• A Windows 10 or Windows 11 host that can run the target game and encode a stream at the same time.
• Sunshine installed on the host and Moonlight available on the R36S.
• Tailscale installed on both endpoints and signed in to the same tailnet.
• A compatible network adapter for the handheld if its hardware does not include built-in Wi-Fi.
• A stable network connection; Ethernet for the host is strongly preferred.
• Local access to the host for initial configuration and recovery.

Before adding remote access, confirm that the game launches correctly on the host. SjslTech makes an important point in the server-notes section: if the host already struggles to run a game, adding real-time capture and encoding will not solve that limitation.

How SjslTech Builds the Streaming Path

The 17-minute video follows a sensible dependency order. Sunshine is configured first, Tailscale is added to the server and handheld next, and Moonlight pairing happens only after both devices appear on the private network.

• 2:35 — Set up the Sunshine server on Windows.
• 7:12 — Add Tailscale to the host.
• 8:24 — Add Tailscale to the R36S.
• 11:57 — Verify both devices in the Tailscale dashboard.
• 12:22 — Pair the Moonlight client with the server.
• 14:45 — Prepare the host to run headless.
• 15:21 — Test game streaming on the handheld.

1. Configure Sunshine on the Windows Host

Install Sunshine from the official project site, then open its web interface and create administrative credentials. Add the desktop or the games you want Moonlight to launch. Keep the application, graphics driver, and Windows installation current before troubleshooting performance.

Test Sunshine and Moonlight on the local network first whenever possible. A successful local test separates streaming configuration from remote-network configuration. If the local session already has a black screen, controller issue, or severe stutter, adding Tailscale will not correct the underlying Sunshine or host problem.

2. Add Tailscale to the Host

Install Tailscale on Windows, sign in, and confirm that the host is online in the admin dashboard. Record its Tailscale device name and private address. Apply access controls so that only the intended devices or users can reach the host; a private network is most useful when its membership and permissions are kept narrow.

3. Add Tailscale to the R36S

SjslTech uses his open-source R36S Tailscale Manager to handle the client side. Follow the repository's current installation and compatibility notes rather than assuming that every R36S clone or custom firmware image behaves identically.

After authentication, verify that the R36S and Windows host both appear online in the same tailnet. This dashboard check is more than administrative housekeeping: it confirms the connectivity layer before Moonlight pairing begins.

4. Pair Moonlight with the Tailscale Host Address

In Moonlight, add the host using its Tailscale address or resolvable tailnet name. Moonlight should present a pairing PIN; approve that PIN through Sunshine on the host. Once paired, select the desktop or a configured game and start a session.

If the host appears locally but not remotely, do not immediately reinstall every component. First check whether both devices are online in Tailscale, whether access controls allow the connection, whether Windows Firewall permits Sunshine, and whether the host is awake.

Running the ZimaBoard 2 Host Headless

A compact server is most useful when it does not need a monitor, keyboard, and mouse attached for every session. SjslTech covers headless operation near the end of the guide, but a reliable headless setup requires more than simply unplugging the display.

• Set Sunshine and Tailscale to start with Windows.
• Prevent the host from entering a sleep state that cannot be recovered remotely.
• Confirm that Sunshine can capture an active display after the monitor is disconnected.
• If Windows removes the display context, use an appropriate dummy display adapter or a tested virtual-display solution.
• Plan a recovery path, such as local access or a separately secured remote-administration method.
• Avoid weakening Windows sign-in security merely to make automatic startup easier.

Test the entire boot-to-stream sequence before relying on it away from home: restart the host, leave it without a monitor, confirm that it returns to the tailnet, and then connect from Moonlight.

What the Game-Streaming Test Actually Shows

At 15:21, SjslTech moves from configuration to an R36S gameplay test. The important result is functional: the handheld reaches the host through the Tailscale path, Moonlight receives the Sunshine stream, and controller input reaches the remote Windows session.

This is valuable real-world evidence, but it should not be read as a universal benchmark. The video does not establish one guaranteed latency, bitrate, frame rate, or game-compatibility result for every network and every host workload.

How to Tune the Stream Without Guessing

There is no single “best” Moonlight preset for every R36S and every remote connection. Tune one variable at a time, beginning with the path most likely to create delay.

1. Stabilize the host connection. Use Ethernet when possible and stop background uploads that compete for outbound bandwidth.
2. Check the Tailscale route. Its connection-type documentation explains direct and relayed paths. A direct path is generally preferable for interactive streaming.
3. Start near the handheld's useful display resolution. Sending substantially more pixels than the client can display consumes bandwidth and encoding time without improving the visible result.
4. Lower bitrate before changing everything else. If blockiness, stalls, or large latency spikes disappear, the network path was likely overloaded.
5. Then test frame rate and resolution separately. Changing one setting per test makes the cause of an improvement visible.

Security Notes for Remote Game Streaming

The appeal of this design is that Sunshine does not need to be intentionally exposed as a public internet service. Keep the Sunshine interface protected with strong credentials, keep Windows and all three networking applications updated, review tailnet membership, and restrict access to the devices that need it. Do not share authentication links or reusable keys in screenshots or public troubleshooting posts.

Tailscale reduces the need for public port forwarding in this workflow, but it does not replace basic endpoint security. Anyone who gains access to the Windows account, Sunshine credentials, or authorized tailnet can potentially reach more than a game library.

Who This Setup Is For

This build makes sense for a tinkerer who already owns an R36S, wants to experiment with Windows game streaming, and values a compact host that can stay available without a desk full of peripherals. It is especially interesting for lighter PC games and for users who understand that the handheld is a terminal, not a replacement GPU.

It is less suitable when the target game already pushes the host to its limit, when the remote connection has inconsistent latency, or when the user expects competitive cloud-gaming responsiveness without tuning. If your primary goal is high-end AAA streaming, start by validating the host's local game and encoding performance rather than assuming the networking stack is the bottleneck.

Final Takeaway

SjslTech's build is compelling because each tool has one clear responsibility. ZimaBoard 2 provides the Windows host, Sunshine provides the stream, Tailscale provides private reachability across networks, and Moonlight turns the R36S into the remote screen and controller.

The strongest way to reproduce it is in layers: make the game stable on the host, prove Sunshine locally, bring both devices onto the same tailnet, pair Moonlight, and only then optimize remote performance and headless startup. That order turns a seemingly complicated remote-gaming project into a sequence of testable steps.

Frequently Asked Questions

Does the R36S run the PC game locally?

No. The Windows host runs and renders the game. The R36S receives a compressed video stream and sends controller input back through Moonlight.

Do I need Tailscale when both devices are at home?

Not necessarily. Sunshine and Moonlight can work on the same local network without Tailscale. Tailscale becomes useful when the host and handheld are on different networks or when you want consistent private addressing.

Does Tailscale guarantee low-latency streaming?

No. It can create a direct path, but some network combinations require a relay. Physical distance, routing, congestion, host upload bandwidth, and client connectivity still affect responsiveness.

Can ZimaBoard 2 replace a high-end gaming PC?

That depends on the games and performance target. Streaming does not remove the host's compute requirement: the host must run the game and encode the video simultaneously. Treat this build as a demonstrated compact streaming host, not a blanket performance promise for every PC title.

Can the host run without a monitor?

Yes, after headless behavior has been tested. Sunshine still needs a usable Windows display context, and the host must remain awake, networked, and able to start the required services after reboot.

Do I need to forward Sunshine ports on my router?

Not for the private Tailscale path demonstrated here. Both endpoints connect through the tailnet, so avoid exposing Sunshine directly to the public internet unless you fully understand and secure an alternative design.