📖 The Jetro Book is the best place to start, guided tour, full grammar reference, each builtin with working examples and some recipes.

Jetro is a compact query language and JSON data processing engine written in Rust. it borrows from two playbooks: Haskell compiler and database planners without pretending to be either.

use jetro::Jetro;
use serde_json::json;

let data = br#"{...}"#;
let jetro = Jetro::from_bytes(data.to_vec())?;
let report = jetro.collect(r#"
{
  "top_paid_premium": $.orders
    .filter(status == "paid" and total >= 100)
    .filter(customer.tier == "gold" or customer.tier == "platinum")
    .sort_by(-total)
    .take(2)
    .map({
      order_id: id,
      who: customer.name,
      tier: customer.tier,
      amount: total,
      label: f"order {@.id}: {customer.name} ({customer.tier}) USD {@.total}",
      line_total: items.map(qty * price).sum(),
      last_event: match events.last() with {
          {kind: "delivered", at: t}    -> {state: "ok",     at: t},
          {kind: "shipped",   at: t}    -> {state: "moving", at: t},
          {kind: "refund", reason: r}   -> {state: "refund", reason: r},
          _                             -> {state: "unknown"}
      }
    }),

  "paid_total": $.orders
    .filter(status == "paid")
    .map(total)
    .sum()
}
"#,
)?;

# Ok::<(), Box<dyn std::error::Error>>(())

[dependencies]
jetro = "0.5.10"

• Expressive, Compact and Familiar
  Jetro reads like the functional iterator chains you already know, it helps you get productive in minutes.

• Query, Shape and Mutate
  Jetro lets you write rich, multi-stage queries that is easy to read, reshape the result into whatever form you need - scalars, arrays, nested objects, computed values, distilled summaries and mutate the document in place.

• Laziness: Try Hard to Do Less
  Jetro's fastest path is the one it never takes, it tries to figure out the smallest possible amount of work upfront and then does only that. It borrows ideas from lazy functional language implementations like Haskell's demand analysis and stream fusion and adapts them to JSON query engine. The engine pulls data on demand, fuses pipeline stages into a single loop when applicable.

• Speed
  Jetro is engineered for throughput from initial parsing phase till output. It accelerates your query with a suite of techniques applied at every layer of the stack. SIMD-accelerated parsing and structural scanning at the byte level, demand analysis and stream fusion at the planner level, and a bytecode VM with cached plans and paths at the runtimelevel. For deep-search queries, Jetro can build a bitmap index over the parsed structure: one bit per structural position, sliced by depth and key, so descendant scans become bitwise AND/OR over packed words instead of recursive tree walks. Selected automatically by the planner.

• Stream processing — Kafka / NATS / Pulsar consumers, Flink / Spark / where each message is JSON and the work is filter -> reshape -> enrich -> forward. Embed Jetro as the per-message transformer, hold one long-lived JetroEngine per consumer, and pay only execution cost per record.
• API response shaping, log analytics, ETL transforms - workloads where response enrichment and reshaping is dominant.
• Ad-hoc and dynamic queries that aren't known at compile time.
• Observability pipelines — filter / reshape / aggregate spans, events, or audit records inline before forwarding.
• Document mutation bulk JSON migrations, config rewrites, fixture generation; chain-writes fused into one traversal per document.
• jq: covers common jq use cases with a simpler, more intuitive method-chain syntax.

Jetro aims to stay as close as realistically possible to idiomatic, statically typed Rust on common query workloads.

The repository ships a cold-start benchmark that runs each query end-to-end (parse + execute + serialize), similar to embedded usage.

Four engines are compared on the same input (N = 8000 records, ~3.9 MB):

Reproduce:

cargo run -p jetro-core --release --example bench_cold
(cd bench/go && go run .)

use jetro::{Jetro, JetroEngine};

let jetro = Jetro::from_bytes(json_bytes)?;
let value = jetro.collect("$.some.expression")?;

let engine = JetroEngine::new();
let first_two = engine.collect_ndjson_matches_file(
    "events.ndjson",
    "level == \"error\"",
    2,
)?;

Jetro is the byte-oriented document handle. JetroEngine is the long-lived engine for cached plans, reusable VM state, and NDJSON processing.

NDJSON APIs evaluate each non-empty line as an independent JSON document while reusing one prepared query plan for the stream.

$                         root document
@                         current item inside map/filter/lambda

$.user.name               field access
$.user?.name              null-safe field access
$.items[0]                index
$.items[1:5]              slice
$..price                  recursive descent

$.books.filter(price > 10)
$.books.sort_by(-rating).take(5)
$.orders.filter(status == "paid").map(total).sum()

$.books.map({title, price})
$.orders.map({
  id,
  customer: customer.name,
  city: customer.address.city,
  total
})

{
  "featured": $.books
    .filter(rating >= 4.5)
    .sort_by(-price)
    .take(3)
    .map({title, author, price}),

  "stats": {
    "count": $.books.count(),
    "avg_price": $.books.map(price).avg(),
    "tags": $.books.flat_map(tags).unique().sort()
  }
}

let min_total = 100 in
$.orders
  .filter(total >= min_total)
  .map({
    id,
    label: f"{customer.name}: ${total}"
  })

$.orders.group_by(status)
$.users.index_by(id)
$.events.count_by(type)

$.user.name.set("Ada")
$.cart.items.filter(qty == 0).delete()
patch $ { .user.active: true }

match $.user with {
    {role: "admin"}                    -> "full",
    {role: "user", verified: true}     -> "limited",
    {role: r, ...*rest}                -> {...*rest, role: r},
    _                                  -> "denied"
}

$..match {
    {tag: "click", id: i} -> i,
    _                     -> false
}

Full syntax reference: jetro-core/src/SYNTAX.md

• Jetrocli: For interactive use in Terminal.
• Jetro Emacs Plugin use Jetro in Emacs.
• Jetro Python Binding: Python Binding for Jetro.
• Jetro Dart Binding: Dart/Flutter Binding for Jetro.

• The Jetro Book the canonical guide - start here.
• jetro-core/src/SYNTAX.md - syntax reference
• CHANGELOG.md - release notes

MIT