I'm not a core.async/UI wizard but have a look at this [0].
It's a tutorial for building a reactive ToDo List application using core.async for event processing, crate [1] for rendering and jayq [2] for DOM manipulation and ajax calls.
Interesting, though I use re-frame [3].
[0] http://rigsomelight.com/2013/07/18/clojurescript-core-async-...
[1] https://github.com/ibdknox/crate
[2] https://github.com/ibdknox/jayq
[3] https://github.com/Day8/re-frame
In RxJS is great. So why have I moved on?day8
re-frame
Clojure2015–2025
day8 / re-frame
re-frame
A ClojureScript framework for building user interfaces, leveraging React
61Distinct people
102Mentions
3Explicit recommenders
5.5KGitHub stars
What to know before exploring
What it is
A ClojureScript framework for building user interfaces, leveraging React
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
ClojureScript's re-frame[0] is my favorite way to React, honestly. PureScript's halogen is also pretty nice. Re-frame has a built-in, functionally pure way to do ajax and…
christophilus used a recommendation phrase. 3 indexed comments match. 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
- day8/re-frame-template · linked in 3 of the same discussions
- reagent-project/reagent · linked in 3 of the same discussions
- thheller/shadow-cljs · linked in 3 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 12:03:30 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 year102 dated mentions
Observed mentions: 2015-02-23 09:22:35 UTC to 2025-07-06 17:09:08 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 |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 28 | 5 | 23 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 11 | 4 | 7 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 15 | 2 | 13 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 15 | 4 | 11 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 11 | 0 | 11 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 12 | 0 | 12 |
| 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 | 2 | 0 | 2 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 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 | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Derived Values, Flowing
This, milord, is my family's axe. We have owned it for almost nine hundred years, see. Of course,
sometimes it needed a new blade. And sometimes it has required a new handle, new designs on the
metalwork, a little refreshing of the ornamentation ... but is this not the nine hundred-year-old
axe of my family? And because it has changed gently over time, it is still a pretty good axe,
y'know. Pretty good.
-- Terry Pratchett, The Fifth Elephant
reflecting on identity, flow and derived values (aka The Ship of Theseus)
Overview
re-frame is a ClojureScript framework for building user interfaces.
It has a data-oriented, functional design. Its primary focus is on high programmer productivity and scaling up to larger Single-Page applications.
Developed in late 2014, and released in 2015, it is mature and stable. It is used by both small startups and companies with over 500 developers, and it has delivered into production applications which are 40K lines of code and beyond.
Across the last 10 years, it has outlasted multiple generations of Javascript churn - just imagine your team's productivity if you didn't have to contend with technical churn, and have new magic burn your fingers every two years. Brand new, exciting concepts like recoiljs (in the React world), have been a regular part of re-frame from the beginning.
re-frame is lucky enough to enjoy an unfair advantage - ClojureScript is a Lisp. Alan Kay
once described Lisp as "Maxwell's equations of software". Paul Graham
described how Lisp was a competitive advantage for his startup. When we use Lisp, we
get to leverage 50 years of foliated excellence from the very best minds available.
And then there's also a thriving ClojureScript community which delivers modern ideas and best-in-class tooling.
Although re-frame leverages React (via Reagent), it only needs
React to be the V in MVC, and no more. re-frame takes a different road to the currently-pervasive idea that Views should be causal (colocated queries, ComponentDidMount, hooks, etc).
In re-frame, events are causal, and views are purely reactive.
Documentation
The re-frame documentation is available here.
Programmatic Diagnostics (1.4.6+)
The documentation includes a
Debugging & Instrumentation
guide for devtools and diagnostic code: source-meta macros, trace tag
schema validation, per-dispatch epoch callbacks, dry-run dispatch with
effect overrides, and subscription cache lookups.
Source-meta opt-in
re-frame.core is the stable function API — reg-event-db /
reg-event-fx / reg-event-ctx / reg-sub / reg-fx and the
dispatch / subscribe family are defns, so (map reg-event-db ...), (apply reg-sub ...), (partial reg-fx ...) work as
written.
For call-site {:file :line} metadata in dev / devtools, alias
re-frame.macros instead. Same call shape, source-meta captured at
expansion time and DCE'd in production CLJS:
;; function API — no source-meta
(:require [re-frame.core :as rf])
;; macro API — same call shape, source-meta captured
(:require [re-frame.macros :as rf])
The Current Version
For full dependency information, see the Clojars page
Getting Help
Licence
re-frame is MIT licenced
Read the full README on GitHubWhat Hacker News says
28 sourcesI wrote a 20k LoC bacon app in 2014 and had the same issue with being able to understand all the pieces individually but having trouble comprehending the whole system.
I don't have non-architecture answers for how to organize code since that's pretty much the point of an architecture. Most of the application organization patterns around the React space are only ~200 lines of code and a description of how the pieces fit together. You don't have to adopt the whole thing immediately but you don't get the full benefits of a pattern until everything works the same way.
For my part, I got a job writing clojurescript full time and migrated the app to re-frame [1][2] this year in pieces over the course of a couple months and it's the first frontend architecture that's made me happy in over a decade of continuous searching. The js version is Redux
Read the rest
but I think Redux is missing middleware as a concept.
[1] https://github.com/Day8/re-frame/
[2] https://github.com/binaryage/pure-frame <- Fork with no global atom
What this provides is a complete event cycle of completely pure functions (the state swap happens in the framework) with all the data in an immutable map in a single atom. By namespacing my subscriptions and events I can see a problem, look at the component, and know immediately where my problem is within ~10 lines of code. It's not perfect but it's pretty good.
One thing that doesn't get mentioned often enough when talking about Clojurescript is the potential for doing server-side rendering of the app without having to run node. [3]
[3] http://yogthos.net/posts/2015-11-24-Serverside-Reagent.html
I've used clojurescript commercially for a couple of years. It has been a good experience.
More than anything it has completely changed my world view (and I'm a very experienced, older programmer who has seen a bit). I feel very lucky to have had this opportunity.
IMO, some of the issues you raise are genuine, some not.
For example, the JVM startup time issue is never, ever a problem. If it is, you aren't using the tools right.
I use Cursive and figwheel etc, so I find the tooling generally fine and in many ways excellent. The trajectory in this area is good.
Debugging initially can be rough. Knowing about things like cljs-devtools can dramatically improve things. But, yeah, valid point.
And, yes, poor error messages can definitely be a problem initially -- although this has improved over the last year.
To get going, I'd recommend you u
Read the rest
se this set of technologies:
- use Cursive/InteliiJ https://cursiveclojure.com/
- use reagent, rather than om. http://reagent-project.github.io/
- use figwheel
- use cljs-devtools with Canary for debugging
- use Schema to provide faint typing - https://github.com/Prismatic/schema
- perhaps use clairvoyant for debugging https://github.com/spellhouse/clairvoyant
- use timbre for logging https://github.com/ptaoussanis/timbre
- use re-frame https://github.com/Day8/re-frame (if the app is slightly more complex) <--- warning I'm biased
- perhaps use re-com - https://github.com/Day8/re-com <--- warning I'm biased
- you may also be interested in the head start provided by http://www.luminusweb.net/ for client/server
-
Perhaps just start here: https://github.com/Day8/re-frame-template and work out. (I'm biased)
Good luck.
Reagent is very nice and by itself very easy to get started with.
That said, I think Om Next is more comparable to Re-frame (https://github.com/Day8/re-frame) as far as being more opinionated about handling data flow.
In that comparison, I don't think it involves any more complex abstractions or deep thought. In both cases, there is some of that, but both cases are also shining examples of explanatory documentation, which to me were edifying to read because they turn those abstractions into concrete implementations, with examples, and explain the deep thought in a clear manner.
In Om Next Quick StartI've read about specter before on its github[1], and I must admit I didn't see the bigger picture that is explained in the opening example of this article.
I thought I could get by with just using:
(-> huge-thing :key1 :key2 first ...)
But now I actually grok the value behind Specter! Great stuff, and I will use it next time I begin up a re-frame[2] app!
[1] https://github.com/nathanmarz/specter
[2] https://github.com/Day8/re-frame/
In Functional-navigational programming in Clojure with SpecterThis may just give you more questions but you might be interested in this: https://github.com/Day8/re-frame
The readme.md is wonderful.
In Introducing Elm to a JavaScript Web AppI've been using reagent with re-frame[1]. Routing just uses goog.events and goog.history to listen for navigation events, secretary[1] to define routes, which update the state rendered by your components. The code is here: https://github.com/Day8/re-frame-template/blob/master/src/le...
[1] https://github.com/Day8/re-frame and https://github.com/Day8/re-frame-template
You'll have to do `lein new re-frame <project> +routes` to pull in the routing template.
[2] https://github.com/gf3/secretary
In React Static SiteRe-Frame: A Reagent Framework for Writing SPAs, in ClojureScript
2 points · Open discussionIf you already know Clojurescript and Reagent reasonably well, I am very taken with re-frame[1] as a UI "framework." The readme is epic, but a great walkthrough of the framework and the reasons behind it. It achieves the same goals as Flux, but because it's cljs things end up being more functional, more powerful, and less verbose. :)
[1] https://github.com/Day8/re-frame
In Modern ClojureScriptI've noticed the f(data) = view paradigm dominate the clojurescript landscape ever since om and reagent[1]. There's also a library that literally uses function calls and parameters for every piece of UI called re-frame[2] (which also has a badass readme).
Using pure functions to compose a UI along with keeping all the data in one place have been a huge win for our project for a few reasons.
1. All it takes to debug what a handler is doing is what effect it has on the DB. Our handler functions are also mostly pure functions which take the current-db as a parameter.
2. We can serialize the state to local storage (or a string) and reload it from local storage (or a string).
3. Using the repl, we can investigate the state of the application while it's running.
[1] http://reagent-project.github.io
[2] https://github.com/Day8/re-frame/
In Pure UIRe-Frame: A Reagent Framework for Writing SPAs, in ClojureScript
3 points · Open discussionSwannodette never disappoints. If you're interested in this approach, you should check out re-frame: https://github.com/Day8/re-frame. The README is a great resource, regardless of whether or not you intend to use the framework.
In Om Next – David Nolen [video]Also such as: https://github.com/Day8/re-frame
In Redux: Atomic Flux with Hot ReloadingYeah, we use re-frame[1]. It's fantastic. I'd say if someone does frontend development at all they should totally read the readme.md for it.[1]
Being able to file away state changes that don't matter in an FRP way has just been an amazing win for our app.
[1] https://github.com/Day8/re-frame/
In Render realtime RethinkDB results in ReactMy take: Facebook are killing it because they are pursuing functional, reactive, declarative designs.
The next step on is to consider using a LANGUAGE that naturally supports this paradigm: Clojurescript or Elm are the obvious choices.
This dreamy utopian future https://speakerdeck.com/chantastic/inline-styles-react-europ... … already exists in both ClojureScript and Elm!! For example, the Reagent library in ClojureScrpt. Is insane popularity imminent?
Shameless plug for an MVC layer: https://github.com/Day8/re-frame
In Facebook Are Killing ItShowing the 15 most recent of 28 sources. Enable JavaScript to search and browse every indexed mention.