# Valent: a GNOME implementation of the KDE Connect protocol > Valent is a C and GNOME based implementation of the KDE Connect protocol, offering contact and notification sync, media control, file and text sharing and a virtual touchpad across your devices. It is an alpha project distributed as a nightly Flatpak, with an unstable API and no stable release tag. **andyholmes/valent** — Connect, control and sync devices - Repository: https://github.com/andyholmes/valent - Website: https://valent.andyholmes.ca - Stars: 922 · Forks: 33 - Language: C - License: NOASSERTION - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/andyholmes-valent ## What the protocol actually gives you across devices The feature list in the project description is the best summary of what Valent does on a daily basis. It syncs contacts, notifications and clipboard content. It controls media players and volume. It shares files, links and text. It provides a virtual touchpad and keyboard, and it surfaces call and text notifications. It can execute custom commands. There is more beyond that list. Each of these is a separate protocol capability rather than a single synced screen. A media player on your phone becomes controllable from your desktop, a file you copy on one device appears on the other, and a notification raised on one machine surfaces on the others. The virtual touchpad and keyboard entry is the one that surprises people. It turns a second device into an input surface for the first, which is the feature that makes a shared desk setup work at all, and it is a protocol level capability rather than a screen sharing hack. Executing custom commands is the extension point that turns the connection into something scriptable. It is also the piece with the clearest security implication, since a command that runs on a peer machine needs the same care as any remote execution feature, and the project describes the connection as secure without documenting the pairing and trust details on the project page. ## A KDE Connect implementation, not a KDE Connect clone Valent is described as an implementation of the KDE Connect protocol, built on GNOME platform libraries. That distinction matters in practice. Implementing an existing protocol means interoperability rather than isolation. A Valent install on your GNOME desktop can talk to a KDE Connect client running on your phone, and the peers discover each other over the local network the way KDE Connect peers do. You are not committing your whole device fleet to one client implementation. It also means Valent inherits the protocol's scope, which is narrower than what a full remote control product might offer. KDE Connect is about nearby devices on the same network: sharing, notification relay, input control. It is not a remote desktop solution, and Valent does not present itself as one. The upstream project is acknowledged in the README, with credit to Albert Vaka and others for developing and maintaining KDE Connect. That acknowledgement is a good signal about protocol fidelity: an independent implementation that credits the protocol owners is more likely to track the specification than a private fork would be. The platform choice shows in the code. The primary language is C, the build is Meson with meson.build and meson.options at the top level, and the topic list names GTK4, KDE Connect, librem5, phosh and pinephone. ## Alpha status, unstable API and how to get hold of it The status section is unambiguous: the project is currently in alpha, it generally works as intended, but it is still missing some features and may contain bugs. That is a plain statement of intent rather than a hedge, and it should shape your expectations. The API carries its own badge, marked unstable in the documentation link, which tells you that plugin authors should not assume a stable surface. The badges at the top of the project page also point to a coverage report and to Weblate for translations, which tells you the project has a translation workflow and tracks test coverage. Installation in practice means the nightly Flatpak. The project explains that if alpha is acceptable, there is a nightly Flatpak to try, and it includes the nightly Flatpak repository so that it updates along with your other applications. The flatpakref is published from the project site. The release history is consistent with alpha. The three listed tags are v1.0.0.alpha.49 from 2025-11-17, v1.0.0.alpha.48 from 2025-09-14 and v1.0.0.alpha.47 from 2025-03-04. There is no 1.0.0 release, so any documentation or tutorial that references a stable Valent release does not match what exists. The repository is not archived and the last push was on 2026-10-11, so the source is moving even though the tags have not reached a stable point. ## The plugin model and the two companion repositories Two related repositories sit alongside the main one and tell you how the project expects to be extended. There is a GNOME Shell extension for Valent, and there is a Valent plugin template. The plugin template is the more interesting of the two for engineers. It tells you that Valent is designed to be extended with plugins rather than patched, which is the only sensible way to build a feature rich desktop client without a single upstream maintainer. A plugin template also means the boundaries between core and extension are drawn somewhere specific, and the template is where that line is documented. The GNOME Shell extension is a separate repository for a reason. Integrating with the shell means living in the shell's process and lifecycle, which is a different integration surface from the main client application. The main repository supports this shape internally. The top level entries include src/ for the implementation, data/ for application data, doc/ for documentation, po/ for translations, tests/, subprojects/ for Meson wrapped dependencies, build-aux/ for build helpers, vapi/ for Vala API bindings, and a REUSE.toml file alongside a LICENSES/ directory. The presence of vapi/ tells you the library is expected to be consumed from Vala as well as from C, and the LICENSES/ directory with REUSE metadata tells you the project tracks per file licensing, which matters for a project with a mixed codebase and third party code. The primary language is C, and valent.doap at the root is the standard GNOME metadata file for the application. ## Where Valent is the wrong choice Several situations rule this out, and none of them are unusual. If you need a stable, supported service, an alpha project with an unstable API badge is the wrong dependency. The project says it may contain bugs, and for something that relays notifications and clipboard content between your devices, a defect has a real cost. If your devices are not on the same network, the protocol's whole model does not apply. This is a nearby device connection, not a relay service, and no amount of local functionality changes that. If you are not on GNOME, you are adopting a project whose stated foundation is GNOME platform libraries. It will run on other desktops to some degree, since it is a GTK4 application, but the integration work is written against GNOME conventions and the shell extension targets GNOME Shell specifically. There is a fourth, subtler limit: the feature list is aspirational in places. A protocol implements a superset of what any one client implements, so a KDE Connect peer on your phone may offer a capability Valent has not implemented yet, and you will find out at pairing time rather than from documentation. The README is candid about missing features, which is honest, but it also means the protocol documentation is not a feature checklist for Valent itself. ## Licensing and the mobile platforms in the topic list The licence field on the repository records a custom type that GitHub cannot classify, and the repository contains both a LICENSE file and a LICENSES/ directory with REUSE.toml metadata. The REUSE setup means individual files carry their own licence information, which is the setup used by projects that mix their own work with code under several different licences. Read the LICENSES/ directory rather than assuming a single standard grant applies to every file, and confirm the terms before shipping it in a product. The topic list is more revealing than it first appears. Alongside GTK4 and KDE Connect, it names librem5, phosh and pinephone. Those are all Linux mobile environments. phosh is the shell used on Linux phones such as the PinePhone and the Librem 5, and librem5 refers to the Librem 5 device. Naming them suggests that one of the intended pairings is a Valent instance on a PinePhone talking to a Valent instance on a desktop, and it also explains a design constraint that the feature list implies. A phone running Phosh is a mobile Linux environment without the notification daemons and background services that a conventional Android or iOS phone provides, so a client that wants background delivery and media control on such a device has to work around a lot of platform assumptions that other implementations take for granted. That is a good deal of engineering for a project at alpha stage, and it tells you where the maintainer is spending the effort. The project home is valent.andyholmes.ca, and the CHANGELOG.md at the repository root, together with the doc/ directory, are where you look for what changed. ## Conclusion Adopt Valent if you run GNOME and want KDE Connect style device integration, because it implements the same protocol, which means a KDE Connect peer on another device can talk to it. Do not adopt it for anything you depend on in production, since the project calls itself alpha, the API is badged unstable, and the latest tag is an alpha build from 2025-11-17 even though the source is being pushed regularly. Verify first that the nightly Flatpak builds and installs on your distribution, that the peer device runs a compatible KDE Connect implementation, and that the specific plugins you need exist, since the protocol supports features Valent may not yet implement. ## FAQ ### What is Valent and what does it do? Valent is an implementation of the KDE Connect protocol built on GNOME platform libraries. It syncs contacts, notifications and clipboard content, controls media players and volume, shares files, links and text, provides a virtual touchpad and keyboard, surfaces call and text notifications, and can execute custom commands. ### How do I install Valent? The project is currently in alpha and points to a nightly Flatpak as the way to try it, with a flatpakref published from the project site. The Flatpak includes the nightly Flatpak repository, so updates arrive along with your other applications. ### Can Valent talk to the official KDE Connect client on my phone? Valent implements the KDE Connect protocol, which is what allows a Valent instance on a GNOME desktop to pair with a KDE Connect peer on another device. Because it is an implementation of the protocol rather than a private variant, peers running the upstream client can interoperate with it. ### Is Valent stable enough to rely on? The README states the project is currently in alpha, that it generally works as intended, but is still missing some features and may contain bugs, and the API is badged unstable. The listed release tags are all alpha builds, v1.0.0.alpha.49 being the most recent. ## Sources - [andyholmes/valent on GitHub](https://github.com/andyholmes/valent) - [Issues](https://github.com/andyholmes/valent/issues) - [Project website](https://valent.andyholmes.ca) - [README](https://github.com/andyholmes/valent/blob/main/README.md) - [Releases](https://github.com/andyholmes/valent/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/andyholmes-valent