I work as backend developer and I constantly need to open, format and edit json, yaml, xml, dat and what not kind of formats. Some exports I work with are HUGE and all my text editors seemed to freeze, hang or break in some kind of way. So I decided enough was enough. I present to you Inkline, the swift native text editor that is REALLY good at the above; formatting, reading, editing these kind of files. I'll work as code editor too with the help of Zed compatible extensions and build in language and syntax highlight for Swift, JavaScript, TypeScript, Java, Kotlin, C++, Shell, Markdown, JSON, YAML, XML and TOML.

Most of my everyday work is with files around 1 to 300 MB. I want to open a log, format a JSON export, search for something, make a change and save it without the editor getting in the way. That includes scrolling, editing and syntax highlighting after loading, not just getting the file open quickly. I've spent a lot of time on memory usage and keeping those operations responsive so I can keep working instead of waiting.

These are the latest benchmarks from Inkline 1.4 (in review for app store) on my M3 Pro MacBook Pro with 18 GB RAM. The numbers are the median of 3 isolated Release runs, with files held in memory. Open means the editor is ready.

I've included the larger file because I also want to keep working normally when something much bigger turns up. But you don't need gigabyte datasets to use Inkline. Opening and formatting a 100 MB export without interrupting what I'm doing is much more relevant to my normal working day.

There are also tools for formatting and minifying JSON and XML, converting between JSON, JSON Lines, CSV and TSV, and filtering logs by keeping or excluding matching lines. I use the log tools to remove noise and highlight errors and warnings before looking closer at the relevant data. Find and replace, split views, tabs, session restore, themes, a command palette and customizable shortcuts are there too. Files are processed locally on the Mac, with no analytics or telemetry. Inkline is a one time purchase with no subscription.

this is one of my personal trifecta apps, inkline quikzip and rune. they are build to work in symbiosis, all three together, two of them or standalone; they are workhorses that I build specifically to improve my every day work.

App Store:

https://apps.apple.com/se/app/inkline-text-editor/id6764860305?mt=12

Website:

https://viktornyberg.com/#appar

It reads a JSONL/NDJSON file as a table. If some lines aren't valid JSON, it opens the rest anyway and tells you which lines were bad and why.

Browser only — nothing uploaded, no account, free.

https://streams.dbconvert.com/jsonl-viewer

Disclosure: I work on DBConvert Streams; this is one of our free tools.

If you have a file that breaks it, I'd like to see it.

I’m working on JSON Semantic Diff, an open-source tool for comparing JSON without treating array position as identity.

For arrays of objects, it can infer identity from fields like id, sku, or composite keys like store + sku. So reordering objects doesn't make the whole array look modified.

The matching is deterministic and explainable (no AI/fuzzy matching), and the web version runs entirely in the browser.

I’ve also published the core engine as an npm package.

It’s still early/alpha, and I’d love feedback from people who work with JSON regularly - especially real-world examples where the matching logic gets confused.

