Remote Mac

2026 Tailscale Remote Mac Always Uses DERP? OrbStack SSH Latency Troubleshooting

VS Code connects, but terminal input lags and repository operations crawl.

The fastest fix for high 2026 Tailscale DERP latency is to check status, ping, and netcheck from both ends first; restore a direct path when the network allows it, use Peer Relay when strict NAT blocks direct traffic, and keep OrbStack’s localhost-only SSH behind the Mac host.

Who should read this

This guide is for anyone using a home or office Mac mini as a daily remote development node and seeing a relay path for a long time.

It also fits engineers using VS Code Remote SSH to reach the Mac before entering an OrbStack Linux environment, and small teams deciding whether to maintain their own node or move to a cloud Mac rental service.

A slow OrbStack terminal is not automatically an OrbStack performance problem. The same symptom can come from the Tailscale path, unstable UDP mapping, SSH forwarding, a container listening on the wrong address, or a Mac that is no longer fully awake.

The first diagnosis: path before workload

A common misdiagnosis looks like this:

  • VS Code opens the remote folder.
  • The integrated terminal accepts input with visible delay.
  • Git fetches or dependency downloads appear unusually slow.
  • The operator changes container CPU or memory settings.
  • The behavior remains unchanged.

The first connection output can also mislead. Tailscale may begin through a DERP relay and later establish a direct connection, or it may remain relayed because the two networks cannot create a usable peer-to-peer path. A single successful login does not prove that the stable data path is direct.

Tailscale documents three relevant connection paths: direct, Peer Relay, and DERP. They are different network paths, not fixed performance grades. A direct path is normally the first path to investigate for a private development node. Peer Relay is a controlled fallback when direct connectivity is not available. DERP remains a relay fallback, but its location and route can make interactive SSH feel worse than a nearby direct or peer-relayed path. See the official Tailscale connection type definitions.

Use this order:

  1. Identify the actual connection type.
  2. Check UDP and NAT conditions on both networks.
  3. Confirm whether SSH terminates on the Mac or somewhere inside OrbStack.
  4. Trace container traffic from the remote client to the service.
  5. Test the Mac after lock, sleep, restart, and power recovery.

This order prevents a host performance change from hiding a network problem.

Connection evidence: direct, Peer Relay, or DERP

Run the commands on both the access computer and the remote Mac. The two devices can see different local network conditions, so checking only one side leaves an important gap.

On the access computer: inspect the peer state

Run:

tailscale status

Look for the remote Mac entry and record whether Tailscale reports a direct connection, a peer relay, or a DERP relay. The exact formatting can vary by version, so the important evidence is the path label and the peer identity, not the spacing of the output.

Then run:

tailscale ping <remote-mac-name-or-tailnet-ip>

The output is useful because Tailscale can report how the ping was delivered. The Tailscale ping reference explains the distinction between ordinary network reachability and the path selected for the probe.

Interpret the result as follows:

  • If the result identifies a direct path, continue by testing SSH interaction and application traffic. Do not change OrbStack yet.
  • If it identifies Peer Relay, check whether the peer relay is close enough and stable for the workload. Treat it as a deliberate fallback, not as evidence that DERP is broken.
  • If it identifies DERP, move to NAT and UDP checks before changing container settings.

On both devices: inspect connectivity conditions

Run:

tailscale netcheck

Execute it once on the access computer and once on the remote Mac. Record UDP availability, the reported mapping behavior, and the preferred DERP region. Tailscale’s device connectivity guidance and firewall documentation provide the relevant interpretation of blocked or restricted traffic.

The next branch is conditional:

  • If both sides report usable UDP and the path still remains DERP, inspect local firewalls, outbound filtering, router behavior, and changing endpoint mappings.
  • If one side cannot use UDP, improve that side first. A single restrictive network can keep the session away from direct connectivity.
  • If both sides sit behind restrictive NAT, stop expecting a configuration tweak to guarantee direct P2P connectivity. Evaluate Peer Relay.
  • If the path changes between direct and DERP, test the network at different times before declaring OrbStack unstable.

No network adjustment guarantees a direct path. The goal is to establish the best path available under the actual NAT and firewall conditions.

Important: A DERP path is not automatically a security failure. The troubleshooting question is latency, stability, and route suitability. Security decisions still depend on access controls, device identity, and service exposure.

NAT and UDP: the real relay triggers

“No public IP” does not mean “no direct connection.” Tailscale can create direct peer paths through NAT traversal when the two networks permit the required traffic. Conversely, having a public-facing router does not guarantee a stable direct path if the local firewall or upstream network filters UDP.

