Two tools that make the reMarkable Paper Pro (with the Type Folio keyboard) far more useful than a notebook:

• inkshell — a real SSH terminal that runs inside the tablet's own interface. Open a tile, type on the Type Folio, and you're in a shell on any computer or server you can SSH to. Tuned for e-ink: fast "A2" refresh, a bold terminal font, sessions that survive sleep/Wi-Fi drops, full Unicode, no on-screen keyboard.
• remapper — turns the Type Folio into a SuperDvorak layout (and adds modifier-key layers), by intercepting the keyboard at the input level.

You install them from your computer over the USB cable with one guided command:

./setup.sh

🧪 Alpha software

This is an early, experimental, alpha-stage project under active development. Expect rough edges, bugs, and changes without notice. Because it runs inside the tablet's own system app, a bad build — or the optional boot-time autostart — can in the worst case leave the device needing a factory recovery. Only use it if you're comfortable with that. The full risk warning and recovery steps are in Safety / risk below.

New to this? The sections "What it's good at, and the trade-offs" and "Safety / risk" below are worth reading before you start.

This software is provided "AS IS", without warranty of any kind. The authors take no responsibility for any damage of any kind — including a bricked, unbootable, or data-wiped device — that may result from using it. You assume all risk.

What that means concretely:

• To install this you must put the tablet into Developer Mode, which erases the tablet's data the first time you enable it. Back up anything you care about first (the reMarkable desktop/mobile apps sync your notebooks).
• This is an unofficial project. It is not made by, endorsed by, or supported by reMarkable. Using it is not covered by your warranty and may void it.
• The default install only writes to a temporary area that is cleared on reboot, so it is relatively low-risk and easy to undo. The optional "load on every boot" step (--enable-autostart) writes to the system partition and carries more risk — see Safety / risk before using it.

If you are not comfortable with that, stop here.

The tablet:

• A reMarkable Paper Pro.
• A Type Folio keyboard (required for the remapper; recommended for the terminal).
• The USB-C cable.

Your computer (macOS or Linux) needs a few free tools. setup.sh checks for them and tells you exactly what's missing and how to install it:

On Linux, install the equivalents with your package manager (apt, dnf, …); Docker must be able to run --platform linux/arm64 images.