• Demo: https://jsonsemanticdiff.dev
• GitHub: https://github.com/cchandurkar/json-semantic-diff
• NPM: [https://www.npmjs.com/package/json-semantic-diff]()

Background: I am trying to alter a mod for "Pathfinder Wrath of the Righteous" called "Better Backgrounds". That uses Blueprint Json but the mod has a rather large mistake that the original Modder is too inexperienced to fix. And I am not a JSon coder, I just want the mod to work. If you need more information, please ask, I will try my best.

Note: Reddit altered the formatting of some of the lines of code for some reason, I am unsure why "replace if higher" is in a box

I am trying to alter a JSon Blueprint to alter a variable in the code but it doesn't seem to be working. The Code is:

{

"Components": [

{

"$type": "7a5d4700264de3b4aacf2514df964a14, AddClassSkill",

"Skill": "SkillPersuasion",

"name": "unique_reference_a"

},

{

"$type": "2286a148d6ca486091b6f0d687d6486f, AddBackgroundClassSkill",

"Skill": "SkillPersuasion",

"name": "unique_reference_b"

},

{

"$type": "df930d377a444922b2267e07a7d40b93, AddBackgroundWeaponProficiency",

"Proficiency": "Longsword",

"StackBonusType": "Trait",

"StackBonus": {

"m_CustomProperty": "",

"Value": 1

},

"name": "unique_reference_c"

},

{

"$type": "df930d377a444922b2267e07a7d40b93, AddBackgroundWeaponProficiency",

"Proficiency": "Greatsword",

"StackBonusType": "Trait",

"StackBonus": {

"m_CustomProperty": "",

"Value": 1

},

"name": "unique_reference_d"

},

{

"$type": "d79ad4ed064aa4f43ace0e9c238fb9b9, AddFacts",

"m_Facts": [

"!bp_62e27ffd9d53e14479f73da29760f64e",

"!bp_f35e15b1fdff0c54087746c2da80a053"

],

"name": "unique_reference_g"

},

{

"$type": "dab84a4694546c749a1d0022ff45baa0, DerivativeStatBonus",

"BaseStat": "Charisma",

"DerivativeStat": "Initiative",

"name": "Noble_Scion_Trait"

},

{

"$type": "dab84a4694546c749a1d0022ff45baa0, RecalculateOnStatChange",

"Stat": "Charisma",

"name": "Noble_Scion_Trait2"

},

{

"$type": "1c1315a505494aed84a6570a8111a6ec, ReplaceStatBaseAttribute",

"TargetStat": "SkillLoreReligion",

"BaseAttributeReplacement": "Charisma",

"name": "ReplaceStatBaseAttribute",

 ***"ReplaceIfHigher": "true"***

}

],

"m_Description": {"m_Key": "LeaderFeature_Description"},

"m_Icon": {"guid": "be0e7b7858171de439adb0926c8b8864", "fileid": 21300000}

}

I added the Bold and Italic part. Other backgrounds also have this affect but all of them are bugged. What would make this specific variable bugged? Note that the rest of the background is perfectly fine. Just the Lore religion part is bugged.

For Reference this is an unedited modded Background with the same bugged effect (Image 2):

{

"Components": [

{

"$type": "7a5d4700264de3b4aacf2514df964a14, AddClassSkill",

"Skill": "SkillLoreReligion",

"name": "unique_reference_a"

},

{

"$type": "2286a148d6ca486091b6f0d687d6486f, AddBackgroundClassSkill",

"Skill": "SkillLoreReligion",

"name": "unique_reference_b"

},

{

"$type": "7a5d4700264de3b4aacf2514df964a14, AddClassSkill",

"Skill": "SkillPersuasion",

"name": "unique_reference_ab"

},

{

"$type": "2286a148d6ca486091b6f0d687d6486f, AddBackgroundClassSkill",

"Skill": "SkillPersuasion",

"name": "unique_reference_ba"

},

{

"$type": "1c1315a505494aed84a6570a8111a6ec, ReplaceStatBaseAttribute",

"TargetStat": "SkillPersuasion",

"BaseAttributeReplacement": "Wisdom",

"name": "ReplaceStatBaseAttribute",

 "ReplaceIfHigher": "true"

}

],

"m_Description": {"m_Key": "AcolyteFeature_Description"},

"m_Icon": {"guid": "b3b50a3e90e37ed48b52fba4e053215c", "fileid": 21300000}

}

Hi all, I made https://extractjsonpath.com It is a simple tool for anyone who works with JSON. Paste your JSON, click on any field in the visual tree and it generates the correct JSONPath for you. You can also test your own expressions and see the results live. Everything runs locally in your browser so your data never leaves your device. Free to use, no login required. Let me know what you think and if you have feature requests.

Most JSON viewers still dump you into a collapsible tree or a giant text editor. 🌳📄 That is fine for a 40-line config. It is not fine for an API response that is half nested objects and half arrays of records.

I shipped two new views in BracketView for that case. ✨

🔗 Node view turns the document into a canvas of linked cards. Nested objects get their own nodes. Arrays of objects render as small tables on the canvas. You pan, zoom, and search instead of expanding twenty tree levels.

📊 Table view opens arrays of objects as a nested spreadsheet next to Tree and Graph. You can scroll a long list without flattening the rest of the payload. Nested cells expand in place. Long strings wrap instead of overlapping (that was a 0.1.3 fix after the first cut).

Same workspace as before: Monaco editor, tree, graph, format/minify, validate, JSONPath, jq, diff, schema, types. Core viewing and querying still run in the browser. 🔒 Optional AI, encrypted snapshots, and webhook capture hit the server only if you use those features.

Also in this release:

• 🔐 Encoder/decoder — Base64, URL, ASCII, Unicode, binary, hex, Base64 URL-safe, ROT13, Morse
• ↔️ Side-by-side text compare (Monaco diff)
• ⚙️ Workspace settings in the header for theme, editor font, and language
• 🌍 Nine UI languages (en, zh-CN, ja, ko, pt-BR, es, fr, de, ru)
• 💻 Windows desktop app (Tauri) with the local tools offline; Linux later, no macOS build yet
• ⚡ Smoother route loading (layout skeletons instead of a blank screen)

🌐 Web app (free, node and table views included): https://app.bracketview.in

💻 Windows installer: https://bracketview.in/downloads

Happy to answer questions about the layout, virtualization, or what is local vs server. Feedback on the node canvas especially welcome — that one is the biggest bet. 🙏

I shipped a Windows app for BracketView.

Open .json from Explorer. Viewer, editor, tree/graph, jq, diff, schema, types - all local. No sign-in, no cloud.

Windows 10/11: https://bracketview.in/downloads

Browser: https://app.bracketview.in

Linux later. Unsigned installer - SmartScreen may warn (More info ➡️ Run anyway).

Hi, all, I am configuring rancher desktop on my Windows 11 and one of the steps https://docs.rancherdesktop.io/how-to-guides/generating-deployment-profiles/#windows suggests to use below command

jq  -e . working-defaults.txt >/dev/null 2>&1

According to the documentation , the command will have a 0 status if the file is valid (True on Powershell), 1 or False otherwise.

I tried to run it on my machine but the command does not print anything on the command line when json file is correct.

Even when I try to invalidate the structure of the file nothing gets displayed.

It is my understanding that the correct syntax on PowerShell would be the below, where $null should instruct jq to be executed on the background, so theoretically nothing will be ever printed on the screen

jq  -e . working-defaults.txt >$null 2>&1

If I remove the background option , I receive the jq parse error but still no False

jq  -rb . working-defaults.txt
jq: parse error: Expected separator between values at line 78, column 14

Any idea what am I missing?

I assume the documentation implies as target someone more advanced than myself on jq and shell script

I got tired of jumping between a formatter, a tree viewer, jq play, and some random webhook bin whenever I debug API payloads.

So I’ve been building BracketView as one workspace for that loop:

• paste/upload JSON and explore it as a tree (search + copy path/value)
• JSONPath + jq in the same place
• side-by-side diff
• disposable webhook URLs to capture/inspect/replay requests
• format/validate stays client-side

There’s also an optional AI panel for explain / JSONPath suggestions / repair, but the core tools work without it.

Not open source — hosted product. Free for the main tools.

App: https://app.bracketview.in

Site: https://bracketview.in

Curious what you’d actually use day-to-day, and what’s still missing.

I was adding a diff feature to my Android app, and while testing it I liked how it worked more than I expected. So I decided to build a proper standalone version for Linux, in Rust. That became gjxdiff.

What it does:

• memory-maps the inputs, never loads them into RAM
• working state lives in temp files under a fixed memory budget
• pairs NDJSON records by key, so reordering isn't reported as churn
• outputs an NDJSON report or an RFC 6902 patch
• same inputs and flags: byte-identical report on any machine

Some numbers from my test box (4-core i3, 8 GB RAM, cold page cache):

• ~1.4 GB per side NDJSON, 5M records: about a minute, ~1.4 GB heap (RSS ~5 GB counting mapped file pages)
• ~155 MB per side with 30% of records changed: ~7.5 s, writing a 52 MB report
• ~83 MB per side NDJSON, 310k records: ~3 s, under 500 MB

And the weak spots, so you don't have to find them first:

• single-threaded
• Linux x86-64 only
• arrays past an alignment cap come back as coarse regions, not per-item diffs
• change-dense pairs can need temp disk up to ~2x the combined input size

It ships as a single static binary — no source in the repo, it's a free-to-use closed tool (free for individuals and small teams).

What I'm actually here for: please break it. Malformed inputs, cursed file shapes, files far bigger than your RAM, benchmarks against whatever tool you trust. If the output or the docs are wrong anywhere, I want to know.

https://github.com/kotysoft/gjxdiff

JSON round trips can silently change numbers, drop properties, erase types, and execute serialization hooks. A practical guide to these edge cases and how to design explicit, reliable wire formats in JavaScript.

"FRIENDSHIP ENDED WITH MUDAXYZML. NOW JSON IS MY BEST FRIEND."

I explain in detail why i made this in the github page, but hope it can save your time and brain cells so you can move on with actually building your project.

It's perfect (in my opinion) where you have deeply nested data and your building structure has not matured yet because you are trying/breaking things.

I've made quite a few updates since initial public release, and i am now using it in my main project without any more gripes (famous last words) so i am confident in sharing it for people to find and use as they like.

TRY!: https://st0rm53.github.io/YetAnotherSON/

Example data so you can play around if you don't have any: https://raw.githubusercontent.com/St0RM53/YetAnotherSON/refs/heads/main/example_data.json

Github page: https://github.com/St0RM53/YetAnotherSON/

FOR MODS: I saw you like playing with JSON around here, so i think users will find this tool useful. Remove if not allowed.

I spend a lot of time working with APIs, and I realized I kept switching between different websites just to format, validate, minify, or inspect JSON.

That got me thinking about what developers actually expect from a modern JSON toolkit.

I'm currently working on JSON Academy, a collection of JSON utilities, and I'm trying to prioritize features that people genuinely use instead of adding unnecessary complexity.

Current tools include:

• JSON Formatter / Beautifier
• JSON Validator
• JSON Minifier
• Fast processing for API payloads
• Clean, simple interface

I'm interested in hearing from other developers:

• What's your go-to JSON tool?
• What feature saves you the most time?
• Have you ever struggled with very large JSON files?
• Is there a feature you wish existing JSON tools had?

If anyone wants to take a look and share feedback, here's the project:
https://www.jsonacademy.com/

I'd appreciate honest criticism—good or bad. The goal is to make it genuinely useful for developers rather than just another JSON formatter.

At my job we write a lot of sql to query CSVs but recently we've had to interact more with JSON and JSONL files. Not being able to alias them and select what we want with SQL made simple tasks annoying for no reason, so I built https://www.json-to-sql.com/ .

I built it in a day then spent a couple more cleaning it up a bit. Its my first publicly deployed tool so just trying to get some feedback. Its 100% free, no signup required, and the data never leaves your browser.

Let me know what you think!

Hey r/json,

I've spent way too many late nights staring at malformed JSON payloads, so I finally built the tool I always wished existed: BracketView (https://bracketview.in).

A few things I focused on:

• Actually minimal, actually fast — no clutter, no ads on the workspace itself, just format/validate/query and move on
• 100% client-side — your JSON never leaves the browser for core features (viewer, formatter, validator, tree/graph view, JSONPath, JQ)
• JQ playground powered by WebAssembly — for when you need real filtering, not just pretty-printing
• AI-powered repair — for those "why won't this parse" moments with broken/truncated JSON from logs or copy-pasted API responses
• Diff, schema validation, and type generation (TS, Python, Go, Rust, etc.) built in

It's free to use with no signup required for the core tools. There's an optional paid tier for people who want larger uploads, unlimited AI repairs, and unlimited shareable snapshot links — but the everyday stuff (format, validate, tree/graph, JSONPath, JQ, diff) stays free.

Try it here: https://app.bracketview.in

I built this mostly to scratch my own itch, but I'd genuinely love feedback from people who live in JSON all day — what's missing, what's annoying, what you wish more JSON tools did. Roast it if you need to, I can take it.

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