HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
bhauman
lein-figwheel
Clojure2014–2022
bhauman / lein-figwheel

lein-figwheel

Figwheel builds your ClojureScript code and hot loads it into the browser as you are coding!

18Distinct people
20Mentions
0Explicit recommenders
2.9KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Figwheel builds your ClojureScript code and hot loads it into the browser as you are coding!

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these 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, 5:04:57 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 year20 dated mentions

Observed mentions: 2014-11-03 23:01:00 UTC to 2022-07-30 21:00:34 UTC.

02462014-01-01 00:00:00 UTC to 2015-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments20142015-01-01 00:00:00 UTC to 2016-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments2016-01-01 00:00:00 UTC to 2017-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2017-01-01 00:00:00 UTC to 2018-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20182019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 1 mentions; 1 submissions, 0 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2022

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20142014-01-01 00:00:00 UTC2015-01-01 00:00:00 UTC101
20152015-01-01 00:00:00 UTC2016-01-01 00:00:00 UTC707
20162016-01-01 00:00:00 UTC2017-01-01 00:00:00 UTC202
20172017-01-01 00:00:00 UTC2018-01-01 00:00:00 UTC404
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC303
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC110
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC101
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC000
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC101

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
lein-figwheel Figwheel builds your ClojureScript code and hot loads it into the browser as you are coding! A new Figwheel!! There is a new Figwheel in town! Figwheel Main is a complete re-write of Figwheel and represents the latest and greatest version of Figwheel. It works great with Leiningen or the new Clojure CLI Tools. So head over to Figwheel Main to give it a try. lein-figwheel Get a quick idea of what figwheel does by watching the 6 minute flappy bird demo of figwheel. Learn even more by watching a 45 minute talk on Figwheel given at ClojureWest 2015. Read the introductory blog post. Support Figwheel If Figwheel has fundamentally redefined the way you do front-end work please take a moment and support it: Donated so far:     2015: $73     2016: $2752     2017(through October): $1979 Current version: Features Live code reloading If you write reloadable code, figwheel can facilitate automated live interactive programming. Every time you save your ClojureScript source file, the changes are sent to the browser so that you can see the effects of modifying your code in real time. Supports Node.js You can use figwheel to live code ClojureScript in Node.js! Static file server The inclusion of a static file server allows you to get a decent ClojureScript development environment up and running quickly. For convenience there is a :ring-handler option so you can load a ring handler into the figwheel server. Live CSS reloading Figwheel will reload your CSS live as well. Live JavaScript reloading Figwheel can live reload your JavaScript source files. Heads up display Figwheel has a non-intrusive heads up display that gives you feedback on how well your project is compiling. By writing a shell script you can click on files in the heads up display and they will open in your editor! Descriptive Errors with Code Context Figwheel provides descriptive compiler errors that point to where the error is in your code. These errors appear in the REPL as well as the heads up display. First Class Configuration Error Reporting It can be quite daunting, when you are configuring a tool for the first time. Figwheel currently offers best-of-class configuration error reporting that will help you if you happen to misconfigure something. Built-in ClojureScript REPL When you launch Figwheel it not only starts a live building/reloading process but it also optionally launches a CLJS REPL into your running application. This REPL shares compilation information with the figwheel builder, so as you change your code the REPL is also aware of the code changes. The REPL also has some special built-in control functions that allow you to control the auto-building process and execute various build tasks without having to stop and rerun lein-figwheel. Robust connection Figwheel's connection is fairly robust. I have experienced figwheel sessions that have lasted for days through multiple OS sleeps. You can also use figwheel like a REPL if you are OK with using print to output the evaluation results to the browser console. Message broadcast Figwheel broadcasts changes to all connected clients. This means you can see code and CSS changes take place in real time on your phone and in your laptop browser simultaneously. Respects dependencies Figwheel will not load a file that has not been required. It will also respond well to new requirements and dependency tree changes. Calculates minimal reload set Figwheel does its best to only reload what needs to be reloaded. This minimizes the surface area of dynamically reloaded code, which in turn should increase the stability of the client environment. Doesn't load code that is generating warnings If your ClojureScript code is generating compiler warnings Figwheel won't load it. This, again, is very helpful in keeping the client environment stable. This behavior is optional and can be turned off. Try Figwheel Make sure you have the latest version of leiningen installed. You can try figwheel out quickly with the flappy bird demo: git clone https://github.com/bhauman/flappy-bird-demo.git then cd into flappy-bird-demo and type lein figwheel You can now goto localhost:3449/index.html and open up src/flappy_bird_demo/core.cljs with your favorite editor and start coding. Make sure you open your browser's development console so you can get feedback about code reloads. If you would prefer to greenfield a new project you can use the figwheel leiningen template. lein new figwheel hello-world Or optionally: lein new figwheel hello-world -- --om ;; for an om based project lein new figwheel hello-world -- --reagent ;; for a reagent based project Learning ClojureScript If you are brand new to ClojureScript it is highly recommended that you do the ClojureScript Quick Start first. If you skip this you will probably suffer. There is a lot to learn when you are first learning ClojureScript, I recommend that you bite off very small pieces at first. Smaller bites than you would take when learning other languages like JavaScript and Ruby. Please don't invest too much time trying to set up a sweet development environment, there is a diverse set of tools that is constantly in flux and it's very difficult to suss out which ones will actually help you. If you spend a lot of time evaluating all these options it can become very frustrating. If you wait a while, and use simple tools you will have much more fun actually using the language itself. Quick Start If you are new to Figwheel here is a Quick Start tutorial. Working through this Quick Start will probably save you a tremendous amount of time. Getting Help You can get help at both the ClojureScript Google Group and on the #clojurescript, #lein-figwheel and #beginners Clojurians Slack Channels Usage Make sure you have the latest version of leiningen installed. Then include the following :dependencies in your project.clj file. [org.clojure/clojure "1.9.0"] [org.clojure/clojurescript "1.10.238"] Then include lein-figwheel in the :plugins s
Read the full README on GitHub

