I think that in most cases jq is launched to extract value from relatively small JSON document, for which raw parsing speed is not affect much. jq is just really slow to start. Version 1.6 was especially abysmally slow to start, 10x times slower than 1.5:
https://github.com/jqlang/jq/issues/1826
So any replacement candidate should also benchmark like hyperfine "jq .a <<< '{"a": 10 }'" . This oneliner does not work but should illustrate the idea.
Also please just use jshon if you need to just extract specific value from some small JSON. jshon uses way less resources by any conceivable metric.
In A Faster Alternative to Jqjqlang
jq
C2012–2026
jqlang / jq
jq
Command-line JSON processor
79Distinct people
104Mentions
2Explicit recommenders
36.1KGitHub stars
What to know before exploring
What it is
Command-line JSON processor
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
I highly recommend anyone to look at jq's VM implementation some time, it's kind of mind-blowing how it works under the hood:…
bouk used a recommendation phrase. 2 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
- asciinema/asciinema · linked in 3 of the same discussions
- burntsushi/ripgrep · linked in 3 of the same discussions
- dbcli/pgcli · 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, 3:56:07 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 year104 dated mentions
Observed mentions: 2012-10-21 17:50:32 UTC to 2026-03-29 02:02:20 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 |
|---|---|---|---|---|---|
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 2 | 1 | 1 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 12 | 0 | 12 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 7 | 0 | 7 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 9 | 0 | 9 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 8 | 3 | 5 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 14 | 3 | 11 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 25 | 5 | 20 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 11 | 0 | 11 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 8 | 2 | 6 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 2 | 0 | 2 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
jq
jq is a lightweight and flexible command-line JSON processor akin to sed,awk,grep, and friends for JSON data. It's written in portable C and has zero runtime dependencies, allowing you to easily slice, filter, map, and transform structured data.
Documentation
Official Documentation: jqlang.org
Try jq Online: play.jqlang.org
Installation
Prebuilt Binaries
Download the latest releases from the GitHub release page.
The platform-specific assets are standalone executables, not archives. On macOS and Linux,
rename the downloaded file to jq and make it executable with chmod +x jq.
Docker Image
Pull the jq image to start quickly with Docker.
Run with Docker
Example: Extracting the version from a package.json file
docker run --rm -i ghcr.io/jqlang/jq:latest < package.json '.version'
Example: Extracting the version from a package.json file with a mounted volume
docker run --rm -i -v "$PWD:$PWD" -w "$PWD" ghcr.io/jqlang/jq:latest '.version' package.json
Building from source
Dependencies
libtool
make
automake
autoconf
Instructions
git submodule update --init # if building from git to get oniguruma
autoreconf -i # if building from git
./configure --with-oniguruma=builtin
make clean # if upgrading from a version previously built from source
make -j8
make check
sudo make install
sudo ldconfig # on Linux, if jq cannot find libjq.so
Build a statically linked version:
make clean
make LDFLAGS=-all-static
If you're not using the latest git version but instead building a released tarball (available on the release page), skip the autoreconf step, and flex or bison won't be needed.
Cross-Compilation
For details on cross-compilation, check out the GitHub Actions file and the cross-compilation wiki page.
Community & Support
Questions & Help: Stack Overflow (jq tag)
Chat & Community: Join us on Discord
Wiki & Advanced Topics: Explore the Wiki
License
jq is released under the MIT License. jq's documentation is
licensed under the Creative Commons CC BY 3.0.
jq uses parts of the open source C library "decNumber", which is distributed
under ICU License
Read the full README on GitHubWhat Hacker News says
104 sourcesI highly recommend anyone to look at jq's VM implementation some time, it's kind of mind-blowing how it works under the hood: https://github.com/jqlang/jq/blob/master/src/execute.c
It does some kind of stack forking which is what allows its funky syntax
In A Faster Alternative to JqGot a bit nerd-sniped here, but first of all we can reduce if A then B else . end === if A then B end since jq 1.7:
jq 'walk(if type == "array" then (if length > 0 then [.[0]] end) end)'
Now we could contract those conditionals:
jq 'walk(if type == "array" and length > 0 then [.[0]] end)'
but it turns out we can even more usefully express if length > 0 then [.[0]] end === [limit(1; .[])] == .[:1]:
jq 'walk(if type == "array" then .[:1] end)'
From here, we can golf it a little further (this is kind of a generic type-matching pattern):
jq 'walk(arrays[:1] // .)'
although this does incur a bit more overhead than checking type directly.
Speaking of overhead, though, it turns out that the implementation of walk/1 (https://github.com/jqlang/jq/blob/master/src/builtin.jq#L212) will actually run the filter on every element of
Read the rest
an array, even though we're about to throw most of them out, which we can eliminate by writing the recursion explicitly:
jq 'def w: if type=="array" then [limit(1; .[]|w)] elif type=="object" then .[] |= w end; w'
which gets the operation down from ~200 ms on my machine (not long enough to really get distracted, but enough to feel the wait) to a perceptually instant ~40 ms (which is mostly just the cost of reading the input). Now we can golf it down a little more:
jq 'def w: if type=="array" then [limit(1; .[]|w)] else objects[] |= w end; w'
jq 'def w: (arrays[:1]|map(w)) // (objects[] |= w); w'
(the precedence here actually allows us to eliminate the parens here...)
jq 'def w: arrays |= .[:1]|iterables[] |= w; w'
And, inaccessibility of the syntax aside, I think this does an incredible job of expressing the essence of what we're trying to do: we trim any array down to its first element, and then recursively apply the same transformation throughout the structure. jq is a very expressive language, it just looks like line noise...
Oh, fantastic. jq has become an integral part of work for me.
I'll use this opportunity to plug the one-liner I use all the time, which summarizes the "structure" of a doc in a jq-able way: https://github.com/stedolan/jq/issues/243#issuecomment-48470... (I didn't write it, I'm just a happy user)
For example:
$ curl -s 'https://ip-ranges.amazonaws.com/ip-ranges.json' | jq -r '[path(..)|map(if type=="number" then "[]" else tostring end)|join(".")|split(".[]")|join("[]")]|unique|map("."+.)|.[]'
.
.createDate
.ipv6_prefixes
.ipv6_prefixes[]
.ipv6_prefixes[].ipv6_prefix
.ipv6_prefixes[].network_border_group
.ipv6_prefixes[].region
.ipv6_prefixes[].service
.prefixes
.prefixes[]
.prefixes[].ip_prefix
.prefixes[].network_border_group
.prefixes[].region
.prefixes[].service
.syncToken
Read the rest
(except I have it aliased to "jq-structure" locally of course. also, if there's a new fancy way to do this, I'm all ears; I've been using this alias for like... almost a decade now :/)
In the spirit of trying out jqfmt, let's see how it formats that one-liner...
~ echo '[path(..)|map(if type=="number" then "[]" else tostring end)|join(".")|split(".[]")|join("[]")]|unique|map("."+.)|.[]' | ~/go/bin/jqfmt -ob -ar -op pipe
[
path(..) |
map(if type == "number" then "[]" else tostring end) |
join(".") |
split(".[]") |
join("[]")
] |
unique |
map("." + .) |
.[]%
~
Not bad! Shame that jqfmt doesn't output a newline at the end, though. The errant `%` is zsh's partial line marker. Also, `-ob -ar -op pipe` seems like a pretty good set of defaults to me - I would prefer that over it (seemingly?) not doing anything with no flags. (At least for this sample snippet.)
I came up with a scheme a number of years ago that takes advantage of the illegality of overlong encodings [0].
Obviously UTF-8 has 256 code units (<00> to <FF>). 128 of them are always valid within a UTF-8 string (ASCII, <00> to <7F>), leaving 128 code units that could be invalid within a UTF-8 string (<80> to <FF>).
There also happen to be exactly 128 2-byte overlong representations (overlong representations of ASCII characters).
Basically, any byte in some input that can't be interpreted as valid UTF-8 can be replaced with a 2-byte overlong representation. This can be used as an extension of WTF-8 so that UTF-16 and UTF-8 errors can both be stored in the same stream. I called the encoding WTF-8b [2], though I'd be interested to know if someone else has come up with the same scheme.
This should technically be "fine" WRT Unicode text pro
Read the rest
cessing, since it involves transforming invalid Unicode into other invalid Unicode. This principle is already used by WTF-8.
I used it to improve preservation of invalid Unicode (ie, random 8-bit data in UTF-8 text or random 16-bit data in JSON strings) in jq, though I suspect the PR [1] won't be accepted. I still find the changes very useful personally, so maybe I'll come up with a different approach some time.
[0] https://github.com/Maxdamantus/jq/blob/911d01aaa5bd33137fadf...
[1] https://github.com/jqlang/jq/pull/2314
[2] I think I used the name "WTF-8b" as an allusion to UTF-8b/surrogateescape/PEP-383 which also encodes ill-formed UTF-8, though UTF-8b is less efficient storage-wise and is not compatible with WTF-8.
The XSL:T equivalent for JSON is jq
https://github.com/jqlang/jq
Learn it. It is insanely useful for mungling json in day to day work.
In XSLT – Native, zero-config build system for the WebHi HN, we ran jq (github.com/jqlang/jq) through our static analysis tool.
It's a fantastic, mature project (13 yrs, 230+ authors, Grade A avg. complexity). However, we found some serious concerns: multiple potential buffer overflows (Red Flags in 9 core files), path traversal issues, and a very low test health score (2.9/100).
Given its widespread use, these findings are pretty significant for anyone relying on it, especially in production pipelines. Full breakdown and data in the post. Curious about your thoughts/experiences.
In Analysis of Jq: Strengths, Critical Security Risks, and 2.9% Test Coverage> in pure Bash.
Not really in "pure bash". Also this needs to be labeled as a "toy".
Using an external tool like 'jq' especially written in C for parsing JSON, one can craft a exploitable JSON input to achieve code execution on the MCP server.
What could possibly go wrong? Maybe this CVE-2025-48060 [0] [1]?
[0] https://github.com/jqlang/jq/issues/3327
[1] https://nvd.nist.gov/vuln/detail/CVE-2025-48060
In Show HN: MCP Server SDK in BashI hope you enjoy it! I sure did. If you enjoy it, you might also enjoy jq (https://github.com/jqlang/jq), which is also a sort of logic programming language (in that it has pervasive generators and backtracking). Icon has an Algol family syntax, while jq is more... Haskell-ish? in a way if you squint hard? Whereas Prolog is a pile of rules. These differences are very interesting. Verse is another language in this vein, and it seems very interesting as well.
Oh, and yesterday's HN thread about Rama is very interesting as well: https://news.ycombinator.com/item?id=41833629
In Can logic programming be liberated from predicates and backtracking? [pdf]In this case, the best tool for the job is the one that will let you:
1. Continue to easily iterate on the solution now and in the future (compiled languages have a built-in hinderance, in that you never know when a given binary corresponds to some state of the source tree)
2. Allow you to trivially talk to inotify/ReadDirectoryChangesW /FSEvents/kqueue/etc so that you only need to read the file when it actually changes
3. Minimise maintenance (installing third-party headers/libraries, setting up a project, etc etc)
I think the answer here is the shell, fswatch, and jq.
https://github.com/emcrisostomo/fswatch https://github.com/jqlang/jq http://man.openbsd.org/sh
In It is never too late to write your own C/C++ command-line utilitiesIncorrect: https://git-scm.com/docs/git-describe#Documentation/git-desc...
> If the working tree has local modification "-dirty" is appended to it.
and one can see their invocation of --dirty here: https://github.com/jqlang/jq/blob/cff5336ec71b6fee396a95bb0e...
In macOS Sequoia is available todayI can't know what "-dirty" implies, but https://github.com/jqlang/jq/commit/cff5336 is a pretty random commit from 2022 :-(
https://github.com/apple-oss-distributions/distribution-macO... hasn't been updated with a "jq" directory yet
In macOS Sequoia is available today> Oh oh, jq has bugs..., I hope you reported them. I wondered more than once whether I could trust the results of my jq invocations.
Yes report, and i'm one of the jq maintainers now a days :) and i think you can trust the result if your doing common things. The bugs i've encountered have usually been in exotic parts, ex https://github.com/jqlang/jq/issues/3128
In Jqjq: Jq Implementation of JqShowing the 15 most recent of 104 sources. Enable JavaScript to search and browse every indexed mention.