How much RAM and CPU does Linksy use? And why it's written in Rust

Linksy's background service uses about 7 MB of memory at home and almost no CPU, even with away from home ready. The window adds about 30 MB of its own on top of GTK while it's open, and nothing once you close it. Linksy itself can move a file at about 360 MB/s, far more than Wi‑Fi carries. Here is how I measured that, what Linksy is built with, and why it's written in Rust.

How much memory does Linksy use?

Linksy is two programs. The service, linksyd, runs in the background: it finds your devices, keeps the connections, moves the files, and shows the tray icon. The app is the window, and it only runs while it's open. Here is each at rest, next to an empty GTK 4 window for scale:

About three quarters of the window is GTK and the graphics driver: a GTK 4 window with nothing in it uses 81 MB on the same laptop. GTK 4 draws with the GPU, and the driver alone adds about 48 MB to every GTK 4 window, Linksy's or any other; that part depends on your graphics card, not on the app. Drawn by the processor instead, the empty window is 33 MB and Linksy's 55 MB.

Linksy's own part, its pages, the history and what it knows about your phones, is the difference: about 20 to 30 MB. Close the window and all of it goes back to the system; only the service stays.

Why does away from home cost more?

Reaching your devices over the internet uses iroh, which checks its paths to the relay every 20 seconds or so to keep them ready. That keeps its code in memory: most of the extra MB is program code, not data. It only runs while one of your paired devices was on the same network as the computer in the last 7 days. Turn it off with linksy settings away off and the service goes back to its at-home size.

What's the difference between PSS and RSS?

System monitors usually show RSS, which counts every shared library in full in every program that uses it, though it's only in memory once. PSS splits shared memory between the programs that share it, so the PSS of everything running adds up to what the computer really uses. The chart shows both: RSS is the number you'll see in your system monitor, a few MB more for the service and about 25 MB more for the window.

I measured each program on its own, so the PSS here counts GTK and the graphics driver in full too. On a desktop where other apps already use them, Linksy's share is smaller than this.

How much CPU does it use?

At rest, almost none. Over 15 minutes on my laptop, with away from home ready, five paired devices and my phone connected, the service used 0.2 percent of one core: about a tenth of a second of work per minute. At home, without away from home, it was 0.04 percent. The window, open on a phone's page, stays under 1 percent. Your battery won't notice either.

Sending is real work, and Linksy does it quickly. I sent 1 GB between two Linksy services on the same laptop, so no network slowed it down. With the file already in memory it took 3 seconds, about 360 MB/s, with each side using about 1.4 cores. Read from a busy disk instead, the same file took 9 seconds: there the disk was the limit, not Linksy. Either way it's about 4 seconds of processor time per GB on each side, for the encryption (TLS 1.3), the checksum every file is checked against (BLAKE3), and the reading and writing. Between a phone and a computer the Wi‑Fi is much slower than that, up to 85 MB/s over Wi‑Fi Direct, so the processor mostly waits for the radio, at about a third of a core on this laptop.

How I measured

• Release builds, the same as the packages, on a ThinkPad E14 (AMD Ryzen 5 5500U, Fedora 44).
• Isolated copies of the service and the window, with their own settings, connected to a stand-in phone, so nothing else on the computer changes the result. Away from home and the CPU at rest are from my own Linksy, as I use it every day.
• Averages, not single readings. Memory (PSS and RSS, from /proc/<pid>/smaps_rollup) and CPU time (from /proc/<pid>/stat) every 10 seconds, over 4 to 15 minutes, leaving out the first 30 seconds of start-up. Linksy hands unused memory back every few minutes, so one reading right after that looks better than the truth.

What keeps it light?

• The window doesn't stay in the background. The tray icon is part of the service, so closing the window really closes it.
• Connections close when there's nothing to do, and open again in a moment when there is, unless you ask Linksy to stay connected.
• Unused memory goes back. The service and the app regularly return what they no longer need to the system.
• History stays small. A transfer of a huge folder keeps the full list of names only up to 1,000 files.
• A ceiling. The service's systemd unit caps it at 64 MB and runs it at a lower priority, so it gives way to whatever you're doing.
• A build made for size, with the hot paths (encryption, checksums, QUIC) built for speed: that change alone took the service from 23 to 14 MB with away ready, at the same transfer speed.

The work so far is in issue #26, "Lighter at rest", with what was tried and what didn't help.

How big is it to download?

Installed, the service is 15 MB and the window 5.6 MB. All of them are on the releases page and in the download section.

What is Linksy built with?

Why not one app for every desktop?

One app for every desktop, in Electron or Flutter, would have been quicker to write. But I wanted Linksy to look and behave like it belongs on your desktop, and to stay light: an Electron app brings a whole browser engine with it, and a Flutter app its own rendering engine, before their first button. A GTK app on GNOME and a Qt app on Plasma use the toolkit the desktop already runs. The cost is mine: every screen exists twice, and a feature isn't released until it's in both apps.

Why Rust?

Honestly, it started with me, not with the project. I wanted a good, well-paid job in systems programming, and Rust is a big part of that world. And I wanted a challenge: for years I'd mostly written TypeScript, Python and other high-level languages, and built fairly simple things. I needed to grow as a developer, and the way to do that was a real project in a harder language.

It also turned out to be the right tool for Linksy:

• No garbage collector, so the memory stays small and flat instead of growing until a collector runs.
• One core everywhere. The same Rust code speaks the protocol on the computer and on the phone, so the two can't disagree.
• Safe by default for code that reads what other devices send: the compiler rules out whole kinds of memory bugs before they ship.
• Serious libraries for exactly this work: QUIC, TLS, async networking and peer-to-peer connections.

The costs are real too: long builds, a steep start, and bigger programs than you'd expect, since everything is built in. For an app that's meant to stay out of your way, I'd make that trade again.

What's next?

The phone's own numbers, memory and battery on Android, and the Plasma app's are next, and I'll add them here once they're measured the same way. If Linksy uses much more on your computer than it does here,open an issue with the output of linksy logs: Linksy isfree and open source, and how light it is matters as much as what it does.