What Hacker News says

20 sources
> When revisiting old projects I have seen countless of Clojure dependencies having died in the meantime. I have replaced utility libraries with more recent utility libraries sometimes several times. Very annoying. Yes, the "best in class" libraries change every few years in Clojure's universe, but they always bring huge improvements that require completely new APIs. For instance: https://github.com/plumatic/schema -> https://github.com/metosin/malli https://github.com/juxt/bidi -> https://github.com/metosin/reitit https://github.com/bhauman/lein-figwheel -> https://github.com/thheller/shadow-cljs https://github.com/stuartsierra/component -> https://github.com/weavejester/integrant https://github.com/technomancy/leiningen -> https://github.com/practicalli/clojure-deps-edn > So overall Clojure is in a strange situation. For picking it up o
Read the rest
n-the-job its not the responsible choice probably for most situations I work in. For my private tinkering the JVM dependency feels just a little too heavyweight. I don't see that Clojure will hit an inflection point of adoption in any way in the future that would make it a viable candidate for me to use at work. I think about programming languages as tools for different bottlenecks. – Computational: Rust – Networking: Go – Business logic: Clojure / Python And for many people Python has everything that Clojure is missing: a very low barrier to enter, and a very stable and well-documented ecosystem of frameworks and libraries.
In Clojure needs a Rails
> If somebody knows other languages/systems that do let me know. Clojure can do this via namespace live reload. ClojureScript is already doing this inside figwheel [1] environment. CommonLisp had this since dawn of time. Kawa [2] can do it, but because it aggressively optimize the code, you need to be careful. Racket can do it as well [3]. [1] https://github.com/bhauman/lein-figwheel [2] https://www.gnu.org/software/kawa/ [3] https://github.com/tonyg/racket-reloadable/tree/master#readm... EDIT: added Kawa and Racket.
In Hot-swapping Python 3 code
The beauty of ClojureScript is that you don't have to recompile and reload your page all the time. Development is done using Figwheel https://github.com/bhauman/lein-figwheel and things reload live in the browser as you change the core in the editor. Not only don't you need to wait for recompilation, you don't even have to reload the page to see the changes. Everything happens interactively as you're writing the code.
In ClojureScript is the most-used functional language that compiles to JavaScript
Well, the CLJS->JS side of story is very polished, Figwheel [1] makes things work smoothly (in-browser errors and warnings, sourcemaps, hot reload all work from the box). You can check out [2] if you are interested. There are two areas that still can be improved in my opinion: * the asset story. Right now I use a gulp task that prepares my assets and outputs CSS into a folder known to Figwheel, which makes hotreloading work automagically. However, if you need a complicated interaction between JS, HTML and CSS (i.e. you use CSS Modules), it can be a bit more involved. * the NPM deps story. AFAIK it's gonna be solved in CLJS core soon, but right now your best bet is to pack all NPM deps using native JS tool (webpack, rollup or w/e) into one file and include it before CLJS-generated JS code. Ah, and in some cases you will need externs, too.
Read the rest
It's actually way less complicated then it sounds, and if you need any help, feel free to reach me through mail (my nickname here at gmail.com). I would be happy to help. [1]: https://github.com/bhauman/lein-figwheel [2]: https://www.youtube.com/watch?v=KZjFVdU8VLI
In Re-Frame: a Reagent Framework for Writing SPAs, in ClojureScript
here is my experience: - creating a project from scratch is easy: lein new reagent-frontend my-project. it creates a project from reagent-frontend template. you can build your app with lein cljsbuild auto or build a production build with lein release. - build time significantly drops, even with advanced optimizations, comparing to webpack. - both component and app state management becomes a lot easier thanks to reagent atoms. - not much of a big deal but hiccup templates make inline styling easier. - you get figwheel! [0] [1] [0] https://github.com/bhauman/lein-figwheel/ [1] https://www.youtube.com/watch?v=j-kj2qwJa_E
In A deep dive into ClojureScript reagent
Start with Figwheel[1] to enable hot-loading code and live reloading: lein new figwheel <app-name> I have used Reagent[2] since I'm only doing prototypes and don't have to worry about production quality. Om/Om Next[3] seems like it would be worth checking out since it does a bunch of clever things that Reagent doesn't. Reagent is very straightforward and therefore might be the better starting point, seeing as you're just starting out. Like the sibling comment pointed out, Reagent uses Hiccup-style data structures to represent HTML. Om can be configured to do the same, but doesn't out of the box last time I checked. Either way, the Hiccup syntax looks like this: [:div [:h1 "Hello world"]] It's just regular arrays with symbols, strings and what-have-you, meaning you can construct them using standard Clojure functions in any way you se
Read the rest
e fit. Add either Reagent or Om to your project.clj, and off you go. [1]: https://github.com/bhauman/lein-figwheel [2]: https://github.com/reagent-project/reagent [3]: https://github.com/omcljs/om
In Why we chose Vue.js over React
We have a good sized clojurescript SPA in production, and it has been a real joy to work with. We are using Reagent, which when coupled with FigWheel[0] goes a long way toward mitigating slow startup, as well as "tooling" issues in general. The live reloading is a fantastic experience. Sourcemaps have been a big help for debugging in general, though we have had several instances of bugs taking a bit of effort to get to the bottom of because of some deep javascript stacktraces -- for the most part the java side of the compiler hasn't been a big deal. Many of these have been type related bugs, so we're looking into adding some schemas[1] going forward where it seems appropriate. Despite those issues, it has overall been a huge productivity boost. We've also witnessed this story only improving with time. The community truly is fantastic
Read the rest
. Lots of very smart, friendly folks doing interesting things. [0] https://github.com/bhauman/lein-figwheel [1] https://github.com/Prismatic/schema
In What Holds Me Back from ClojureScript
Oh definitely think the prediction is absurd. I didn't realize it wasn't obvious from my post. The problem I outline is not that static typing involves additional boilerplate. It's the inherent additional cognitive load it introduces. A smarter compiler isn't going to help you there. The fallacy of Elben's argument is in the assumption that there will be only advances in the field of static typing. Meanwhile, people working with dynamic languages are improving their tools at an astonishing pace. For example, working with an editor like Cursive provides many refactoring options you could only expect from a static language a few years ago. The biggest benefit though comes from interactivity though. Dynamic languages lend themselves extremely well to providing live coding environments. This allows for tools like the REPL and things like Figw
Read the rest
heel https://github.com/bhauman/lein-figwheel and this kind workflow will be difficult to match for static languages.
In The sky is not falling – about the supposed end of dynamic languages
I was mostly referring to development paradigms and methodology in my original post, but in terms of tooling, I personally haven't see any tooling on the native side even approach the increased productivity provided by the instantaneous feedback loops that countless hot-reload implementations can offer for the web. https://github.com/gaearon/babel-plugin-react-transform/ http://gaearon.github.io/react-hot-loader/ https://github.com/bhauman/lein-figwheel
In React Native for Android

Showing the 15 most recent of 20 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.