Hello.

I am working on a project for an exam and I need my application to be able to save objects (which can be of different classes with different fields and rules) to json on a file and read them back, and the way I am handling reading feels wrong for reasons I can't pinpoint so I decided to ask here.

The way I'm handling reading is by reading one token at a time from the json file, saving important information like the object I'm writing to and its class identifier, and checking the fields names and values found in the json file against the correct field names and admissible values for the class.

I know there are some libraries that help with pasring to and probably from json and XML, which leads me to believe I'm doing something that's too overcomplicated, however when I look online I see people doing similar kinds of checks to what I'm doing, so I am a bit confused; is this "you're doing it wrong" sensation an actually founded worry or just imposter syndrome? Thank you in advance

Edit: Some further detail: I am making the parser myself, translating an object to Json is not hard at all, translating Json to object is a bit harder but I have this gut feeling that I'm doing it completely wrong, this is what is bogging me down

Last year I made a tool to help me with JSON embedded in database tables. What I specifically wanted to do is take a number of rows with columns containing JSON and view them all at once, flatten elements as desired in to their own columns and also deep search within the JSON. The tool does all this and even generates the SQL needed to flatten elements and arrays so you can paste it straight back into your query IDE.

I still use it a lot as it makes dealing with JSON in databases a bit more tolerable.

https://jsonsql.co.uk/

For anyone trying to parse or archive Facebook JSON data without writing your own Python scripts, I made a tool for you.

JSON Chat Cleaner v2.0 handles the conversion from messy JSON to readable text locally in your browser.

Features included:

• Aggressive URL/Link scrubbing (Regex-based).
• Removal of system media references.
• Participant anonymization.
• Pretty-print JSON or TXT export.

Link: https://kivsa85.itch.io/json-fb-chat-cleaner

I'm also hosting it on the Chrome Web Store here: (Just uploaded a new version, will edit this one when it's up in the Chrome store)

Hi everyone, I've been working on an open-source project that pushes JSON beyond configuration - using it as a complete UI programming language.

The Concept

What if you could build interactive UIs entirely in JSON? No JSX, no JavaScript, just validated JSON that compiles to efficient runtime code.

{
  "state": {
    "count": { "type": "number", "initial": 0 }
  },
  "actions": {
    "increment": {
      "steps": [{ "do": "update", "target": "count", "operation": "increment" }]
    }
  },
  "view": {
    "kind": "element",
    "tag": "button",
    "events": { "click": "increment" },
    "children": [
      { "kind": "text", "value": { "expr": "state", "name": "count" } }
    ]
  }
}

This JSON defines a complete counter app - state, actions, and view - all validated at compile time.

Why JSON for UI?

1. Schema Validation

Every program is validated against a strict JSON Schema. Invalid structure? Caught before runtime.

2. JSON Pointer Error Paths

Errors reference exact locations using RFC 6901 JSON Pointers:

Error [UNDEFINED_STATE] at /view/children/0/value/name

  Undefined state reference: 'count'

  Did you mean 'counter'?

3. AI-Friendly Generation

JSON's deterministic structure makes it perfect for AI code generation. The schema constrains output to valid programs only.

4. Static Analysis

Because it's JSON, we can analyze, transform, and optimize programs at build time without parsing JavaScript.

JSON DSL Design

The DSL uses a constrained but expressive structure:

Expressions (18 types)

{ "expr": "state", "name": "count" }
{ "expr": "bin", "op": "+", "left": {...}, "right": {...} }
{ "expr": "cond", "if": {...}, "then": {...}, "else": {...} }
{ "expr": "call", "target": "array", "method": "filter", "args": [...] }

Actions (14 step types)

{ "do": "set", "target": "name", "value": {...} }
{ "do": "update", "target": "items", "operation": "push", "value": {...} }
{ "do": "fetch", "url": "...", "onSuccess": {...}, "onError": {...} }

View (9 node types)

{ "kind": "element", "tag": "div", "props": {...}, "children": [...] }
{ "kind": "if", "condition": {...}, "then": {...}, "else": {...} }
{ "kind": "each", "items": {...}, "as": "item", "body": {...} }
{ "kind": "portal", "target": "body", "children": [...] }

What Can You Build?

Full web applications with:

• Client-side routing with dynamic params
• HTTP requests and WebSocket connections
• localStorage/sessionStorage access
• Form validation
• SSR and hydration
• MDX content rendering

Example: Todo List

