# reactivex/rxgo

**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/reactivex-rxgo).**

5,091 stars · 344 forks · Go · MIT

## Links

- GitHub: https://github.com/ReactiveX/RxGo
- awesome-repositories: https://awesome-repositories.com/repository/reactivex-rxgo.md

## Topics

`async` `asynchronous` `concurrency` `go` `golang` `hacktoberfest` `observable` `reactivex` `streaming`

## Description

RxGo is a functional reactive programming library and an implementation of ReactiveX for the Go language. It serves as an asynchronous stream processing toolkit designed to coordinate event-based programs and data flows using the observable pattern.

The library enables the construction of asynchronous processing pipelines that transform, filter, and combine event sequences. It distinguishes itself through the use of functional operators to compose these pipelines and provides mechanisms for managing concurrent execution.

The toolkit covers a broad range of stream orchestration capabilities, including data aggregation, multi-stream combination, and the conversion of streams into static data structures. It includes built-in support for error recovery, backpressure control to regulate data production speeds, and worker pooling to parallelize processing across CPU cores.

## Tags

### Programming Languages & Runtimes

- [Asynchronous Stream Processing Frameworks](https://awesome-repositories.com/f/programming-languages-runtimes/asynchronous-stream-processing-frameworks.md) — Provides a comprehensive framework for composing asynchronous data pipelines with built-in backpressure and non-blocking operators.
- [ReactiveX Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/reactivex-implementations.md) — Implements the ReactiveX standard for the Go language, enabling the use of observable sequences.
- [Stream Combinators](https://awesome-repositories.com/f/programming-languages-runtimes/asynchronous-streams/stream-combinators.md) — Offers operators for merging, concatenating, or zipping multiple asynchronous streams into a single unified sequence. ([source](https://github.com/reactivex/rxgo#readme))
- [Goroutine Pools](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/task-orchestration-frameworks/thread-pools/goroutine-pools.md) — Provides goroutine pools to distribute stream processing tasks and execute transformations in parallel across CPU cores.
- [Event Stream Concurrency Control](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtime-internals-foundations/runtime-architecture/event-loop-concurrency/event-stream-concurrency-control.md) — Regulates the processing of event streams by deploying worker pools to parallelize operator execution across CPU cores. ([source](https://github.com/reactivex/rxgo#readme))

### Software Engineering & Architecture

- [Functional Pipelines](https://awesome-repositories.com/f/software-engineering-architecture/functional-pipelines.md) — Implements architectural patterns for chaining data transformations using pure higher-order functions to map, filter, and reduce items.
- [Observer Patterns](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/state-management/reactive-subscription-systems/observer-patterns.md) — Implements the observer pattern to decouple data emission from consumption through a subscription model with callbacks.
- [Asynchronous Event Pipelines](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-event-pipelines.md) — Enables building data processing sequences in Go that transform and filter events using concurrent execution.
- [Backpressure Management](https://awesome-repositories.com/f/software-engineering-architecture/backpressure-management.md) — Implements a core architectural primitive for regulating data flow between producers and consumers to prevent resource exhaustion.
- [Event Stream Merging](https://awesome-repositories.com/f/software-engineering-architecture/event-sourcing/event-stream-merging.md) — Provides techniques for combining multiple asynchronous data sources into single observable sequences through merging and zipping.
- [Stream Generators](https://awesome-repositories.com/f/software-engineering-architecture/flow-modularization/modular-flow-composition/observable-streams/stream-generators.md) — Provides diverse methods to generate event streams from static data, channels, and time-based intervals. ([source](https://github.com/reactivex/rxgo#readme))
- [Functional Reactive Programming Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/functional-reactive-programming-frameworks.md) — Combines functional programming patterns with reactive data streams to transform and filter asynchronous event sequences.
- [Observer Pattern Implementations](https://awesome-repositories.com/f/software-engineering-architecture/observable-state-management/observer-pattern-implementations.md) — Provides a concrete implementation of the observer pattern to coordinate asynchronous events and data emissions.
- [In-Memory Communication Channels](https://awesome-repositories.com/f/software-engineering-architecture/producer-consumer-workflow-managers/in-memory-communication-channels.md) — Uses Go channels as thread-safe buffers for data exchange between producers and consumers within concurrent pipelines.
- [Reactive Programming Implementations](https://awesome-repositories.com/f/software-engineering-architecture/reactive-programming-implementations.md) — Provides a full implementation of the ReactiveX functional reactive programming model for the Go language.
- [Observable Stream Recovery](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/expected-error-handling/observable-stream-recovery.md) — Provides mechanisms to capture exceptions and restart or recover observable pipelines to prevent termination. ([source](https://github.com/reactivex/rxgo#readme))
- [Real-Time Stream Filtering](https://awesome-repositories.com/f/software-engineering-architecture/real-time-stream-filtering.md) — Processing live event sequences by applying predicates, debouncing, and time-based filters to extract specific information.
- [Stream Operator Chains](https://awesome-repositories.com/f/software-engineering-architecture/stream-piping/function-composition-operators/stream-operator-chains.md) — Links discrete processing functions into sequences where data flows from one operator to the next.
- [Stream Value Consumption](https://awesome-repositories.com/f/software-engineering-architecture/stream-value-consumption.md) — Provides general-purpose value sinks that process stream elements via blocking channels or non-blocking callbacks. ([source](https://github.com/reactivex/rxgo#readme))

### Part of an Awesome List

- [Stream Composition Libraries](https://awesome-repositories.com/f/awesome-lists/devtools/streaming-libraries/stream-composition-libraries.md) — Provides a library for chaining operators that map, merge, filter, and retry emissions with backpressure and error handling. ([source](https://github.com/reactivex/rxgo#readme))
- [Task Scheduling and Queues](https://awesome-repositories.com/f/awesome-lists/devops/task-scheduling-and-queues.md) — Reactive extensions for asynchronous data streams.

### Data & Databases

- [Event Stream Filtering](https://awesome-repositories.com/f/data-databases/event-based-stream-processing/event-stream-filtering.md) — The library selects specific items from a stream based on predicates, time-based debouncing, or index positions. ([source](https://github.com/reactivex/rxgo#readme))
- [Stream Processing Pipelines](https://awesome-repositories.com/f/data-databases/stream-processing-pipelines.md) — Implements high-throughput data processing pipelines that handle continuous streams using concurrent worker pools. ([source](https://github.com/reactivex/rxgo#readme))
- [Concurrent Data Processors](https://awesome-repositories.com/f/data-databases/concurrent-data-processors.md) — Provides a toolkit for distributing computational workloads across multiple CPU cores for high-throughput stream processing.
- [Stream Mathematical Aggregations](https://awesome-repositories.com/f/data-databases/stream-mathematical-aggregations.md) — Calculates statistical aggregates such as sums, averages, and counts across asynchronous data sequences. ([source](https://github.com/reactivex/rxgo#readme))
- [Stream Transformations](https://awesome-repositories.com/f/data-databases/stream-transformations.md) — Provides real-time processing of data streams to apply operations like mapping, buffering, grouping, or flattening. ([source](https://github.com/reactivex/rxgo#readme))

### Networking & Communication

- [Subscription Coordination](https://awesome-repositories.com/f/networking-communication/real-time-event-streams/publish-subscribe-event-systems/event-stream-subscriptions/subscription-coordination.md) — Implements connectable observables that coordinate data emission across multiple synchronized observers. ([source](https://github.com/reactivex/rxgo#readme))