CraysCoop
Coop is a desktop Nostr messenger that puts private direct messages first instead of treating them as a side drawer in a timeline app. Its best story is not size. It is focus: NIP-17 chat, desktop builds, Rust and GPUI, and the very human need for a quiet place to write.
A desktop messenger, not another feed
Coop is refreshing because it does not try to become your whole Nostr life. It is a messenger. That sounds almost too small until you remember how many social apps treat direct messages as a cramped afterthought beside the feed. A timeline app wants to show you the world. A messenger should let you sit with one conversation, type without noise, search without drama, and trust that the private side of the protocol is being handled with care.
NostrApps gives the catalog version: Coop is a direct-message client for desktop, with safe DMs through NIP-17. The GitHub README says it is a simple, fast and reliable Nostr client for secure messaging across platforms. The app's own tagline is sharper: chat freely, stay private on Nostr. Those short descriptions are enough to locate the product. Coop is not a general-purpose feed client like Amethyst or Primal. It is not a group-room experiment like Chachi. It is a desktop chat surface for people who want Nostr DMs to feel like an app, not a protocol chore.
That focus is useful. Private messaging is one of the places where Nostr has to earn trust the hard way. Public notes can fail loudly. If a relay misses one, you see it. If a private message implementation is sloppy, you may not notice the leak until much later. Sender and receiver metadata, relay choice, key storage, wrapping, deletion, file handling and backup copies all matter. Coop's narrow product shape lets the reader ask those questions directly.
The desktop angle matters too. A lot of Nostr experimentation happens on phones or in web clients. Coop is for the computer. Its release assets include Windows installers, macOS DMGs, Linux tarballs, Snap packages and Flatpak packages. That is a different daily rhythm: keyboard, long chats, work context, local files, multiple windows, maybe a user who wants one quiet Nostr inbox while the rest of the network lives somewhere else.
NIP-17 is the center of gravity
Coop's first public identity was NIP-17. The early Nostr announcement described it as a small chat app based on NIP-17, ready for testing, intentionally simple, and not trying to be fancy. That is the right starting point because NIP-17 is not a decoration. It defines the current private direct-message scheme for Nostr, using NIP-44 encryption and NIP-59 gift wrapping.
The important idea is that the final event stored on a relay is a gift wrap. It is not a plain "Alice sent Bob a message" record. The real message is a rumor, then sealed, then wrapped, with the visible wrapper using a random key. NIP-17 also defines a user's preferred DM relays through kind 10050. A sender should publish to the recipient's listed DM relays, and clients need to be careful when no such list exists. This is exactly the kind of detail that makes or breaks a DM app.
NIP-17 has real benefits, but it is not magic. It hides participant identities and message metadata from public relay observers better than old NIP-04 direct messages. It also introduces operational work: clients have to discover DM relays, produce separate wrapped events for sender and receiver, verify the relationship between rumor and seal, manage spam risks and keep message recovery sane. A private chat app is not just a text box with encryption sprinkled on top. It is a relay choreography.
Coop's release history shows that the maintainers know this. v0.3.0 includes a change to reject gift wraps whose rumor pubkey does not match the seal signer, which maps directly to a safety requirement in the NIP-17 model. It also stores DM rumors without re-signing and adds outbound DM relay hints. Those changes are technical, but the user-facing meaning is plain: private messaging is fragile enough that correctness matters more than shiny interface claims.
The first promise was modest
The original Coop announcement is worth reading because it has the tone of a builder showing a real tool, not a marketing department announcing a revolution. It described Coop as a little chat app based on NIP-17, asked people to test it, and pointed to release v0.1.4. The builder also said Coop did not yet support Nostr Connect through NIP-46 at that time, but stored the user's secret key as an encrypted NIP-49 value in the operating system's secure keyring.
That detail is important. A desktop Nostr app has to do something with the key. Browser signers are common on the web. Mobile signers like Amber are part of the Android story. Desktop apps can use external signing paths, local encrypted keystores or other patterns. Coop's early answer was not perfect or final, but it was at least explicit: encrypted key storage through NIP-49 and the OS keyring, instead of casually throwing raw private keys into an app database.
The announcement also explained message routing in a practical way: when sending a message, Coop would send to the other user's inbox relays and keep a backup version on the sender's inbox relays. That is the DM-relay problem in one sentence. Private chat on Nostr cannot assume there is one central inbox. It has to know where the recipient receives DMs and how the sender will recover their own conversation later.
Coop has grown since that first release, but the modest origin still helps define the app. It was not born as an everything client. It was born around a specific pain: NIP-17 messaging on desktop needed a focused interface. When you read the current repo, release notes and screenshots, you can still see that original shape underneath the extra work.
Rust, GPUI and the Lume lineage
The current Coop repository is a Rust project under LumeHQ. It is GPL-3.0 licensed, not archived, and GitHub API data on June 6, 2026 shows 192 stars, 13 forks, 17 open issues, a created date of June 30, 2024, and the last push on January 11, 2026. The GitHub page lists 347 commits. The public homepage field points to `https://reya.su/coop`, but that URL currently returns 404, so the repo and releases page are the dependable sources.
The README says Coop is built with Rust and GPUI, with Nostr behavior handled by Rust Nostr SDK. GPUI is the UI framework associated with Zed's ecosystem, and it gives Coop a different feel from web-wrapper desktop apps. The repository layout also shows a modular application: account, auto_update, chat, chat_ui, common, encryption, encryption_ui, key_store, person, relay_auth, settings, state, theme, title_bar and UI crates.
The Cargo workspace makes the Nostr choices visible. It depends on `nostr-sdk`, `nostr-connect` and `nostr-lmdb` from the rust-nostr project. The `nostr-sdk` features include `nip96`, `nip59`, `nip49` and `nip44`. That feature set matches the app's job: file/storage integration, gift wrapping, encrypted private-key encoding and modern encryption. You do not need to memorize those NIP numbers, but you should notice that the codebase's dependencies line up with the messaging claims.
Coop also carries the Lume lineage. Lume was a desktop Nostr client project, and Coop feels like a narrower descendant: same broad interest in desktop Nostr, but focused on chat. That matters because desktop apps are expensive to maintain. Packaging across Windows, macOS and Linux is annoying. Native UI work is slow. A DM-first client choosing Rust and GPUI is a bet that performance, desktop feel and maintainable systems code are worth the extra effort.
What v0.3.0 reveals
The latest stable GitHub release is v0.3.0, published December 8, 2025. It ships ten platform assets: Linux aarch64 and x86_64 tarballs, macOS aarch64 and x64 DMGs, Windows ARM64 and x64 setup executables, Snap packages for aarch64 and x86_64, and Flatpak packages for aarch64 and x86_64. That distribution footprint is one of the strongest signs that Coop is a real desktop app rather than a screenshot project.
The v0.3.0 notes also show the kind of work happening under the surface. There is a custom gossip implementation, multiple keystores, gift-wrap validation, DM rumor storage without re-signing, outbound DM relay hints, UI restructuring, a Nostr-based auto updater, onboarding improvements, profile popup improvements, search refinement and a backend rewrite marked as not tested. The release page also warns that the NIP-4e feature is experimental and should be used at your own risk.
That warning is good. It is the kind of caution a private-message app should carry. Experimental encryption or messaging features are not toys, and users need to know when they are stepping outside the safer path. A release note that says "use it at your own risk" is more trustworthy than a page that pretends every feature is equally mature.
The release sequence before v0.3.0 is also revealing. v0.2.8 added failed-message resend, a seen-on-relays viewer per message and detection of user DM relays when opening a chat panel. v0.2.10 fixed duplicated sent messages and duplicated replies, and made NIP-46 public-key handling more consistent. These are not glamorous release notes. They are messaging app notes. They tell you the app was wrestling with the real bugs that appear when encrypted relay-based messaging becomes a daily interface.
The desktop safety question
Coop deserves a careful trust paragraph because desktop messaging apps carry two kinds of risk. The first is the Nostr protocol risk: wrong relay routing, bad wrapping, weak key handling, metadata leaks or broken message recovery. The second is ordinary software risk: you download an installer, run it on your computer and grant it access to whatever a desktop app can touch.
The project helps itself by being open source and GPL-3.0, by publishing releases through GitHub, and by using Rust Nostr SDK rather than inventing every protocol primitive from scratch. But the user still has work to do. Download from the official `lumehq/coop` releases page. Check the release date and asset name. Prefer builds that match your operating system cleanly. If your platform has signing or sandboxing warnings, read them. If the homepage is unavailable, do not use random mirrors that happen to look convenient.
Key storage is the other point. Coop's early announcement said it encrypted the secret key as NIP-49 and stored it in the OS secure keyring. The current release notes mention multiple keystores, which suggests the app has expanded how it handles identity. That can be good, but it also means the user should understand which keystore they are selecting. A DM client is only as private as its key handling, encryption implementation, relay routing and update path.
The practical advice is boring because boring is good here. Start with a low-risk account. Test a DM with someone who can receive NIP-17 messages in another client. Check whether Coop finds the recipient's DM relays. Send, receive, restart the app, and see whether history survives. Only then decide whether it deserves a more important key.
Who Coop is really for
Coop is for people who want a dedicated Nostr DM surface on a computer. If your Nostr life is mostly public posting, you may get more from a full client. If you need mobile chat, 0xchat, Amethyst, Damus or Primal may be the first place to look. If you want one quiet desktop app for private conversations, Coop becomes more interesting.
It is also for builders who want to study how NIP-17 messaging becomes an actual product. The repo is useful even if you never install the app. It shows how a desktop client organizes chat UI, encryption UI, key stores, relay authentication, settings, state and auto-update work around Nostr. It shows that private messaging is not only about the encryption spec. It is about the whole chain from key to relay to recovery to user confidence.
Coop's best quality is restraint. It does not need to be the Nostr super app. The network already has enough clients trying to become the front door to everything. Coop can be judged by a narrower, harder standard: can it make private Nostr messaging on desktop feel calm, usable and technically honest? That is plenty of ambition for one app.
If the project keeps moving, the things to watch are release cadence, homepage availability, NIP-46 or external signing support, keystore clarity, DM relay discovery, message recovery, cross-client compatibility and whether experimental features stay clearly labeled. A good messenger should almost disappear while you are writing. A good Nostr messenger should disappear only after it has shown you enough about keys and relays to deserve that trust.
Sources worth opening
This article keeps claims close to the public project trail. Open these if you want to verify Coop's code, releases, NIP-17 model or desktop packaging yourself.
- Coop GitHub repository
- Coop README
- Coop releases
- Coop v0.3.0 release
- Coop v0.1.4 early release
- Coop announcement on Nostr
- NostrApps listing for Coop
- Coop homepage listed by GitHub
- Rust Nostr SDK
- GPUI
- NIP-17: Private Direct Messages
- NIP-59: Gift Wrap
- NIP-44: Versioned encryption
- NIP-49: Private key encryption
- OpenSats explainer on private DMs
- NIP-25 reactions
- NIP-27 text note references
- Nostr protocol NIPs repository
- NIP-01 basic protocol flow
- NIP-05 DNS identifiers
- NIP-07 browser signer capability
- NIP-10 text note threading
- NIP-11 relay information document
- NIP-19 bech32 encoded entities
- NIP-46 remote signing
