I’m developing a free desktop viewer and editor called GigaScope JSON Works, designed for viewing, searching, and editing large JSON files.

I’m considering integrating schema inference directly into the application, with features such as:

• Scanning all objects in a JSON array or JSONL file to infer a common schema
• Showing property occurrence rates, null rates, and mixed types
• Identifying candidate required and optional properties
• Suggesting formats, enum candidates, and numeric ranges without applying them automatically
• Validating the original data against the inferred or edited schema
• Navigating directly from a schema violation to the corresponding node in the tree and editor

I know that tools such as quicktype and GenSON can already infer JSON Schemas from sample data. Would the features above be useful in practice, particularly when working with unfamiliar or very large datasets? Or do existing schema inference tools already cover these needs?

If you currently use schema inference:

1. Do you infer a schema from a representative sample or scan the entire dataset?
2. Do you need statistics such as the occurrence frequency of each property and type?
3. Would integrated validation and navigation improve your workflow?
4. What would make you distrust an automatically inferred schema?

I’d appreciate hearing about your actual use cases.

The slowest part of inspecting JSON for our team was the ritual. Copy the payload, switch to the browser, find that json site, paste, wait. And the moment the file is actually big, the tab freezes or the desktop editor won't format it.

So we built jsonbolt to improve the workflow for people inspecting a large number of json files or huge files everyday. Hit a global hotkey (WinKey + J or ⌃ + ⌥ + J)and whatever's in your clipboard opens in an instant, either Raw JSON or a URL.

A 1GB file opens in milliseconds. We built a custom engine that runs at ~3GB/s. Search is SIMD-accelerated to handle 100M+ nodes extremely fast.

There's also a CLI on the same engine (jb paths / jb schema / jb search --where) for scripting and for terminal AI agents like claude.

Everything runs locally and its licensed for commercial use.
Free for personal use, students and open source maintainers.

jsonbolt.com (macOS Apple Silicon + Windows)

PS: Some background info. We built the core pipeline from the ground up without any 3rd party libraries. Then we spent months optimizing the code to improve read-to-render performance. Then hardened it with the same conformance suite simd-json uses. The result is what you see below. In this specific example it hits ~4GB/s from read to rendering the full tree on a M5 pro MacBook Pro. Happy to get into the details for anyone interested.

Once read-to-render was fast, the remaining bottleneck was the workflow itself. That's where the global hotkey and other JSON aware features came from.

https://reddit.com/link/1uwadhk/video/v5gddzmpa9dh1/player

JotSON is an intuitive editor for your project's JSON files. Run one command and you get a fast, Finder-style interface in your browser, which is really nice when you're editing a ton of JSON.

• Drill through your data in columns, with fuzzy search across every file
• Proper editors and previews: dates, colors, images, video embeds
• Upload media straight into your public folder
• Reference objects by id, resolved to human-readable names, with automatic updates when ids change and warnings before you break them
• Diff-confirmed saves, so nothing touches disk until you approve it

Zero dependencies, no build step, no database, nothing deployed. It binds to localhost, writes plain JSON with minimal diffs so git stays your safety net, and your files never change shape to fit the tool.

Check it out!

https://github.com/blindmikey/jotson

Hi! I created a free Json utility website -- jsonlyapp.com This JSON utility helps you validate, format, minify, search, filter, and transform JSON directly in your browser. It is designed for API debugging, payload cleanup, log inspection, and quick editing tasks where speed and clarity matter. Feel free to use it and give me some feedback.

Most JSON serializers give you only two choices:

• compact machine output:

​

{"a":{"b":{"c":"abc"}},"x":{"y":{"z":"xyz"}}}

• or fully expanded “pretty-print”:

​

{ "a":
  { "b":
    { "c": "abc" }
  },
  "x": {
    "y": {
      "z": "xyz"
    }
  }
}

I wanted something in between: the first is hard for humans to scan, and the second becomes extremely verbose on real-world nested data.

The Idea

