CraysGossip
Gossip is Michael Dilger's native Rust desktop client for Nostr: fast, local, LMDB-backed, privacy-conscious and built around the relay-seeking model that later became central to NIP-65 outbox thinking.
A feed client with old-school nerve
Gossip feels like a client from the older, sharper internet: a real desktop program, built for people who want to understand what the machine is doing. It is not trying to be the smoothest social app in the room. It is trying to be a fast, local, configurable Nostr workstation that does not hide the hard parts of the protocol behind a soft feed.
That makes it unusual in a good way. Most Nostr clients try to make relays, keys, media loading and spam feel invisible. Gossip takes the opposite bet. It gives you a window onto the actual structure: who you follow, which relays are used, where your events are supposed to go, which media should load, what should be filtered, which lists are public, which lists are private, and how much trust you want to place in strangers, relays and defaults.
The official repository describes Gossip as a desktop client for Nostr. NostrApps calls it an efficient desktop client and highlights the same traits that define the project: it runs on Windows, macOS and Linux; it avoids browser technology; it is written for performance in Rust; it uses LMDB for storage; it supports the outbox model; it offers a large settings surface; and it has privacy options including Tor-oriented usage and controls for media loading and follow-list exposure.
If you are used to mobile clients, Gossip may feel blunt at first. That is part of its character. It does not flatter the user with a sealed product surface. It assumes you might be the kind of person who wants to tune the relays, read the logs, inspect the event, copy the JSON, export the encrypted key, change the spam filter, prune the database and still post a normal note when you are done.
The name is a relay theory
The most important thing about Gossip is not the feed. It is the relay model. Early Nostr clients often behaved as if the user had a simple relay list and everyone could just meet there. That works only while the network is small, social graphs overlap heavily and nobody cares much about missed replies. Once the network grows, a client has a harder job: it has to find where each person actually publishes and where mentions are likely to arrive.
Gossip was named before the language around NIP-65 settled. Its README says the "Gossip Model" was named after this client because Gossip never depended on one simple list of relays. From the beginning it tried to find posts from followed people wherever those posts were likely to be, using relay lists and additional heuristics. Later, NIP-65 formalized relay list metadata as kind 10002: users advertise read and write relays, and clients should use those hints when downloading a person's events or publishing events that mention them.
That sounds like protocol trivia until you use Nostr at scale. The relay question is the difference between "my client kind of works when my friends use the same relays" and "my client can keep finding people across a messy network." Gossip connects to the relays needed to cover the people you follow, tries not to connect to more than necessary, and adjusts when relays are down or disconnecting. It treats discovery as a living task.
This is why Gossip matters historically. The app is not just another implementation of other people's ideas. Its design language helped name one of the core client problems in Nostr: how do you find the people you follow without blasting every relay forever? If you want to understand why outbox thinking matters, Gossip is one of the clients you should study.
Keys, privacy and the desktop bargain
Gossip's security posture is inseparable from its desktop nature. The project deliberately avoids browser-tech except for ordinary HTTP and WebSocket work needed by Nostr. The README is direct about the reason: the browser stack is enormous, complex and full of attack surface. Gossip uses a native UI instead, originally described as simple OpenGL-style rendering and built today around the Rust egui/eframe ecosystem.
The key-handling philosophy is also explicit. Gossip stores private keys encrypted under a passphrase on disk, requires that passphrase when needed, and uses memory-zeroing practices where it can. It is not promising hardware-token-level isolation. It is saying: for a normal native desktop app, let us at least take private keys seriously.
The configuration docs add more texture. A new user can generate or import an identity. The Account area exposes npub, nprofile and encrypted private-key material. The GUI is primarily one account at a time, but environment variables such as GOSSIP_PROFILE and GOSSIP_DIR can create separate data directories and profiles. Gossip does not yet use a remote NIP-46 bunker as its own key manager, but it can operate as a Nostr Connect signer for other applications.
Privacy controls are everywhere. You can run it in offline mode. You can require approval before connecting or authenticating to new relays. You can decide whether to fetch avatars, media, NIP-05 records and metadata automatically. You can avoid loading images, hide or reveal content-warning material, and choose how much of your relay setup should be advertised. If your threat model is serious, the README points toward Tor-oriented environments such as QubesOS, Whonix, Tails or torsocks rather than pretending a checkbox makes you invisible.
Moderation with your hands on the wheel
Gossip's moderation story is practical, not ceremonial. It gives you several ways to shape what enters your attention. You can define person lists and read a feed from a smaller group instead of the whole social graph. You can mute people and synchronize that mute list with other clients. You can dismiss a thread locally until restart. You can show content warnings and require an explicit reveal before viewing sensitive material.
The spam controls are especially telling. Gossip can mark certain relays as SpamSafe, so unknown-person replies are fetched only from relays you trust for that purpose. It also ships with a Rhai script hook for spam filtering. That means a technical user can write or adjust a filter script rather than waiting for a platform policy team to decide what counts as junk. This is not plug-and-play moderation for everyone. It is closer to giving you a toolbox and letting you decide how strict the workshop should be.
There is also a small but important detail in the README: global and per-relay feeds can be ephemeral. Gossip can show a relay's public flow without permanently saving those notes and media to your computer. That is a sane distinction. Sometimes you want a local archive of your actual network. Sometimes you only want to glance at a relay without bringing the whole room home with you.
The configuration docs make clear that the defaults are meant to be usable, but Gossip is not afraid of settings. It even gives reset-to-default controls for changed settings so you can experiment and recover. That tells you the intended audience. This is a client for people who want a say in how the feed is made.
Inside the Rust machine
The codebase is Rust almost all the way down. GitHub lists the repository language as Rust, and the workspace is split into gossip-lib, gossip-bin and gossip-cache. The README names Rust, egui, LMDB, Tungstenite, Tokio, Serde and Speedy as important technology. The Cargo files show a little more: nostr-types, tokio-tungstenite, reqwest, heed for LMDB access, rhai for scripting, zeroize for sensitive memory handling, image tooling, blurhash, QR code support and optional video-related features.
That stack explains the feel. Gossip is not a web view wrapped in a desktop shell. It is a native client with its own database, rendering loop, network tasks, relay logic, cache and command surface. The execution docs even tell users to pay attention to console logs and to tune RUST_LOG when needed. There is a --rapid mode for some slow-storage systems, with the honest warning that local data can be corrupted after a crash if the filesystem does not preserve write ordering.
Local storage is a major part of the product. Gossip moved from SQLite to LMDB in earlier releases and later added tools and docs for pruning old events, compacting LMDB data, rebuilding indexes and removing unused person records. This is the unglamorous side of a serious desktop client: if you actually keep a local view of a large Nostr graph, you must care about storage growth, indexing, cached files and maintenance.
The NIP support document is also revealing. Gossip supports a broad set of practical client NIPs: basic protocol flow, follow lists, NIP-05 identifiers, deletion requests, NIP-10 threading conventions, NIP-17 private DMs with NIP-44 encryption and NIP-59 gift wrap, NIP-21 nostr URLs, NIP-36 sensitive content, NIP-42 relay auth, NIP-46 as signer, NIP-49 encrypted private keys, NIP-50 search, NIP-57 zaps and NIP-65 relay list metadata. It also supports Blossom server requirements and user server lists. This is not a toy implementation.
Releases and rough edges
The repository was created in November 2022 and remains active. Michael Dilger is the main maintainer, with a long contribution trail and additional contributors including bu5hm4nn, ezicheq, dtonon, nbenaglia, fiatjaf and others. The latest stable release checked here is v0.14.0, published on March 16, 2025. The current master branch has moved beyond that, with the package version showing 0.15.0-unstable in the Cargo metadata.
Release v0.14.0 is a real cross-platform desktop release, not a vague download page. The assets include Windows MSI, macOS DMGs for Apple Silicon and x86_64, a Flatpak, an AppImage archive and a Debian package. The release notes highlight visible social-client improvements like showing zappers and reaction details, better search, undo send for direct messages, faster image and video loading, better thread loading, relay UI sorting and filters, more responsive UI work, protocol handling changes and a major fetcher rewrite.
The rough edge is the same as the strength: Gossip exposes more machinery than casual users may want. It has many settings, console logs, relay concepts, storage maintenance and privacy tradeoffs. It is a tool you learn. If you want a glossy social app that makes every decision for you, Gossip may feel demanding. If you want to know why a note is found, why a relay is touched, why a picture is not loading, or why your feed contains what it contains, that demand becomes the point.
The license trail is clear in the source: the package metadata and README use MIT licensing. One small note for readers who check the GitHub API: automated GitHub license detection can be less precise than reading the repository's own license and Cargo metadata. For reuse questions, read the license file itself.
Who should run Gossip
Run Gossip if you want a Nostr client that treats you like the operator of your own social machine. Run it if you care about native desktop software, local storage, relay behavior, configurable privacy and a client that can act as a signer for other apps. Run it if you want to understand Nostr's outbox model in a way that a sleek web client may never force you to understand.
Do not run it expecting invisibility from one privacy toggle, or permanent freedom from spam because a client has a filter. Gossip gives you tools. It does not remove the need to think. That is refreshing. The app's whole character is a refusal to pretend that decentralized social networking becomes simple just because the interface is pretty.
For Crays, Gossip is important because it represents a different branch of the Nostr app tree. It is not chasing consumer polish first. It is building a power-client grammar: local database, relay intelligence, key custody, moderation knobs, direct message standards, command-line escape hatches and cross-platform packages. That branch matters. Protocols are not kept alive only by beautiful onboarding. They are also kept alive by stubborn clients that let experienced users see and shape the machinery.
Sources worth opening
These are the project and protocol sources worth opening if you want to verify Gossip beyond the app directory summary.
- mikedilger/gossip GitHub repository
- Gossip releases
- Gossip release v0.14.0
- Michael Dilger on GitHub
- NostrApps listing for Gossip
- Gossip README
- Gossip installation and usage docs
- Gossip configuration docs
- Gossip execution docs
- Gossip pruning docs
- Gossip NIP support matrix
- Gossip change log
- Gossip workspace Cargo.toml
- Gossip binary Cargo.toml
- Gossip library Cargo.toml
- NIP-65 Relay List Metadata
- 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
