HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
ReactiveX
rxjs
TypeScript2015–2023
ReactiveX / rxjs

rxjs

A reactive programming library for JavaScript

Web DevelopmentLibraries & SDKs
Explore on GitHubRead Hacker News discussions
20Distinct people
20Mentions
0Explicit recommenders
31.7KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

A reactive programming library for JavaScript

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year20 dated mentions

Observed mentions: 2015-11-03 01:54:55 UTC to 2023-12-23 14:42:53 UTC.

02462015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20152016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 6 mentions; 3 submissions, 3 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20192020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2023

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC303
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC633
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC202
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC404
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC303
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC000
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC000
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC101
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC101

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
RxJS RxJS is a library for composing asynchronous and event-based programs with Observable values. This repository contains the platform-based next generation of RxJS, planned for release as RxJS 9. RxJS 9 is prerelease work in development. The planned first beta is 9.0.0-beta.0, but it has not been published to npm yet. The next tag still points to the earlier RxJS 8 prerelease, while RxJS 7 remains the production latest line and continues to be maintained. Why RxJS 9? What happened to RxJS 8? RxJS 8 was real work, not a skipped release. Development began years ago and was paused while the Web Platform Observable proposal was finalized. The new implementation is a platform-based generation rather than a continuation of that paused RxJS 8 branch, so it starts at version 9 to make the architectural break unmistakable and avoid presenting the old RxJS 8 work as the released product. What is different in RxJS 9? RxJS uses the native web-platform Observable when one exists and installs a conforming fallback only when needed. RxJS operators and factories are exact, module-owned Symbols. They do not add string-named RxJS methods to the platform API. Platform Observable behavior and producer-per-subscription behavior are explicit, separate contracts. Use ColdObservable when each direct subscription must create its own producer. Cancellation is built on AbortSignal and the platform Subscriber lifecycle. Published JavaScript is ESM-only. Current Node can bridge require() to the same ESM files; there is no duplicate CommonJS build. Preview the RxJS 9 API The following example shows the planned beta API. Until 9.0.0-beta.0 is published, do not use npm's next tag to install RxJS 9. import { ColdObservable } from 'rxjs'; import { map } from 'rxjs/map'; const source = new ColdObservable<number>((subscriber) => { subscriber.next(1); subscriber.next(2); subscriber.complete(); }); source[map]((value) => value * 2).subscribe(console.log); Import the Symbol and call it with bracket syntax. A platform method such as observable.map(project) remains the platform contract; observable[map](project) is the separately versioned RxJS contract. Packages and documentation Package Purpose Documentation rxjs Symbol extensions and intentional RxJS primitives Package guide · API · RxJS 7 migration @rxjs/observable-polyfill Conditional platform Observable fallback Package guide @rxjs/test Implementation-neutral virtual-time and marble testing Package guide @rxjs/migrate Deterministic migration engine and canonical agent Skill Package guide Release support, budgets, and exact environment gates are documented in the rxjs package. The irreversible npm publication process is the public secure release runbook. The RxJS 9 security-assurance document explains the release evidence, verification commands, sole-maintainer model, and OpenSSF Scorecard in context. Repository-wide design records live in docs/rxjs-next. Supported environments The planned beta supports Node 22.13+ and Node 24 as blocking lanes, with Node 26 in an advisory lane. Current Chrome, Firefox, desktop Safari, Mobile Safari, Deno, Bun, and Webpack 5 are blocking. Every supported consumer receives the same ESM implementation, so Deno and Bun support adds no runtime-specific package or application-bundle code. Contributing Requires Node 22.13+ and pnpm 10.34.5. Run commands from the repository root. pnpm install pnpm --filter rxjs exec vitest --run src pnpm --filter rxjs run test:package pnpm run release:check Start with the repository contribution guide and the rxjs package contribution guide. The active execution queue is PROJECT_PLAN.md. The complete source-pinned RxJS 7 corpus intentionally retains reviewed lifecycle and compatibility divergences, so it is migration evidence rather than a blanket RxJS 9 compatibility gate. Focused source, package, runtime, browser, performance, and WPT commands are the release gates. Community and governance Code of Conduct Contribution guidelines Apache 2.0 License Issues Discussions
Read the full README on GitHub

What Hacker News says