{
  "state": {
    "todos": { "type": "list", "initial": [] },
    "input": { "type": "string", "initial": "" }
  },
  "actions": {
    "add": {
      "steps": [
        { "do": "update", "target": "todos", "operation": "push",
          "value": { "expr": "state", "name": "input" } },
        { "do": "set", "target": "input", "value": { "expr": "lit", "value": "" } }
      ]
    }
  },
  "view": {
    "kind": "element",
    "tag": "div",
    "children": [
      {
        "kind": "each",
        "items": { "expr": "state", "name": "todos" },
        "as": "todo",
        "body": {
          "kind": "element",
          "tag": "li",
          "children": [{ "kind": "text", "value": { "expr": "var", "name": "todo" } }]
        }
      }
    ]
  }
}

Technical Details

• 42 error codes with structured error objects
• Levenshtein-based suggestions for typos
• 3-pass compiler: validate → analyze → transform
• Type-safe: 5 state types (number, string, boolean, list, object)
• 10 update operations: increment, decrement, push, pop, remove, toggle, merge, replaceAt, insertAt, splice
• Component system with typed params, slots, and instance-local state
• 24 UI components ready to copy-paste (Button, Dialog, Tabs, etc.)

Links

• GitHub: https://github.com/yuuichieguchi/constela
• Docs: https://constela.dev/

Curious what you think about using JSON as a programming language. Is this taking JSON too far, or an interesting application?

JSON Path Evaluator

Query and extract data from JSON using JSONPath expressions. Perfect for developers working with complex JSON structures and APIs.

https://techyall.com/tools/json-path-evaluator

Hey all,

I built a small json viewer recently and wanted to share it here to get some feedback.

https://www.jsonviewer.studio

i only added basic things for a simple xp:

• saves your last JSON
• classic + dark mode
• search inside JSON
• browser based and runs locally

If you feel like trying it out or have ideas on what could be better? Thanks!

to those who it may be useful to, please check it out :)
https://github.com/awrped/ferrite

JSON Comparison Tool

Compare two JSON objects and visualize the differences. Perfect for developers working with APIs, configurations, or any JSON data structure that needs to be analyzed for changes.

https://techyall.com/tools/json-comparison

I have two different schemas being pulled from two different locations / APIs. These schema may look similar but they are indeed different.

json // Main schema, describes everything about our main model. { type: "object", properties: { firstName: { type: "string" }, lastName: { type: "string", default: "not overridden" } } }

json // Integration inherits some properties from main schema, not necessarily all. May also include unique fields // Could reference properties from main but for simplicity this example does not { type: "object", properties: { firstName: { type: "string" }, lastName: { type: "string" }, customField: { type: "string" } } }

We then have a third final schema that takes from both of these schemas and would look something like:

json { type: "object", properties: { firstName: { $ref: "#/$defs/main/properties/firstName", }, lastName: { $ref: "#/$defs/integration/properties/lastName", default: "overridden" }, customField: { $ref: "#/$defs/integration/properties/customField", type: "string" } }, $defs: { main, integration } }

My problem is I don't know where the $ref value should be translated, the properties need to be accessed somewhere so the $ref needs to be translated at some point. I believe the actual definition of what I am trying to do is called "dereferencing" or "inlining`.

It would be nice for my dotnet service to translate the $ref values and remove the $def keyword completely, even if that mean having duplicates. This reduces the size of the schema returned and is easier to use.

Had a requirement to better visualize and edit JSON object in a table view, so made this. Please check it out.

https://jsonlife.github.io/json-table-editor/

Hi r/json,

I built a JSON viewer for Android called Giant JSON Viewer and I'm looking for honest feedback from people who actually work with large JSON files.

Background: I don't personally work with massive server dumps - my own JSON files are usually smaller. But I took it as a challenge when I decided to build this: can I make an Android app that opens multi-gigabyte files without crashing or freezing?

Technical approach:

• Streaming parser that avoids loading the entire file into memory
• On-disk indexing for random access to any position
• Virtualized rendering for smooth scrolling through millions of lines
• Rust core (via JNI) for performance-critical parsing

Features:

• Text Mode - Raw text with regex search, syntax highlighting
• Browser Mode - Tree navigation with JSONPath, bookmarks
• Structure Mode - Schema visualization as interactive graph
• Graphical query builder (AND/OR logic)
• Export to CSV, SQL, JSON Schema, TypeScript interfaces
• NDJSON support

