# Install Inkline on reMarkable 2

Inkline is an early terminal application for reMarkable 2. This procedure is the
supported way to install, verify, launch and remove it. The current target is
firmware **3.28**, with the official **3.28.0.172 / Qt 6.10.3** SDK pairing. It does not support
reMarkable 1, Paper Pro or Move. Read the current feature limits in the README
before relying on it for daily work.

## 1. Establish SSH access

Connect the tablet to your computer by USB and obtain its root password from
Settings → General → Help → About → Copyrights and licenses. reMarkable 2 does
not require Paper Pro's developer-mode reset; the manufacturer's
[developer documentation](https://developer.remarkable.com/documentation/developer-mode)
explicitly distinguishes the first two tablet generations.
On reMarkable 2, USB SSH normally uses `10.11.99.1`:

```sh
ssh root@10.11.99.1
exit
```

Verify the host fingerprint before accepting it. Inkline's installer refuses
unknown or changed host keys and never edits `known_hosts`. An SSH config alias
can replace `root@10.11.99.1` in all commands below. The alias `remarkable` is only
a convenience in the development setup, not an installer requirement.

## 2. Obtain the bundle

The **0.4.18** bundle targets firmware **3.28** and includes AppLoad, the PDF
reader and guide, composite USB Send, powered-hub Receive, and Outpost modem/radio
tools. The older 0.4.12 download remains available for firmware 3.27; do not use
that bundle on 3.28.

On your computer, download `inkline-rm2.tar.gz` and
`inkline-rm2.tar.gz.sha256` from the
[0.4.18 download](https://inkline.goblinreactor.com/downloads/v0.4.18/inkline-rm2.tar.gz).
Use the compiled Inkline bundle; source-only archives do not contain the
application. The bundle is about 240 MiB
and includes the installer, uninstall script, source archives and licenses.
Installation needs SSH and SCP on your computer, with no SDK, compiler or
additional tablet package manager.

Alternatively, download both files from a terminal on your computer:

```sh
curl -fLO https://inkline.goblinreactor.com/downloads/v0.4.18/inkline-rm2.tar.gz
curl -fLO https://inkline.goblinreactor.com/downloads/v0.4.18/inkline-rm2.tar.gz.sha256
```

The download includes matching sources and licenses for the app and bundled tools.
To compile the application yourself, see [building from source](#building-from-source).

## 3. Check, then install

The tablet needs **Python 3** for this installer and its bundled helpers. If
`python3 --version` is unavailable in the tablet's SSH session, first install
the [Python utility](https://inkline.goblinreactor.com/install.html?utility=python3#utilities).
Use its **2026-10-07 or newer** installer for firmware 3.28. An already working
Python installation can be kept; no third-party Python modules are required.

From the directory containing the archive and its checksum, verify it locally
and stream it into a fresh tablet RAM directory. Streaming avoids keeping both
the compressed archive and the expanded bundle in the tablet's limited RAM:

```sh
sh <<'INKLINE_INSTALL'
set -eu
if command -v sha256sum >/dev/null; then
    sha256sum -c inkline-rm2.tar.gz.sha256
else
    shasum -a 256 -c inkline-rm2.tar.gz.sha256
fi
ssh -T -o StrictHostKeyChecking=yes root@10.11.99.1 '
    set -eu
    umask 077
    inkline_stage=$(mktemp -d /tmp/inkline-install.XXXXXX)
    trap "rm -rf -- \"$inkline_stage\"" EXIT
    trap "exit 130" HUP INT TERM
    tar -xzf - -C "$inkline_stage"
    "$inkline_stage/inkline/install-device.sh" --check
    "$inkline_stage/inkline/install-device.sh"
' < inkline-rm2.tar.gz
INKLINE_INSTALL
```

Preflight checks the hardware, firmware, stock Qt plugins, font, available
memory policy and application startup. `/tmp`, `/dev/shm` and `/run` must be tmpfs and
swap must be disabled. The bundle is uploaded into RAM and its manifest is
checked before any persistent application files are created. `--check` leaves
the notebook interface running and makes no persistent installation changes.

Installation creates:

- `/home/root/.local/share/inkline/`: versioned application bundles, sources and licenses.
- `/home/root/inkline`: the command used to launch, stop and uninstall Inkline.
- `~/.local/bin/inkline-battery` and `~/.local/bin/inkline-wifi`: managed links
  to the battery and Wi-Fi command-line tools.
- A managed `/etc/systemd/system/inkline-hotkey.service` file and a relative
  enable link in `multi-user.target.wants/`. The unit is readable before `/home`
  mounts; `RequiresMountsFor` waits for the application bundle before starting
  the keyboard launcher. Updates migrate the old links into `/home` automatically.

An unrelated file at either location makes installation stop. Reinstalling the
same verified bundle is supported. Upgrades retain the previous release
directory, and the `current` symlink switches only after the new files verify.
The installer preserves an already running Inkline session; quit
and reopen Inkline when ready to use the update.
The notebook interface remains the default application. System libraries and
existing notebook files are preserved; the installer adds its own guide document. The installer needs writable systemd configuration
for the shortcut service; it does not remount a read-only system partition.

When installation finishes, the command returns to your computer’s shell.

## 4. Verify and launch

First run the display demonstration. It exits after ten seconds and restores
the notebook interface automatically:

```sh
ssh root@10.11.99.1 '~/inkline demo --quit-after 10'
```

Then press **Opt+RightAlt+T on your Type Folio or external USB keyboard** to launch
a shell directly on the tablet. The shortcut remains available after reboot.
The small launcher observes the shortcut without grabbing the keyboard or
recording typed text.

For a touch-only launch, open **AppLoad → Inkline**. The standard installer
includes compatible, pinned AppLoad and XOVI releases and registers the icon.
After a reboot, click the physical power button **three times quickly** to
enable AppLoad. The stock notebook interface remains the normal boot path.
Activation is confined to the current boot and restores notebooks if it fails.
Existing independent AppLoad installations are checked and reused.

The icon opens USB settings. Tap **Receive** for a powered hub,
or **Send → Pen only** to use the tablet with a laptop. Inkline shows a
soft keyboard for text entry outside Receive when the Folio is inactive.
When Type Folio is inactive, **↺ / ↻** buttons at the bottom rotate the display
in quarter turns. Opening the Folio restores its landscape layout.

SSH remains available as a fallback:

```sh
ssh root@10.11.99.1 '~/inkline start'
```

The shell runs on the tablet. Use SSH or your preferred mosh client from that
shell to reach another machine. Inkline does not install a mosh client.

Use Type Folio, the built-in soft keyboard or a USB keyboard. Qt discovers input devices; Inkline does not
assume a particular `/dev/input/eventN`. For a USB keyboard, a suitable USB host
adapter or hub is required. When the keyboard occupies the USB port, use the on-device shortcut. Wi-Fi SSH
using the tablet's Wi-Fi address is another option. Actual USB host wiring and keyboard
layout/hotplug behavior should be checked with your hardware.

Useful controls:

- Tap **Quit** or press **Ctrl+Shift+Q**, then confirm, to return to notebooks.
  Type `exit` to close one terminal; closing the last one also returns to notebooks.
- Tap **Esc** or use **Ctrl+[** when your Folio has no Escape key.
- **Right Alt/Option+Up/Down** sends PageUp/PageDown to the application.
- Scrollback is disabled to conserve RAM, so vertical two-finger motion has no
  saved history to reveal. Swipe two fingers left or right to switch terminals.
  One finger selects text. The pen reports mouse
  events to applications that request them; hold Shift to select text instead.
- Without an active Folio, `~/inkline start --rotate 0|90|180|270` sets the initial display orientation. The bottom arrows rotate it while running.
- `~/inkline start --font-size 32` overrides the saved text size for this launch (6–48 pixels).
- Pinching and Settings adjust text size inside the terminal. Pinch in one-pixel
  steps for finer control; keyboard zoom combinations have been removed.
- Left Alt+Space opens the Unicode keyboard; right Alt/Option+Space opens Settings;
  right Option+C/V uses the RAM clipboard. Ctrl+Shift+B reaches terminal programs unchanged.
- `~/inkline stop` restores notebooks from another SSH session.
- Press and release the physical power button to suspend; press it again to
  wake. A high-contrast sleep screen remains visible while the tablet is asleep;
  the live terminal returns after wake or if an inhibitor rejects suspension.
  Shells and editor buffers stay in RAM. Network connections may need to
  reconnect. Quit and reopen Inkline after upgrading to activate this behavior.

Inkline 0.4.12 includes right Alt/Option shortcuts, nine terminal slots,
quit confirmation, a Settings button, and a saved Caps Lock/Control toggle.
Each new terminal shows a brief guide and a tiny Goblin logo.
Inkline sets `HOME=/home/root` for tablet sessions, including shells opened by
the keyboard shortcut, so `cd` without arguments returns home.
See [keyboard settings](keyboard.md) for the complete controls.

### Wi-Fi on the tablet

Open **Settings → Wi-Fi** directly, or choose **Wi-Fi** in the shared
**Main / Shortcuts / USB / Wi-Fi / Done** footer. **Done** closes setup. The list marks the connected network with `●` and
saved profiles with `◆`. Choose a row, then Connect or Forget. A WPA password
is masked and held only in RAM. Enterprise, WEP and SAE-only networks are shown
but cannot yet be configured by Inkline.

The command-line interface uses the firmware's existing `wpa_supplicant` service:

```sh
inkline-wifi status
inkline-wifi list
inkline-wifi pick
# The launcher alias is equivalent:
~/inkline wifi list
```

`pick` scans, prints a numbered list and securely prompts when a new WPA Personal
network needs a password. For scripts, use `inkline-wifi --help`; pass a password
on standard input with `--password-stdin`, never in an argument. Scanning and
switching an already saved network do not write the Wi-Fi configuration. A new
profile is saved once and only after a successful connection. `forget --yes`
performs one deliberate configuration write. Inkline creates no Wi-Fi history,
cache or log files.

Open **Settings → About & licenses** for Inkline's GPLv3-or-later terms,
copyright notices, source information and complete third-party licenses.
They are available offline. Previous/Next chooses a component; Page Up/Down,
the mouse wheel, or a finger/pen drag scrolls the text. **Main** returns to
Settings; **Done** closes setup.
The same notice files and corresponding source archives ship in the bundle.

### Program shortcuts and the manual

Register a program with `~/inkline shortcut register e emacs`, then launch it
with Opt+RightAlt+E. Use `~/inkline shortcut list` and `~/inkline shortcut deregister e`
to manage bindings. Opt+RightAlt+T is permanent. Hold Opt+RightAlt+Backspace for two
seconds to stop a malfunctioning shortcut app and restart Inkline; emergency
recovery closes all terminal sessions. See [global shortcuts](global-shortcuts.md)
for native e-paper apps, session preservation, and recovery limits.

The standard installer adds the nine-language [Inkline Manual.pdf](Inkline%20Manual.pdf)
as a pinned **Inkline Guide** on the main **My files** page. It briefly stops the
notebook interface while publishing the new PDF and metadata, then restores it;
existing terminal sessions survive installation. Reinstalling an unchanged guide
preserves its name, location, annotations and Trash state. A changed guide becomes
a new document, so annotated older editions remain available. Uninstall keeps guides.

Open **Settings → Documents** to browse guides and all downloaded reMarkable
documents by name and folder. Tap a PDF to read its original pages while terminal
sessions continue. Use Previous/Next or the page-position bar to navigate.
**Copy path** makes PDF, EPUB and native notebook files accessible to terminal
programs. Read handwritten annotations, notebooks and EPUBs in **My files**;
the built-in reader displays original PDF pages only.

```sh
~/inkline documents --list          # Names, folders, types and local paths as JSON
~/inkline documents                 # Open the library in the running terminal
~/inkline documents /path/file.pdf  # Open a PDF in the running terminal
~/inkline manual                    # Read the bundled guide inside Inkline
~/inkline manual --install          # Retry adding the guide to My files
```

Opening Inkline temporarily stops `xochitl`, the notebook interface. A service
loaded only into `/run` restores it on normal exit and process failure. The
terminal survives the SSH connection closing. A separate shortcut service is enabled at boot. Rebooting starts the usual
notebook interface with the shortcut available in the background.

### Display response, contrast, and shell preferences

Open Settings with right Alt/Option+Space and drag **Text darkness**, or focus
it with Tab and use Left/Right. 50% is the original rendering; darker values
strengthen antialiased letter edges. Text colors and graphics retain their
original values. **Minimum contrast** keeps foreground and background luminance
apart when a terminal program chooses hard-to-read colors.

The **E-paper updates** row offers five tradeoffs. **Crisp is the default** and
uses the higher-quality content mode. Fast uses the low-latency animation mode,
Balanced uses normal UI mode, Mono favors black-and-white text, and Saver batches
command output for 120 ms so bursts request fewer screen updates. Existing
explicitly saved modes are preserved. All settings stay in RAM across terminals,
Settings visits and sleep. Inkline saves changed preferences together at normal
exit, including a service stop; unchanged sessions write nothing. Forced kills,
crashes and power loss can discard changes made since launch.

Normal typing redraws only libghostty's dirty rows on a retained grayscale
surface. This avoids the previous full-screen raster and comparison on every
character; e-paper waveform time remains and depends on the chosen profile.

Inkline starts interactive Bash so the tablet's `~/.bashrc` is loaded. Optional
Python/pip cache preferences belong in that file; see [Python setup](python.md).
The installer adds a marked, Inkline-only prompt block that calls
`inkline-battery --percentage`; it preserves the rest of `.bashrc` and removes
the block on uninstall. Run `inkline-battery` or `~/inkline battery` to see the
percentage and charging state directly. The bottom bar refreshes the same
read-only kernel value once per minute.

## Recovery and removal

Successful upgrades remove obsolete app and utility releases automatically.
The current release and releases used by running programs are protected. App
cleanup retries when the session closes; `~/inkline cleanup --check` previews
remaining app releases and `~/inkline cleanup` removes them. Documents and
settings are outside the release directories and are preserved.

To reclaim older utility releases without uninstalling the current version,
preview with `~/inkline cleanup emacs --check`, then run
`~/inkline cleanup emacs`. Replace `emacs` with another installed utility name
as needed. Current releases, releases used by running programs and unrecognized
paths are kept. Close an old program and retry to remove its retained files.
Newly built utility installers run this cleanup after a successful upgrade.

From SSH:

```sh
~/inkline stop
~/inkline uninstall
```

Removal stops and disables the shortcut service, stops Inkline, starts and
checks `xochitl`, removes the temporary service link, and deletes only Inkline's marked application directory and launcher. It
does not remove files you created elsewhere from the shell. Imported guides and the shared AppLoad/XOVI installation are retained; only Inkline’s AppLoad entry is removed.

If the launcher itself is unavailable, restore the stock interface with:

```sh
systemctl stop inkline.service
systemctl start xochitl.service
```

Firmware updates can change Qt or the display plugin ABI. After updating, run
the installer's preflight again before launching. The current installer refuses
firmware outside the 3.28 line rather than guessing compatibility.

## Building from source

From an Inkline source checkout, install **Zig 0.16.0**, **CMake 3.24+**, **Ninja**,
**pkg-config**, **Git**, and **Python 3.12+**. The tablet build uses the official
SDK's Qt, libpng and GNU C++ libraries. Host Qt and MuPDF’s `mutool` are needed for desktop tests.
The cross build has been exercised on Apple Silicon macOS; Linux host support
has not yet been tested. Leave several gigabytes of free space for the SDK,
extracted headers, source and compiler caches.

```sh
git clone https://github.com/adamdeprince/inkline.git
cd inkline
scripts/build-tablet.sh
python3 scripts/fetch-appload.py
python3 scripts/package-pdf.py
python3 scripts/package.py
scripts/install.sh root@10.11.99.1 --check
scripts/install.sh root@10.11.99.1
```

The build downloads the pinned SDK (about 400 MB), verifies its SHA-256, and
extracts the target headers and libraries. It does not execute the Linux SDK
installer. It also fetches the pinned libghostty-vt source and applies the
included ARM/libc patches. The result is `build/dist/inkline-rm2.tar.gz`, with an
adjacent SHA-256 file. The host-side script uploads this bundle into a fresh RAM
directory and uses the same included device installer as the prebuilt release.

The single nine-language PDF is built from `docs/manual.tex` and its language
chapters with **LuaLaTeX**: `python3 scripts/build-manual.py`. See the
[manual build instructions](manual/README.md) for matching macOS/Linux tools,
fonts and temporary cache paths. The finished PDF is committed, so installers
need no TeX or PDF generation tools. LaTeX utility installation instructions
remain on the website.

Global launchers use the separate Folio Opt key; on USB keyboards its equivalent
is Windows/Command (Super). Use Settings → Shortcuts to edit bindings.
The terminal launcher, custom commands and held emergency recovery all require
Opt+RightAlt. Ordinary Ctrl+Alt remains available to Emacs. After upgrading, quit
and reopen Inkline to load the new input handling and Settings page.

## USB tools and typewriter

The terminal bundle installs `inkline-usb`, `keyboard-send` and `tablet-send` in `~/.local/bin`.
`~/inkline usb …`, `~/inkline type …`, and `inkline-type` remain compatible.
Install the Python
utility from the website before using outgoing keyboard or drawing tablet mode. The stock
network/host controls need no Python; no additional Python modules are needed.

Choose Settings → USB → Send. **USB network · On/Off** is an independent toggle,
on by default. Networking, keyboard HID and pen HID can be active together.
Changing the toggle reconnects USB and pauses live input; reopen Typewriter and tap Send, or tap Start forwarding in Pen only.
Choose **Keyboard + pen** with an open, attached Type Folio, then select the receiving-computer profile before
opening Typewriter. Its editor stays local and keeps multiple documents in RAM.
**Files** lists RAM documents and clickable files/folders; **New** adds a buffer.
**Send** sends physical keys directly without modifying documents or repainting
per key. Tap documents from RAM or disk to send snapshots in tap order at
5, 10, 20, 40 or 80 characters/second. A key interrupts that queue and resumes
physical keyboard input immediately. Document speed never delays raw keys.
Use a finger to select **Editor** to stop output or **Exit typewriter** to return
to USB settings. Typewriter has its own navigation and no display rotation controls.
Save writes the selected document. Normal exit saves named documents and all
buffers to the recovery file `~/.inkline-typewriter-draft`.

Windows document Unicode requires WinCompose; Mac and Linux use their documented
host input methods. For a US Folio's symbols, choose a US layout on the laptop;
the direct sender maps printed punctuation and number keys to US HID reports,
including right Alt+0 for `+` and right Alt+minus for `=`. The [PDF manual](Inkline%20Manual.pdf)
covers all nine languages and is bundled for My files. The graphical browser
reads UTF-8 files up to 16 MiB each; the command-line sender streams files without
a fixed size limit or temporary spool files.
Typewriter requires the Folio throughout use: folding or detaching it stops
both senders and keeps the draft. Fingers control its buttons, cursor and text
selection. Pen and eraser input never activates local controls in Typewriter,
including Files and the Unicode picker. Its finger-operated **Pen: Windows /
macOS / Linux** buttons switch pen profiles while keyboard typing continues;
lift the pen before the next stroke. Pen output uses the standard HID eraser
and inverted-tool flags, contact pressure, tilt and proximity.

Installation preserves current terminals and the current USB role. Quit and
reopen Inkline to load this update. Once the new service is loaded, exit and
crash cleanup restore USB networking. Switching from Receive to Send or exiting Inkline disarms Auto and ends an active modem session before
restoring networking. Unknown gadgets are preserved. Raw keyboard forwarding never stores typed text.


### Drawing tablet over USB

In **Settings → USB → Send → Pen only**, choose **Windows**, **macOS** or **Linux**,
then **Pen** or **Mouse**. Every profile defaults to the same standard USB HID
pen protocol; the profile supplies host-specific setup guidance. Connect a
USB data cable directly to the laptop and tap **Start forwarding**.

Pen mode reports absolute position, 4096 pressure levels, tilt, proximity,
barrel button and eraser state when supported by the physical pen. Use a
drawing app with pen pressure enabled (Windows Ink on Windows). Pressure and
eraser behavior must still be verified on each host OS and in the intended
drawing app. **Mouse** is a selectable compatibility mode on all three hosts:
hover moves the pointer, tip contact drags/clicks, and eraser contact or the
barrel button is a right click. Mouse mode does not carry pressure or tilt.
The descriptor uses the open
[USB HID Usage Tables](https://usb.org/document-library/hid-usage-tables-17),
with no Wacom-specific protocol, host-side receiver or SSH transport.
USB networking is optional and independent. Keyboard Unicode profiles and WinCompose are unrelated to pen use.

The entire pen surface maps to the laptop. **270° is the default orientation**
and appears first on the left, followed by 0°, 90° and 180°. Each arrow points
toward the edge of the tablet that maps to the laptop's “up”, relative to the
menu as you read it. Changing orientation reconnects the USB interface so the physical dimensions
are reported correctly. Host tablet/display settings choose the target monitor
and aspect-ratio mapping. Lift the pen away before tapping controls with a
finger; touches while the pen is nearby are ignored. Tap **Stop forwarding**
or press Escape to stop. Closing settings, losing focus, sleeping, changing
profiles and USB mode changes also stop forwarding. The sender releases the
pen and mouse buttons on normal exit and errors; unplugging, overflow or a
stalled host requires an explicit Start again. No stroke data is saved.

Command-line equivalents, run on the tablet after installation:

```sh
inkline-usb send-tablet             # Default 270°; optionally specify 0, 90 or 180
tablet-send --host windows         # Also: mac or linux
tablet-send --host mac --output mouse
inkline-usb network                # Restore USB Ethernet after stopping
```

Run only one sender at a time; Ctrl+C releases the pen. The on-screen workflow
does not require these commands or an SSH connection. USB networking stays on
alongside HID unless you turn it off. `inkline-usb send-network off` and `on`
change that toggle. Reboot and normal Inkline exit restore the stock network mode.

Automated checks cover HID descriptor decoding, pen reports, simulated evdev
input, release/error handling, UI controls and USB mode rollback. Enumeration,
pressure, tilt, eraser behavior and coordinate orientation on physical laptops
remain release acceptance checks; automated checks do not establish those.

### Modem companion

To include userspace PPP in an Inkline installer, build the Inkline Outpost
bundle with its `build-userspace-ppp.sh`, `build-userspace-ssh.sh` and `package.py`, then use
`scripts/package.py --outpost-bundle /path/to/inkline-outpost-rm2.tar.gz`.
The Python utility is required. The bundled installer installs the backend at
`/home/root/usb-modes` and enables a localhost proxy; it never dials.

USB and typewriter settings have **Receive** and **Send** menus. In Receive,
start the host role once, then attach keyboard, mouse, Ethernet adapter, modem
and radio through a powered hub. Keyboard, mouse and Ethernet discovery is
automatic. Modem and goTenna are independently switchable and can run together.
Ethernet uses DHCP through NetworkManager on newer firmware or networkd on
older firmware, with a compatible USB Ethernet driver required. The installer
prevents both managers from configuring the same supported USB adapter.

Send contains **USB network · On/Off**, **Keyboard + pen**, and
**Pen only**. Tapping Receive starts host mode immediately; entering Send restores USB networking by default. USB setup screens
share **Main / Shortcuts / USB / Wi-Fi / Done** navigation. **Done** closes setup.
In **Receive → Modem settings**, edit the dial
number (default `#777`) and choose **Off**, **On**, or **Auto**. On calls now and
holds; Auto calls on proxy demand, holds while any connection is open, and
hangs up when the last connection closes. The delay defaults to Immediately;
Use the Auto disconnect slider to choose a delay. An idle SSH session holds the call.
Selecting a Send function disarms Auto and ends the call; Receive controls preserve other hub devices.
New Inkline terminals automatically use the same SOCKS proxy address across
network changes. With the updated Outpost companion, ordinary connections follow the kernel
Ethernet/Wi-Fi route and otherwise follow modem policy. Mesh destinations use
the radio independently. If the modem is off, a connected radio can provide
an Internet gateway. Existing TCP connections may need restarting if their bearer disappears.
The battery footer and shell prompt display modem state. Installing an update
requires Modem Off, including when Auto is waiting between calls.

The proxy supports SOCKS5 UDP ASSOCIATE as well as TCP CONNECT, including DNS
over PPP. The installed Goblin Skiff fork can use
`goblin-skiff --socks5-proxy=127.0.0.1:1080 user@host`. Its UDP association holds
Auto open and can reconnect after a bearer change without another SSH login.
An unused UDP association does not dial until the first datagram. A 15-second
hangup delay can bridge the gap between SSH setup and UDP startup. IPv4/domain
destinations and IP fragmentation are supported over PPP. The Goblin Modem radio backend
also supports IPv6. SOCKS fragmentation is not supported. Stock Mosh does not understand the proxy option.

SSH and Git SSH remotes use that same proxy through a managed block appended
to `~/.ssh/config`. The installer creates the file if absent, preserves existing
settings and host aliases, saves `~/.ssh/config.outpost-backup` before its first
edit, and updates its block without duplicates on repeat installs. Earlier
`ProxyCommand` and `ProxyJump` entries keep precedence. The bundled OpenSSH
client is installed at `~/.local/bin/ssh` because the firmware client lacks
config support; an existing OpenSSH client there is retained. No SSH server
or system client is replaced. Hostname resolution takes place through SOCKS.
A separate managed block at the beginning of the config sets `ControlMaster no`,
`ControlPath none`, and `ControlPersist no` device-wide, overriding old caching
settings without removing them. Finished commands leave no idle SSH master.

The proxy settings apply only to terminal children. Background book sync and
system updates keep normal networking, with no kernel route onto satellite.
Terminal-launched downloaders can use the proxy too, so run package/book
downloads while on Wi-Fi. No kernel changes are required.

<a id="gotenna-public-ipv6-mesh"></a>

### Public IPv6 mesh with goTenna Mesh radios

goTenna and goTenna Mesh are trademarks of goTenna, Inc. Inkline and Inkline Outpost are independent projects, not affiliated with or endorsed by goTenna, Inc.

With a powered USB hub and goTenna Mesh radio attached, choose **Settings →
USB → Receive**, then turn **goTenna On**. Updated Inkline, Mac
and Linux clients join the same public channel automatically. No private key
exchange is needed. Each radio has an IPv6 address derived from its identity.
Update all participants to the compact-format driver.

Run `gotenna-peers` to list discovered names, IPv6/IPv4 addresses, hops, and
incoming-IP or outgoing-only roles. The command only reads current discovery
state; it does not connect the radio or probe services. The tablet uses a
userspace driver and is an outgoing-only client, with no TUN or kernel change.

When **goTenna On** is selected, mesh names and addresses use the radio for
SOCKS5 TCP/UDP while Ethernet, Wi-Fi and modem remain available for other destinations. For example, `ssh your-user@workstation.mesh`
uses the managed SSH proxy configuration. Use your remote account name and
authorized SSH key. IPv6 is preferred; IPv4 aliases remain for compatibility.
The channel is public; SSH, TLS and Skiff provide application encryption.

The Modem panel also shows the tablet's Wi-Fi address and a complete copyable
proxy environment setting for another computer. Enable **Share proxy** to
accept clients on the Wi-Fi subnet. Sharing starts off; this does not create a
system-wide default route over the modem or radio.

### Battery polling and proxy startup

Battery hardware is read once per minute. Modem status is read separately from
RAM once per second, and the footer redraws only when its visible status changes.

The installer places managed Outpost service files in `/etc/systemd/system`,
where systemd can read them before `/home` mounts. The services wait for their
installed runtime before starting. Connecting a goTenna Mesh radio also starts the terminal
proxy. Existing home-linked units are migrated automatically; unrelated units
and service drop-ins are preserved. The installer checks for conflicts before
changing the application release.

Installer SSH defaults continue to prefer post-quantum key exchange. Personal
host settings and overrides remain in `~/.ssh/config`.