# nats-io/nats-server

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/nats-io-nats-server).**

19,177 stars · 1,737 forks · Go · apache-2.0

## Links

- GitHub: https://github.com/nats-io/nats-server
- Homepage: https://nats.io
- awesome-repositories: https://awesome-repositories.com/repository/nats-io-nats-server.md

## Topics

`cloud` `cloud-computing` `cloud-native` `connected-vehicle` `distributed-systems` `edge` `edge-ai` `edge-computing` `go` `golang` `message-bus` `message-queue` `messaging` `microservices-architecture` `nats-server`

## Description

NATS Server is a high-performance, lightweight messaging system designed for cloud-native applications, edge computing, and distributed microservices. It functions as a distributed publish-subscribe broker that routes messages using hierarchical, dot-separated subject strings, enabling decoupled communication between services without requiring centralized broker lookups. The system supports core messaging patterns including asynchronous publish-subscribe, request-reply, and load-balanced queue processing.

The platform distinguishes itself through a decentralized architecture that eliminates the need for centralized user databases or complex service discovery. It utilizes cryptographically signed JSON Web Tokens for identity and permission management, and maintains a self-healing mesh network through gossip-based cluster discovery. For isolated or edge environments, the server supports leaf-node proxying, which tunnels traffic through persistent connections to bridge local and remote namespaces.

Beyond basic messaging, the system provides a robust capability surface for distributed state and data management. This includes log-structured stream persistence for reliable message replay and durable delivery, as well as an integrated, atomic key-value store for managing configuration and state across services. The architecture enforces multi-tenant isolation by segregating traffic into independent accounts, each with granular access control policies that govern cross-account data sharing and service interaction.

The server is designed for flexible deployment, ranging from single-process instances embedded within applications to globally distributed superclusters spanning multiple cloud providers. It provides comprehensive observability through real-time metrics, event tracing, and integration with standard monitoring tools.

## Tags

### DevOps & Infrastructure

