goMarkableStream: streaming a reMarkable tablet screen to a browser

The streaming server runs on the tablet, not on your computer

goMarkableStream is a single Go binary that you copy onto the reMarkable and start there. The tablet serves the screen, and any browser on your network opens it. That arrangement is the point of the project: the README frames its primary goal as letting users stream the tablet screen to a web browser without hacks or modifications that could void the warranty, and lists no warranty voiding and no client side installation among its core benefits. The client is a browser, so nothing has to be installed on the machine doing the viewing. The homepage points to a hosted documentation site, and the repository is written in Go with an http.go, a listener.go and an auth.go at the top level, which is the shape of a small HTTP server rather than a library.

Getting on: USB-C, SSH, and one binary download

The README's quick start begins by connecting the tablet over a USB-C cable and opening a root shell on it.

ssh [email protected]

From there you download the release binary that matches your hardware, make it executable and run it. The quick start uses a DEVICE variable set to RM2 for the reMarkable 2 or RMPRO for the Paper Pro, and the download steps fetch the latest tagged release.

wget -O goMarkableStream https://github.com/owulveryck/goMarkableStream/releases/download/$VERSION/gomarkablestream-$DEVICE
chmod +x goMarkableStream
./goMarkableStream

The README also lists four binary variants in a table: RMPRO for the Paper Pro on arm64, RM2 for the reMarkable 2 on arm, and a -lite variant of each without Tailscale support, the lite builds being smaller because they drop that dependency. After the server starts you open https://10.11.99.1:2001 in a browser, with default credentials of admin and password, and the README notes that you can also connect over Wi-Fi using the tablet IP address or remarkable.local. with a trailing dot on Apple devices.

Firmware version decides which build you need

The README is unusually explicit about hardware and firmware support, which is where most of the practical risk sits. The reMarkable 2 with firmware 3.24 and later is the actively supported and tested configuration. The Paper Pro is listed as experimental, with initial support where some features may not work as expected. Older firmware has its own table: below 3.4 you need a version below 0.8.6, from 3.4 up to but not including 3.6 you need a version at or above 0.8.6 and below 0.11.0, and from 3.6 up to but not including 3.24 you need 0.11.0 or later, which may work but is not actively tested. Full colour RGBA streaming of PDFs and documents is tied to firmware 3.24 and later. In other words the tool follows the tablet's own update cycle, and a tablet that auto-updates can move out from under the version you installed.

Delta compression and WebGL keep the stream light

The streaming mechanism described in the README rests on three ideas. Rendering is WebGL based in the browser, which the README lists as the reason for smooth, efficient display. Bandwidth comes from delta compression, so only changed pixels are transmitted rather than a full frame each time, which matters on a tablet that is also running its own UI. The frame rate is not fixed: it is adjustable through URL parameters, which lets you trade latency against load depending on whether you are annotating live or just watching. Colour is handled separately, with RGBA streaming giving full colour from PDFs and documents on firmware 3.24 and later. The client also has a help overlay, a side menu for rotation, layer control and the Funnel toggle, and a connection status indicator with auto-reconnection.

The laser pointer, layer control and Reveal.js presentation mode

The interaction features are what separate this from a plain screen mirror. A red laser pointer follows the position of the pen, toggled with the L key, and the R key rotates the view while the ? key opens a help overlay listing gestures and shortcuts. Swipe gestures handle slide navigation, and the drawing layer can be toggled above or below embedded content, which is how you annotate over a PDF. Presentation mode goes further: it can embed a presentation or a video in the background, with Reveal.js integration for full slide control from the tablet itself. That combination is the closest thing to a classroom tool here, letting a presenter run slides and mark them up on the reMarkable at the same time while the audience watches the browser stream.

Tailscale for remote access, in two flavours

The Tailscale integration is the reason the -lite builds exist at all. The standard binaries register as a node on your tailnet, so you can reach the reMarkable from anywhere without exposing it to the public internet. Tailscale Funnel goes further and shares the screen publicly through the funnel with automatic QR code generation for viewers, and the README lists an ephemeral mode where the tablet registers as a temporary node that is removed when it disconnects. The Go module shows how heavy this is: tailscale.com v1.94.1 is a direct dependency, and the source tree has parallel files for it, including tailscale.go, tailscale_enabled.go, tailscale_stub.go and a matching stub set, which is the standard way to compile the feature out for the lite binaries.

Running it as a systemd service on the tablet

Because the tablet runs Linux, the binary can be installed as a service so it starts on boot. The README recommends the built-in subcommand.

./goMarkableStream install

That creates the service file and enables it, and the settings can be changed by editing /home/root/.config/goMarkableStream/env. The README also shows the manual equivalent, which is useful if you want to see what the generated unit file contains.

cat <<'EOF' > /etc/systemd/system/goMarkableStream.service
[Unit]
Description=goMarkableStream Server

[Service]
ExecStart=/home/root/goMarkableStream
Restart=always

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl enable --now goMarkableStream.service

Status and logs come from systemctl status goMarkableStream.service and journalctl -u goMarkableStream.service. The README carries an operational warning worth taking seriously: after a reMarkable system update you may need to re-download the binary and reinstall, which is the operational cost of running your own binary on a device the vendor also updates.

MIT licensed, Go 1.26, and a Makefile with the right cross targets

The licence is MIT, so the code can be reused and modified freely as long as the notice is kept. The go.mod names the module github.com/owulveryck/goMarkableStream and requires Go 1.26, with the direct dependencies being xxhash for hashing, envconfig for environment variables, klauspost/compress for compression and tailscale. The Makefile sets the cross-compilation defaults that matter here, with GOOS as linux, CGO_ENABLED as 0 and GOARCH as amd64, then defines targets that override the architecture for each device: build-remarkable-2 sets GOARCH=arm and GOARM=7, and build-remarkable-paper-pro sets GOARCH=arm64, each with a matching variant that adds the trace build tag. The build uses -trimpath and the -s -w linker flags to strip symbols and paths, which is what keeps the binaries small enough to ship to a tablet over a slow link.

Editorial conclusion

goMarkableStream fits owners of a reMarkable 2 on firmware 3.24 or later who want to present, annotate over Reveal.js slides, or reach the tablet from another machine without opening the device to a public network. It does not fit Paper Pro users who need guaranteed behaviour, since the README calls that support experimental, nor anyone who cannot accept the default admin and password credentials on first run. Verify first that your firmware version is 3.24 or above, that the client shows the RGBA stream correctly, and that you have changed the default credentials before exposing the tablet on a tailnet.

Frequently asked questions

Official sources

1. License: MIT
2. owulveryck/goMarkableStream on GitHub
3. Project website
4. README
5. Releases