Separate the likely causes instead of treating NAT as one category:

  • Hard or symmetric NAT: endpoint mappings may not be reusable between peers, making direct negotiation difficult.
  • Two restrictive networks: both the office and home networks can contribute constraints, even if each works normally for web browsing.
  • Enterprise firewall policy: outbound UDP or related traffic may be filtered while TCP-based applications continue to work.
  • Changing egress mappings: mobile, office, and managed networks can change the observed endpoint during a session.
  • Host firewall rules: the Mac may be online while local rules interfere with Tailscale traffic or SSH.

Use the evidence from netcheck, then apply the least disruptive response:

  • If one network can be changed, improve its UDP handling or NAT behavior and test again.
  • If neither network can be changed, evaluate Peer Relay using Tailscale’s Peer Relay documentation.
  • If a nearby, controlled peer can carry the traffic, compare that option with the current DERP route.
  • Consider a custom DERP deployment only after proving that the problem is relay location or policy, not a broken SSH or OrbStack design.

A custom DERP server is not a universal latency cure. It adds operations, availability, access, and update responsibilities. If the Mac is also expected to survive unattended restarts, that operational cost matters.

OrbStack SSH: keep the Mac as the entry point

OrbStack’s built-in SSH is an important boundary. Its default behavior allows localhost connections rather than treating the built-in endpoint as a general remote access service. The OrbStack SSH documentation is the authority for this behavior.

The safe default path is:

Remote client
    -> Tailscale
        -> Mac system SSH
            -> OrbStack Linux machine
                -> shell or development service

Do not turn an OrbStack localhost port into a broadly exposed Tailnet or internet-facing endpoint merely because the Mac itself is reachable.

Use one of these designs:

Mac-first access

Log in to the Mac through Tailscale SSH or the Mac’s system SSH service. From that session, enter the OrbStack Linux machine using the supported local workflow. This keeps the initial trust boundary on the Mac and avoids exposing the built-in OrbStack SSH listener.

This design is usually the right choice when the engineer needs the Mac host, several OrbStack machines, or host-side tools in the same session.

Dedicated Linux SSH

If the Linux environment must be addressed independently, configure an SSH service inside the relevant Linux machine and manage its user authorization separately. The service should listen only where the architecture requires it. Its keys, users, logs, and update process should not be treated as identical to Mac access.

For VS Code Remote SSH, use a host entry that reflects the intended hop. The first host can be the Mac, with a controlled jump or forwarding arrangement for the Linux environment. The VS Code Remote SSH documentation covers host aliases, SSH configuration, and jump-style access patterns.

The decision rule is simple:

  • If the editor only needs a shell and files inside OrbStack, use Mac-first access.
  • If several users or tools require independent Linux identity and service access, configure a dedicated Linux SSH service.
  • If the only reason to expose an OrbStack port is convenience, remove the exposure and keep the connection on the Mac host.

Container ports: trace the full data flow

A container port that opens on the Mac does not automatically become reachable from a remote Tailnet client. Several addresses can be involved:

Remote client
    -> Mac Tailscale address
        -> Mac host firewall and port binding
            -> OrbStack virtual network
                -> Linux machine or container
                    -> service listening address

Check each boundary.

Container port mapping

Confirm that the container publishes the service port to the expected OrbStack or host interface. A service bound only to a container-local address may not be reachable through the host mapping. The OrbStack container networking documentation explains the relevant port and network behavior.

Host networking

If the workload uses host networking, the service may bind differently from a normal container port mapping. Check the actual listening address inside the Linux environment and on the Mac-facing side. Do not assume that a successful local browser test proves remote reachability.

Linux service binding

A service listening on 127.0.0.1 inside the Linux machine is not equivalent to a service listening on the machine’s reachable interface. Change the binding only when the service needs remote access, and pair it with authentication and an allowlist.

LAN exposure settings

OrbStack network settings can affect whether a published service is available beyond the local Mac. Treat an “expose to LAN” option as a deliberate trust decision, not a generic connectivity fix. If the remote client already reaches the Mac through Tailscale, exposing the service to the physical LAN may be unnecessary.

Use this test sequence:

  • From the Mac, test the service through the local host address.
  • From the remote client, test the Mac’s Tailscale address and intended port.
  • If the first works and the second fails, inspect Mac binding, firewall, and OrbStack exposure.
  • If both fail, inspect the Linux service binding and container mapping.
  • If the second works without authentication, add access control before keeping the port available.

Avoid an all-ports rule. It expands the attack surface and makes later troubleshooting harder because unrelated services become reachable through the same path.

