Remote Desktop - Raspberry Pi to Ubuntu

xholonWorkbook.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--Xholon Workbook http://www.primordion.com/Xholon/gwt/ MIT License, Copyright (C) Ken Webb, Sat Feb 07 2026 20:00:21 GMT-0500 (Eastern Standard Time)-->
<XholonWorkbook>

<Notes><![CDATA[
Xholon
------
Title: Remote Desktop - Raspberry Pi to Ubuntu
Description: 
Url: http://www.primordion.com/Xholon/gwt/
InternalName: 
Keywords: 

My Notes
--------
2026 Feb 7


() https://en.wikipedia.org/wiki/Xrdp
    xrdp is a free and open-source implementation of Microsoft RDP (Remote Desktop Protocol) server
    that enables operating systems other than Microsoft Windows (such as Linux and BSD-style operating systems)
    to provide a fully functional RDP-compatible remote desktop experience.
    It works by bridging graphics from the X Window System to the client
    and relaying controls from the client back to X Window Server. 

() https://www.xrdp.org/
    an open-source Remote Desktop Protocol server
    
    xrdp provides a graphical login to remote machines using RDP (Microsoft Remote Desktop Protocol).
    xrdp accepts connections from variety of RDP clients:
      FreeRDP, rdesktop, NeutrinoRDP and Microsoft Remote Desktop Client (for Windows, macOS, iOS and Android).

    As Windows-to-Windows Remote Desktop can, xrdp supports not only graphics remoting but also
      two-way clipboard transfer (text, bitmap, file)
      audio redirection
      drive redirection (mount local client drives on remote machine)

    RDP transport is encrypted using TLS by default.

]]></Notes>

<markdown><![CDATA[
ken@Mac ~ % ollama run gemma3:12b

>>> 
>>> I have two computers connected through ethernet. Each has an IP address. Computer A is a Raspberry Pi 5 running Raspberry Pi OS. Computer B runs Ubuntu. What software can I run th 
... at will allow A to be a remote desktop client of B?

Okay, you want to use your Raspberry Pi (Computer A) as a remote desktop client to connect to your Ubuntu machine (Computer B) over your local Ethernet network. Here's a 
breakdown of software options, considerations, and setup instructions.  I'll provide several options, ranging in complexity and feature set.

**Understanding the Roles**

*   **Computer B (Ubuntu):** This will be the *server*. It needs to *host* the desktop session that Computer A will connect to.
*   **Computer A (Raspberry Pi):** This will be the *client*. It will *display* and *interact* with the remote desktop hosted on Computer B.

**Software Options (ranked roughly in order of common use and relative ease of setup):**

1.  **VNC (Virtual Network Computing)** - Highly Recommended for Simplicity
    *   **What it is:** VNC is a standard protocol for remote desktop access. It's generally easy to set up and works well on Linux.
    *   **Server (Computer B - Ubuntu):**
        *   **Option 1: `xrdp` (Recommended for Ubuntu)**  `xrdp` is an open-source implementation of the Remote Desktop Protocol (RDP) server for Linux. It's designed to work 
with VNC. This is the simplest way to get VNC working on Ubuntu.
            *   `sudo apt update`
            *   `sudo apt install xrdp`
            *   `sudo systemctl enable xrdp`
            *   `sudo systemctl start xrdp`
        *   **Option 2: `TightVNCServer` or `RealVNC Server`:**  These are standalone VNC servers. They might require more configuration to integrate with your desktop 
environment.  You'll likely need to set up your `.vnc/xstartup` file to launch your desktop environment (e.g., GNOME, KDE, XFCE).  I'll omit detailed instructions for these since 
`xrdp` is significantly easier.
    *   **Client (Computer A - Raspberry Pi):**
        *   **`Remmina`:** (Easiest, Good Feature Set) A popular and user-friendly remote desktop client.
            *   `sudo apt update`
            *   `sudo apt install remmina`
            *   Launch Remmina.
            *   Click "+", select "RDP", and enter Computer B's IP address.  You'll likely need to provide your Ubuntu username and password.
        *   **`RealVNC Viewer`:**  If you use RealVNC Server on Ubuntu, this is the corresponding client.  Download from the RealVNC website.  (Not strictly necessary if you use 
`Remmina` with `xrdp`.)

2.  **RDP (Remote Desktop Protocol) -  Good if you prefer Windows-style experience**
    *   **What it is:** The standard remote desktop protocol used by Windows.  `xrdp` above enables this on Ubuntu.
    *   **Server (Computer B - Ubuntu):** `xrdp` (as installed above)
    *   **Client (Computer A - Raspberry Pi):**
        *   **`Remmina`:**  (As mentioned above, it supports RDP).  Remmina is likely the easiest option.

3.  **X11 Forwarding over SSH - Secure, but potentially slower**
    *   **What it is:** Allows you to display graphical applications running on Computer B on Computer A via an SSH connection.  It's secure but can be slower than VNC or RDP, 
especially for full desktop sessions.
    *   **Server (Computer B - Ubuntu):** SSH server must be enabled (it usually is by default).
    *   **Client (Computer A - Raspberry Pi):**
        *   `ssh -X username@computer_b_ip_address`
        *   After connecting, you can launch graphical applications on Computer B, and they will appear on Computer A.  This is *not* a full desktop environment; it's for running 
individual applications.

4.  **NoMachine - Excellent Performance (often)**
    *   **What it is:** A proprietary remote desktop solution known for its good performance and features.
    *   **Server (Computer B - Ubuntu):** Download and install the NoMachine server from [https://www.nomachine.com/](https://www.nomachine.com/)
    *   **Client (Computer A - Raspberry Pi):** Download and install the NoMachine client from the same website.
    *   NoMachine often requires creating an account, but it's generally well-regarded.

**Important Considerations & Troubleshooting**

*   **Firewall:**  Make sure your firewall (both on Computer B and potentially on your router) allows traffic on the appropriate ports.
    *   **VNC:**  Typically uses port 5900 + display number (e.g., 5901 for display :1)
    *   **RDP:**  Uses port 3389
    *   **SSH:** Uses port 22
    *   **NoMachine:** Uses port 4000
    *   On Ubuntu, use `sudo ufw allow <port>` to open ports.
*   **IP Addresses:**  Make sure you know the correct IP address of Computer B.  You can find it using `ip addr` or `ifconfig` on Computer B.  Also, make sure both computers are 
on the same subnet.
*   **Username/Password:**  You'll need a valid username and password for Computer B to authenticate.
*   **Desktop Environment:**  If using a standalone VNC server (like `TightVNCServer`), you might need to configure the `.vnc/xstartup` file to launch your preferred desktop 
environment.  This is usually not required with `xrdp`.
*   **Performance:**  The Raspberry Pi 5 is capable, but performance will still be limited by its network connection and processing power.  VNC and RDP are generally good 
choices. NoMachine often provides the best performance.  X11 forwarding can be slow for a full desktop.
*   **Security:** For more sensitive data, consider using SSH tunneling with VNC or RDP.  This encrypts the traffic between the computers.



**My Recommendation (to get you up and running quickly):**

1.  **On Computer B (Ubuntu):** Install `xrdp` (as described above).
2.  **On Computer A (Raspberry Pi):** Install `Remmina`.
3.  Connect using Remmina and specify Computer B's IP address.

This combination is generally the easiest to set up and provides a reasonably good remote desktop experience.  Let me know if you run into any specific problems or have further 
questions.  Good luck!


>>> Send a message (/? for help)

]]></markdown> 

<_-.XholonClass>

  <!-- domain objects -->
  <PhysicalSystem/>
  <Block/>
  <Brick/>
  
  <!-- quantities -->
  <Height superClass="Quantity"/>
  
</_-.XholonClass>

<xholonClassDetails>
  <Block>
    <port name="height" connector="Height"/>
  </Block>
</xholonClassDetails>

<PhysicalSystem>
  <Block>
    <Height>0.1 m</Height>
  </Block>
  <Brick multiplicity="2"/>
</PhysicalSystem>

<Blockbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  var a = 123;
  var b = 456;
  var c = a * b;
  if (console) {
    console.log(c);
  }
  //# sourceURL=Blockbehavior.js
]]></Blockbehavior>

<Heightbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  var myHeight, testing;
  var beh = {
    postConfigure: function() {
      testing = Math.floor(Math.random() * 10);
      myHeight = this.cnode.parent();
    },
    act: function() {
      myHeight.println(this.toString());
    },
    toString: function() {
      return "testing:" + testing;
    }
  }
  //# sourceURL=Heightbehavior.js
]]></Heightbehavior>

<Brickbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  $wnd.xh.Brickbehavior = function Brickbehavior() {}

  $wnd.xh.Brickbehavior.prototype.postConfigure = function() {
    this.brick = this.cnode.parent();
    this.iam = " red brick";
  };

  $wnd.xh.Brickbehavior.prototype.act = function() {
    this.brick.println("I am a" + this.iam);
  };
  //# sourceURL=Brickbehavior.js
]]></Brickbehavior>

<Brickbehavior implName="org.primordion.xholon.base.Behavior_gwtjs"><![CDATA[
  console.log("I'm another brick behavior");
]]></Brickbehavior>

<SvgClient><Attribute_String roleName="svgUri"><![CDATA[data:image/svg+xml,
<svg width="100" height="50" xmlns="http://www.w3.org/2000/svg">
  <g>
    <title>Block</title>
    <rect id="PhysicalSystem/Block" fill="#98FB98" height="50" width="50" x="25" y="0"/>
    <g>
      <title>Height</title>
      <rect id="PhysicalSystem/Block/Height" fill="#6AB06A" height="50" width="10" x="80" y="0"/>
    </g>
  </g>
</svg>
]]></Attribute_String><Attribute_String roleName="setup">${MODELNAME_DEFAULT},${SVGURI_DEFAULT}</Attribute_String></SvgClient>

</XholonWorkbook>