But have you seen flow? I don't think it's stalled at all, and Nubank seems to have become an enabler to the ecosystem.
I mean, Datomic is free to use!
[core.async.flow]: https://github.com/clojure/core.async/commit/03b97e0b3e0ec32...
In Why Clojure?clojure
core.async
Clojure2013–2025
clojure / core.async
core.async
Facilities for async programming and communication in Clojure
42Distinct people
49Mentions
1Explicit recommenders
2.1KGitHub stars
What to know before exploring
What it is
Facilities for async programming and communication in Clojure
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
Actually that's the one thing that's driven me away from Clojure. I love the simplicity behind the language and it makes simple things actually simple - which isn't as trivial…
moonchrome used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- clj-commons/manifold · linked in 2 of the same discussions
- taoensso/timbre · linked in 2 of the same discussions
- weavejester/compojure · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 11:56:56 AM 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 year49 dated mentions
Observed mentions: 2013-06-28 21:40:31 UTC to 2025-02-23 21:58:48 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 16 | 3 | 13 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 4 | 2 | 2 |
From the project README
An excerpt from the repository, fetched Nov 12, 2026.
Read the project’s introduction
core.async
A Clojure library providing facilities for async programming and communication.
Documentation
Rationale
API docs
Code walkthrough
Presentations
Rich Hickey on core.async
Tim Baldridge on core.async from Clojure/conj 2013 (code).
Tim Baldridge on go macro internals - part 1 part 2
Releases and Dependency Information
This project follows the version scheme MAJOR.MINOR.COMMITS where MAJOR and MINOR provide some relative indication of the size of the change, but do not follow semantic versioning. In general, all changes endeavor to be non-breaking (by moving to new names rather than by breaking existing names). COMMITS is an ever-increasing counter of commits since the beginning of this repository.
Latest release: 1.9.865
All Released Versions
deps.edn dependency information:
org.clojure/core.async {:mvn/version "1.9.865"}
Leiningen dependency information:
[org.clojure/core.async "1.9.865"]
Maven dependency information:
<dependency>
<groupId>org.clojure</groupId>
<artifactId>core.async</artifactId>
<version>1.9.865</version>
</dependency>
Contributing
Contributing to Clojure projects requires a signed Contributor Agreement. Pull requests and GitHub issues are not accepted; please use the core.async JIRA project to report problems or enhancements.
To run the ClojureScript tests:
lein cljsbuild once
open script/runtests.html
View JavaScript console for test results
License
Distributed under the Eclipse Public License, the same as Clojure.
Copyright © Rich Hickey and contributors
Changelog
Release 1.10.870-alpha2 on 2026-04-06
ASYNC-275 (CLJ) Fixed flow/futurize to retain original behavior of propagating exceptions
Release 1.10.864-alpha1 on 2026-03-19
Alpha release of core.async.flow - all APIs subject to change
ASYNC-274 (CLJ) Fixed flow/futurize stopped returning a future on Executor change
ASYNC-270 (CLJ) futurize with no :exec arg throws
Release 1.9.865 on 2026-03-19 (accumulated changes since 1.8.741)
Added datafy support for channels and buffers
ASYNC-273 (CLJ) alts!! callbacks should dispatch on caller when possible
ASYNC-272 (CLJ) Use JVM virtual threads in io-thread
ASYNC-269 (CLJ) Noop callbacks dispatch on caller thread
Release 1.9.859-alpha4 on 2026-03-16
ASYNC-273 (CLJ) alts!! callbacks should dispatch on caller when possible
ASYNC-274 (CLJ) Fixed flow/futurize stopped returning a future on Executor change
ASYNC-270 (CLJ) futurize with no :exec arg throws
Release 1.9.847-alpha3 on 2026-03-11
Flow - first cut of broadcast system
ASYNC-262 (CLJ) REVERTED from 1.9.829-alpha2
ASYNC-272 (CLJ) Use JVM virtual threads in io-thread
ASYNC-269 (CLJ) Noop callbacks dispatch on caller thread
Release 1.9.829-alpha2 on 2025-10-01
ASYNC-262 (CLJ) Use virtual threads when available for go and io-thread
Release 1.9.808-alpha1 on 2025-04-28
First alpha release of core.async.flow - all APIs subject to change
Added datafy support for channels and buffers
Release 1.8.741 on 2025-04-07
ASYNC-234 (CLJ) Inactive alt handlers hold strong references to (potentially large) caller state after the alt completes
Release 1.8.735 on 2025.04.02
Fix reflection warnings when using clojure.core.async.go-checking
Release 1.8.730 on 2025.04.02, effective changes since last non-beta release:
ASYNC-256 (CLJ) Add io-thread and System property clojure.core.async.executor-factory
ASYNC-260 (CLJ) Remove now unused property clojure.core.async.pool-size
ASYNC-255 (CLJ) alts guards against put of nil message on entry
Release 1.8.726-beta3 on 2025.03.31
ASYNC-259 (CLJ) Update clojure.core.async.go-checking with new executor pools
Release 1.8.718-beta2 on 2025.03.10
ASYNC-259 (CLJ) Implement clojure.core.async.go-checking with new executor pools
ASYNC-260 (CLJ) Remove now unused property clojure.core.async.pool-size
ASYNC-261 (CLJ) Put clojure.core.async/thread-macro-executor var back into place
Release 1.8.711-beta1 on 2025.02.19
ASYNC-256 (CLJ) Add io-thread and System property clojure.core.async.executor-factory
ASYNC-255 (CLJ) alts guards against put of nil message on entry
Update tools.analyzer.jvm to 1.3.2
Release 1.7.701 on 2024.12.17
ASYNC-254 (CLJ) Completions for blocking ops can be directly delivered without enqueuing for dispatch
ASYNC-252 (CLJ) Move go expander from ioc-macros to impl.go namespace
ASYNC-246 (CLJ) Fix non-deterministic test
Update deps to latest
Release 1.6.681 on 2023.08.09
Revert ASYNC-248 (CLJ) due to the issues in ASYNC-249
Update to tools.analyzer.jvm 1.2.3
Release 1.6.673 on 2022.10.27
ASYNC-248 (CLJ) Dynamically load ioc analyzer only when needed
Perf improvements in go macro compilation
Note: as of this version, core.async requires Clojure 1.10
Release 1.5.648 on 2021.12.14
Update dep for tools.analyzer.jvm to 1.2.2
Release 1.5.644 on 2021.12.06
Update dep for tools.analyzer.jvm to 1.2.1
Release 1.5.640 on 2021.11.23
ASYNC-204 (both) On put to closed channel, commit handler to allow pending alt ops to be cleaned up
ASYNC-235 (both) Fix ioc-macros/return-chan registers a callback with incorrect arity
ASYNC-144 (both) Tweak docstring in pipeline-async
ASYNC-238 (both) Fix a/map with empty chan vector hangs
Release 1.4.627 on 2021.11.03
ASYNC-132 (CLJS) Can't close over locals in #js in go)
ASYNC-117 (CLJS) let-bindings unavailable in #js literals in go-blocks
Update dep for tools.analyzer.jvm to 1.2.0
Release 1.3.618 on 2021.04.26
ASYNC-237 (CLJS) timeout timers access array elements with out-of-bounds index
Release 1.3.610 on 2020.07.24
Update dep for tools.analyzer.jvm to 1.1.0
Release 1.2.603 on 2020.05.11
Fix bug in cljs impl of onto-chan! in 1.2.598
Release 1.2.598 on 2020.05.11
Add onto-chan! and to-chan! to cljs core.async
Release 1.2.593 on 2020.05.11
onto-chan use of go-loop incompatible with blocking colls, replace with onto-chan! and onto-chan!!
Release 1.1.587 on 2020.04.01
Added :require-macros for the promise interop from 1.1.582
Release 1.1.582 on 2020.03.31
Bumped deps -
Read the full README on GitHubWhat Hacker News says
49 sourcesAlso an example gist: https://gist.github.com/richhickey/fbc1439372b1f5319bb37aa19...
And documentation in the namespace: https://github.com/clojure/core.async/blob/master/src/main/c...
In Clojure core.async.flowRich Hickey Added core.async.flow
4 points · Open discussionAs the other commenter pointed out, this isn't restricted to strongly-typed functional languages.
Clojure has core.async, which implements "goroutines" without any special support from the language. In fact, the `go` macro[1] is a compiler in disguise: transforming code into SSA form then constructing a state machine to deal with the "yield" points of async code. [2]
core.async runs on both Clojure and ClojureScript (i.e. both JVM and JavaScript). So in some sense, ClojureScript had something like Golang's concurrency well before ES6 was published.
[1] https://github.com/clojure/core.async/blob/master/src/main/c...
[2] https://github.com/clojure/core.async/blob/master/src/main/c...
In OCaml Syntax Sucks (2016)If you're not familiar with lisps in general, it might be hard to grok the differences between lisp-macros (as used in Clojure) and "normal" macros you see in other (non-lisp [sans Elixir I think]) languages.
But, if you are familiar already, and just wanna see examples of neat macros that makes the API nicer than what a function could provide, here are a few:
- https://github.com/clojure/core.async/blob/master/examples/w...
- https://github.com/weavejester/compojure
- https://github.com/ptaoussanis/timbre
- https://github.com/krisajenkins/yesql
Furthermore, macros enables APIs like this, that would be impossible to have in JavaScript for example:
(spy :info (* 5 4 3 2 1)) => 120
%> 15-Jun-13 19:19:13 localhost INFO [my-app.core] - (* 5 4 3 2 1) => 120
`spy` here doesn't just print what the `` form is returning, but the form
Read the rest
itself too. You wouldn't be able to achieve this without macros, as the evaluation of the `` form would happen before it gets passed to `spy`, so the initial form is already gone. Instead, a macro received the very code you pass into it, so you can print it, inspect it, rewrite it or whatever.
> which still hasn't caught up to modern trends (static types, asynchronism, etc...)
Ignoring the fact that your modern trends aren't modern. I don't think any of these statements really are true for Lisp as a family of languages:
For example Racket has typed Racket.
https://docs.racket-lang.org/ts-guide/
For asynchronicity Clojure has clojure.async
https://github.com/clojure/core.async
> and with a very poor tooling (lack of IDE's)
Lisps have fantastic support in Emacs and VSCode and are in general simple enough languages that often the heavyweight of an IDE is not needed. But if you want IDEs there are:
Dr. Racket - https://docs.racket-lang.org/drracket/index.html
Cursive - https://cursive-ide.com/
Emacs/Cider - https://docs.cider.mx/cider/index.html
> and library ecosystem (building websites, parallelism, GUI, etc...)
Websites - Reagen
Read the rest
t, a ClojureScript wrapper for React https://github.com/reagent-project/reagent
GUIs - Clojure has the entirety of Java to steal GUIs from - Ex: https://github.com/cljfx/cljfx
Just because the Lisp family is old and has a simple syntax does not mean it's an antiquated language or that there are not new developments going on there.
Multi-threaded code is normally not implemented in an async style, but instead is done where each thread of execution is synchronous.
Async style comes into play generally for languages that lack real threads, or as a way to manage callbacks (even if single threaded), or in order to wait for blocking IO without the need for a real thread.
So ya, it's idiomatic to use blocking to coordinate between different threads in Clojure, same as Java.
Java decided to work on making stackful coroutines instead of stackless like C#. That requires a lot more work, but should be coming eventually to Java. At that point, your "blocking" code in Clojure will no longer block a real thread, but a lightweight fiber instead. But patience is needed for it.
In the meantime, if you're dealing with non-blocking IO that operates with callback semantics or other ca
Read the rest
llback style code, what you can do in Clojure to make working with that easier is use one of:
> core.async - https://github.com/clojure/core.async
> Promesa - https://github.com/funcool/promesa
> Missionary - https://github.com/leonoel/missionary
> Missionary's lower level coroutine lib - https://github.com/leonoel/cloroutine/blob/master/doc/02-asy...
"you can change the fundamental data structure and the algo still works" - it doesn't really pan out, and it's not important in my experience of using Clojure for about ~8 years.
What makes Clojure worth it is the pervasive reduction of mutable state across your program without the cost and rigidity of creating types everywhere. Also great sharing of code across Clojure and ClojureScript:
- You want your dates to behave the same on client and server? You got it: https://github.com/juxt/tick
- You want your logging/debugging code to be the same? You got it: https://github.com/ptaoussanis/timbre
- You want good async primitives? No problem: https://github.com/clojure/core.async
- And many more...
I haven't seen another language that is as good as Clojure(Script) at this. Nowadays .cljc (.clj + .cljs) files really rock.
In Rich Hickey and Brian Beckman – Inside Clojure (2009) [video]Yeah, referring to the initial release of core.async (Clojure implementation of CSP) which seems to have been in late 2013 (https://github.com/clojure/core.async). Clojure usually ships new features as libraries rather than changing the core language, so both a feature and a library I guess.
In Erlang: The New Scalable ETS Ordered_setAnd core.async, bringing go blocks, channels, and parking semantics to Clojure
https://github.com/clojure/core.async/
In A History of Clojure [pdf]What is a language feature of Kotlin is available as a library in Clojure: https://github.com/clojure/core.async/
In Why Continuations Are Coming to JavaNot my experience - for eg. I remember reading trough implementation of a clojure standard lib core.async (this was years ago) https://github.com/clojure/core.async/blob/master/src/main/c...
It took me a long time to figure out what's going on in that code - I remember realizing how it would have been much simpler to read in a popular statically typed language like C#, types are a lot like compiler verified documentation and in undocumented code they help a lot. To be fair this is not the norm - I've seen many cases where Clojure removed incredible amounts of boilerplate and made reading the code straightforward, and the nicest thing about it was that it made simple things simple.
I haven't worked with Clojure in couple of years, the reason I left it is because I felt it wouldn't scale well in the real world (in terms of developers and te
Read the rest
ams) but it really helped me "get" LISP and FP so I don't regreat learning it
Low signal-to-noise posts about Clojure are damaging to adoption because it doesn't say anything about why Clojure is a good option on the JVM.
Instead, I will try to give some reasons why Clojure is a good fit for high-performance stream fusion, which I presume AppsFlyer has to do a lot of:
- [Onyx](https://github.com/onyx-platform/onyx) for distributed, masterless, fault-tolerant data processing
- [core.async](https://github.com/clojure/core.async) for CSP-style events through a channel abstraction. I miss core.async so much in every other language, I generally end up implementing a subset of the semantics.
- [Transducers](https://clojure.org/reference/transducers) for composable transformations, e.g.
(filter odd?) ;; returns a transducer that filters odd
(map inc) ;; returns a mapping transducer for incrementing
(take 5
Read the rest
) ;; returns a transducer that will take the first 5 values of a sequence
(def xf
(comp
(filter odd?)
(map inc)
(take 5)))
(into [] xf (range 100)) ;; => [2 4 6 8 10]
Note that no intermediate data structures are created during these transformations, so it's super fast.
- [Specter](https://github.com/nathanmarz/specter) decomplects navigation and transformation, pulling apart the "where" from the "how". In most imperative languages whenever the shape or performance characteristics your data structures change, you also have to update all the code that transforms it. Not with Specter.
- Zach Tellman's [Manifold](https://github.com/ztellman/manifold) provides event-streaming abstractions on top of async workflows like lazy sequences, core.async and Java's BlockingQueues.
This was also asked a year ago, and I pointed to Zach Tellman, and that comment was upvoted by others. I'll post the same again. Because he always has excellent reasons for the decisions that he makes, I find it interesting to read his code and try to figure out why he made the decisions that he did. This is in Clojure:
https://github.com/ztellman/manifold/blob/master/src/manifol...
Also, it is fascinating to consider how Go routines were implemented as part of Clojure core. Huey Petersen wrote a fantastic analysis of how state machines were used to implement Communicating Sequential Processes:
http://hueypetersen.com/posts/2013/08/02/the-state-machines-...
You can read along while looking at the source code here:
https://github.com/clojure/core.async
This is a great implementation of Communicating Sequential Processes, first described by
Read the rest
Tony Hoare in 1977:
https://en.wikipedia.org/wiki/Communicating_sequential_proce...
This is the same technique that Javascript/NodeJS uses to implement its async.
Showing the 15 most recent of 49 sources. Enable JavaScript to search and browse every indexed mention.