Clojure is a very pleasant language to develop in. I have found it easier to develop a JavaFX-UI program in Clojure than in Java.
If you want to go the route of running a server on the user's machine and serving it through the user's browser, ClojureScript and Reagent/Re-Frame are excellent choices. Re-Frame, https://github.com/Day8/re-frame, in particular has very nice documentation.
Clojure lets you use anything in the Java universe while ClojureScript gives you access to all the JavaScript stuff, including Node.
There is a lot of tutorial information for both languages.
In Ask HN: How to do cross platform GUI?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, 10:01:16 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
12 sourcesRe-frame is a layer on top of reagent, which is an API for using React in cljs. If you want to use react, you can also just directly use reagent which is the preference of many in the community. The boilerplate and verbosity required for reframe could be overkill for many small projects, especially for solo developers, where pure reagent often thrives. However reframe’s restrictions can be helpful in team environments.
The library github page is an entertaining display of equal parts vanity and hyperbole: https://github.com/day8/re-frame/
In Re-Frame: Build web apps in ClojureScript and ReactIt's weird how in the JS community rewrites of react are common in the CLJS community using React as a runtime is more common:
- https://reagent-project.github.io/
- https://github.com/day8/re-frame
- https://github.com/tonsky/rum
And my favourite
- https://github.com/fulcrologic/fulcro
Hosting your work on top of another ecosystem, such that you can still use the underlying ecosystem, gives you a lot of leverage out the gate
In Show HN: Noact – React-like Virtual DOM library in 70 lines of TypeScriptI kind of know where you are coming from. 'Back in the day', early Clojure adopters would ask one to read SICP before asking questions. SICP is indeed the best CS book I have read but that attitude was uncalled for.
But things have changed. Clojure and Clojurescript community is among the most helpful and Stackoverflow questions are promptly answered. If you take the time , like I did, you will find that Clojurescript has awesome tooling. Go though the tutorial on Figwheel.main (https://figwheel.org/docs/ ) and then check out re-frame TodoMVC here https://github.com/day8/re-frame/tree/master/examples/todomv... or this simpler reframe tutorial from here https://opengisgal.wordpress.com/2018/05/19/re-frame-clojure... . And this here is the Reagent cookbook https://github.com/reagent-project/reagent-cookbook . Good Luck!
In A History of Clojure [pdf]Sounds a lot like re-frame[1] (which I believe predates Redux), they even call the state "atoms."
[1] https://github.com/Day8/re-frame
In Recoil – A state management library for ReactWe just re-evaluated our choices and selected Fulcro. Below is a slightly edited version of how we came to this conclusion.
As a business building an extremely ambitious product on a tight budget, we
want to be able to:
* Focus as much time and thought on building features that bring value to our
customers, rather than, for example, building a bespoke protocol between the
browser and back-end if a better alternative is available.
* Share early iterations of our application with everyone in our organization
easily. Capture feedback and push out new iterations quickly.
* Be able to support new customers immediately. Our feature road-map will
always be in constant flux, but at no point should our ability to make
changes with confidence be compromised. In addition to feature development,
tests and automation must be priorities. Ou
Read the rest
r development and production
environments must match.
* Be ready to onboard new team members. "Works on my laptop" is never
acceptable. Enough of our application must be documented and automated so
that anyone with a technical background "reasonably proficient" in our work
can contribute without requiring hand-holding. Or course, we'd never turn
down a request for help.
Our requirements are:
* Clojure, Clojurescript, and Datomic are immutable choices. We love these
solutions for their simplicity and expressiveness. We believe these are the
best choices available for achieving our long-term business goals.
* Be measurable. Our work should be guided by data not guesswork.
* Be testable. The entire application should have 100% test coverage as
measured by its acceptance or integration tests (not unit tests). Changes
should be made with confidence.
* Be performant. As builders of both the front-end and back-end components, we
should encourage cooperation between them, not purposefully isolate
them. Our customers and the end-user experience should be our priorities,
not artificial divisions between software components or technical teams.
Each component of the application should cooperate to support progressive
enhancement where every URL is a real URL that, when requested, returns a
server-side rendered page view. Further actions by the user result in
browser-side changes through API calls and minimal component updates.
* Be pragmatic. We should be eager to innovate when the need arises. However,
we should be humble enough to understand that sometimes, as software
developers, we can become enamored with new toys that are entertaining, and
possibly educational, but offer little business value. We should choose
existing solutions to our problems that are acceptable enough over building
our own solutions simply because we want to. For example, a standards-based
protocol, like https://github.com/edn-query-language/eql, that allows
clients to craft their own queries with little to no server-side updates is
preferable to our current bespoke solution.
* Be documented and supported. Our choices should have active, helpful, and
inclusive development communities built around them.
Our choices are:
* Rum, https://github.com/tonsky/rum
Rum is a solid piece of software, created and maintained by @tonsky, that
provides a minimal wrapper around react for creating client-side components,
and supports server-side rendering. Although rum does not provide a protocol
between client and server, nor a client component state-management solution.
* Reagent, https://github.com/reagent-project/reagent
Together with Re-frame, https://github.com/Day8/re-frame, this is by far the
most popular choice for building reactive client components in
Clojurescript. These do not include the server-side solutions we need.
* Hoplon, http://hoplon.io
Hoplon was created in-house at AdZerk, and later spun-out as an open source
project. Hoplon is a complete solution although it uses a less intuitive
spreadsheet-like method for building applications with little obvious
advantage, and would not be compatible with Datomic without considerable
effort.
* Luminus, https://luminusweb.com
Luminus is a complete solution like Ruby-on-Rails, and is tightly coupled to
SQL. Like Hoplon, Luminus would not be compatible with Datomic without
considerable effort.
* Pedestal, http://pedestal.io
Pedestal is supported by Cognitect, the custodians of Clojure and the
creators of Datomic. Except Pedestal is best suited for building server-side
APIs, and applications that need to stream data in "near real-time" to large
numbers of concurrently connected clients.
* Fulcro, https://fulcro.fulcrologic.com/
Fulcro is based on Om.Next, provides both front-end and back-end components
that work well together, includes tools for building and debugging both,
supports server-side rendering, and is supported by a diverse
community. Paid commercial support is provided by the core developer team at
Fulcro Logic.
* Datomic Cloud, https://www.datomic.com
Datomic Cloud is a special version of the Datomic database that is tightly
integrated with AWS. Datomic Cloud includes a set of Cloud Formation
templates for running Datomic in AWS, and taking advantage of AWS specific
features, such as auto-scaling groups and load-balancers for distributing
traffic across a cluster of Datomic peers. Datomic Cloud also includes Ions,
https://docs.datomic.com/cloud/ions/ions.html, to help run Clojure functions
as AWS Lambdas. Cognitech claims Datomic Cloud is a suitable framework for
building complete applications. Unfortunately Datomic Cloud alone is
insufficient. Datomic Cloud lacks a framework for building and testing
client-side applications, and a protocol for interacting with Ions.
"Reagent is the recommended approach for building ClojureScript applications with Luminus."
Reagent is nice, but if you want global state management, re-frame adds most familiar concepts from redux but without as much boilerplate: https://github.com/day8/re-frame
In Luminus – A Clojure Web FrameworkYou may want to have a look at how re-frame[0] (ClojureScript) does this or redux-toolkit[1]. The issues you mention are discussed there and solved well.
There is a controller in the sense you are describing, but the reads and writes are clearly decoupled as separate, functional steps, while the data is just a plain composition of maps and lists.
Putting these operations into classes is a regression from this point of view. You suddenly get these artificial objects (models) that get harder to extend, reuse and change, because you have relations between objects that you somehow need to model and synchronize as well.
Imagine if databases worked this way. Gladly they don't. They have a uniform, declarative language that you use to interact with them and the data is just data, no matter if it is a Person, Cat or w/e.
So in a sense these libra
Read the rest
ries are re-inventing databases to handle GUI state in the browser, which is a good thing.
[0] https://github.com/Day8/re-frame
[1] https://redux-toolkit.js.org/
Overwhelmingly positive. There've been rough edges, and the learning curve is rather steep – especially if you haven't used Clojure before – but it's worth it.
Re-frame [0] in particular has been a joy to use; I've developed a few large apps in it and they've been quite easy to maintain.
[0]: https://github.com/day8/re-frame/
In Show HN: Word Champions, a word game written in ClojureScriptYou use a global db atom in re-frame for global state, but there's nothing stopping you from using a reagent atom local to a component, is there?
I never thought of the existence of the global db as the thing that ALL state should go in., or is that a community best practice?
Edit: after digging through the re-frame docs themselves, you can see here that local reagent atoms are used for local state even with the global app db: https://github.com/day8/re-frame/blob/69a3fcd411369fff65404e...
In Things I wish I knew about state management when I started writing React appsFor more complex state handling in SPAs (subscription, event handling) re-frame is a really great framework based on reagent/cljs.
https://github.com/day8/re-frame
In Things I wish I knew about state management when I started writing React appsI can't help thinking of this excerpt from re-frame's docs:
> Now, you think and design abstractly for a living, and that repetition will feel uncomfortable. It will call to you like a Siren: "refaaaaactoooor meeeee". "Maaaake it DRYYYY". So here's my tip: tie yourself to the mast and sail on. That repetition is good. It is serving a purpose. Just sail on.
https://github.com/Day8/re-frame/blob/master/docs/Subscripti...
In Goodbye, Clean Code