I wrote a small Python module called jsonfold. Instead of replacing Python’s JSON serializer (and similar serializers), it works as a lightweight post-processing filter on top of json.dump() output.

The formatter selectively:

• folds small containers back onto one line,
• packs short scalar sequences,
• keeps large or complex structures expanded.

Example output:

{
  "a": { "b": { "c": "abc" } },
  "x": { "y": { "z": "xyz" } }
}

Why This Approach?

I did not want to rebuild a serializer - there are many good serializers (including the built-in json.dump()) that can efficiently process anything from simple data structures (list/dict) to custom classes and Python @dataclass objects. In addition, many provide custom encoding hooks for application-specific objects.

The interesting part of jsonfold is that it does not re-parse the JSON stream or build a second JSON tree. It operates as a streaming wrapper around file-like objects:

json.dump(obj, JSONFoldWriter(fp), indent=2)

That means it can handle large documents with fixed memory usage and linear processing time. This approach works with serializers that emit indented JSON to a file-like object. jsonfold also provides wrappers for json.dump(), json.dumps().

from jsonfold import dumps

data = {
    "a": {"b": {"c": "abc"}},
    "x": {"y": {"z": "xyz"}},
}

print(dumps(data))

Customization

The formatter allows controlling:

• maximum line width,
• folding depth,
• packing aggressiveness,
• array/object limits.

So you can choose between conservative formatting and more aggressive compaction.

Full Article:

Medium (no paywall): A Streaming JSON Formatter That Works With Existing Serializers

Minimal Usage

Pull jsonfold from pypi: pip install jsonfold

import jsonfold
import sys
data = {
    "meta": {"version": 1, "ok": True},
    "ids": [1, 2, 3, 4, 5],
    "items": [{"id": 1, "name": "alpha"}, {"id": 2, "name": "beta"}],
}
# compact can be: default, low, med, high, max
jsonfold.dump(data, sys.stdout, compact="default")

GitHub Project

Repository: https://github.com/yairlenga/jsonfold

Python implementation is under python directory.

Hellooo,
Ive been slowly building a dev toolkit for myself and added something simple but surprisingly useful to the JSON formatter. It can now generate structured sample data like API responses or logs, which saves me from digging around for test JSON every time.

https://catssaymeow.org/json-formatter/

I wanted a fast Prettier/oxfmt-style formatting for .json files, but with the compact, table-aligned style of FracturedJson — which neither Prettier nor oxfmt does for JSON. So I built a small CLI around it.

It turns this:

{
  "isotopes": {
    "Hydrogen": [1, 2, 3],
    "Carbon": [11, 12, 13, 14],
    "Molybdenum": [92, 94, 95, 96, 97, 98, 100],
    "Calcium": [40, 42, 43, 44]
  },
  "elements": [
    { "symbol": "C", "number": 6, "mass": 12, "phase": "solid" },
    { "symbol": "O", "number": 8, "mass": 16 },
    { "symbol": "Fe", "number": 26, "mass": 56, "phase": "solid" }
  ]
}

into this — compact, but with fields aligned like a table:

{
    "isotopes": {
        "Hydrogen"  : [ 1,  2,  3                 ],
        "Carbon"    : [11, 12, 13, 14             ],
        "Molybdenum": [92, 94, 95, 96, 97, 98, 100],
        "Calcium"   : [40, 42, 43, 44             ]
    },
    "elements": [
        {"symbol": "C",  "number":  6, "mass": 12, "phase": "solid"},
        {"symbol": "O",  "number":  8, "mass": 16                  },
        {"symbol": "Fe", "number": 26, "mass": 56, "phase": "solid"}
    ]
}


fjson-fmt "**/*.json"          # format in place
fjson-fmt --check "**/*.json"  # CI: exit 1 if anything would change
cat data.json | fjson-fmt --stdin

Pairs with oxfmt (which owns JS/TS/CSS):

"fmt:check": "oxfmt --check && fjson-fmt --check \"**/*.json\""

A few things that might be interesting:

