awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
ThreeDotsLabs avatar

ThreeDotsLabs/watermill

0
View on GitHub↗

Watermill

Watermill is a Go library for building event-driven applications. It provides a framework for implementing event-driven architectures through a consistent interface for message publishing and subscribing, featuring a pub/sub message router and event stream processing pipelines.

The library uses interface-based abstractions to decouple message producers and consumers from the underlying message broker. This allows different messaging technologies to be swapped via plugin-based broker integration. It employs a router-driven dispatch system and middleware-based pipelines to manage cross-cutting concerns and business logic.

The framework provides tools for coordinating distributed event processing and complex application patterns. This includes support for event sourcing to track application state as a sequence of events and the saga pattern for coordinating distributed transactions across multiple services.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
watermill.io
↗

Features

  • Broker Abstractions - Provides a common set of Go interfaces to decouple producers and consumers regardless of the underlying message broker.
  • Streaming Processors - Ships a pipeline for processing message streams with configurable middlewares for business logic and resiliency.
  • Message Queue Integrations - Connects Go services to various message brokers using a consistent interface for publishing and subscribing.
  • Message Routing - Implements a system for orchestrating and directing messages between decoupled publishers and subscribers.
  • Message Stream Handlers - Provides utilities for managing asynchronous message streams with configurable middleware for business logic and resiliency.
  • Pub-Sub Messaging - Implements a routing system that decouples components by moving data between different publishers and subscribers.
  • Asynchronous Messaging - Handles high-volume event streams by decoupling message reception from execution using non-blocking Go channels.
  • Event-Driven Architectures - Provides a framework for building reactive Go applications that communicate through asynchronous events.
  • Event-Driven Frameworks - Provides a comprehensive Go library for building event-driven applications with consistent publishing and subscribing interfaces.
  • Event Driven Messaging - Directs messages from specific topics to designated handlers based on a centralized routing configuration.
  • Composable Middleware Pipelines - Wraps message handlers in composable middleware chains to manage cross-cutting concerns like logging and retries.
  • Distributed Event Routers - Handles streams of data across multiple services with built-in support for routing and resiliency patterns.
  • Broker Adapters - Allows different messaging technologies to be swapped via a standard publisher and subscriber adapter system.
  • Saga Coordinators - Manages complex distributed transactions across multiple services by coordinating local events and compensations.
  • Event Sourcing - Implements patterns to track application state as an immutable sequence of events for complete history maintenance.
  • Distributed Coordination Patterns - Provides an interface for managing complex patterns such as event sourcing and sagas to coordinate requests.
  • Data Processing and Streams - Message-driven application library.
  • Messaging Systems - Toolkit for building event-driven applications and streams.
  • Implementation Patterns - Event-driven application building with Pub/Sub and CQRS middleware.
  • Messaging - Listed in the “Messaging” section of the Awesome Go awesome list.
9,760 stars·497 forks·Go·MIT·41 views

Star history

Star history chart for threedotslabs/watermillStar history chart for threedotslabs/watermill

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Watermill

These projects share indexed features with Watermill. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • masstransit/masstransitMassTransit avatar

    MassTransit/MassTransit

    7,760View on GitHub↗

    MassTransit is a .NET distributed application framework and asynchronous messaging library designed for building distributed systems. It serves as an enterprise service bus implementation that handles the routing, transformation, and delivery of messages between decoupled services. The framework provides a message broker abstraction layer, which decouples application code from specific messaging infrastructure such as RabbitMQ, Azure Service Bus, or Amazon SQS. It supports event-driven architecture and asynchronous microservices communication to improve system scalability and availability. T

    C#azure-service-busc-sharpdotnet
    View on GitHub↗7,760
  • nats-io/nats.gonats-io avatar

    nats-io/nats.go

    6,657View on GitHub↗

    This is a Golang client library for interacting with a cloud native distributed messaging system. It provides the necessary tools for Go applications to exchange messages using publish-subscribe and request-reply patterns, as well as specialized clients for managing persistent streams and distributed storage. The library includes a JetStream client for durable message streaming and replay, a Key-Value store client for managing distributed state with versioning and watchers, and an Object Store client for the storage and retrieval of large binary files via chunked delivery. The implementation

    Gocloud-nativecloud-native-architecturescloud-native-microservices
    View on GitHub↗6,657
  • serverless/event-gatewayserverless avatar

    serverless/event-gateway

    1,647View on GitHub↗

    The Event Gateway is a unified routing layer designed to connect HTTP requests and cloud events to serverless functions across multiple providers and infrastructure environments. It functions as a centralized platform for managing event-driven architectures, enabling developers to register, map, and trigger remote functions in response to incoming web traffic or asynchronous system events. The platform distinguishes itself through a plugin-based middleware pipeline that allows for custom logic execution during the request lifecycle, enabling developers to intercept, validate, or transform eve

    Godataflowevent-drivenevent-router
    View on GitHub↗1,647
  • doocs/advanced-javadoocs avatar

    doocs/advanced-java

    78,987View on GitHub↗

    This project is a comprehensive Java backend engineering guide and technical reference focused on high-concurrency design, distributed systems, and microservices architecture. It provides detailed strategies for decomposing monolithic applications, managing service discovery, and implementing the architectural patterns required for scalable backend environments. The repository distinguishes itself through an extensive collection of big data algorithmic references and database scaling strategies. It covers memory-efficient techniques for analyzing massive datasets, such as Top-K element extrac

    Javaadvanced-javadistributed-search-enginedistributed-systems
    View on GitHub↗78,987
Compare all 30 related projects→

Frequently asked questions

What does threedotslabs/watermill do?

Watermill is a Go library for building event-driven applications. It provides a framework for implementing event-driven architectures through a consistent interface for message publishing and subscribing, featuring a pub/sub message router and event stream processing pipelines.

What are the main features of threedotslabs/watermill?

The main features of threedotslabs/watermill are: Broker Abstractions, Streaming Processors, Message Queue Integrations, Message Routing, Message Stream Handlers, Pub-Sub Messaging, Asynchronous Messaging, Event-Driven Architectures.

Which projects share features with threedotslabs/watermill?

Projects with overlapping indexed features include: masstransit/masstransit — MassTransit is a .NET distributed application framework and asynchronous messaging library designed for building… nats-io/nats.go — This is a Golang client library for interacting with a cloud native distributed messaging system. It provides the… serverless/event-gateway — The Event Gateway is a unified routing layer designed to connect HTTP requests and cloud events to serverless… doocs/advanced-java — This project is a comprehensive Java backend engineering guide and technical reference focused on high-concurrency… microservices-patterns/ftgo-application — This project is a Java microservices reference implementation that demonstrates the application of structural design… threedotslabs/wild-workouts-go-ddd-example — This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query…