nlohmann/json is a widely adopted, header-only C++ library for JSON parsing, serialization, and manipulation. It provides a single-header `json.hpp` (or multi-header variant) that implements a full-featured `basic_json` class template with support for JSON Pointer, JSON Patch, JSON Merge Patch, and binary formats (CBOR, MessagePack, BSON, UBJSON, BJData). The library is designed for modern C++ (C++11 through C++20/23) and emphasizes intuitive syntax, trivial integration, and rigorous testing. It includes a SAX interface for streaming/event-driven parsing, ADL-based customization for user-defined types, and macros for declarative serialization of enums and structs. The architecture is a classic template-based library with a deep hierarchy of internal detail headers under `include/nlohmann/detail/`. The core `basic_json` class is parameterized on object type, array type, string type, boolean type, number types, allocator, and serializer, allowing extensive customization. The library is distributed as both a multi-header tree and an amalgamated single header (generated by a Python script). It has no runtime dependencies beyond the C++ standard library and is compatible with all major compilers and platforms. Key entry points are the `json::parse()` and `json::sax_parse()` functions for deserialization, `json::dump()` for serialization, and the various `to_*`/`from_*` functions for binary formats. The library is extensively tested with over 100 unit test files, fuzz testing (AFL and libFuzzer), and compliance suites (JSONTestSuite, nativejson-benchmark). It is maintained with active CI across Linux, macOS, and Windows, and has a large ecosystem of package manager integrations.
Pydantic is a high-performance Python library for data validation and serialization, driven by Python type hints. Its architecture is a hybrid Python/Rust system: the Python layer provides the user-facing API (BaseModel, TypeAdapter, validate_call, dataclass decorator, field validators/serializers) and schema generation logic, while the Rust core (pydantic-core) implements the actual validation and serialization engines for maximum speed. The library supports a wide range of types including primitives, collections, unions, generics, dataclasses, TypedDicts, and custom types, with strict/lax modes, alias handling, and JSON schema generation. Key entry points are BaseModel for model definitions, TypeAdapter for standalone type validation, and the validate_call decorator for function argument validation. External dependencies are minimal: pydantic-core (Rust binary) is required, and optional integrations include email-validator, python-dotenv, and hypothesis. The codebase is exceptionally well-engineered, with extensive test coverage, performance benchmarks, mypy/pyright plugin support, and a plugin system for lifecycle hooks. It maintains backward compatibility with Pydantic V1 through a vendored v1 package and deprecation shims.
This is the core tree-sitter repository, providing a parser generator toolchain and an incremental parsing runtime library. In production, it consumes grammar definitions written in a JavaScript DSL or JSON format and generates standalone C parsers (or WebAssembly modules) that can parse source code incrementally at keystroke speed. The architecture comprises a minimal C library (`lib/src/`) that implements a GLR parser with error recovery, a Rust-based generator (`crates/generate/`) that compiles grammars into LR parse tables and emits C code, a CLI tool (`crates/cli/`) for developing/testing grammars and performing syntax highlighting/querying, and bindings for Rust, Node.js/TypeScript, and Web. The system is designed for integration into editors (e.g., VS Code, Neovim) and code analysis tools, offering incremental parsing, tree queries, syntax highlighting, and symbol tagging. External dependencies are minimal for the C core (none), while the Rust toolchain depends on wasmtime, QuickJS, and standard crates. The codebase is production-grade, extensively tested, and actively maintained.
Wuffs is a memory-safe programming language and toolchain for writing parsers and codecs, with C code generation as its primary output. The system provides a comprehensive library of decoders for image formats (JPEG, PNG, GIF, BMP, WebP, etc.), compression formats (Deflate, Zlib, Gzip, LZMA, XZ, BZip2, etc.), and checksums (CRC32, Adler32, SHA256). It is designed to eliminate buffer overflows, integer overflows, and null pointer dereferences at compile time through formal verification and interval arithmetic, without runtime overhead. The architecture consists of a custom DSL (Wuffs language) with a Go-based compiler (parser, type checker, optimizer), a C code generator that produces a single-file header-only C library, and a set of auxiliary C++ modules for high-level APIs. Key entry points include the `wuffs` CLI tool for managing packages and generating C code, the `wuffs-c` tool for C-specific operations, and the generated `wuffs-unsupported-snapshot.c` file that can be dropped into any C project. External dependencies are minimal: the development toolchain requires Go, but the generated C library has no dependencies beyond standard C. The system is used in production (e.g., GIF decoder in Google Chrome) and is benchmarked as 1.3–6× faster than equivalent C libraries.
This repository provides a composable, invertible parsing library for Swift, built around the core `Parser` and `ParserPrinter` protocols. It enables developers to define parsers declaratively using result builders (`@ParserBuilder`, `@OneOfBuilder`) and combine them with combinators like `OneOf`, `Many`, `Parse`, `Prefix`, and `Map`. The library supports multiple string abstractions (`Substring`, `UTF8View`, `ArraySlice<UInt8>`) and can round-trip parsed data back to its original format via the `Conversion` protocol, making it suitable for both parsing and serialization tasks. The architecture is protocol-oriented and highly modular. Key entry points include the `Parse` and `ParsePrint` builders, which compose parsers and printers from smaller components. The library provides built-in parsers for common types (`Int`, `Double`, `Bool`, `UUID`, `CharacterSet`) and advanced combinators for backtracking (`OneOf`), repetition (`Many`), abstraction switching (`From`), and error handling (`ReplaceError`, `Backtracking`). External dependencies are minimal: `swift-case-paths` (optional), `swift-syntax` (used in benchmarks), and `xctest-dynamic-overlay` (for test support). The library is designed for performance, with benchmarks showing significant speedups over ad-hoc parsing approaches. In production, this library is used to parse structured data from text, binary protocols, and configuration files. Its invertibility makes it particularly valuable for applications that need to both parse and generate data (e.g., serializers, code generators, DSL interpreters). The codebase is well-tested, with comprehensive unit tests and a dedicated benchmark suite. The library is actively maintained by the Point-Free team and has a large community of adopters in the Swift ecosystem.
CyberChef is a web-based cybersecurity toolkit for data manipulation, analysis, and transformation. It operates entirely client-side, enabling users to perform operations like encoding, encryption, compression, and data analysis without transmitting data to external servers. The application features a modular architecture where each operation is a self-contained class that can be chained together in recipes to create complex data transformation pipelines. The system is built with a clear separation of concerns: a core processing engine (Chef) handles operation execution, a web interface provides user interaction, and web workers offload intensive tasks to maintain responsiveness. Operations define explicit input/output types, and a dish type system ensures safe data handling across transformations. The project includes a Node.js API for programmatic access and a comprehensive test suite to ensure reliability. Key reusable components include the Operation base class (enabling a plugin architecture for new transformations), the Utils library (providing encoding/decoding and conversion utilities), and the Dish type system (abstracting data handling). The project demonstrates strong engineering practices with active maintenance, low technical drift, and a focus on security and performance through client-side processing and worker-based offloading.
Valibot is a modular, type-safe schema validation library for TypeScript with zero external dependencies. It provides a comprehensive set of schemas (string, number, object, array, union, etc.), validation actions (email, minLength, regex, etc.), transformation actions (toNumber, toUpperCase, parseJson, etc.), and composition methods (pipe, fallback, forward, cache). The library is tree-shakeable, supports both sync and async validation, and achieves 100% test coverage. Its architecture follows a consistent action/schema object pattern with a `~run` method for runtime validation and extensive TypeScript generics for type inference (InferInput, InferOutput, InferIssue). The repository is a monorepo containing the core library, a documentation website built with Qwik, a codemod for migrating from Zod to Valibot, a JSON Schema conversion package, and an i18n package for localized error messages. The primary entry point is `library/src/index.ts`, which re-exports all schemas, actions, methods, and utilities. Data flows involve defining schemas, optionally piping actions, and then calling `parse` or `safeParse` to validate input against the schema. The library implements the Standard Schema specification for interoperability.
Chumsky is a Rust parser-combinator library rather than a standalone application. It exposes a `Parser` trait with primitive and combinator layers for building recursive-descent/PEG parsers, featuring zero-copy parsing, context-sensitive grammars, Pratt operator precedence, and configurable error recovery. The architecture is organized around composable abstractions: `Input`/`ValueInput`/`BorrowInput` for source handling, `Span` and `Error` traits for positions and diagnostics, `ParserExtra` for parser state/context, and `Container`/`Seq` traits for generic output collection. The main entry points are the public API in `src/lib.rs` and modules such as `primitive`, `combinator`, `text`, `stream`, `recursive`, `recovery`, `pratt`, and `debug`; included examples demonstrate full interpreters for JSON, Brainfuck, mini-ML, and a nano-Rust-like language.
Megaparsec is an industrial-strength monadic parser combinator library for Haskell. It provides a feature-rich balance between speed, flexibility, and quality of parse errors. The library supports parsing String, ByteString, and Text (both strict and lazy) input streams, with sophisticated error reporting that includes source code position highlighting, custom error components, and bundled error messages. It includes utilities for whitespace and comment handling, indentation-sensitive grammars, and lexing of numbers and literals. The architecture is modular, with core parsing functionality in Text.Megaparsec and specialized modules for byte/char processing, error handling, and lexing.
jc (JSON Convert) is a mature Python library and CLI tool that converts the output of over 150 command-line tools, system files, and common data formats into structured JSON. It operates both as a piped command-line utility (`jc <command>`) and as a programmable Python module (`jc.parse('parser_name', data)`), enabling seamless integration with jq, scripting, and automation pipelines. The architecture follows a consistent parser pattern: each parser module defines an `info` metadata class and a `parse(data, raw, quiet)` function, with optional `_process()` for type coercion. Streaming parsers (suffixed `_s`) use generator-based patterns for real-time output. The library includes vendored dependencies for ASN.1, plist, EDID, and TOML parsing, and supports cross-platform execution across Linux, macOS, FreeBSD, and Windows. The primary data flow is stdin or file input → parser module → structured dict/list output (JSON or YAML). Key entry points include the CLI (`jc/cli.py`), the library API (`jc/lib.py`), and individual parser modules under `jc/parsers/`. The project maintains an extensive test suite with fixtures captured from multiple OS versions, ensuring robustness against command output variations. It also provides shell completions, a plugin system for custom parsers, and documentation generation scripts. While the codebase is well-engineered with clean abstractions, the sheer number of parsers and reliance on vendored libraries introduce moderate maintenance surface area.
JSONy is a high-performance JSON parsing and serialization library for the Nim programming language. It bypasses the intermediate JSON node step used by the standard library, directly converting between JSON strings and Nim data structures for improved speed and reduced garbage collection pressure. The library features a flexible hook system (newHook, postHook, parseHook, dumpHook, etc.) that allows customization of the serialization and deserialization process for complex scenarios like handling missing fields, renaming fields, processing enums, and working with JSON-in-json. It supports a wide range of Nim types including primitives, sequences, arrays, objects, ref objects, options, enums, tuples, sets, tables, and custom types via hooks. The implementation avoids StringStream overhead by working directly with memory buffers and parses numbers without intermediate string allocations.
This is a full-stack PHP web application for parsing, storing, and viewing DMARC aggregate (RUA) reports. It provides a web interface for administrators to manage domains, users, and reports, and includes CLI utilities for automated report fetching, cleanup, and summary email generation. The architecture follows a layered design with database abstraction via mapper interfaces, multiple report source implementations (IMAP mailboxes, local directories, remote filesystems, file uploads), and a plugin system. The front-end uses vanilla JavaScript with custom reusable UI components (tables, dialogs, multiselect) and a hash-less router. The codebase is well-structured, includes unit tests, and demonstrates strong software engineering patterns such as the repository pattern, factory methods, and interface-segregated database mappers. However, it relies on PHP extensions like imap (deprecated in PHP 8.4), uses MySQL-specific SQL, and has some XSS concerns due to innerHTML usage. It is not a data research repository; it is a production-ready application for managing DMARC reporting.
node-xml2js is a mature, well-tested Node.js library for bidirectional conversion between XML and JavaScript objects. It uses sax-js for parsing and xmlbuilder-js for building, providing a simple callback or Promise-based API. The library supports extensive configuration options including attribute and tag name processors, value processors, namespace handling, CDATA, and various output formatting. The source code is written in CoffeeScript (compiled to JavaScript), which is now a deprecated language, and the dependencies are outdated (sax >=0.6.0, xmlbuilder ~11.0.0). While the library is functionally complete and has been widely used (over 4900 stars), it has not seen active development in years, and the CoffeeScript source presents a barrier for modern contributions. The codebase is well-structured with clear separation of concerns, but the technical drift is high due to the use of deprecated tools and outdated dependency versions.