SAsammy0910·May 20, 2026
you may be interested in this recent PR https://github.com/clj-kondo/clj-kondo/pull/2840
that supports building macros from source (!)
In 8 Years of Clojureclj-kondo
clj-kondo
Clojure2019–2026
clj-kondo / clj-kondo
clj-kondo
Static analyzer and linter for Clojure code that sparks joy
14Distinct people
27Mentions
0Explicit recommenders
1.9KGitHub stars
What to know before exploring
What it is
Static analyzer and linter for Clojure code that sparks joy
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
- babashka/babashka · linked in 3 of the same discussions
- babashka/sci · linked in 3 of the same discussions
- borkdude/jet · 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, 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 year27 dated mentions
Observed mentions: 2019-03-25 14:44:48 UTC to 2026-05-20 17:00:10 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
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 |
|---|---|---|---|---|---|
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 11 | 6 | 5 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 6 | 1 | 5 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 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 | 4 | 1 | 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 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 0 | 1 |
What Hacker News says
27 sources> There is no way to know what's being passed around without reading the source of the whole chain.
But that's not what a Clojure dev would do.
1) We use Malli [0] (or similar) to check specs and coerce types if needed at every point. Checks can be left on in production (I do), or disable–up to you.
2) If the coercion is difficult, use something like Meander. [1]
3) If even that isn't straightforward and you need actual logic in the loop, use Specter. [2]
4) If you're not sure what going on at intermediate steps, use FlowStorm [3].
5) But you're going to be processing a lot of data you haven't seen before! Use, Malli with test.check [4] and make use of property-based testing with generators.
None of this is "advanced" Clojure, this is bread-and-butter stuff I use every day.
6) Need a Notebook-like experience to get better visualization of
Read the rest
intermediate data? Use Clerk [5].
7) Need special checks on API usage within your codebase? Use clj-kondo [6] with custom linters. They're less than 10 lines each.
Unlike default-mutable languages, or typed, it's safe and easy to use libraries with Clojure and they tend to have very little churn. Total opposite from Python or JavaScript (if you're used to that).
It's almost impossible to give the impression of what it is like to develop with Clojure if you've only ever used languages with static typing, or languages from the Algol family.
Honestly, I hated Clojure's syntax at first BECAUSE I COULDN'T READ IT, and I loathed "structural editing." After 2-3 weeks, I read it just fine and it's hard to remember I ever couldn't do so. Now I like it, and structural editing makes it so easy to change your code, I couldn't live without it at this point.
Basically, all my "fears"/dislikes were unfounded—it was a skill issue on my part, not a problem with Clojure.
[0] https://github.com/metosin/malli
[1] https://github.com/noprompt/meander
[2] https://github.com/redplanetlabs/specter
[3] https://www.flow-storm.org/
[4] https://github.com/clojure/test.check
[5] https://clerk.vision/
[6] https://github.com/clj-kondo/clj-kondo
clojure-lsp and clj-kondo work with any editor and are both excellent.
https://github.com/clojure-lsp/clojure-lsp
https://github.com/clj-kondo/clj-kondo
I've always used (Neo)Vim with Clojure.
In Try ClojureMay I interest you in some unmentioned static analyzer possibilities for Clojure:
https://github.com/clj-kondo/clj-kondo
https://github.com/jonase/eastwood
You seem dissatisfied with Clojure in your day job -- I am sure that there are others that would be happier in your situation.
In Strong static typing, a hill I'm willing to die onclj-kondo helps with catching those types of errors. it works really well
https://github.com/clj-kondo/clj-kondo
In (next Rich)Clj-kondo: a static analyzer and linter for Clojure
3 points · Open discussionSure!
Spec: https://github.com/edn-format/edn
Example (linter config): https://github.com/clj-kondo/clj-kondo/blob/634294183a0aa2ca...
In The Yaml document from hellExamples of Clojure projects that compile to native:
- babashka (https://github.com/babashka/babashka)
- clj-kondo (https://github.com/clj-kondo/clj-kondo)
- jet (https://github.com/borkdude/jet)
SCI (https://github.com/babashka/sci) is a Clojure interpreter that allows you to evaluate Clojure code even inside of the final native binary and is used in all of the above projects.
Feel free to bug me with questions in the graalvm channel on Clojurians Slack.
In GraalVM 22.1: Developer experience improvements, Apple Silicon builds, and morePHP and JavaScript and Python are also dynamically typed the solution isn't yet another incompatible type system, there are so many type systems that don't work together, spec is also turing complete
Turing completeness in a type system allows you to use the type system as a meta coding language which is a fantastic amount of
string to hoist yourself with, putting meta languages inside languages is a miserable place to be
I'd argue that most people just want the language to check for mistakes, clj-kondo is great and effective at doing this
https://github.com/clj-kondo/clj-kondo/blob/master/doc/edito...
If you want types at your system boundaries like on your API then specs or malli is great for that
A great thing that Rich Hickey always advocated is separating out problems and then solving them individually I think modern type systems tr
Read the rest
y and take on too many problems at once, static analysis tools are great because they're uncoupled by time and are laser focused on detecting mistakes only
- Clojure without clj-kondo
- PHP without phpstan/psalm/phan
All bad ideas, modern tooling can detect errors in your code before you finish your code expression, but you do need to go out of your way to setup it up
Most people do not
and then complain about types instead of talking about static analysis
If you are ever coding Clojure you should be following this:
https://github.com/clj-kondo/clj-kondo/blob/master/doc/edito...
In Six years of professional Clojure developmentNowadays, you can get VSCode support for Clojure pretty much out of the box with calva[1] extension working together with clj-kondo [2] almost without any configuration. It works great - I've switched over from Cursive and I'm not looking back.
[1] https://calva.io/
[2] https://github.com/borkdude/clj-kondo/blob/master/doc/editor...
In Ask HN: I want to start learning Lisp. Where do I begin?I had a similar issue with a clj-kondo, a Clojure linter.
https://github.com/borkdude/clj-kondo/issues/1036
The reason of the memory leak was: I used a memoized function on some argument that should be GC-ed after one run, but as memoized functions store their arguments for future comparison, it was kept in memory forever.
In I Tried to Reduce Pylint Memory UsageDisclaimer: Not exactly what you are looking for but very close and might suit your needs or spark your interest anyways.
I've been playing around with datahike[0] a lot recently. It is a Clojure Datalog based DB like Datomic[1] and in fact mimics its API and behavior, but will by default just write to a directory (not a single file last time I checked) and (will?) support other back-ends such as PostgreSQL. Checkout the repo for more information on the differences.
These DBs are not exactly graph DBs (like for example Neo4j) but modelling and (recursively) querying graph data is very much a straight-forward use-case.
Schemas are attribute based rather than record/collection based, so you get the kind of schema flexibility you are used to from graph DBs.
Another interesting fact is that these are 'immutable' or rather value oriented by de
Read the rest
fault. In simple terms: transactions are additions of facts rather than mutations.
Datalog is the primary query language which has really interesting/nice properties. It is worth checking out just for that fact. In Clojure these queries are just normal Clojure data-structures. One of the Clojure linters clj-kondo[2] even ships with static analysis for the soundness of these queries.
[0] https://github.com/replikativ/datahike
[1] https://www.datomic.com/
[2] https://github.com/borkdude/clj-kondo
Clj-kondo: a linter for Clojure code that sparks joy
4 points · Open discussionConsistency in Clojure comes mainly from things like:
FP is the default idiom, state is very isolated and explicit.
The language is dead simple and often declarative.
The way you write Clojure programs is by attaching a REPL to your editor and by evaluating expressions in isolation. And you'll be running a linter like clj-kondo[1]. This has a similar effect as running a type checker (and it in fact does catch a lot of things that a type checker does).
Clojure spec can express much more than most (mainstream) type systems, is itself introspective and can be used for generative testing.
First class support for names: Keywords are not explicitly attached to their containers/data-structures but can be optionally be attached to namespaces and specs. This means a lot of problems that arise when changing code are simply avoided in Clojure. They
Read the rest
still carry around the semantics and consistency you gave them, regardless of where they are used.
I've been working on a side project since about a year now and I can't remember when I last had a type error.
[1] https://github.com/borkdude/clj-kondo
Showing the 15 most recent of 27 sources. Enable JavaScript to search and browse every indexed mention.