- [Distributed Messaging](https://awesome-repositories.com/f/devops-infrastructure/distributed-messaging.md) — Implements a scalable, resilient messaging backbone supporting publish-subscribe, request-reply, and load-balanced queue patterns. ([source](https://docs.nats.io/nats-concepts/service_infrastructure.md))
- [Message Queues](https://awesome-repositories.com/f/devops-infrastructure/message-queues.md) — Functions as a cloud-native messaging infrastructure supporting persistent streams and load-balanced work queues. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/slow_consumers.md))
- [Cluster Bridging](https://awesome-repositories.com/f/devops-infrastructure/cluster-management/cluster-bridging.md) — Links geographically distributed clusters using gateways to enable disaster recovery and location-aware message processing. ([source](https://docs.nats.io/running-a-nats-service/introduction.md))
- [Deployment Scaling](https://awesome-repositories.com/f/devops-infrastructure/deployment-scaling.md) — Provides flexible deployment configurations ranging from single-process edge instances to globally distributed superclusters. ([source](https://docs.nats.io/nats-concepts/what-is-nats.md))
- [Graceful Shutdowns](https://awesome-repositories.com/f/devops-infrastructure/graceful-shutdowns.md) — Provides a maintenance mode that rejects new connections and drains existing ones before stopping the server process. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))
- [High Availability Clusters](https://awesome-repositories.com/f/devops-infrastructure/high-availability-clusters.md) — Maintains high availability through self-healing clusters, leaf nodes, and superclusters for flexible deployment. ([source](https://docs.nats.io/nats-concepts/overview/compare-nats.md))
- [Queue-Based Message Distribution](https://awesome-repositories.com/f/devops-infrastructure/message-queues/queue-based-message-distribution.md) — Enables horizontal load balancing by grouping subscribers so each message is delivered to only one member of the group. ([source](https://docs.nats.io/nats-concepts/core-nats/queue.md))
- [Zero-Downtime Deployments](https://awesome-repositories.com/f/devops-infrastructure/zero-downtime-deployments.md) — Applies changes to server settings and credentials without downtime by signaling the running process. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/username_password.md))
- [Messaging Infrastructure](https://awesome-repositories.com/f/devops-infrastructure/messaging-infrastructure.md) — Automates the deployment and configuration of messaging servers within continuous integration pipelines. ([source](https://docs.nats.io/running-a-nats-service/configuration/resource_management/configuration_mgmt/github_actions.md))
- [Cluster Node Management](https://awesome-repositories.com/f/devops-infrastructure/cluster-node-management.md) — Automates the eviction of unresponsive cluster peers to maintain data redundancy and cluster health. ([source](https://docs.nats.io/running-a-nats-service/configuration/clustering/jetstream_clustering/administration.md))
- [Distributed Task Queues](https://awesome-repositories.com/f/devops-infrastructure/distributed-task-queues.md) — Scales work queues by distributing message processing across multiple horizontal pull-based workers. ([source](https://docs.nats.io/nats-concepts/jetstream/consumers/example_configuration.md))
- [Resource Quotas](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/configuration-policy-enforcement/resource-quotas.md) — Limits memory and disk storage capacity for specific accounts to ensure predictable performance. ([source](https://docs.nats.io/running-a-nats-service/configuration/resource_management.md))
- [Service Health Monitoring](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/operational-observability-access/service-health-monitoring.md) — Provides automated responses for service discovery and metadata queries to monitor operational health. ([source](https://docs.nats.io/using-nats/developer/services.md))
- [Resource Controllers](https://awesome-repositories.com/f/devops-infrastructure/kubernetes-cluster-management/resource-controllers.md) — Enables defining and maintaining message streams using standard Kubernetes cluster resource definitions. ([source](https://docs.nats.io/running-a-nats-service/configuration/resource_management/configuration_mgmt/kubernetes_controller.md))
- [Messaging Servers](https://awesome-repositories.com/f/devops-infrastructure/messaging-servers.md) — Connects multiple messaging server instances to share state and distribute traffic. ([source](https://docs.nats.io/running-a-nats-service/nats_docker/docker_swarm.md))
- [Delivery Patterns](https://awesome-repositories.com/f/devops-infrastructure/messaging-servers/delivery-patterns.md) — Supports both server-initiated push and client-requested pull delivery for flexible throughput management. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/consumers.md))
- [Request Routing](https://awesome-repositories.com/f/devops-infrastructure/request-routing.md) — Prioritizes local service delivery within a cluster and only routes requests to remote regions when no local listeners are available to handle the traffic. ([source](https://docs.nats.io/nats-concepts/core-nats/queue.md))
- [Rolling Update Orchestrators](https://awesome-repositories.com/f/devops-infrastructure/rolling-update-orchestrators.md) — Updates clusters by cycling through nodes one at a time using graceful shutdown to ensure service continuity. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/upgrading_cluster.md))
- [Server Lifecycle Managers](https://awesome-repositories.com/f/devops-infrastructure/automation-orchestration/server-lifecycle-managers.md) — Supports process signaling for shutdowns, configuration reloads, and log file rotation during runtime. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/signals.md))
- [Connection Termination](https://awesome-repositories.com/f/devops-infrastructure/client-connectivity-tools/connection-termination.md) — Ensures data integrity during shutdown by processing all pending and inflight messages before closing connections. ([source](https://docs.nats.io/using-nats/developer/receiving/drain.md))
- [Infrastructure Provisioning Tools](https://awesome-repositories.com/f/devops-infrastructure/cloud-infrastructure/infrastructure-provisioning-management/infrastructure-provisioning-tools.md) — Automates the lifecycle management of messaging streams and consumers using infrastructure-as-code patterns. ([source](https://docs.nats.io/running-a-nats-service/configuration/resource_management/configuration_mgmt.md))
- [Distributed Infrastructure](https://awesome-repositories.com/f/devops-infrastructure/distributed-infrastructure.md) — Connects separate messaging environments across cloud and edge systems to create a unified communication fabric. ([source](https://docs.nats.io/nats-concepts/overview.md))
- [Infrastructure as Code](https://awesome-repositories.com/f/devops-infrastructure/infrastructure-as-code.md) — Automates the deployment of messaging resources using declarative files for consistent environment configuration. ([source](https://docs.nats.io/running-a-nats-service/configuration/resource_management/configuration_mgmt/terraform.md))
- [Platform as a Service](https://awesome-repositories.com/f/devops-infrastructure/platform-as-a-service.md) — Operates a messaging server as a single process, fault-tolerant cluster, or globally distributed super-cluster. ([source](https://docs.nats.io/nats-concepts/service_infrastructure/adaptive_edge_deployment.md))

### Networking & Communication

- [Publish-Subscribe Messaging](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/publish-subscribe-messaging.md) — Provides a high-performance publish-subscribe messaging backbone for decoupled communication between distributed services. ([source](https://docs.nats.io/using-nats/developer/anatomy.md))
- [Messaging Services](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services.md) — Runs a server process that listens for client connections to facilitate communication between distributed services. ([source](https://docs.nats.io/nats-concepts/what-is-nats/walkthrough_setup.md))
- [Client-to-Client Messaging](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/publish-subscribe-messaging/client-to-client-messaging.md) — Enables decoupled, asynchronous communication between services using publish-subscribe and request-reply patterns. ([source](https://docs.nats.io/nats-concepts/what-is-nats.md))
- [Message Brokers](https://awesome-repositories.com/f/networking-communication/message-brokers.md) — Provides a high-performance, lightweight messaging broker for asynchronous communication and decoupled service interaction using subject-based routing.
- [Reliable Event Delivery Systems](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-reliability/reliable-event-delivery-systems.md) — Supports persistent event streaming with configurable retention policies for reliable delivery and state recovery.
- [Message Brokers](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/message-brokers.md) — Facilitates asynchronous data exchange between distributed services using publish-subscribe and request-reply patterns. ([source](https://docs.nats.io/using-nats/nats-tools/nats_cli.md))
- [Cluster Discovery Mechanisms](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-systems-coordination/cluster-discovery-mechanisms.md) — Maintains a self-healing mesh network using gossip-based discovery for automated cluster membership. ([source](https://docs.nats.io/using-nats/developer/connecting/cluster.md))
- [Message Stream Handlers](https://awesome-repositories.com/f/networking-communication/message-stream-handlers.md) — Capture and store messages published to specific subjects using configurable retention policies and cluster-level placement. ([source](https://docs.nats.io/nats-concepts/core-nats.md))
- [Message Stream Replayers](https://awesome-repositories.com/f/networking-communication/message-stream-handlers/stream-message-fetchers/message-stream-replayers.md) — Store published messages in a distributed engine to allow consumers to retrieve historical data or replay streams on demand. ([source](https://docs.nats.io/nats-concepts/jetstream.md))
- [Service Discovery](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/service-discovery.md) — Exposes discoverable services by grouping operations into versioned endpoints for distributed interaction. ([source](https://docs.nats.io/using-nats/developer/services.md))
- [Messaging Client Connections](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/communication-protocols-standards/network-protocols/connection-establishment-protocols/messaging-client-connections.md) — Provides flexible client connectivity using standard protocols, TLS, and WebSockets for distributed service communication. ([source](https://docs.nats.io/nats-concepts/connectivity.md))
- [Cross-Account Replication](https://awesome-repositories.com/f/networking-communication/data-streaming/cross-account-replication.md) — Enables secure cross-account data sharing through explicit import and export definitions with activation token support. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security/jwt.md))
- [Distributed State Management](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/data-synchronization-consistency/distributed-state-management.md) — Provides key-value stores with versioning and time-to-live settings for sharing state between services. ([source](https://docs.nats.io/readme.md))
- [Load Balancers](https://awesome-repositories.com/f/networking-communication/load-balancers.md) — Distributes incoming requests across dynamic groups of responders to scale processing capacity. ([source](https://docs.nats.io/nats-concepts/core-nats/reqreply.md))
- [Message Delivery Guarantees](https://awesome-repositories.com/f/networking-communication/message-delivery-guarantees.md) — Provides configurable acknowledgment modes to ensure reliable message delivery and processing confirmation. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/model_deep_dive.md))
- [Multi-Cluster Connectivity Fabrics](https://awesome-repositories.com/f/networking-communication/multi-cluster-connectivity-fabrics.md) — Links multiple independent messaging clusters into a unified mesh for cross-cluster communication and optimized routing. ([source](https://docs.nats.io/running-a-nats-service/configuration/gateways.md))
- [Multi-Cluster Service Connectivity](https://awesome-repositories.com/f/networking-communication/multi-cluster-service-connectivity.md) — Configures client connections with multiple server addresses and secure transport protocols for high availability. ([source](https://docs.nats.io/running-a-nats-service/clients.md))
- [Publish-Subscribe Systems](https://awesome-repositories.com/f/networking-communication/publish-subscribe-systems.md) — Supports hierarchical subject-based routing with wildcard pattern matching for flexible message subscription. ([source](https://docs.nats.io/nats-concepts/subjects.md))
- [Edge Proxies](https://awesome-repositories.com/f/networking-communication/request-proxies/edge-proxies.md) — Extends messaging backbones to isolated environments by tunneling traffic through persistent edge connections.
- [Connection Reconnection Policies](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/communication-paradigms/server-to-client-event-emissions/connection-reconnection-policies.md) — Implements automatic reconnection logic and error recovery to maintain persistent communication channels between clients and server clusters. ([source](https://docs.nats.io/reference/reference-protocols/nats-protocol/nats-client-dev.md))
- [Connection Establishment Protocols](https://awesome-repositories.com/f/networking-communication/communication-protocols-architectures/communication-protocols-standards/network-protocols/connection-establishment-protocols.md) — Supports robust network connection establishment across TCP, TLS, and WebSockets with built-in cluster discovery. ([source](https://docs.nats.io/using-nats/developer/connecting.md))
- [Connection Management](https://awesome-repositories.com/f/networking-communication/connection-management.md) — Automatically restores network links and re-establishes subscriptions after a disconnection, allowing applications to self-heal without manual intervention or additional configuration. ([source](https://docs.nats.io/using-nats/developer/connecting/reconnect.md))
- [Client Connection Distribution](https://awesome-repositories.com/f/networking-communication/load-balancers/client-connection-distribution.md) — Balances traffic across cluster nodes using built-in discovery to maintain high throughput without external load balancers. ([source](https://docs.nats.io/running-a-nats-service/environment.md))
- [At-Most-Once Delivery](https://awesome-repositories.com/f/networking-communication/message-delivery-guarantees/at-most-once-delivery.md) — Provides fire-and-forget message delivery for high-performance, non-persistent communication. ([source](https://docs.nats.io/nats-concepts/what-is-nats.md))
- [Message Subscription Management](https://awesome-repositories.com/f/networking-communication/message-queue-clients/message-subscription-management.md) — Controls data flow by managing client interest in specific message subjects. ([source](https://docs.nats.io/reference/reference-protocols/nats-protocol-demo.md))
- [Message Delivery Guarantees](https://awesome-repositories.com/f/networking-communication/network-reliability-diagnostics/network-reliability/message-delivery-guarantees.md) — Configures stream delivery policies to support historical replay, sequence resumption, or real-time delivery. ([source](https://docs.nats.io/nats-concepts/jetstream/consumers.md))
- [Message Ordering Guarantees](https://awesome-repositories.com/f/networking-communication/network-reliability-diagnostics/reliability-scaling/message-ordering-guarantees.md) — Ensures sequential, gap-free message processing for consumers, automatically handling reconnections while maintaining strict order. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/consumers.md))
- [Cluster Discovery Services](https://awesome-repositories.com/f/networking-communication/cluster-discovery-services.md) — Identifies active servers within a cluster through automated discovery requests. ([source](https://docs.nats.io/running-a-nats-service/configuration/sys_accounts/sys_accounts.md))
- [Real-Time Data Streams](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/real-time-data-streams.md) — Forwards incoming stream messages to a secondary destination subject in real-time to support high-scale consumption. ([source](https://docs.nats.io/nats-concepts/jetstream/streams.md))
- [Flow Control Mechanisms](https://awesome-repositories.com/f/networking-communication/flow-control-mechanisms.md) — Regulates message throughput using acknowledgment windows and pending message limits to prevent client overload. ([source](https://docs.nats.io/nats-concepts/jetstream/consumers.md))
- [Message Broker Consumers](https://awesome-repositories.com/f/networking-communication/message-broker-consumers.md) — Defines retrieval rules for message consumers, including delivery modes, filtering, and acknowledgment policies. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/consumers.md))
- [Consumer Group Coordinators](https://awesome-repositories.com/f/networking-communication/message-broker-consumers/consumer-group-coordinators.md) — Balances message processing workloads by distributing streams across multiple consumer instances. ([source](https://docs.nats.io/nats-concepts/jetstream/js_walkthrough.md))
- [Slow Consumer Eviction](https://awesome-repositories.com/f/networking-communication/message-broker-consumers/slow-consumer-eviction.md) — Protects system stability by terminating connections to subscribers that cannot keep up with message processing rates. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/slow_consumers.md))
- [Message Queue Clients](https://awesome-repositories.com/f/networking-communication/message-queue-clients.md) — Limits which queue groups a client can join or subscribe to, allowing granular control over load-balanced message consumption. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/authorization.md))
- [Message Scheduling](https://awesome-repositories.com/f/networking-communication/message-scheduling.md) — Supports delayed message delivery and recurring tasks using cron-style scheduling expressions. ([source](https://docs.nats.io/nats-concepts/jetstream/headers.md))
- [Message Stream Orchestration](https://awesome-repositories.com/f/networking-communication/message-stream-orchestration.md) — Manages data persistence and consumer delivery states to ensure reliable message processing. ([source](https://docs.nats.io/running-a-nats-service/nats_admin.md))
- [Message Integrity Controls](https://awesome-repositories.com/f/networking-communication/messaging-integrations/message-integrity-controls.md) — Applies deduplication and concurrency controls to published messages to ensure data consistency and prevent duplicate processing. ([source](https://docs.nats.io/nats-concepts/jetstream/headers.md))
- [Network Topology Extensions](https://awesome-repositories.com/f/networking-communication/network-topology-extensions.md) — Connects remote messaging servers to a central hub to aggregate traffic and extend service reach. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes/leafnode_conf.md))
- [Topology Abstraction Layers](https://awesome-repositories.com/f/networking-communication/network-topology-extensions/topology-abstraction-layers.md) — Decouples applications from network changes by automatically updating client connections when server deployments evolve. ([source](https://docs.nats.io/nats-concepts/overview.md))
- [Real-Time Messaging Systems](https://awesome-repositories.com/f/networking-communication/real-time-messaging-systems.md) — Retrieves historical and real-time messages from streams using flexible delivery policies. ([source](https://docs.nats.io/nats-concepts/jetstream/js_walkthrough.md))
- [Synchronous Message Receivers](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-reliability/synchronous-message-receivers.md) — Allows blocking the execution thread to wait for and retrieve incoming messages from a specific subject. ([source](https://docs.nats.io/using-nats/developer/receiving/sync.md))
- [Retained Messages](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/publish-subscribe-messaging/retained-messages.md) — Stores messages with a retain flag to ensure new subscribers receive the most recent state. ([source](https://docs.nats.io/running-a-nats-service/configuration/mqtt.md))
- [Throughput Benchmarking](https://awesome-repositories.com/f/networking-communication/communication-platforms-services/messaging-notification-systems/messaging-services/message-broker-infrastructure/publish-subscribe-messaging/throughput-benchmarking.md) — Measures message delivery rates and latency for publishers and subscribers by simulating various client counts and message sizes. ([source](https://docs.nats.io/using-nats/nats-tools.md))
- [Data Streaming](https://awesome-repositories.com/f/networking-communication/data-streaming.md) — Configures and maintains data streams with support for backup and restoration tasks. ([source](https://docs.nats.io/using-nats/nats-tools/nats_cli.md))
- [Data Synchronization and Consistency](https://awesome-repositories.com/f/networking-communication/distributed-systems-p2p/distributed-computing/data-synchronization-consistency.md) — Mirrors data between streams using automated retries and heartbeats to maintain consistency across distributed environments. ([source](https://docs.nats.io/reference/reference-protocols/nats_api_reference.md))
- [Domain Identifiers](https://awesome-repositories.com/f/networking-communication/domain-traffic-filters/domain-identifiers.md) — Allows assigning unique domain names to server groups to create independent namespaces and disambiguate API requests. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes/jetstream_leafnodes.md))
- [Ephemeral Consumers](https://awesome-repositories.com/f/networking-communication/message-broker-consumers/consumer-group-managers/ephemeral-consumers.md) — Creates short-lived consumers that persist only while active and are removed once all subscriptions are closed. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/model_deep_dive.md))
- [Stream Message Fetchers](https://awesome-repositories.com/f/networking-communication/message-stream-handlers/stream-message-fetchers.md) — Supports granular retrieval of stored stream messages by sequence number or bulk snapshot operations. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/consumers.md))
- [Messaging Integrations](https://awesome-repositories.com/f/networking-communication/messaging-integrations.md) — Connects to external message brokers and event streaming platforms to synchronize data flows. ([source](https://docs.nats.io/nats-concepts/connectivity.md))
- [Messaging Systems](https://awesome-repositories.com/f/networking-communication/messaging-systems.md) — Rewrites message subjects dynamically as they enter the system to support namespace translation and compatibility. ([source](https://docs.nats.io/nats-concepts/subject_mapping.md))
- [Network Data Compression](https://awesome-repositories.com/f/networking-communication/network-data-compression.md) — Reduces bandwidth usage between connected servers by applying compression algorithms to messaging streams and WebSocket frames. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes/leafnode_conf.md))
- [Network Connectivity Configurations](https://awesome-repositories.com/f/networking-communication/network-infrastructure-routing/network-infrastructure-configuration/network-management/dns-connectivity-management/network-connectivity-configurations.md) — Defines host, port, and protocol settings for client connections, including support for TLS, WebSockets, and MQTT. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))
- [Connection Lifecycle Managers](https://awesome-repositories.com/f/networking-communication/network-reliability-diagnostics/connection-session-management/connection-management/connection-lifecycle-managers.md) — Manages automated state transitions and reconnection logic for persistent network connections. ([source](https://docs.nats.io/using-nats/developer/connecting/reconnect/events.md))
- [Scatter-Gather Patterns](https://awesome-repositories.com/f/networking-communication/scatter-gather-patterns.md) — Supports scatter-gather patterns by broadcasting requests to multiple subscribers and collecting responses within a time window. ([source](https://docs.nats.io/using-nats/developer/sending/request_reply.md))

### Data & Databases

- [Distributed Key-Value Stores](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/specialized-storage-engines/distributed-key-value-stores.md) — Integrates a replicated, atomic storage engine for managing configuration and state across distributed services. ([source](https://docs.nats.io/nats-concepts/jetstream/key-value-store.md))
- [Subject Subscription Filtering](https://awesome-repositories.com/f/data-databases/data-stream-subscriptions/subject-subscription-filtering.md) — Routes messages using hierarchical subject matching to enable decoupled publish-subscribe communication. ([source](https://docs.nats.io/reference/reference-protocols/nats-protocol.md))
- [Durable Event Logs](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/stream-processing-systems/data-streaming/durable-event-logs.md) — Provides log-structured stream persistence for reliable message replay and durable delivery.
- [Distributed Key-Value Stores](https://awesome-repositories.com/f/data-databases/distributed-key-value-stores.md) — Provides an atomic, replicated key-value store integrated into the messaging layer for distributed state management.
- [Persistent Storage Providers](https://awesome-repositories.com/f/data-databases/persistent-storage-providers.md) — Provides a high-performance storage layer for stream persistence, message replay, and reliable delivery. ([source](https://docs.nats.io/running-a-nats-service/introduction/running.md))
- [Data Persistence](https://awesome-repositories.com/f/data-databases/data-persistence.md) — Store message sequences to enable temporal decoupling, allowing subscribers to replay historical data or consume messages as a work queue. ([source](https://docs.nats.io/readme.md))
- [Data Streaming](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/stream-processing-systems/data-streaming.md) — Creates, updates, deletes, and purges message streams to organize and persist data within the messaging infrastructure. ([source](https://docs.nats.io/reference/reference-protocols/nats_api_reference.md))
- [Data Replication](https://awesome-repositories.com/f/data-databases/data-replication.md) — Synchronizes message streams and consumer states across multiple server nodes using consensus groups to ensure high availability. ([source](https://docs.nats.io/running-a-nats-service/configuration/clustering/jetstream_clustering.md))
- [Atomic Key-Value Operations](https://awesome-repositories.com/f/data-databases/database-management-systems/database-engines/nosql/key-value-stores/atomic-key-value-operations.md) — Executes conditional updates on stored values to enable distributed locking and concurrency control across multiple clients. ([source](https://docs.nats.io/nats-concepts/jetstream/key-value-store.md))
- [Messaging Throughput Scaling](https://awesome-repositories.com/f/data-databases/horizontal-database-scaling/resource-scaling-strategies/resource-aware-scaling-controllers/messaging-throughput-scaling.md) — Adjusts CPU and memory allocations to match message volume, network bandwidth, and persistence requirements for both standard messaging and persistent stream storage. ([source](https://docs.nats.io/running-a-nats-service/introduction/installation.md))
- [Replication Protocols](https://awesome-repositories.com/f/data-databases/replication-protocols.md) — Distributes stream data across multiple cluster nodes using consensus protocols to ensure high availability and fault tolerance. ([source](https://docs.nats.io/running-a-nats-service/configuration/clustering/jetstream_clustering/administration.md))
- [Connection Establishment](https://awesome-repositories.com/f/data-databases/connection-establishment.md) — Establishes persistent connections between distributed services to exchange data using various messaging patterns. ([source](https://docs.nats.io/using-nats/nats-tools.md))
- [Data Persistence and Storage](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage.md) — Stores messages in memory or on disk, enabling durable subscriptions and the ability to replay historical data. ([source](https://docs.nats.io/nats-concepts/overview/compare-nats.md))
- [Exactly-Once Processing Semantics](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/data-processing-frameworks/exactly-once-processing-semantics.md) — Combines message deduplication with synchronous acknowledgment verification to ensure messages are processed exactly once without loss or duplication. ([source](https://docs.nats.io/nats-concepts/jetstream.md))
- [Subscription Interest Synchronization](https://awesome-repositories.com/f/data-databases/edge-to-cloud-synchronization/subscription-interest-synchronization.md) — Communicates interest in specific subjects across servers to ensure messages are routed only to nodes with active subscribers. ([source](https://docs.nats.io/reference/reference-protocols/nats-server-protocol.md))
- [Message Storage](https://awesome-repositories.com/f/data-databases/message-storage.md) — Stores incoming messages on disk to ensure data durability and allow for later retrieval by consumers. ([source](https://docs.nats.io/running-a-nats-service/nats_docker/jetstream_docker.md))
- [Namespace Isolation](https://awesome-repositories.com/f/data-databases/namespace-isolation.md) — Segregates message traffic into independent accounts to prevent unauthorized cross-account access. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro.md))
- [Primary-Replica Replication](https://awesome-repositories.com/f/data-databases/primary-replica-replication.md) — Automatically maintains stream replication factors by replacing failed replicas within a cluster. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/disaster_recovery.md))
- [Consumer Offset Trackers](https://awesome-repositories.com/f/data-databases/consumer-offset-trackers.md) — Maintains durable message tracking across server restarts or uses ephemeral consumers for transient, auto-cleaning message views. ([source](https://docs.nats.io/nats-concepts/jetstream/consumers.md))
- [Data Change Subscriptions](https://awesome-repositories.com/f/data-databases/data-change-subscriptions.md) — Provides real-time subscription mechanisms to trigger actions whenever specific key-value data is modified. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/kv.md))
- [Message Deduplication](https://awesome-repositories.com/f/data-databases/data-deduplication-tools/message-deduplication.md) — Prevents duplicate data ingestion by tracking unique message identifiers within configurable time windows. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/model_deep_dive.md))
- [Retention Policies](https://awesome-repositories.com/f/data-databases/data-governance-modeling/data-management-governance/data-lifecycle-retention/retention-policies.md) — Configures message persistence limits based on age, size, or count to manage data retention. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/model_deep_dive.md))
- [Pull Consumer Scalers](https://awesome-repositories.com/f/data-databases/horizontal-scaling-architectures/pull-consumer-scalers.md) — Enables horizontal scaling of message processing through demand-driven pull consumers. ([source](https://docs.nats.io/nats-concepts/jetstream.md))
- [Data Storage](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/data-persistence-storage/data-storage.md) — Deletes individual messages or clears stored data within a stream to manage storage capacity and lifecycle requirements. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/streams.md))
- [Streaming Data Processing](https://awesome-repositories.com/f/data-databases/data-engineering/distributed-compute-frameworks/streaming-data-processing.md) — Supports push and pull patterns for consuming persistent log data at scale. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream.md))
- [Stream Processing](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/stream-processing-systems/stream-processing.md) — Interleaves multiple data streams with support for subject-based transformations and filtering. ([source](https://docs.nats.io/nats-concepts/jetstream/streams.md))
- [Data Retention Policies](https://awesome-repositories.com/f/data-databases/data-retention-policies.md) — Configures stream limits based on age, size, or count, with automated discard policies to manage storage capacity. ([source](https://docs.nats.io/nats-concepts/jetstream.md))
- [Stream Snapshotters](https://awesome-repositories.com/f/data-databases/data-snapshotting/stream-snapshotters.md) — Facilitates data durability and disaster recovery by creating point-in-time snapshots of stream configurations and payloads. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/disaster_recovery.md))
- [Key-Value Pair Managers](https://awesome-repositories.com/f/data-databases/key-value-pair-managers.md) — Provides isolated storage containers for key-value pairs to manage data sets independently. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/kv.md))
- [Atomic Key Updaters](https://awesome-repositories.com/f/data-databases/key-value-stores/atomic-key-updaters.md) — Supports atomic, conditional updates to key-value data to ensure consistency during state changes. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/kv.md))
- [Binary Object Chunkers](https://awesome-repositories.com/f/data-databases/object-storage-services/binary-object-chunkers.md) — Manages large binary objects by automatically chunking data for efficient storage and retrieval. ([source](https://docs.nats.io/nats-concepts/jetstream.md))
- [Storage Configuration](https://awesome-repositories.com/f/data-databases/storage-configuration.md) — Defines persistent storage containers that specify captured subjects and data retention policies. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/publish.md))
- [Stream Filters](https://awesome-repositories.com/f/data-databases/stream-filters.md) — Applies server-side subject matching to deliver only relevant subsets of messages to specific consumers, reducing unnecessary network traffic. ([source](https://docs.nats.io/nats-concepts/jetstream/consumers.md))
- [Stream Lifecycle Management](https://awesome-repositories.com/f/data-databases/stream-lifecycle-management.md) — Provides administrative controls to purge, delete, or inspect stored message data and consumer configurations. ([source](https://docs.nats.io/nats-concepts/jetstream/js_walkthrough.md))

### Security & Cryptography

- [Multi-tenant Security](https://awesome-repositories.com/f/security-cryptography/governance-policy-frameworks/security-infrastructure/multi-tenant-security.md) — Implements decentralized security through isolated accounts and shared resources, allowing fine-grained control over user permissions and connection restrictions. ([source](https://docs.nats.io/nats-concepts/overview/compare-nats.md))
- [Decentralized Token Authorization](https://awesome-repositories.com/f/security-cryptography/jwt-authentication/jwt-decoders/decentralized-token-authorization.md) — Validates client identity and permissions using decentralized, cryptographically signed tokens.
- [Connection Authentication Mechanisms](https://awesome-repositories.com/f/security-cryptography/connection-authentication-mechanisms.md) — Validates incoming client identities using methods including tokens, passwords, TLS certificates, and NKEYs. ([source](https://docs.nats.io/nats-concepts/security.md))
- [Identity and Access Management](https://awesome-repositories.com/f/security-cryptography/identity-access-management.md) — Configures operators, accounts, and users with granular permissions for secure messaging interactions. ([source](https://docs.nats.io/using-nats/nats-tools/nsc.md))
- [Access Control and Authorization](https://awesome-repositories.com/f/security-cryptography/identity-access-management/authentication-strategies/authorization-and-user-administration/access-control-authorization.md) — Enforces granular access control by embedding publication and subscription restrictions directly into user tokens for decentralized management. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/jwt.md))
- [Mutual TLS Authentication](https://awesome-repositories.com/f/security-cryptography/identity-access-management/authentication-strategies/machine-and-protocol-identity/specialized-authentication-protocols/mutual-tls-authentication.md) — Validates client identity using multiple methods including TLS, NKEYS, credentials, tokens, or standard password pairs. ([source](https://docs.nats.io/nats-concepts/overview/compare-nats.md))
- [JWT Identity Management](https://awesome-repositories.com/f/security-cryptography/identity-and-access-management-servers/jwt-identity-management.md) — Uses decentralized JSON Web Tokens to define permissions and identity without storing private keys on the server. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security/jwt.md))
- [JWT Authentication](https://awesome-repositories.com/f/security-cryptography/jwt-authentication.md) — Validates client identity and permissions using decentralized JSON Web Tokens managed by an external authority or local resolver. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))
- [Multi-Tenancy Security](https://awesome-repositories.com/f/security-cryptography/multi-tenancy-security.md) — Isolates messaging traffic into independent accounts with separate subject namespaces and controlled cross-account communication. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))
- [Messaging Isolation Fabrics](https://awesome-repositories.com/f/security-cryptography/multi-tenant-isolation-layers/messaging-isolation-fabrics.md) — Enforces multi-tenant security by isolating messaging traffic into independent accounts with granular access control and controlled cross-account data sharing.
- [Multi-Tenant Security](https://awesome-repositories.com/f/security-cryptography/multi-tenant-security.md) — Segregates messaging traffic into independent accounts with granular access control for multi-tenant isolation. ([source](https://docs.nats.io/nats-concepts/security.md))
- [Peer Communication Security](https://awesome-repositories.com/f/security-cryptography/network-infrastructure-security/peer-communication-security.md) — Enforces mutual TLS authentication for all inter-server connections to ensure only verified nodes can join or communicate within a cluster. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/tls_mutual_auth/cluster_tls.md))
- [Subject Access Restrictions](https://awesome-repositories.com/f/security-cryptography/security/policies/host-resource-access/file-system-access-controls/path-access-restrictions/path-access-restrictions/subject-access-restrictions.md) — Controls client ability to publish or subscribe to specific message subjects using allow and deny lists and wildcard patterns. ([source](https://docs.nats.io/nats-concepts/security.md))
- [Authentication Clients](https://awesome-repositories.com/f/security-cryptography/authentication-clients.md) — Validates incoming client connections using username and password credentials. ([source](https://docs.nats.io/using-nats/developer/connecting/userpass.md))
- [Challenge-Response Authenticators](https://awesome-repositories.com/f/security-cryptography/authentication-clients/challenge-response-authenticators.md) — Verifies client identity using a challenge-response mechanism where the client signs a server-provided nonce. ([source](https://docs.nats.io/using-nats/developer/connecting/nkey.md))
- [Credential Authentication](https://awesome-repositories.com/f/security-cryptography/authentication-clients/credential-authentication.md) — Enforces password-based access control for incoming connections to ensure only authorized clients can interact with the messaging server. ([source](https://docs.nats.io/reference/reference-protocols/nats-protocol/nats-client-dev.md))
- [Request Access Restrictions](https://awesome-repositories.com/f/security-cryptography/domain-access-restrictions/request-access-restrictions.md) — Enforces connection security by requiring clients to provide valid credentials before interacting with the messaging system. ([source](https://docs.nats.io/running-a-nats-service/introduction/flags.md))
- [Encrypted Connection Handlers](https://awesome-repositories.com/f/security-cryptography/encrypted-connection-handlers.md) — Secures communication between clients and the server by enforcing TLS encryption with configurable cipher suites and protocol versions. ([source](https://docs.nats.io/nats-concepts/security.md))
- [Identity Hierarchies](https://awesome-repositories.com/f/security-cryptography/identity-and-access-management/identity-hierarchies.md) — Implements hierarchical trust chains using public-key signatures to define operators, accounts, and users with specific access limits. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/basics.md))
- [Remote Service Authentication](https://awesome-repositories.com/f/security-cryptography/remote-service-authentication.md) — Validates incoming and outgoing server connections using credentials, Nkeys, or JWT-based signatures to ensure only authorized nodes join the network. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes/leafnode_conf.md))
- [Secure Connection Managers](https://awesome-repositories.com/f/security-cryptography/secure-connection-managers.md) — Establishes authenticated and encrypted persistent channels for secure data exchange. ([source](https://docs.nats.io/using-nats/developer/anatomy.md))
- [Secure Network Communication](https://awesome-repositories.com/f/security-cryptography/secure-network-communication.md) — Secures communication between clients and servers using TLS to prevent eavesdropping and verify server identity. ([source](https://docs.nats.io/using-nats/developer/connecting/tls.md))
- [TLS Transfer Security](https://awesome-repositories.com/f/security-cryptography/tls-transfer-security.md) — Provides TLS-based encryption for network traffic to prevent unauthorized access and ensure secure communication. ([source](https://docs.nats.io/running-a-nats-service/introduction/flags.md))
- [Token Authentication](https://awesome-repositories.com/f/security-cryptography/token-authentication.md) — Validates client identities using digitally signed JSON Web Tokens that establish a chain of trust without requiring server-side configuration changes. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security.md))
- [Zero Trust Access Controls](https://awesome-repositories.com/f/security-cryptography/zero-trust-access-controls.md) — Authenticates and authorizes all connections using TLS and JSON Web Tokens to ensure secure distributed communication. ([source](https://docs.nats.io/readme.md))
- [Context Isolation Strategies](https://awesome-repositories.com/f/security-cryptography/application-and-system-security/sandbox-and-isolation/runtime-process-isolation/context-isolation-strategies.md) — Organizes communication into distinct accounts to ensure message isolation between contexts. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security/jwt.md))
- [Client Certificate Authentication](https://awesome-repositories.com/f/security-cryptography/client-certificate-authentication.md) — Validates client identity by verifying certificates against a trusted certificate authority or mapping attributes to user identities. ([source](https://docs.nats.io/using-nats/developer/connecting/tls.md))
- [Client Certificate Management](https://awesome-repositories.com/f/security-cryptography/client-certificate-management.md) — Requires and validates client certificates during the TLS handshake to verify identity, optionally mapping certificate values to specific user accounts. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/tls.md))
- [Client Credentials](https://awesome-repositories.com/f/security-cryptography/client-credentials.md) — Validates incoming connections against a defined list of usernames and passwords to ensure authorized access. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/username_password.md))
- [Data Encryption](https://awesome-repositories.com/f/security-cryptography/data-encryption.md) — Protects persistent message data stored on disk by applying encryption to ensure information remains secure. ([source](https://docs.nats.io/nats-concepts/security.md))
- [Environment Isolation](https://awesome-repositories.com/f/security-cryptography/environment-isolation.md) — Creates logically separated storage domains to ensure resource isolation within shared messaging infrastructure. ([source](https://docs.nats.io/running-a-nats-service/configuration/resource_management.md))
- [Key-Scoped Permissions](https://awesome-repositories.com/f/security-cryptography/identity-access-management/access-control/data-resource-permissions/key-level-access-controls/key-scoped-permissions.md) — Associates specific access permissions with a signing key so that any user signed by that key inherits those restrictions. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/signing_keys.md))
- [Digital Signature Validators](https://awesome-repositories.com/f/security-cryptography/identity-access-management/access-control/digital-signature-validators.md) — Validates client identity by requiring a digital signature of a server-generated challenge. ([source](https://docs.nats.io/using-nats/nats-tools/nk.md))
- [Stream Access Restrictions](https://awesome-repositories.com/f/security-cryptography/identity-access-management/authentication-strategies/authorization-and-user-administration/access-control-authorization/import-access-authorizers/stream-access-restrictions.md) — Limits access to specific data streams by requiring authorization tokens, ensuring only designated accounts can import private resources. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/streams.md))
- [Credential Revocation](https://awesome-repositories.com/f/security-cryptography/identity-access-management/credential-lifecycle-management/credential-revocation.md) — Invalidates specific user sessions, activation tokens, or entire accounts by updating revocation lists or removing signing keys. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security/jwt.md))
- [Messaging Session Persistence](https://awesome-repositories.com/f/security-cryptography/identity-access-management/session-management/stateful-session-persistence/messaging-session-persistence.md) — Maintain session state and message delivery status across reconnections, ensuring reliable communication even if the network is interrupted. ([source](https://docs.nats.io/running-a-nats-service/configuration/mqtt.md))
- [Identity and Access Management](https://awesome-repositories.com/f/security-cryptography/identity-and-access-management.md) — Generates and manages cryptographic keys and authentication tokens to define user permissions and access control policies. ([source](https://docs.nats.io/using-nats/nats-tools.md))
- [Security Isolation Mechanisms](https://awesome-repositories.com/f/security-cryptography/security-isolation-mechanisms.md) — Creates secure, isolated messaging contexts to maintain data silos across multiple tenants. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/accounts.md))
- [Service Communication Security](https://awesome-repositories.com/f/security-cryptography/service-communication-security.md) — Enforces mutual authentication and encrypted transit between messaging nodes using TLS and certificate-based validation. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes/leafnode_conf.md))
- [User Account Management](https://awesome-repositories.com/f/security-cryptography/user-account-management.md) — Restricts user access to specific message subjects by defining granular publish and subscribe permissions for individual accounts and users. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/basics.md))
- [Guest Access Mappers](https://awesome-repositories.com/f/security-cryptography/access-control/guest-access-policies/guest-access-mappers.md) — Maps clients connecting without credentials to a specific user identity within a designated account. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/accounts.md))
- [Account Management](https://awesome-repositories.com/f/security-cryptography/account-management.md) — Delegates account administration to external entities using trust chains for decentralized resource management. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/jwt.md))
- [Authentication Services](https://awesome-repositories.com/f/security-cryptography/authentication-services.md) — Offloads client identity verification and permission checks to an external application-defined service, allowing integration with existing identity providers. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_callout.md))
- [Hybrid Authentication Providers](https://awesome-repositories.com/f/security-cryptography/authentication-systems/concurrent-authentication-methods/hybrid-authentication-providers.md) — Supports simultaneous use of static key-based credentials and decentralized token-based identity systems. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/jwt/jwt_nkey_auth.md))
- [Dynamic Permission Templates](https://awesome-repositories.com/f/security-cryptography/identity-access-management/access-control/access-control-models/permission-based-security/dynamic-permission-templates.md) — Generates unique, user-specific subject permissions using dynamic placeholders within scoped signing keys. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/signing_keys.md))
- [Service Access Revocation](https://awesome-repositories.com/f/security-cryptography/identity-access-management/authentication-strategies/authorization-and-user-administration/access-control-authorization/import-access-authorizers/service-access-revocation.md) — Invalidates specific account access to shared exports at a defined time, ensuring previous authorization tokens are no longer accepted. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/revocation.md))
- [Identity & Key Management](https://awesome-repositories.com/f/security-cryptography/identity-key-management.md) — Generates public and private key pairs to establish secure, verifiable identities for messaging clients. ([source](https://docs.nats.io/using-nats/nats-tools/nk.md))
- [Identity Management](https://awesome-repositories.com/f/security-cryptography/identity-management.md) — Manages account identities and authorization tokens locally within server configuration files. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/jwt/mem_resolver.md))
- [Leaf Node Traffic Restrictions](https://awesome-repositories.com/f/security-cryptography/secure-node-networking/leaf-node-traffic-restrictions.md) — Limits message flow between local and remote systems by applying authorization policies to leaf node connections. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes.md))
- [User Access Revocation](https://awesome-repositories.com/f/security-cryptography/user-access-management/user-access-revocation.md) — Invalidates existing user credentials based on a specific timestamp, requiring new credentials for continued access. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/revocation.md))
- [WebSocket Security](https://awesome-repositories.com/f/security-cryptography/websocket-security.md) — Validates incoming WebSocket connections using various security methods including tokens, certificates, and identity-based credentials. ([source](https://docs.nats.io/running-a-nats-service/configuration/websocket/websocket_conf.md))
- [Account Claim Resolvers](https://awesome-repositories.com/f/security-cryptography/account-management/account-claim-resolvers.md) — Configures how the server retrieves and updates account information using static memory, remote HTTP, or dynamic lookups. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security/jwt.md))
- [Account Synchronization](https://awesome-repositories.com/f/security-cryptography/account-management/account-synchronization.md) — Synchronizes account credentials with external operators to ensure consistent access control across distributed environments. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/managed.md))
- [Traffic Isolation](https://awesome-repositories.com/f/security-cryptography/account-management/traffic-isolation.md) — Assigns dedicated network routes to specific accounts to reduce latency and minimize protocol overhead by removing account identifiers from transmitted message headers. ([source](https://docs.nats.io/running-a-nats-service/configuration/clustering/v2_routes.md))
- [Authorization Services](https://awesome-repositories.com/f/security-cryptography/identity-access-management/authentication-strategies/authorization-and-user-administration/access-control-authorization/authorization-services.md) — Delegates authentication and authorization decisions to external services via real-time callouts. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/security.md))
- [Credential File Parsers](https://awesome-repositories.com/f/security-cryptography/identity-access-management/authentication-strategies/session-and-credential-handling/session-credential-management/credential-file-parsers.md) — Verifies client identity using a local file containing a JSON Web Token and a private NKey to establish secure connections. ([source](https://docs.nats.io/using-nats/developer/connecting/creds.md))
- [Account Identity Resolvers](https://awesome-repositories.com/f/security-cryptography/identity-access-management/identity-management/account-linking/account-identity-resolvers.md) — Configures how the server retrieves and validates account information using local memory, messaging-based lookups, or external services. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/auth_intro/jwt/resolver.md))
- [Storage Encryption](https://awesome-repositories.com/f/security-cryptography/storage-encryption.md) — Protects persistent message data by applying encryption to ensure information remains secure even if the underlying storage is compromised. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/encryption_at_rest.md))
- [Account Configuration Syncing](https://awesome-repositories.com/f/security-cryptography/user-account-management/account-configuration-syncing.md) — Automates the distribution of account and user definitions to messaging servers via centralized resolution. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/basics.md))

### Software Engineering & Architecture

- [Distributed Key-Value Stores](https://awesome-repositories.com/f/software-engineering-architecture/distributed-systems/distributed-data-management/distributed-key-value-stores.md) — Provides an atomic, replicated key-value store for managing configuration or state across microservices and edge deployments. ([source](https://docs.nats.io/nats-concepts/jetstream.md))
- [Hierarchical Subject Organization](https://awesome-repositories.com/f/software-engineering-architecture/hierarchical-data-structures/hierarchical-subject-organization.md) — Organizes communication channels into dot-separated namespaces to simplify security and filtering policies. ([source](https://docs.nats.io/nats-concepts/subjects.md))
- [Distributed Storage Clusters](https://awesome-repositories.com/f/software-engineering-architecture/distributed-systems/distributed-data-management/distributed-storage-clusters.md) — Connects multiple server instances into a unified network to share message traffic and provide horizontal scalability across different nodes. ([source](https://docs.nats.io/running-a-nats-service/introduction/flags.md))
- [Distributed Task Queues](https://awesome-repositories.com/f/software-engineering-architecture/distributed-task-queues.md) — Balances message processing across multiple service instances using named queue groups. ([source](https://docs.nats.io/using-nats/developer/anatomy.md))
- [Messaging Patterns](https://awesome-repositories.com/f/software-engineering-architecture/messaging-patterns.md) — Facilitates bidirectional request-reply communication patterns by dynamically routing responses to specific reply subjects. ([source](https://docs.nats.io/using-nats/developer/receiving/reply.md))
- [Remote Service Invocations](https://awesome-repositories.com/f/software-engineering-architecture/service-locators/remote-service-invocations.md) — Facilitates transparent remote service calls using message-based request-reply patterns. ([source](https://docs.nats.io/using-nats/developer/anatomy.md))
- [Asynchronous Messaging](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-messaging.md) — Implements non-blocking, event-driven message reception via callback handlers for efficient processing. ([source](https://docs.nats.io/using-nats/developer/receiving/async.md))
- [Distributed Coordination Systems](https://awesome-repositories.com/f/software-engineering-architecture/distributed-coordination-systems.md) — Automates cluster coordination by enabling nodes to discover peers and establish consensus groups upon joining. ([source](https://docs.nats.io/running-a-nats-service/configuration/clustering/jetstream_clustering.md))
- [Service Access Restrictions](https://awesome-repositories.com/f/software-engineering-architecture/naming-conventions/reserved-names/access-restrictions/service-account-permissions/service-access-restrictions.md) — Limits access to private services by requiring activation tokens that grant specific accounts permission to interact with the service. ([source](https://docs.nats.io/using-nats/nats-tools/nsc/services.md))
- [Response Permission Controllers](https://awesome-repositories.com/f/software-engineering-architecture/application-frameworks/application-framework-extensions/request-response-extensions/response-permission-controllers.md) — Configures response limits and temporary access rules to secure dynamic reply subjects in request-reply exchanges. ([source](https://docs.nats.io/running-a-nats-service/configuration/securing_nats/authorization.md))
- [Subject Namespace Mapping](https://awesome-repositories.com/f/software-engineering-architecture/execution-control/namespace-isolation/subject-namespace-mapping.md) — Redirects incoming messages from one subject to another, allowing for namespace migrations or subject reordering using wildcard token references. ([source](https://docs.nats.io/running-a-nats-service/configuration/configuring_subject_mapping.md))
- [Message Header Attachments](https://awesome-repositories.com/f/software-engineering-architecture/metadata-attachments/message-header-attachments.md) — Includes custom header fields and optional reply addresses within message payloads to support complex routing. ([source](https://docs.nats.io/nats-concepts/core-nats/pubsub.md))
- [Propagation Filters](https://awesome-repositories.com/f/software-engineering-architecture/execution-control/namespace-isolation/subject-namespace-mapping/propagation-filters.md) — Filters traffic across network links by explicitly denying the import or export of specific subjects to control data visibility and flow. ([source](https://docs.nats.io/running-a-nats-service/configuration/leafnodes/leafnode_conf.md))
- [Key History Trackers](https://awesome-repositories.com/f/software-engineering-architecture/historical-state-verification/historical-value-trackers/key-history-trackers.md) — Allows auditing and state reconstruction by retrieving historical value sequences for specific keys. ([source](https://docs.nats.io/nats-concepts/jetstream/key-value-store.md))
- [Connection Lifecycle](https://awesome-repositories.com/f/software-engineering-architecture/middleware/connection-lifecycle.md) — Exposes lifecycle hooks to monitor connection status changes and handle asynchronous runtime errors. ([source](https://docs.nats.io/using-nats/developer/connecting/reconnect.md))
- [Dead Letter Queues](https://awesome-repositories.com/f/software-engineering-architecture/queue-implementations/dead-letter-queues.md) — Tracks failed delivery attempts to route problematic data to specialized handlers for inspection or recovery. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/consumers.md))
- [Stream Replicators](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/reactive-messaging/reactive-event-driven-systems/asynchronous-data-processing/asynchronous-log-streaming/stream-replicators.md) — Provides automated asynchronous replication of message streams to support geographic distribution and data aggregation. ([source](https://docs.nats.io/nats-concepts/jetstream/source_and_mirror.md))

### System Administration & Monitoring

- [Patterns](https://awesome-repositories.com/f/system-administration-monitoring/log-analysis-tools/latency-monitoring/request-reply/patterns.md) — Implements bidirectional request-reply communication by dynamically routing responses back to the original requester. ([source](https://docs.nats.io/nats-concepts/core-nats/reqreply.md))
- [Cluster Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/cluster-monitoring.md) — Provides real-time dashboards and metrics for tracking cluster health and resource utilization across the messaging fabric. ([source](https://docs.nats.io/running-a-nats-service/configuration/clustering/jetstream_clustering/administration.md))
- [Server Metrics](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/metric-performance-monitors/server-metrics.md) — Provides HTTP endpoints returning real-time statistics on server health, connections, and message persistence. ([source](https://docs.nats.io/running-a-nats-service/configuration/monitoring.md))
- [Observability Tracing](https://awesome-repositories.com/f/system-administration-monitoring/observability-tracing.md) — Generates and aggregates diagnostic events across system boundaries to monitor message flow and subsystem interactions. ([source](https://docs.nats.io/nats-concepts/jetstream/headers.md))
- [Health Monitoring Endpoints](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/operational-health-alerting/health-monitoring-endpoints.md) — Exposes standardized HTTP endpoints for reporting real-time server health and operational status. ([source](https://docs.nats.io/nats-concepts/what-is-nats/walkthrough_setup.md))
- [Prometheus Exporters](https://awesome-repositories.com/f/system-administration-monitoring/prometheus-exporters.md) — Translates internal server performance data into Prometheus-compatible formats for long-term storage. ([source](https://docs.nats.io/running-a-nats-service/configuration/monitoring.md))
- [Account Resource Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/usage-monitoring/account-resource-monitoring.md) — Tracks current memory and storage consumption against defined limits to ensure multi-tenant environments remain within allocated quotas. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/jetstream_admin/account.md))
- [Subscription Callback Handlers](https://awesome-repositories.com/f/system-administration-monitoring/alert-notification-systems/subscription-management/subscription-callback-handlers.md) — Routes incoming messages to application logic by mapping subscription identifiers to handler functions. ([source](https://docs.nats.io/reference/reference-protocols/nats-protocol/nats-client-dev.md))
- [Cluster Health Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/cluster-health-monitoring.md) — Queries performance metrics and cluster health statistics using request-reply patterns. ([source](https://docs.nats.io/running-a-nats-service/configuration/sys_accounts/sys_accounts.md))
- [Graceful Shutdown Mechanisms](https://awesome-repositories.com/f/system-administration-monitoring/graceful-shutdown-mechanisms.md) — Provides lifecycle controls for graceful shutdowns, configuration reloads, and log rotation. ([source](https://docs.nats.io/running-a-nats-service/nats_admin.md))
- [Account Statistics Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/account-statistics-monitoring.md) — Retrieves real-time metrics and usage limits for accounts to ensure operational visibility and capacity planning. ([source](https://docs.nats.io/reference/reference-protocols/nats_api_reference.md))
- [Connection Throughput Trackers](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/account-statistics-monitoring/connection-throughput-trackers.md) — Reports metrics on data throughput including the total count of messages sent and received by a client. ([source](https://docs.nats.io/using-nats/developer/connecting/events.md))
- [Link Health Maintenance](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/operational-health-alerting/infrastructure-health-observability/link-health-maintenance.md) — Uses periodic heartbeat signals to verify the status of inter-server links and automatically disconnect unresponsive nodes. ([source](https://docs.nats.io/reference/reference-protocols/nats-server-protocol.md))
- [Stream Status Monitors](https://awesome-repositories.com/f/system-administration-monitoring/task-status-monitors/stream-status-monitors.md) — Retrieves health information and usage statistics for streams and consumers to maintain system visibility. ([source](https://docs.nats.io/using-nats/developer/develop_jetstream/streams.md))
- [Traffic Monitoring Tools](https://awesome-repositories.com/f/system-administration-monitoring/traffic-monitoring-tools.md) — Streams message traffic to external observers for auditing and observability without impacting primary processing. ([source](https://docs.nats.io/nats-concepts/jetstream/consumers/example_configuration.md))
- [Automated Server Maintenance](https://awesome-repositories.com/f/system-administration-monitoring/automated-server-maintenance.md) — Streamlines server administration and configuration updates through a command-line interface. ([source](https://docs.nats.io/using-nats/nats-tools.md))
- [Event Monitoring Systems](https://awesome-repositories.com/f/system-administration-monitoring/event-monitoring-systems.md) — Broadcasts operational events to dedicated subjects, enabling real-time analysis of infrastructure activity. ([source](https://docs.nats.io/running-a-nats-service/nats_admin/monitoring/monitoring_jetstream.md))
- [Request-Reply](https://awesome-repositories.com/f/system-administration-monitoring/log-analysis-tools/latency-monitoring/request-reply.md) — Evaluates the round-trip time and throughput of synchronous request-reply interactions between service instances. ([source](https://docs.nats.io/using-nats/nats-tools/nats_cli/natsbench.md))
- [Distributed Tracing](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/distributed-tracing-execution-analysis/distributed-tracing.md) — Captures and exports message metadata using open telemetry standards to monitor distributed request paths. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))
- [Resource Usage Limiters](https://awesome-repositories.com/f/system-administration-monitoring/resource-usage-limiters.md) — Caps system usage by restricting connection counts, message payload sizes, subscription limits, and memory buffers to protect server stability. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))
- [Session Health Monitors](https://awesome-repositories.com/f/system-administration-monitoring/session-tracking/session-health-monitors.md) — Pings connected clients periodically and disconnects those that fail to respond within a defined timeframe to prune inactive sessions. ([source](https://docs.nats.io/reference/reference-protocols/nats-protocol/nats-client-dev.md))
- [System Event Monitors](https://awesome-repositories.com/f/system-administration-monitoring/system-event-monitors.md) — Broadcasts server-side lifecycle and activity notifications to dedicated subjects for infrastructure tracking. ([source](https://docs.nats.io/running-a-nats-service/configuration/sys_accounts.md))

### Development Tools & Productivity

- [Configuration Hot-Reloading](https://awesome-repositories.com/f/development-tools-productivity/configuration-hot-reloading.md) — Updates server settings without requiring a restart or disconnecting active clients via process signals. ([source](https://docs.nats.io/running-a-nats-service/configuration.md))

### Mobile Development

- [Global Messaging Fabrics](https://awesome-repositories.com/f/mobile-development/mobile-capabilities/messaging/global-messaging-fabrics.md) — Joins multiple independent clusters into a global messaging fabric for seamless cross-cluster communication. ([source](https://docs.nats.io/nats-concepts/service_infrastructure.md))

### Web Development

- [Multi-Protocol Clients](https://awesome-repositories.com/f/web-development/multi-protocol-clients.md) — Accepts connections from diverse clients using native protocols, MQTT, and WebSockets. ([source](https://docs.nats.io/readme.md))
- [Responder Availability Notifications](https://awesome-repositories.com/f/web-development/backend-development/request-response-handling/responder-availability-notifications.md) — Sends an immediate signal to a client when no subscribers are available to process a request, preventing applications from hanging on blocked calls. ([source](https://docs.nats.io/nats-concepts/core-nats/queue.md))
- [Endpoint Specification](https://awesome-repositories.com/f/web-development/custom-api-endpoints/endpoint-specification.md) — Exposes specific operations as individual endpoints to handle incoming requests from clients. ([source](https://docs.nats.io/using-nats/developer/services.md))