On the tablet: Settings → General → Software (on some versions it's under Help / About) → enable Developer Mode.

• This wipes the tablet the first time. Sync/back up your notebooks first.
• When it's done, the tablet shows a screen with a root SSH password. Keep it handy — you'll paste it into setup.sh in a moment. (The password changes every time you toggle Developer Mode.)

Plug the tablet into your computer. It appears as a small USB network device at the address 10.11.99.1 — the same on every reMarkable.

git clone --recursive https://github.com/smith-chris/inkshell.git
cd inkshell

(--recursive pulls in the small xovi build tool. If you forget it, run git submodule update --init --recursive afterwards.)

./setup.sh

It will, in order:

1. Check your computer has the tools above (and tell you how to get any it's missing).
2. Ask for the tablet's SSH password and save it to a local .env file (gitignored — it never leaves your machine). It pre-fills the root user and the 10.11.99.1 USB address for you.
3. Test the USB connection — and if it can't reach the tablet, tell you why (cable, Developer Mode, or wrong password).
4. Build the terminal, install the extension framework on the tablet, deploy inkshell, and restart the tablet's interface.

The first build downloads reMarkable's official toolchain and can take a few minutes; later runs are fast.

On the tablet, find the inkshell tile in the sidebar (it takes the place of the stock "Terminal" tile). Open it. The first time, a short setup wizard asks for the SSH host you want to connect to — type it on the folio (e.g. you@your-computer.local) and you're in.

You can enter the SSH target right on the tablet (the in-app wizard), or set it up from your computer so the tablet logs in without a password (using an SSH key):

./setup.sh configure-target root@10.11.99.1 you@your-computer.local laptop

This generates a key on the tablet, authorizes it on your computer, and sets inkshell's target. It makes changes on your computer (adds the key to ~/.ssh/authorized_keys) and needs Remote Login / SSH enabled there.

Security notes — your computer's exposure.

• The tablet's key is added to ~/.ssh/authorized_keys with a restrict,pty prefix, which disables SSH port, agent and X11 forwarding for that key. It does not sandbox the shell itself — anyone who obtains the tablet's private key (it lives on the tablet, readable only by root) could still open a shell on your computer as you — so keep the tablet secure. Revoke access any time by deleting that line from ~/.ssh/authorized_keys.
• Enabling Remote Login opens SSH on your computer to your local network. Keep it key-only (disable password login in System Settings → General → Sharing → Remote Login → Options, or PasswordAuthentication no), and consider limiting it to specific users/networks. inkshell needs it only while the tablet is connecting.
• First-run setup asks you to compare a host-key fingerprint before trusting your computer. Do it over USB (./setup.sh configure-target) or on a network you trust — that check is what stops a man-in-the-middle.
• Your terminal scrollback is kept in a tmux server on your computer and survives tablet disconnects/reboots. Clear it any time with tmux -L inkshell kill-server.

inkshell is just SSH: it can reach a computer only while that computer is powered on, awake, and running SSH (Remote Login enabled), and is reachable from the network the tablet is currently on.

• On the same network (home/office Wi-Fi): use the computer's local name or IP, e.g. you@your-computer.local. Nothing else to set up.
• From anywhere else: put both the tablet and the computer on a private mesh VPN such as Tailscale (free for personal use) and connect to the computer's Tailscale name. You get a stable address that works on any network with nothing exposed to the public internet (avoid forwarding SSH ports on your router — it puts your computer in front of the whole internet). The reMarkable runs Linux (ARM64), so Tailscale can run on it too — this is an advanced, do-it-yourself step; follow Tailscale's docs and the reMarkable community guides.

Keep the target computer from sleeping while you rely on it (macOS: disable sleep, or run caffeinate; Linux: disable suspend) — if it sleeps, the session drops.

By default the tablet does not load the terminal framework automatically after a reboot (this is the safe choice). Re-enable it any time with:

./setup.sh start

If you want it to load on every boot automatically, see Safety / risk and then:

./setup.sh --enable-autostart

Build and install the keyboard remapper:

./setup.sh --remapper-only      # just the remapper
./setup.sh --both               # inkshell and the remapper

The remapper is a small keyboard-input filter. It cannot crash the tablet's interface — if it ever fails you simply get the stock keyboard back — so it's safe to install as a boot service (the installer offers to). The layout itself lives in remapper/superdvorak-remapper.c; edit and rebuild to customise it.

./setup.sh uninstall

Removes inkshell, and offers to also remove the whole framework, the boot autostart, and the remapper service. (You can always fully reset the device by disabling Developer Mode.)

inkshell runs as an extension under xovi, an injection framework for the tablet's xochitl app, so the terminal lives inside the normal interface instead of replacing it. The terminal engine is a fork of rm-literm (GPL-2.0), heavily reworked for the Paper Pro's colour e-ink panel. The build cross-compiles to the tablet's ARM64 architecture inside a Docker image using reMarkable's public SDK.

More detail for contributors: docs/ARCHITECTURE.md.

Good for: a real, persistent SSH terminal you carry on the tablet — checking on a server, kicking off a build, editing over vim/tmux, tailing logs — with a physical keyboard and a glare-free screen that lasts days on a charge. Sessions survive sleep, Wi-Fi drops, and reconnects.

Trade-offs to understand before you install:

• It's an SSH terminal, not a local shell. inkshell is the front-end; the actual work runs on a computer or server you SSH into. With nothing to connect to, there's little to do — there is no useful local shell on the tablet itself.
• E-ink, not an LCD. Typing uses a fast "A2" refresh that trades shades of grey for speed, so expect some ghosting until the next full repaint. It's tuned to feel responsive, but it will never be an LCD terminal.
• A Type Folio is assumed. The terminal is usable without one but designed around a physical keyboard; the remapper requires it.
• Unofficial and invasive. It injects into the stock app via xovi. It can't touch your notebooks, but it does run inside xochitl — see Safety / risk.
• Tied to your OS version. A reMarkable software update can require a rebuild before the tile works again (the qmldiff "hashtab" is OS-version-specific).
• The remote-browser tab is optional, Mac-only, and advanced. It needs a companion daemon running on a Mac with Chrome. It's off by default and not needed for the terminal.

The default install (./setup.sh) writes only under /home/root/xovi/ on the tablet. That area is temporary storage, cleared on every reboot, so a bad install can't persist — worst case you reboot and you're back to stock, or you run ./setup.sh uninstall.

The optional autostart (./setup.sh --enable-autostart) is different: it writes one small file to the tablet's read-only system partition so the framework loads on every boot. This is the one genuinely risky step. If the extension that loads at boot is broken, xochitl (the entire interface) can crash on start and keep crashing — a boot loop in which the inkshell tile and the UI never come up.

Understood risks:

• Boot loop. A bad autostarted build can leave the interface stuck restarting.
• A reMarkable software update may overwrite the file (harmless — autostart just stops working) or refuse to apply.

1. First, undo it over USB — this usually works and loses no data. A crashing app does not take down the base system: the tablet's SSH service over the USB cable (root@10.11.99.1) is normally still reachable even while the UI loops. From your computer, either run ./setup.sh uninstall, or manually delete the boot file and reboot:

   ssh root@10.11.99.1 "rm -f /lib/systemd/system/xochitl.service.d/99-xovi.conf && systemctl daemon-reload && reboot"

   The tablet comes back to stock, notebooks untouched.

2. If even USB SSH is unreachable — use reMarkable's official recovery. If the device is wedged so badly that SSH never comes up, the only fix is reMarkable's own recovery tool, rm_recover, run over the device's USB recovery mode (the i.MX serial-download mode). It reflashes the OS and wipes the device — a factory reset. Follow reMarkable's official recovery instructions for the exact steps — do not improvise: https://support.remarkable.com (search "recovery"). Afterwards you re-enable Developer Mode and reinstall from scratch (the qmldiff hashtab is rebuilt by bootstrap-xovi.sh).

Recommendation: leave autostart off until you've run inkshell via ./setup.sh start across several reboots and confirmed it's stable on your device and OS version. The default install (no autostart) cannot boot-loop you — a reboot always returns you to stock.

• inkshell is GPL-2.0, forked from rburchell/literm via asivery/rm-literm.
• xovi and the xovi extension ecosystem — by asivery. Installed from the public rm-xovi-extensions releases.
• The e-ink rendering approach was informed by Err0r-v2/Scanly.
• Bundled fonts: FiraCode (SIL OFL 1.1), Hack (MIT), Iosevka (SIL OFL 1.1 — see inkshell-xovi/data/iosevka.LICENSE), Noto Emoji (see inkshell-xovi/data/noto-emoji.LICENSE), and GNU Unifont (see inkshell-xovi/data/unifont.LICENSE).

This repository is released under the GNU General Public License v2.0 — see LICENSE.