Who jnv is for#
DevOps engineers inspecting Kubernetes resources
Pipe kubectl JSON output directly into jnv to explore pod specs, service definitions, or resource status fields. Tab-completion surfaces available keys within the Kubernetes JSON structure, letting you drill into nested fields without knowing the exact path in advance.
Skip if:
If you need to process Kubernetes JSON in scripts or CI automation, plain jq or Kubernetes-native tools are better suited. jnv is designed for interactive exploration, not scripted batch extraction.
Backend developers debugging API responses
Pipe a curl response into jnv to explore the JSON shape and locate the correct field path. Once you have the right filter, Ctrl+Q copies it to the clipboard for use in scripts or documentation. This beats running jq repeatedly with trial-and-error filter strings.
Skip if:
If the API response is very large (hundreds of megabytes), jnv may render slowly. A streaming JSON processor handles that scale better than a TUI viewer.
Data engineers working with JSON Lines log streams
jnv supports JSON Lines format natively, so piping a newline-delimited log stream into it works without pre-processing. Set max_streams in config.toml to cap how many objects load into memory when working with high-volume log output.
Skip if:
If you need to aggregate, count, or group across thousands of log records, a dedicated log query tool or jq with aggregation functions is more appropriate than an interactive viewer.
The problem it solves#
Writing jq filters against JSON from the command line is iterative and slow. You run a filter, see an error or wrong output, adjust the filter, run it again. With deeply nested structures, this cycle is painful because the data shape is not visible while you type, auto-completion does not exist in raw jq, and copy-pasting filter fragments between terminal runs interrupts the workflow.
The pain is especially acute when exploring unfamiliar JSON, such as a new API response, a Kubernetes resource, or log output from a service. The standard workaround is to pipe JSON through jq with multiple filter passes or switch to a browser-based tool, which means leaving the terminal context entirely.
How it solves it#
Live jq filter editor with real-time preview
Type a jq filter in the editor pane and see the filtered JSON result update immediately in the viewer pane. The tool uses jaq, a jq-compatible Rust engine, so filter syntax matches jq exactly. No separate jq installation is required.
Auto-completion for JSON keys and array indices
Tab-triggered auto-completion suggests object keys and array indices from the current data, covering the Identity, Object Identifier-Index, and Array Index jq constructs. Completion candidates load in background chunks to stay responsive on large inputs.
Syntax-highlighted JSON viewer
The viewer pane applies color coding for keys, string values, numbers, booleans, and null values. Nodes expand and collapse individually or all at once with keyboard shortcuts. Long lines wrap or truncate based on the overflow_mode setting in config.toml.
JSON Lines and stdin support
Reads from a file path or from stdin via a pipe, and handles both standard JSON and JSON Lines format (multiple newline-delimited JSON objects). This covers log inspection and API response tailing where output is a stream of separate objects.
TOML configuration file
All visual and behavioral settings live in a config.toml file created automatically on first run. Configure editor appearance, debounce timing, keybindings, and completion list size. Default paths are platform-specific: ~/.config/jnv/config.toml on Linux, ~/Library/Application Support/jnv/config.toml on macOS.
Clipboard copy and stdout pipeline output
Ctrl+Q copies the current jq filter string to the clipboard; Ctrl+O copies the current JSON result. The --write-to-stdout flag pipes the filtered output to stdout on exit, keeping jnv composable in shell pipelines.
Strengths and trade-offs#
Strengths
- No jq dependency requiredjnv bundles jaq, a Rust implementation of the jq filter language, as part of its binary. Users on systems where installing jq is inconvenient, such as Windows or minimal Linux containers, get full jq-syntax filtering without managing a separate package.
- Single binary, zero server overheadjnv ships as one compiled Rust binary with no daemon or background process. Installation takes one command via Homebrew, Cargo, or Nix, and uninstalling is equally clean. There is no port to expose and no database to configure.
- Active development with 6,100+ GitHub starsThe repository has over 6,100 stars and received code pushes as recently as September 2026, showing ongoing maintenance. Inspired by jid and jiq, jnv has grown into one of the more widely used interactive jq tools in the terminal ecosystem, with topics spanning Kubernetes, autocomplete, and CLI tooling.
- Shell pipeline integrationInput comes from a file argument or piped stdin, and the --write-to-stdout flag sends the filtered result to stdout on exit. This means jnv fits existing shell scripts and one-liners without requiring a GUI or browser context switch.
Trade-offs
- -Auto-completion covers only three basic jq constructsThe README explicitly limits auto-completion to Identity, Object Identifier-Index, and Array Index filters. Complex jq expressions such as select(), map(), or recursive descent operators are not suggested. Users writing advanced jq pipelines must know the full syntax from memory.
- -Terminal-compatibility edge cases with 31 open issuesThe README warns that depending on the terminal and environment, characters and styles may not display correctly, and specific key bindings and decorative characters may not function in certain terminal emulators. With 31 open issues, some rendering and keybinding edge cases remain unresolved.
jnv vs alternatives#
jnv vs JSON Crack
jnv and JSON Crack both let you explore JSON data, but they serve different workflows. JSON Crack is a web-based visual tool that renders JSON as a connected graph diagram and offers a paid tier with additional features. jnv runs entirely in the terminal as a compiled Rust binary with no GUI component.
| Feature | jnv | JSON Crack |
|---|---|---|
| Interface | Terminal TUI | Web GUI |
| License | MIT | Proprietary (freemium) |
| Filter language | jq-compatible (via jaq) | JSONPath / visual query |
| Offline use | Yes | Requires app install |
| Shell pipeline | Stdin input, stdout output | Not designed for CLI use |
jnv is the better choice when you work in the terminal and need to stay in a shell pipeline. Piping curl or kubectl output into jnv, exploring the JSON structure with tab-completion, and copying the working filter to the clipboard with Ctrl+Q is a workflow that JSON Crack does not support. JSON Crack is worth considering when you need to visualize JSON structure as a diagram, share it with colleagues who prefer a graphical view, or explore JSON where a graph layout helps reveal relationships between nodes.
jnv vs Dadroit JSON Viewer
Dadroit JSON Viewer is a paid native desktop application built for handling very large JSON files, targeting data analysts who need fast rendering of files in the hundreds of megabytes or larger. jnv is a terminal tool without a native large-file binary parser optimized for that scale.
jnv is the better choice for developers who need interactive jq filtering and field exploration during normal development and debugging workflows. Dadroit is worth considering when your JSON files are too large for any terminal tool to handle comfortably and you need a native GUI with fast search across millions of records.
Quick start#
Install via Homebrew for macOS and Linux, or via Cargo for any system with a Rust toolchain.
```bash
brew install jnv
cargo install jnv
```What it's built on#
- Languages
- Rust
- Infrastructure
- Kubernetes
FAQ#
Does jnv require jq to be installed?
No. jnv bundles jaq, a Rust implementation of the jq filter language, as part of its binary. You do not need a separate jq installation. The filter syntax is jq-compatible, so existing jq knowledge transfers directly.
What JSON formats does jnv support?
jnv supports standard single-object JSON files and JSON Lines format (multiple JSON objects separated by newlines). Input can come from a file path argument or from stdin via a pipe, making it compatible with curl, kubectl, and other CLI tools that output JSON.
Can I save or export my jq filter from jnv?
Yes. Ctrl+Q copies the current jq filter string to the clipboard. The --write-to-stdout flag pipes the filtered JSON result to stdout on exit, so you can redirect it to a file or chain it into another command in a shell pipeline.
Is jnv available on Windows?
jnv can be installed on Windows via Cargo (cargo install jnv) or conda-forge. The configuration file is stored at C:\Users{Username}\AppData\Roaming\jnv\config.toml. The README notes that some keybindings and decorative characters may not display correctly in all terminal emulators, including some Windows terminals.
How is jnv different from using jq directly?
jq is a non-interactive command-line filter: you write a filter, run it, and read the output. jnv wraps jq-compatible filtering in a terminal TUI that shows the filtered result as you type and offers auto-completion for field names from the actual data. This makes it faster to explore unfamiliar JSON without prior knowledge of the data structure.
Similar open-source tools#
FckSignups
Open-source tools that work instantly, no signup required
pdf-inspector
Rust-powered PDF parser with smart OCR routing for AI pipelines
crawl4ai
LLM-ready web crawling without API keys or rate limits
deer-flow
Build super agents with DeerFlow's powerful framework
jaq
Rust-built jq clone: faster execution, YAML/TOML support, MIT license
Fluent-Qt
Fluent UI component library for Qt Widgets in C++17 and Python