Sleep and restart: separate offline from relayed

A relay diagnosis is irrelevant when the Mac is not fully online. After sleep, restart, or power loss, the failure may be at the host lifecycle layer rather than the network path.

Check these areas on the Mac:

  • Automatic sleep behavior for the intended power source.
  • Network wake or related wake settings where the model and macOS version support them.
  • Automatic startup after power failure, if the hardware and firmware expose that option.
  • Tailscale login state after restart.
  • System SSH availability after the user session is locked.
  • OrbStack machine state after the host returns.
  • The development service’s own restart policy.

Apple’s desktop energy and sleep settings should be used as the reference because available options can vary by Mac model, power state, and macOS version.

A useful unattended acceptance run is:

  • Lock the Mac and verify Tailscale reachability.
  • Let the Mac sleep and test Tailscale status, ping, and system SSH.
  • Restart the Mac and confirm that Tailscale reconnects without interactive repair.
  • Stop and restore power if the deployment requires power-loss recovery.
  • Confirm OrbStack machines and development services after each recovery state.
  • Record whether the path is direct, Peer Relay, or DERP after recovery.

If Tailscale reports a valid path but SSH fails after sleep, inspect host login state, firewall rules, and service startup. If the device disappears from Tailscale entirely, investigate wake, power, network association, and automatic login behavior before tuning SSH.

Decision branches for the next move

Use these conditions rather than changing several layers at once:

  • If tailscale ping is direct and SSH is slow: keep the network unchanged and inspect Mac load, SSH multiplexing, disk activity, and OrbStack workload.
  • If the result is DERP and both sides have usable UDP: inspect firewall and NAT behavior, then test again before considering relay changes.
  • If strict NAT remains after network review: choose Peer Relay when a controlled peer and acceptable route are available.
  • If OrbStack SSH is the only exposed endpoint: move access to Mac system SSH and enter the Linux environment locally.
  • If the container works on the Mac but not through the Tailscale address: inspect port mapping, binding, host firewall, and exposure settings in that order.
  • If recovery after sleep or power loss fails: prioritize host lifecycle reliability over further network optimization.
  • If the node stays dependent on a distant DERP route and cannot meet unattended recovery needs: compare a continuously available cloud Mac with the maintenance burden of the self-hosted node.

This also answers the common question about whether to build a private DERP server. Choose it only when the existing relay path is the proven bottleneck and the team is prepared to operate another network service. Otherwise, Peer Relay or a better-connected Mac host may solve the problem with less operational overhead.

Self-hosted Mac or cloud Mac: final comparison

Before changing providers or hardware, save the evidence: path type, netcheck output, SSH entry point, container exposure, sleep result, restart result, and power-recovery result. That record turns a vague “remote Mac feels slow” complaint into a purchasing decision.

Option Strong fit Main limitation Choose it when
Self-hosted Mac mini Existing hardware, physical access, local files, controlled home or office network Requires power, wake, updates, NAT troubleshooting, and recovery checks The owner can maintain the node and accepts occasional network or host operations
Peer-relayed self-hosted Mac Strict NAT where direct traffic is not dependable Still depends on the Mac being online and on the relay path remaining suitable Direct access cannot be restored, but the node’s lifecycle is reliable
Cloud Mac through KuzCloud Temporary development, remote access without home-network administration, team evaluation Rental terms, region, and access model must match the workload The team values predictable availability over maintaining physical hardware

A self-hosted Mac remains attractive when local peripherals, resident data, or long-running workloads justify ownership. It becomes a poor long-term fit when the node repeatedly disappears after sleep, depends on a distant DERP route, or requires a technically skilled person to restore access after every power event.

KuzCloud’s Mac rental options can be compared by the required region, delivery method, online availability, and rental period rather than by a single latency claim. Teams that already know the target region can review the regional Mac pricing pages and confirm access details through the KuzCloud help center.

For a temporary environment, a cloud Mac removes several weaknesses of the current setup: no home router NAT to repair, no dependence on household power, and no need to expose OrbStack services through a personal network. It does not remove every decision, because developers still need to verify SSH policy, region, persistence, and software compatibility. However, when direct connectivity remains unavailable and sleep recovery fails acceptance, renting an always-available Mac is often a cleaner engineering choice than continuing to tune OrbStack ports around an unreliable host.

Move Your Remote Mac Workloads to KuzCloud

Deploy an always-on cloud Mac to avoid sleep, home-network, and intermittent connectivity issues.

Run SSH sessions, development tools, and containerized workloads on a remotely accessible Mac.