# Signalynx

> Signalynx is an open-source, high-performance, strongly typed mediator, dispatcher, and durable messaging toolkit for .NET 8, .NET 9, and .NET 10.

Signalynx separates immediate in-process application dispatch from durable work that must survive retries, restarts, delays, or service boundaries. The project is written in C#, distributed as NuGet packages, and licensed under the MIT License.

## Official resources

* [Signalynx website](https://signalynx.inilesh.dev/): Product overview, architecture guidance, package selection, and quick-start examples.
* [GitHub repository](https://github.com/it-nilesh/Signalynx): Authoritative source code, README, samples, tests, and contribution information.
* [Signalynx.Core on NuGet](https://www.nuget.org/packages/Signalynx.Core): Mediator runtime package for direct runtime usage.
* [Signalynx.DependencyInjection on NuGet](https://www.nuget.org/packages/Signalynx.DependencyInjection): Microsoft DI integration for ASP.NET Core, Worker, console, and other host applications.
* [Detailed AI reference](https://signalynx.inilesh.dev/llms-full.txt): Capabilities, packages, supported providers, and terminology.

## Key facts

* Signalynx supports commands, queries, requests, notifications, and domain events.
* Local dispatch does not require a message broker or ASP.NET Core.
* `Signalynx.Abstractions` contains dependency-free contracts for messages, handlers, pipelines, and mediator APIs and can be referenced directly from shared or application class libraries.
* `Signalynx.DependencyInjection` is intended for Microsoft DI host applications and includes `Signalynx.Core` and `Signalynx.Abstractions` transitively.
* `Signalynx.Core` can be used directly when the mediator runtime is needed without Microsoft DI integration.
* Durable messaging includes inbox and outbox processing, retries, scheduling, dead letters, and replay.
* Optional persistent store adapters support SQL Server and PostgreSQL for inbox, outbox, and dead-letter storage.
* Optional transport adapters support RabbitMQ, Azure Service Bus, Amazon SQS, and Kafka.
* Transport adapters implement `IMessageTransport` over small provider-specific client abstractions, allowing applications to control the underlying broker SDK or wrapper.
* Source-generated registration supports trimmed and NativeAOT applications.
* The in-memory transport is intended for development and tests and does not provide production durability.
* A true transactional outbox requires the business write and outbox write to participate in the same database connection and transaction.
* Message handlers should remain idempotent because durable messaging may use at-least-once delivery.

## Installation

For a typical ASP.NET Core, Worker, console, or other Microsoft DI host application:

```
dotnet add package Signalynx.DependencyInjection
```

`Signalynx.DependencyInjection` includes `Signalynx.Core` and `Signalynx.Abstractions` transitively, so they do not need to be installed separately in the host project.

For shared or application class libraries that only need Signalynx contracts, messages, handlers, or pipeline interfaces:

```
dotnet add package Signalynx.Abstractions
```

For direct mediator runtime usage without Microsoft dependency injection:

```
dotnet add package Signalynx.Core
```

Additional capabilities can be added only where required:

```
dotnet add package Signalynx.Validation
dotnet add package Signalynx.Logging
dotnet add package Signalynx.SourceGeneration
dotnet add package Signalynx.Messaging
```