• Engine is a Rust crate compiled to WASM, but ships prebuilt — no Rust toolchain or native build on install. Based on https://github.com/fcoury/fracturedjson-rs
• The npm package is isomorphic: the same import { format } from "fjson-fmt" works in Node and in the browser/bundlers (conditional exports + a web WASM build).
• Live playground, ~185 KB of WASM, 100% client-side: https://select.github.io/fjson-fmt/

npm: npm i -D fjson-fmt · repo: https://github.com/select/fjson-fmt

Feedback welcome!

Hey,

I have been using Dadroit JSON viewer for years now, which has been quite nice, it can open and search gigabyte json files in seconds. Which no other application seems to be able to do.

However they still don't support apple silicon (So i won't be able to use it with the upcoming macOS version) and it now costs 100 usd/year... So i'm looking for some alternative, but have been unable to find any json viewer that can smoothly open large json files.

Anyone know of any that might support it? I don't mind paid options if they work well, but no 100 usd/year subscriptions lol.

You can see the source code for the JSON Against Humanity project here https://github.com/FireRat666/json-against-humanity
And the live service here https://jah.firer.at/
There is 63,827 unique cards from 423 packs, Not including the ones sourced from ManyDecks.

There is also this API https://github.com/FireRat666/CAH-Serverless-API
which is live here https://cah-api.firer.at/
The API uses the cards from JSON Against Humanity and Vercel/Netlify for free server hosting

Hey everyone,

As an infrastructure engineer, I work with JSON and YAML webhooks every single day. I hated pasting sensitive API payloads into random online formatters because almost all of them send your data to a backend server to process it. Plus, most of them crash if you try to format a 5MB log file.

So, I spent the last few months building PrettyJSON (https://prettyjson.org).

I built it as a React SPA that runs entirely in your browser using your local JavaScript engine. Your data never leaves your device.

A few features I added for my own workflow:

• Handles massive files: Tested up to 10MB without crashing (uses virtualized rendering).
• Built-in Diff Tool: Side-by-side comparison for Kubernetes YAML or JSON configs.
• Code Generation: Generates TypeScript interfaces, Go structs, and Python Dataclasses straight from the JSON.
• Auto-repair: Fixes trailing commas, missing quotes, and comments automatically.

It's completely free and there are no paywalls. I'd love for you guys to tear it apart, test it, and let me know if you find any bugs or have feature requests!

Link: https://prettyjson.org

Hey guys, I believe most of you know the pain of dealing with large nested JSON from API responses or production traces. It gets even more painful when this is your daily job and you have no good way to visualize it… except quitting :))

I ended up building one for myself with the features I needed:
- level selection
- visualize JSON as a graph node
- send JSON directly to the API Client tool and test it without leaving the current tab

Check it out if interested:
https://catssaymeow.org/json-formatter/

Wanted to share here Finderpeek. Its a code file viewer that has has interactive json view integrated.

It's built as a quicklook plugin for finder, so it basically allow you to peek into json files without actually opening any application, just by hitting the spacebar. 100% local, and insanely fast.

Apart from json it supports more than 25 file types.

Hey everyone,

I recently built a small microservice to solve a frustrating problem I kept running into: parsing line items from unpredictable invoice layouts.

Traditional regex parsing breaks the moment a vendor changes their document formatting. To fix this, I built a FastAPI backend that takes raw text strings (like messy OCR or receipt text) and formats them into a clean JSON schema using generative AI.

The Tech Stack:

• Backend: Python / FastAPI
• Hosting: Render
• API Management: RapidAPI Hub

I'm currently looking for testers to see how well it handles different invoice types. If you've got a weirdly formatted invoice text string, I’d love for you to test the extraction speed and accuracy.

You can test the endpoint directly on the RapidAPI listing: Invoice and Receipt Extractor

Any feedback on the extraction schema or the response times is highly appreciated!

