---
id: rx
version: "3.2.0"
license: MIT License
license_treatment: permissive
maintenance: active
---

# Rx — Reactive Extensions (Rx) for Python

License: permissive · Maintenance: active · Downloads: 4.7M/mo

## What it is and what it does

RxPY is a Python implementation of Reactive Extensions, a library for building programs that handle asynchronous data and events through observable sequences. Instead of polling or callback-based approaches, you represent data streams as Observables and transform them using chainable operators like map, filter, and group_by. The library handles the threading and scheduling complexity, letting you focus on the logic of data transformation.

The package is designed for developers working with event-driven systems, real-time data processing, or any scenario where asynchronous composition matters. It includes over 120 operators and runs on Python 3.6 or above with no external runtime dependencies, making it straightforward to integrate into existing projects.

Use it for:

- Build real-time data pipelines that transform and filter event streams from APIs or message queues
- Implement reactive UI updates or event handlers that respond to user input and system events
- Compose complex asynchronous workflows where multiple data sources need coordinated handling
- Create event-driven microservices that react to incoming messages or state changes
- Handle time-based operations like throttling, debouncing, or windowing of event streams

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

RxPY provides a library for composing asynchronous and event-based programs using observable sequences and query operators, allowing developers to represent and manipulate asynchronous data streams in Python.

Yes, if you need reactive programming patterns in Python. RxPY is production-stable, permissively licensed, and has no dependencies. The main consideration is whether observable-based composition fits your use case better than native async/await—RxPY excels at complex event orchestration but adds a learning curve for teams unfamiliar with reactive paradigms.

## Install

pip install rx
uv add rx
poetry add rx

## Installing Rx

Before you install: Low friction installation with no runtime dependencies. Actively maintained with recent commits and a stable production release status, though the latest release was in 2021.

License in practice: MIT License permits commercial and private use with minimal restrictions, making it suitable for most projects without licensing concerns.

Quickstart:

pip install rx

import rx
from rx import operators as ops

source = rx.of("Alpha", "Beta", "Gamma")
composed = source.pipe(
    ops.map(lambda s: len(s)),
    ops.filter(lambda i: i >= 5)
)
composed.subscribe(lambda value: print(value))

Requires Python 3.6 or above.

Verify before relying:

- Whether the 1937 days since release reflects a stable mature library or indicates stalled development relative to reactive programming ecosystem changes
- Performance characteristics and scalability limits for high-throughput event streams
- Compatibility with modern async/await patterns versus the observable-based API

## Package facts

- License: MIT License (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: active
- Downloads: 4.7M/month (top 5,000 on PyPI)
- Known vulnerabilities: none known

## Tags

reactive programming python, observable sequences, asynchronous event handling, reactive extensions, composable async streams, event-driven programming, rxpy operators, reactive-programming, async-events, stream-processing

[View on SkillFed](https://skillfed.io/packages/rx) · [View on PyPI](https://pypi.org/project/rx/)