> For the complete documentation index, see [llms.txt](https://docs.hello-robot.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.hello-robot.com/stretch4_docs/working-with-stretch/general_use/connecting-to-stretch.md).

# Connecting to Stretch

Stretch can be accessed in two ways:

* Tethered Setup: Directly connect a monitor, keyboard, and mouse to the robot
* Untethered Setup: Access the robot remotely from another computer

### Tethered Setup <a href="#tethered_setup" id="tethered_setup"></a>

Stretch 4 includes an onboard computer located within the robot’s trunk, commonly referred to as the Intel NUC. This system runs Ubuntu 24.04 and serves as the primary environment for development, testing, and visualization.

A tethered setup allows you to interact directly with the robot by connecting peripherals such as a monitor, keyboard, and mouse to the onboard computer.

#### Hardware Access and Ports <a href="#hardware_access_and_ports" id="hardware_access_and_ports"></a>

<figure><img src="/files/pLDpTyG3t2x6pKJmRMT8" alt=""><figcaption></figcaption></figure>

The main connectivity panel is located in the trunk, alongside the power controls. It provides:

* 3 × USB-A 2.0 ports
* HDMI port
* Ethernet port
* Power On/Sleep/Off button
* Charging port

Additional USB ports are distributed across the robot and are internally connected to the same onboard computer:

* Wrist: USB-A 2.0
* Head: USB-A 3.2 and USB-C 3.2

These ports allow you to connect peripherals and sensors at convenient locations depending on your setup.

#### Setting Up a Wired Connection <a href="#setting_up_a_wired_connection" id="setting_up_a_wired_connection"></a>

To begin using Stretch in tethered mode:

* Connect a monitor to the HDMI port in the trunk
* Connect a USB keyboard and mouse (wired or via wireless dongle)
* Power on the robot using the trunk’s On/Off button

After booting, the onboard computer will display the Ubuntu desktop environment on the connected monitor.

The default user login credentials came in the box with the robot. By default, the robot is not configured to ask for your password on boot, but may ask for it later if the NUC goes to sleep.

### Untethered Setup <a href="#untethered_setup" id="untethered_setup"></a>

> Once your robot is on the network, you can access it remotely from your computer. This is the preferred way to work with Stretch for most users. The options below range from full desktop access to lightweight development workflows.

#### RustDesk <a href="#rustdesk" id="rustdesk"></a>

If you plan to access Stretch through RustDesk without a physical monitor connected, you’ll need a dummy HDMI dongle. You don’t need the dongle during RustDesk installation. For setup, first connect the robot to your host computer with a standard HDMI cable. The dummy HDMI dongle is only required afterward, once RustDesk is installed.

**Why use this?**

RustDesk is the simplest way to access the full Stretch desktop remotely. It provides a complete graphical interface, making it ideal for working within the Ubuntu environment and using tools such as RViz without additional network configuration.

* Full desktop access
* Works across different networks (no VPN required)
* Minimal setup required
* Best balance for visualization and usability
* Requires a dummy HDMI dongle for headless use

**Install Steps**

1. [Download and install RustDesk](https://rustdesk.com/) on your host machine.
2. Make sure an HDMI cable is connected between your host computer and the robot. Open RustDesk on the robot, either from the applications menu or by running:

   ```
   rustdesk
   ```

<figure><img src="/files/oXNjXYakRJZFb3EgkzVL" alt=""><figcaption></figcaption></figure>

3. Note the `ID` shown in RustDesk, you will need it later.
4. Set a `Permanent password`:
   1. Click the edit icon:

      <figure><img src="/files/7ZTwHH99PrYqMXRcuyHY" alt=""><figcaption></figcaption></figure>
   2. Click `Security` on the left-hand side, then select `Unlock security settings`:

      <figure><img src="/files/jWa0LCESS6X1c3caP6R0" alt=""><figcaption></figcaption></figure>
   3. Click `Set permanent password` and set your password:

      <figure><img src="/files/EL4sDWzYDifhueQHeJXM" alt=""><figcaption></figcaption></figure>
5. Close RustDesk on the robot. Disconnect the HDMI cable, connect the dummy HDMI dongle to the robot, and open RustDesk on your host machine. Enter the robot’s `ID` and permanent password. That’s it, you now have a remote connection to the robot using RustDesk:

   <figure><img src="/files/hMdkUIe1xPnzfVv1kHry" alt=""><figcaption></figcaption></figure>

#### RDP / Tailscale <a href="#rdp_-_tailscale" id="rdp_-_tailscale"></a>

**Why use this?**

This setup gives you secure, direct access to Stretch from anywhere. Tailscale connects your computer and the robot on a private network, and RDP lets you open a full desktop session remotely.

* Full desktop access without needing a local connection
* Works across networks via Tailscale
* More setup required (VPN + remote desktop)
* Stable and reliable for longer sessions

**Install Steps**

1. **Create a Tailscale Account**: Go to the [Tailscale Sign Up Page](https://login.tailscale.com/start) and create an account using your preferred single sign-on (SSO) provider (such as Google, Microsoft, GitHub, or Apple). Select *Personal use* (which allows up to 100 devices for free) or *Business use*.
2. **Download and Install the Client**: Navigate to the [Tailscale Download Page](https://tailscale.com/download) and download the client that corresponds to your operating system (Windows, macOS, iOS, Android, Linux, or NAS devices).
   * **Tip for the Stretch Robot (Ubuntu)**: You can install Tailscale directly on the robot's onboard computer by running:

     ```bash
     curl -fsSL https://tailscale.com/install.sh | sh
     ```
3. **Log In and Connect**: Open the Tailscale app you just installed. The app will either prompt you to log in automatically through your default web browser, or you can click the Tailscale icon in your system tray/menu bar and click **Log in**. Log in with the same SSO credentials you used in Step 1, and authorize the connection.
   * **On the Stretch Robot (Linux)**: Run the following command to start and authenticate Tailscale:

     ```bash
     sudo tailscale up
     ```

     Open the URL printed in the terminal to authorize the robot on your Tailscale network.

**Connecting via RDP**

Once Tailscale is active on both your remote computer and the robot, you can access the robot's full Ubuntu desktop remotely via RDP:

1. **Enable Remote Desktop on the Robot**:

   * Access the robot's desktop (using a tethered monitor, or during initial setup).
   * Open the **Settings** application.
   * Search for **Remote Desktop** in the settings search bar (or navigate to **System** > **Remote Desktop**).
   * Toggle **Remote Desktop** to **ON**.
   * Under **Authentication**, note the username (typically `hello-robot`) and password, or set a new password. You will need these credentials to connect.
   * Make sure **Remote Control** is enabled so you can interact with the screen.

   <figure><img src="/files/75yrCUKQLSqab7P5l0Qg" alt=""><figcaption></figcaption></figure>
2. **Connect from Your Remote PC**:

   * Open the RDP client on your host computer:
     * **Windows**: Open the built-in **Remote Desktop Connection** tool (`mstsc`).
     * **macOS**: Download and open **Microsoft Remote Desktop** from the App Store.
     * **Linux**: Use a remote desktop client like **Remmina**.
   * Enter the robot's private **Tailscale IP address** (which you can find in the Tailscale Admin Console, or by running `tailscale ip -4` in the robot's terminal).
   * When prompted, enter the Remote Desktop username and password that you configured on the robot.

   <figure><img src="/files/pKHPlRlgMZU9ivMRFUX3" alt=""><figcaption></figcaption></figure>

> \[!NOTE] Just like with RustDesk, GNOME's built-in RDP server requires the dummy HDMI dongle to be plugged into the robot's trunk HDMI port if you plan to connect to it headlessly (without a physical monitor connected).

#### SSH + VS Code <a href="#ssh__vs_code" id="ssh__vs_code"></a>

**Why use this?**

This method is focused on development and performance. Instead of streaming a desktop, you connect directly to the robot’s environment, making it the fastest and most reliable option for coding, debugging, and running ROS nodes.

* No GUI, lightweight access
* Best performance (no streaming overhead)
* Ideal for development workflows
* Reliable across networks

**Install Steps**

1. [Download and install Visual Studio Code](https://code.visualstudio.com/download) on your Host machine.
2. Inside VS Code:
   * Go to `Extensions` (left sidebar or `Ctrl+Shift+X`).
   * Search for `Remote - SSH` (by Microsoft).
   * Click `Install`.
3. Open SSH Configuration:
   * Press: `Ctrl + Shift + P`.
   * Type: `Remote-SSH: Open SSH Configuration File`.
   * Select: `~/.ssh/config`.
4. Add Your Stretch Robot:
   * Add a new entry like this:

     ```
     Host stretch
         HostName <ROBOT_IP>
         User hello-robot
     ```
   * `stretch` is the host alias used to initiate the connection. You may rename it if desired.
   * Replace `<ROBOT_IP>` with your robot's IP address. To find it, run the following on the robot (via a tethered terminal or RustDesk):

     ```bash
     ifconfig -a
     ```

     Look for the `wlan0` (or similar wireless) interface — the `inet` field is the robot's Wi-Fi IP address, which is typically in the `10.1.10.xxx` range.
   * The login user should remain `hello-robot`.
   * Save the file.
5. First Connection
   * You can start the connection in two ways:
     * Command Palette:
       * Press: `Ctrl + Shift + P`.
       * Type: `Remote-SSH: Connect to Host`.
     * UI shortcut:
       * Click the bottom-left corner of VS Code
       * Select `Open a Remote Window`
       * Then choose `Connect to Host…`
   * Select `stretch` or whatever host alias name you have set.
   * On first connection, you may see a prompt like: `"stretch" has fingerprint "…". Are you sure you want to continue?`. Select `Continue` to proceed.
   * Enter the password that came in the box with the robot.
   * Once connected, VS Code installs a small server on the robot automatically. After that, you will notice a new VS Code window, you are fully inside Stretch robot.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hello-robot.com/stretch4_docs/working-with-stretch/general_use/connecting-to-stretch.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.