I have been building GUI applications with Java and Swing for some time. I am willing to go on-the-record and state that Swing provides a reliable and thorough cross-platform GUI toolkit. Once you put the work in, you really can build an application that looks native-ish and does the same thing on Windows, Linux/GTK and Mac OSX. Unfortunately the learning curve is quite steep, many things are more complicated then they need to be.
I have just started working on GUI apps with Clojure and the story is much better so far! Seesaw[0] definitely slims up the Swing code, and I've been using Core.Async[1] to remove a lot of the callback handlers. So far, so good. :-) It's definitely worth looking into.
[0] https://github.com/daveray/seesaw
[1] https://github.com/clojure/core.async
In A glimpse into a new programming language under development at Microsoftclojure
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
16 sourcesAsk HN: starter books for learning about grammars, parsers and compilers?
I'd like to get a solid footing in the concepts and formalisms that underlie libraries such as instaparse[1], PEG.js[2] and the SSA approach taken in Clojure's core.async library[3].
Working with those libraries, reading source code, and referencing Wikipedia is a great way to learn, but I'd like to take in some worthwhile books, lecture series, etc. as well. While I'm not opposed to "pure theory" treatments, my preference would be for resources that provide a good mix of theory and concrete examples.
What recommendations do other HN readers have in this regard?
[1] https://github.com/Engelberg/instaparse
[2] https://github.com/dmajda/pegjs
[3] https://github.com/clojure/core.async/blob/master/src/main/clojure/clojure/core/as…
7 points · Open discussionThat's a fair question, to be sure.
However, your comments regarding monads see a bit off. I've seen the same sentiments expressed elsewhere (i.e. by others), so I think they represent something of a common misunderstanding.
First of all, monads are simply programming patterns which relate a set of values to a set of of functions. For any monad X, we can 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(x), f ) == f(x);
// => true
Right Identity
mBind( mReturn(x), mReturn ) == mReturn(x);
// => true
Associativity
mBind( mBind( mReturn(x), f ), g ) == mBind( mReturn(x), function(x) { return mBind( f(x), g ); } );
// => true
Abov
Read the rest
e, x is any value in the Monad X; f and g are 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, including catching a host of errors 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].
In my case, I'm working on an SCXML-like[3] framework which builds on Google Polymer, core.async and protocol-monads (and core.logic at some point?). By using the State Monad pattern (together with trampolines and core.async channels), the algorithms of SCXML can be implemented in a manner that's not dependent on side effects, instead flowing the "global state" between the computational steps in a manner that is consisent and relatively easy to reason about. To boot, by using channels to link together steps in the "mainEventLoop", time is deliberately yielded back to the CPU, making the framework even more concurrency friendly. The project will be open source soon, and I can follow up with some links to source code once it goes public on GitHub.
[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...
[3] http://www.w3.org/TR/scxml/
Monads are used in Clojure, just not for this particular use-case because it's unnecessary the majority of the time.
A good example of monad (and macros) use would be: http://github.com/clojure/core.async
In Scaling Scala vs JavaClojure: More core.async goodies: operations on channels, multiplexing, Pub/sub
3 points · Open discussionHaha, I had a double-take when I clicked the link.
I didn't mean to misrepresent core.async. I just heard about it one day and got compelled enough by a walkthrough[1] to convince myself I could figure enough of it out to make something happen in my nrepl buffer. Which happens to also describe my approach to life now that I think about it. Except, you know, in my life buffer.
[1]: https://github.com/clojure/core.async/blob/master/examples/w...
In Go Concurrency Patterns ported to Clojurehttps://github.com/clojure/core.async/blob/master/examples/w... seems to be the only "documentation" I've found.
In Go Concurrency Patterns ported to Clojure> Using Thread/sleep inside of a go block is questionable. Using >!! and <!! inside a go block is simply wrong.
They both block the thread and any other go-blocks that happen to be mapped to it. I think you get 2 x NUM_CPU threads in the dedicated pool for channels, so either of these is a mistake. (Aside: I'm not sure why you were down voted for saying this.)
When you need to wait inside of a go-block, the correct way is to use (timeout millis), which creates and then closes a channel.
This has some nice examples: https://github.com/clojure/core.async/blob/master/examples/w...
In Go Concurrency Patterns ported to ClojureDefinitely. Also, for Scala/Java, there's Akka[1], for Clojure/ClojureScript there's core.async[2], and for Clojure/Java there's Quasar/Pulsar[3]
[1] http://akka.io/
[2] https://github.com/clojure/core.async
[3] http://puniverse.github.io/pulsar/
In The Future of ProgrammingThat's the plan - as you can see here https://github.com/clojure/core.async/blob/master/src/main/c... we pick the fastest mechanism available for scheduling tasks depending on the environment. So that's MessageChannel for modern browsers, setImmediate for Node & IE 10, and setTimeout for everyone else.
In ClojureScript Core.async TodosIf you're referring to core.async specifically, keep in mind it's very new. Its readme[1] goes as far as to say, "This library is work-in-progress, experimental, broken etc. It should only be used by people working on it, ATM." With more maturity will surely come more examples and tutorials.
But if you mean Clojure(Script) in general, I kind of agree. There are some beginner friendly tutorials; lately Andrew Brehaut's intro to the Clojure web stack[2] has been smooth going for me, despite being a bit dated. But you have to look around. In particular, I've found the small-scale mechanics of the language easy to pick up via Clojure Koans[3], 4clojure[4], and ClojureDocs[5]. What's missing the most IMHO is approachable introductions to the big-picture concepts. Especially the less generically lispy, more Clojure-specific parts, concerned wit
Read the rest
h concurrency and state. (I hear the book Clojure Programming by Emerick et al. is good for that... have yet to read.)
I kind of understand Clojure not being easy or quick to learn, because powerful tools take time to master. But even with that said, it could be better. When I get confident with Clojure I hope to be part of a new wave of Clojurists who write really beginner-friendly tutorials :) I think it won't be the "gurus" who write them, but regular joes/janes like you and me for whom the initial difficulty of this stuff is still a fresh memory.
[1] https://github.com/clojure/core.async
[2] http://brehaut.net/blog/2011/ring_introduction
[3] https://github.com/functional-koans/clojure-koans
[4] http://4clojure.com/
[5] http://clojuredocs.org/
The default for multiplexing is non-deterministic choice. You can specify the :priority flag [1] if you want deterministic choice when multiplexing. Reads and writes will block for a non-deterministic amount of time, but their sequencing will be deterministic. That's the beauty of the CSP model: You can achieve some level of local determinism within a particular thread of control. Makes it much easier to reason about the non-deterministic outside world.
[1]: https://github.com/clojure/core.async/blob/bb77337b3e9ce2118...
In Communicating Sequential ProcessesClojure/core.async walk through by Alex Miller
2 points · Open discussionyou could do it with channels, but also by extending the go macro itself. The mini compiler behind the go macro is designed to be extensible. In the test suite for core.async the compiler is run through a series of tests using a "runner" implementation of the go macro: https://github.com/clojure/core.async/blob/master/src/test/c...
I've had generators working several times with an approach like this, but as it doesn't really fit with the rest of the library, I removed them.
All that being said, these APIs are internal and could change at any moment.
In Clojure core.async and Go: A Code ComparisonI believe you have the wrong case there. The source [0] is available for your review.
[0] https://github.com/clojure/core.async/
In Clojure core.async ChannelsShowing the 15 most recent of 16 sources. Enable JavaScript to search and browse every indexed mention.