20 sources
azangru·Dec 23, 2023
> This proposal makes the same mistake as various stream implementations (including RxJS in the past) of making operators methods on the observable. I don't think they are making a mistake. I am sure Ben knows what he is doing, given how it was he who refactored rxjs 5 with all operators being methods on the Observable, to rxjs 6 with pipeable operators. But, their objective is not to bring rxjs into the browser, but rather to bring the Observable primitive into the browser. And, like Array prototype, which has methods, Observable, in order to be even minimally useful, needs some methods, which they modelled after TC39 iterators, for the sake of consistency. They say: > We expect userland libraries to provide more niche operators that integrate with the Observable API central to this proposal, potentially shipping natively if they get eno
Read the rest
ugh momentum to graduate to the platform. But for this initial proposal, we'd like to restrict the set of operators to those that follow the precedent stated above, similar to how web platform APIs that are declared Setlike and Maplike have native properties inspired by TC39's Map and Set objects. Therefore we'd consider most discussion of expanding this set as out-of-scope for the initial proposal, suitable for discussion in an appendix. Any long tail of operators could conceivably follow along if there is support for the native Observable API presented in this explainer. As to > We really need a `pipe` operator, at minimum Maybe we don't. Note that in RxJS version 8, they have introduced a new way of piping observables, which is the rx function [0]. Maybe they are thinking of something similar for the browser. Or maybe they are thinking of using the native pipeline operator if it ever gets approved. In the meantime, for any complex manipulations on observables, users will probably still import relevant functions from libraries. 0 - https://github.com/ReactiveX/rxjs/issues/7203
In What We Need Instead of "Web Components"
upzylon·Aug 7, 2022
When programming in a functional style, quite of often I find myself wanting to rewrite nested function calls as a chain. Hopefully at some point the proposed pipe operator will make it into JavaScript and TypeScript but for now defining a pipe function will have to do. The function should allow rewriting something like double(square(half(2))) as pipe(half, square, double)(2) For a while now I've struggled to implement the type definition for that function, so that every passed-in function can only accept the return type of the previous function as its parameter and the resulting function will take the arguments of the first function as its parameters and return the type of the last function. The main problem with this is that trying to define a type for pipe's arguments up-front would require typing them as an infinitely-recursive
Read the rest
type that TypeScript cannot handle. A common workaround for this is to define pipe's type separately for every number of arguments it can take. This is for example how RXJS defines its pipe function: https://github.com/ReactiveX/rxjs/blob/f174d38554d404f21f98a... Other common solutions are to make concessions like requiring all functions to have the same return type or letting pipe only take one function at a time and returning an object with methods to add another function and invoke the chain. None of these solutions are satisfying in my opinion. I think I've finally found an implementation that fulfills all these criteria. The argument and return types of passed in functions are correctly enforced (no matter the number of passed-in functions) and the pipe function returns a function that accepts the arguments of the first function, invokes all functions in turn with the result of the last, and correctly returns the type of the last function of the chain. Including asynchronous functions in the chain works to: if a function returns a promise that promise is resolved before being passed into the next function and the function returned from pipe will return a promise as its type. There is one disadvantage to the implementation that I'm aware of: When passing in anonymous functions, the types of their arguments can not be inferred if they aren't annotated. That means that pipe(() => 10, n => n.toString()) would return the type () => any but I think that's an acceptable tradeoff because when annotated pipe(() => 10, (n: number) => n.toString()) it will return the correct type () => string Thought the implementation might be worth sharing here in case it's useful to someone else and because it's an interesting problem to solve in TypeScript's type system. If you have any suggestions on how to improve the function's typing or know of any better implementations, I'd appreciate it if you would let me know! Edit: I meant to link to the pipe part of the readme, but I see the link is just to the repo, that's unfortunate. Here is the relevant section of the readme: https://github.com/MathisBullinger/froebel#pipe and here the implementation: https://github.com/MathisBullinger/froebel/blob/main/pipe.ts...
In A generically typed pipe function in TypeScript
stupidcar·Mar 28, 2019
It's ironic that the author's recommendation of using `shareReplay(1)` actually leaks a subscription as well. Unless the operator is a supplied with `{ refCount: true }` config parameter, it does not unsubscribe from the source observable, even when all its subscribers unsubscribe: https://github.com/ReactiveX/rxjs/blob/master/src/internal/o... Sadly, issues like this seem to crop up all the time when using reactive programming. I'm not as anti-reactive as most other commenters here seem to be, but there's no doubt that certain areas, particularly memory safety, sharing and buffering, seem hard to understand and get right.
In Observables, Side-Effects, and Subscriptions: Some Reactive Best Practices
sqs·Nov 27, 2018
> I think Sourcegraph is trying here but that still does not seem to use some kind of accurate and structured information like you have in the code, it still seems not use build rules Sourcegraph does use language servers (same as your editor would use) to get precise definitions and references. For example ("find references" on some open-source code): Go: https://sourcegraph.com/github.com/theupdateframework/notary... TypeScript: https://sourcegraph.com/github.com/ReactiveX/rxjs/-/blob/src... It understands many build tools, but not all. Go, JavaScript, TypeScript, Java, Python, and PHP support is all pretty solid. If you use the most common build tools for your language, it usually works well. It degrades un-gracefully if you use custom build tools or scripts, unfortunately, but we're working on making it support more build tools and cu
Read the rest
stomization. Sourcegraph development is open source; if you notice any problems, let us know in the issue tracker at https://github.com/sourcegraph/sourcegraph.
In Cloud Source Repositories

Showing the 15 most recent of 20 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.