What next? Job control signals?? :) (EDIT: How about tmux?)
Anyways, this is fantastic. Finally, proper ssh functionality!
This will encourage development of console (text-oriented) apps for Windows, which I hope will be much simpler. Interfacing with the console can be really difficult if you're coming from *nix. Ideally all the WIN32-specific code in, e.g., jq[0], could be ripped out.
[0] https://github.com/stedolan/jq (look in src/main.c)
In Introducing the Windows Pseudo Console (ConPty)jqlang
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 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 6:59:22 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
12 sourcesSupport for the necessary recording is available since version 2.0.0.
This can be done via jq [0]. See the simple script [1] I made. It relies on things like tab-expansion yielding the same results, so beware.
[0]: https://github.com/stedolan/jq
[1]: https://0x0.st/sj0G.txt (License: AGPLv3, credit to my handle)
In Asciinema – Record and share your terminal sessionsFormatting:
Written in Rust
- fd: A simple, fast and user-friendly alternative to 'find'
https://github.com/sharkdp/fd
- ripgrep: ripgrep recursively searches directories for a regex pattern
https://github.com/BurntSushi/ripgrep
- exa: Replacement for 'ls' written in Rust
https://github.com/ogham/exa
- bat: A 'cat' replacement. I recommend following the customizations.
https://github.com/sharkdp/bat
Written in Python
- asciinema: Terminal session recorder
https://github.com/asciinema/asciinema
- httpie: Modern command line HTTP client
https://github.com/jakubroztocil/httpie
- visidata: A terminal spreadsheet multitool for discovering and arranging data
https://github.com/saulpw/visidata
- youtube-dl: Command-line program to download videos from YouTube.com and other video sites
https://github.com/rg3/youtu
Read the rest
be-dl
- pgcli: Postgres cli with autocomplete and syntax highlighting
https://github.com/dbcli/pgcli
Written in C
- jq: Command-line JSON processor
https://github.com/stedolan/jq
- tmux: a terminal multiplexer
https://github.com/tmux/tmux
- pspg: postgres pager (you can combine it with pgcli)
https://github.com/okbob/pspg
reply
Written in Rust:
- fd: A simple, fast and user-friendly alternative to 'find'
https://github.com/sharkdp/fd
- ripgrep: ripgrep recursively searches directories for a regex pattern
https://github.com/BurntSushi/ripgrep
- exa: Replacement for 'ls' written in Rust
https://github.com/ogham/exa
- bat: A 'cat' replacement. I recommend following the customizations.
https://github.com/sharkdp/bat
Written in Python:
- asciinema: Terminal session recorder
https://github.com/asciinema/asciinema
- httpie: Modern command line HTTP client
https://github.com/jakubroztocil/httpie
- visidata: A terminal spreadsheet multitool for discovering and arranging data
https://github.com/saulpw/visidata
- youtube-dl: Command-line program to download videos from YouTube.com and other video sites
Read the rest
https://github.com/rg3/youtube-dl
- pgcli: Postgres cli with autocomplete and syntax highlighting
https://github.com/dbcli/pgcli
Written in C
- jq: Command-line JSON processor
https://github.com/stedolan/jq
- tmux: a terminal multiplexer
https://github.com/tmux/tmux
- pspg: postgres pager (you can combine it with pgcli)
https://github.com/okbob/pspg
Some of them that I can't live without are
- git-standup http://github.com/kamranahmedse/git-standup
- z https://github.com/rupa/z
- ZSH https://github.com/robbyrussell/oh-my-zsh
Apart from that, some that I use time to time
- curl-size https://github.com/egoist/curl-size
- ripgrep https://github.com/BurntSushi/ripgrep
- jq https://github.com/stedolan/jq
- asciinema https://github.com/asciinema/asciinema
In Ask HN: What are your favorite terminal programs?Sounds a lot like jq's jv API: https://github.com/stedolan/jq/wiki/C-API:-jv
In Immutable.rs: immutable data structures for RustWith an immutable data structure the only synchronization cost is that of atomic reference count increment/decrement, but it feels like you're mutating shared objects, so the API is very easy to use.
For an example API I'm familiar with, see https://github.com/stedolan/jq/wiki/C-API:-jv
In Immutable.rs: immutable data structures for RustIf this is at all like jq's libjq's jv API [0], then this it will be great. The C-coded jv API gives you immutable JSON-ish data structures, with the illusion (and sometimes truth) that they are actually mutable.
For example, say you have
jv foo(jv a)
{
return jv_array_append(a, jv_string("foo"));
}
Here `jv_array_append()` looks like it must mutate `a`. What actually happens under the covers is that if `a` has just one reference, then indeed, `a` will be mutated, but if it has more than one reference then a new array will be constructed as a copy of `a`, `a`'s reference count will be decremented, the copy will be mutated, and lastly the copy will be returned.
This might make it a bit clearer:
jv a = jv_array();
a = jv_array_append(a, jv_true());
a = jv_array_append(a, jv_false());
a = jv_array_append(
Read the rest
a, jv_null());
Each assignment to `a` here can be a brand new array, though since in this code snippet `a` will always have just one reference, in fact `a` will always be mutated.
Now, look at this:
jv a = JV_ARRAY(jv_true(), jv_false(), jv_null());
set_thingy(jv_copy(a));
a = jv_array_append(a, jv_number(10));
here at the third line `a` might have two references, depending on what `set_thingy()` might have done with its reference. Perhaps `set_thingy()` saved its reference in a global or thread-local variable, or some object reachable from a global or thread-local variable, in which case the last call to `jv_array_append()` in this example will produce a brand new array.
See the jq jv wiki[1].
Now, this is all C. But in Rust all of this would be even more powerful.
[0] https://github.com/stedolan/jq/blob/master/src/jv.h
[1] https://github.com/stedolan/jq/wiki/C-API:-jv
This could really use some examples.
I hope this is as easy to use as, say, the jv functions in libjq [0].
[0] https://github.com/stedolan/jq/blob/master/src/jv.h
In Immutable.rs: immutable data structures for RustThis is perfect for jq[0].
[0] https://github.com/stedolan/jq
In LibBF – a small library to handle arbitrary precision floating point numbersI'm not sure how to build a lock-less doubly-linked list in C, honestly, and it may not be possible. I've authored several lock-less data structures in C, but I've not thought about this one... A singly-linked list is easy-peasy for addition at the head or tail (just atomic reads and atomic compare-and-swap), though deletion is tricky (because the obvious CAS thing to do is racy if you'd free the deleted element, and you do want to free it eventually...).
A good pattern for thread-safety is to use immutable data structures. jq's jv API [0] is a great example of how to make it easy to deal with immutable data structures. Of course, you don't get to have cycles this way and so you don't get to have doubly-linked lists. Also, for root state you kinda need something like a thread-safe variable (of which there are a number of flavors in C
Read the rest
lojure, Haskell, and others) where when you read it you're guaranteed to have a stable reference to the value, but also guaranteed that garbage will be collected -- this is great when the values are immutable data structures.
You could have cycles in immutable data structures if you install the cycle before ever sharing with other threads and can make sure you don't fall into a loop when releasing the immutable value. But this is the sort of thing that requires "unsafe mode" unless the compiler/runtime can figure out that a) you haven't shared the thing yet, b) it won't be mutated once shared. I don't know how to figure that out statically, but that might be a good avenue for research.
[0] https://github.com/stedolan/jq/wiki/C-API:-jv
Besides's this projects cli, jp (https://github.com/jmespath/jp), I see jl (https://github.com/chrisdone/jl) and jq (https://github.com/stedolan/jq/) in the comments. I wonder if anyone has had experience with all three (or even just one) and can comment on their experiences?
In JMESPath – A query language for JSON