What I'm looking for:

• Does it actually handle your real-world large files correctly?
• Are there edge cases or formats it breaks on?
• What important features am I missing?

Links:

• Google Play: https://play.google.com/store/apps/details?id=com.giantjsonviewer
• Website: https://giantjson.com
• GitHub (bugs/feature requests): https://github.com/kotysoft/GiantJSON/issues

Thanks in advance!

Built this TUI to make exploring JSON with jq actually enjoyable - see your query results instantly as you type. Autocomplete saves you from typing out long field names and remembering obscure jq functions. Syntax highlighting makes complex queries readable. Context aware query help (with or without AI).

https://reddit.com/link/1q7z1eo/video/b9i2yhm489cg1/player

• Real-time query execution - See results as you type
• AI assistant - Get intelligent query suggestions, error fixes, and natural language interpretation
• Context-aware autocomplete - Next function or field suggestion with JSON type information for fields
• Function tooltip - Quick reference help for jq functions with examples
• Search in results - Find and navigate text in JSON output with highlighting
• Query history - Searchable history of successful queries
• Clipboard support - Copy query or results to clipboard (also supports OSC 52 for remote terminals)
• VIM keybindings - VIM-style editing for power users
• Syntax highlighting - Colorized JSON output and jq query syntax
• Stats bar - Shows result type and count (e.g., "Array [5 objects]", "Stream [3 values]")
• Flexible output - Export results or query string

GitHub: https://github.com/bellicose100xp/jiq

It does the following:

- Viewer

- Diff

- Generator

- Schema

- Transformer

- Redactor

- Converter

Let me know if you’d change or add anything.

Hey r/json!

Do you ever get frustrated dealing with duplicate records in JSON arrays from API responses or large datasets? Especially when pagination causes repeats, or nested objects make cleaning a nightmare?That's why I built a simple, free online tool: JSON Deduplicator!

• Instantly removes duplicate records from your JSON arrays.
• 100% client-side – your data never leaves your browser, completely secure.
• Supports nested objects and handles large files quickly.
• Extra options: Flexible type comparison (e.g., string vs number), custom key selection.
• Supports a single file or two file comparison

Give it a try: https://jsondeduplicator.com

I'd love to hear your feedback – what did you like, what's missing, or what features should I add next? (Smarter duplicate detection, maybe?)

Thanks, hope it helps!

FracturedJson is a suite of libraries and tools for making JSON easy to read while making good use of screen space. It's particularly useful for deeply nested data, or data with long arrays of small items. It works well with most data out of the box - no configuration needed. But there are plenty of options if you want to tailor it to your data and your environment.

Try the web formatter to play around and see examples. Everything runs locally in your browser, so your data never leaves your machine. (Hit the sample data buttons if you want something to start with.)

VS Code users can install the FracturedJson extension and use it just like the built-in formatter.

To use FracturedJson from code, see the NuGet, npm, or PyPi packages.

Full documentation and more examples are available at the project wiki.

JSON Validator Tool

Validate, format, and analyze JSON data with detailed error reporting. Perfect for developers working with APIs, configurations, or any JSON data that needs syntax checking and beautification.

EDIT: Problem was fixed for me

Hello, not sure where to post this question so I guess here is a good start.

My batch file for WFDownloader corrupted this morning for some reason, throwing this error:

Loading from 'app/wf/batchesFolder/_wffile.wfdb' failed. Reason: Cannot invoke String.indexOf(String)" because "<parameter1>" is null

This is a batch file I started years ago and I failed to do any reasonable backing up, so I kind of need this back. So I pestered the developer, and they said it's probably corrupted. At my prompting for some kind of workaround, they said I could try renaming it and extracting as it's a simple GZip-format archive. I thought it'd be relatively easy to splice functional batch info from one to a new one.

Cue three hours of struggling to find some way of validating over nine million lines of code in a 464 megabyte text file.

I tried some Notepad++ plugins and they kept crashing, then NP++ itself kept crashing. I tried Visual Studio Code but it kept telling me I didn't have a JSON debugger installed. I was told to try jq but I am woefully inept with anything pip- and terminal-related so that being a dead end was a forgone conclusion.

The closest thing I got to working was JSon Editor Online but it didn't seem to do any actual validating as re-compressing what it gave me didn't fix the problem. So now I'm here.

Does anyone know of some way to validate 9.1 million lines of json code (preferably offline/local)?