It's also a perfect example of the limitations of that approach - core.async had to make serious compromises in its interface because it was 'just a library': expressions with <!'s and other calls can't just be pulled into functions or for-comprehensions like normal code. That's not to say it's poorly-done, or not useful - it is well done and useful, and those compromises are in line with clojure's goal of integrating well with host vms. It's just an example of how builtins can be "simpler" sometimes. https://github.com/clojure/core.async/wiki/Go-Block-Best-Pra...
In Why Go Is Not Good (2014)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, 6:01:08 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 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
7 sourcesWhat a strange argument. The difference is that clojure is about as extensible a language as it's possible to have.
A macro system in a homoiconic language allows you to implement many types of semantic sugar or things that would be full-on 'language features' in other languages as a simple library. See core.async: https://github.com/clojure/core.async
In Why Go Is Not Good (2014)Correct me if I'm wrong, but describing core.async as "a library" isn't perfect in the context of a golang discussion. Doesn't the `go` macro rewrite the abstract syntax tree / JVM bytecode to make e.g. the `!<` macro co-operate with the channel?
https://github.com/clojure/core.async/blob/master/src/main/c...
That's not something that could be done with golang as far as I know.
In Why Go Is Not Good (2014)+1 on this. Clojure's core.async[0] is the perfect example of an implementation of CSP as a library.
Even JS can be used to implement such concepts via the use of generators[1].
[0] https://github.com/clojure/core.async
[1] https://github.com/ubolonton/js-csp
In Why Go Is Not Good (2014)It's part of the std lib.
But yeah you're basically on the same page as me.
Java doesn't have the ability to be extended in the ways that clojure or python can.
Python also allows for functional programming to a certain degree, but clojure is a lot more powerful when it comes to language extensions.
Threads as a library (for js environments) for clojure.
https://github.com/clojure/core.async
Logic programming for clojure.
https://github.com/clojure/core.logic
Declarative UI building, with dataflow semantics.
http://reagent-project.github.io
Additionally immutability makes your life a lot easier. Parallel computing in clojure is a no brainer, you just change your map to pmap, and that's it.
In Metabase: Why we picked ClojureClojure and ClojureScript have core.async which does a great/better job https://github.com/clojure/core.async/blob/master/examples/w...
There's also a video if you care to watch https://www.youtube.com/watch?v=enwIIGzhahw
In The Path to Parallel JavaScriptHaving also struggled with Monads before having an aha! moment, I've tried on occasion to help boil it down for those on the search for understanding.
The hardest thing to get is that Monads aren't quite as "tangible" (not sure of a better word) as concepts like variable, object, property, instance, function, method. They are essentially relational and require something of a mental leap akin to coming to grips with how JavaScript's event loop is bound up in the control flow of your code, which otherwise proceeds from top to bottom of a .js file; or the rules governing closures and asynchronous function evaluation in this or that language.
The following is reprised from one of my HN comments in 2013.
-------
Monads are programming patterns which relate a set of values to a set of of functions – that's pretty much it! For any monad X, we ca
Read the rest
n say that a function is monadic if it returns a value in the X Monad. The set of values are precisely those such that the following three Monad Laws[1] hold:
[ Using JavaScript syntax, they can be approximated as... ]
Left Identity
mBind( mReturn(a), f ) == f(a);
// => true
Right Identity
mBind( mReturn(a), mReturn ) == mReturn(a);
// => true
Associativity
mBind( mBind( mReturn(a), f ), g ) == mBind( mReturn(a),
function(a) {
return mBind( f(a), g );
} );
// => true
Above, `a` is (basically) any value, while `f` and `g` are any monadic functions for the same Monad. The definitions of `mBind` and `mReturn` will vary depending on the Monad, but the same laws (and sometimes additional properties) hold for each group of things taken as a whole – the monadic values, monadic functions, and the `mBind` and `mReturn` pair for those values and functions.
As you can see, there is nothing special that requires a statically typed language. That being said, if your language is statically typed, and even more so if its type system has advanced capabilities (e.g. Haskell's type system), then the relationships between the monadic values and functions can be leveraged to do a number of useful things, e.g. catching a host of bugs at compile time (though that's true regardless of Monads).
If your language is dynamically typed, then you won't get those extra benefits, but you can still take advantage of the fact that Monads can abstract away a great deal of plumbing between various pieces of your program.
Sometimes the Monad patterns will appear in a language under another name, or will be used "under the hood" to implement a particular API. Clojure/Script's `let` for example is essentially the Identity Monad; and its `for` is very much akin to the List Monad (the same is true for list comprehensions in other languages). The core.async library involves an inspiring application of the State Monad pattern[2].
[1] http://en.wikipedia.org/wiki/Monad_(functional_programming)#...
[2] https://github.com/clojure/core.async/blob/master/src/main/c...
[&] https://github.com/clojure/core.async/blob/master/src/main/c...