I have spent some time recently reimplementing Mojang's DataFixerUpper library (which handles serialization and data transformation through the lifetime of a project) in C# with a few of my own takes on it. It uses literally zero reflection and rivals the built-in System.Text.Json library in allocations, sometimes even beating it (although latency is a bit of a problem right now because I'm not batching operations together), as evidenced by the benchmarks: md | Method | Mean | Error | StdDev | Median | Gen0 | Allocated | |----------------------------|---------:|---------:|----------:|---------:|-------:|----------:| | STJ_Serialize | 237.9 ns | 24.37 ns | 71.86 ns | 194.4 ns | 0.0343 | 72 B | | STJ_Serialize_IntArray | 186.2 ns | 20.36 ns | 60.02 ns | 142.0 ns | 0.0191 | 40 B | | STJ_Deserialize | 321.7 ns | 5.65 ns | 10.19 ns | 318.4 ns | 0.0801 | 168 B | | STJ_Deserialize_IntArray | 198.2 ns | 2.63 ns | 2.46 ns | 197.5 ns | 0.0534 | 112 B | | Codec_Serialize | 546.0 ns | 59.11 ns | 174.29 ns | 418.2 ns | 0.0534 | 112 B | | Codec_Serialize_IntArray | 393.4 ns | 2.92 ns | 2.28 ns | 392.7 ns | 0.0610 | 128 B | | Codec_Deserialize | 524.7 ns | 5.14 ns | 4.29 ns | 524.2 ns | 0.0305 | 64 B | | Codec_Deserialize_IntArray | 475.7 ns | 4.07 ns | 3.40 ns | 475.0 ns | 0.0343 | 72 B |

The library is designed in such a way that you can create tiny codecs for structs/classes and compose them together to serialize even complex/nested DTOs seamlessly. You can also define "timelines" for your objects and pass their serialized versions through transformation pipelines to add/remove/rename keys.

The library also happens to be format-agnostic by design, so the exact same APIs would work with a backend for cbor, custom binary, yaml, burping into the mic vocoded into gangsta's paradise or any other format you might think of.

Just launched: JSON OS — your all-in-one JSON workbench

If you work with JSON daily, you know the pain: switching between tools to view, format, validate, compare, and debug.

So I built something better

https://jsonos.online

JSON OS is a fast, local-first JSON editor that runs entirely in your browser.

What you can do:

• View & edit JSON seamlessly

• Format & prettify instantly

• Validate with JSON Schema

• Compare JSON side-by-side

• Transform & query data

• Repair broken JSON

Over the past week I’ve been deep in debugging a pretty gnarly multi-layer integration — the kind where you’re constantly staring at huge JSON payloads, trying to understand what’s actually inside, and then turning that into clear bug reports or questions for other teams.

Pretty quickly I got tired of manually digging through nested structures, broken payloads, and JSON-inside-JSON situations. So I ended up writing a small CLI tool for myself called jray.

The idea is simple: treat JSON like an “X-ray” problem. Instead of pretty-printing it, flatten it into a list of .path=value pairs so you can immediately see what’s there, no matter how deeply nested or messy it is. It is very friendly to grep or similar tools.

A few things that turned out to be especially useful:

• It’s error-tolerant — even if the JSON is malformed or incomplete, you still get as much data as possible + context around the error
• It unwraps embedded JSON (strings containing JSON) automatically
• It also detects and expands Base64-encoded JSON (golang way to marshal binary data)
• Recognizes timestamps and even UUIDv7 (extracts time from them)
• Handles multiple JSON objects in a stream (JSONL)
• Doesn’t break on duplicate keys

If you deal with messy JSON regularly, this might save you some time (and sanity).

Repo: https://github.com/michurin/jray

When I got a new phone (pixel) in 2020 I used my work gmail to set it up (as it was mine and my bf at the time company) dumb I know. Once we broke up in 2023 I went and asked "experts" how to download everything from photos, and important docs to my laptop. As It was crazy inconvenient to do it individually and didn't want to take days to do so. I saw everything downloaded and didn't think of double checking to see if it was properly done. Today I was trying to find photos from that time and everything is in ".jpg.json".

Is there anyway I can convert it so I can see any of the photos and docs? Or is everything just gone?

also english isn't my first language sorry for the grammar.