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.
Uppy is a modular, client-side JavaScript file upload library with a companion server (Companion) for remote provider integrations. It provides a plugin-based architecture where core functionality (file selection, upload strategies, UI components) is encapsulated in reusable packages. The client-side library supports drag-and-drop, webcam/screen capture, image editing, thumbnail generation, and multiple upload backends (tus resumable, AWS S3 multipart, XHR, Transloadit). The Companion server handles OAuth flows, remote file listing/download from providers like Google Drive, Dropbox, Box, OneDrive, Facebook, Zoom, Unsplash, and WebDAV, as well as S3 presigning and Transloadit Storage integration. The repository is a monorepo with over 50 packages, including framework-specific wrappers for React, Vue, Svelte, and Angular, plus headless controllers for custom UI. Key entry points are @uppy/core (Uppy class, plugin system), @uppy/dashboard (main UI), @uppy/companion (Express server), and @uppy/aws-s3 (S3 upload client). Data flows: user selects files via UI plugins, which are then uploaded via configured uploader plugins; remote sources are fetched through Companion using OAuth tokens. External dependencies include tus-js-client, AWS SDK, Transloadit API, and various OAuth providers. The codebase is well-tested with unit, integration, and browser tests, and uses modern TypeScript, ESM, and Preact for UI.
CodExt is a Python library and command-line tool that extends the standard library's codecs with over 120 custom encodings for data transformation. It provides encoding/decoding functionalities across domains including base encodings (baseN, base45, base85, etc.), cryptography (Vigenère, RSA, XOR), compression (gzip, LZ77/LZ78), steganography, and language-based transformations (Leetspeak, Morse, Braille). The system features a heuristic-based guess mode for automated multi-layered decoding and a macro system for chaining codecs. Architected as a plugin-based library, it allows dynamic registration of new codecs and is designed for CTF, security, and data obfuscation tasks. The codebase demonstrates strong modularity with clear separation of concerns between core functionality, codec implementations, and utility modules.
This repository is a comprehensive Go library for geometric data structures and operations. It provides implementations of OGC-standard geometry types (Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, GeometryCollection) with support for 2D, 3D, and measured dimensions. The library includes algorithms for computational geometry (area, centroid, convex hull, line intersection, etc.) and encoders/decoders for formats like WKT, WKB, GeoJSON, KML, and IGC. Architecture is modular: core `geom` package defines types and interfaces, `xy`/`xyz` packages handle planar/spatial algorithms, `encoding/*` packages manage format serialization, and utilities like `transform` and `sorting` offer reusable helpers. Command-line tools for IGC parsing and PostGIS integration demonstrate practical usage. The code emphasizes clean separation of concerns, interface-driven design, and thorough testing including property-based and fuzzing tests.
This repository is the official reference implementation of the VP8 and VP9 video codec standards (libvpx), maintained by the WebM project. It provides a C library for encoding and decoding VP8/VP9 video streams, with support for multiple container formats (IVF, WebM, Y4M), real-time and two-pass encoding, scalable video coding (SVC), and high-bit-depth profiles (10/12-bit). The architecture is a classic monolithic codec library: a public API layer (`vpx_codec_*` functions) dispatches to internal encoder/decoder state machines, which in turn call a large set of DSP primitives (transforms, quantization, motion estimation, loop filtering, entropy coding) implemented in both portable C and heavily optimized SIMD for x86 (SSE2/SSE4/AVX2/AVX512), ARM (NEON, SVE), MIPS (MSA, DSPR2), PowerPC (VSX), and LoongArch (LSX). The build system uses custom `.mk` files with runtime CPU detection (RTCD) to select the appropriate function pointer at runtime, enabling a single binary to run across diverse hardware. The primary data flow is frame-by-frame: raw YUV frames enter the encoder, are transformed, quantized, entropy-coded, and output as a bitstream; the decoder reverses the process. Rate control models buffer fullness and scene complexity to meet target bitrates. The codebase includes extensive Google Test-based unit tests covering algorithm correctness, bitstream conformance, and performance benchmarks. Example applications (`vpxenc`, `vpxdec`, `simple_encoder`, `simple_decoder`) demonstrate the API and serve as integration tests. Key entry points include `vpx_codec_enc_init()`, `vpx_codec_encode()`, `vpx_codec_dec_init()`, `vpx_codec_decode()`, and the control interface (`vpx_codec_control_`). External dependencies are minimal (only standard C library and optional platform headers); third-party code includes Google Test, libwebm (WebM mux/demux), libyuv (color conversion, bundled), and x86inc.asm (NASM macros). The repository also contains research-oriented tools under `tools/3D-Reconstruction/` (Python/Processing sketches for motion estimation and 3D reconstruction) which are experimental and not part of the core library.
DockYard/elixir-mail is an Elixir library for building, parsing, and rendering email messages according to RFC 2822 and related MIME standards. It provides a composable API to create simple and multipart email messages, handle various transfer encodings (Base64, Quoted-Printable, 7bit, 8bit, binary), and parse incoming email into structured data. The library is structured around a core `Mail.Message` struct with separate modules for encoding, parsing, rendering, and MIME type lookup. It does not require any external runtime dependencies beyond the Erlang/OTP standard library.
qs is a JavaScript library for parsing and stringifying URL query strings with support for nested objects, arrays, and custom formatting. It is designed as a drop-in replacement for Node.js's built-in querystring module but with enhanced security features, including protection against prototype pollution, configurable depth limits, and parameter/array size limits. The library exposes three main functions: `parse`, `stringify`, and `formats`, all accessible from the single entry point `lib/index.js`. Internally, it uses a side-channel pattern for cycle detection and overflow tracking, and implements a chunked UTF-8 encoder to handle surrogate pairs safely. The codebase is well-tested with an extensive suite of edge-case tests, and it is distributed as an npm package with browser builds via Browserify. Architecturally, qs is a focused, single-purpose library with a clean separation of concerns: parsing logic in `lib/parse.js`, serialization in `lib/stringify.js`, shared utilities in `lib/utils.js`, and formatting constants in `lib/formats.js`. It follows a functional style with option normalization functions that validate and fill defaults, making the API robust against misuse. The library has a long history (over a decade) and is widely adopted (nearly 9000 stars), but its maintenance shows signs of high release churn and legacy support burdens, including backporting fixes to older Node.js versions (>=0.6) and maintaining outdated packaging artifacts like `bower.json` and `component.json`. Despite these legacy concerns, the core code is well-crafted, security-conscious, and actively maintained with frequent releases and responsive issue triage.
Apache Commons Codec is a mature Java library providing a comprehensive set of encoders and decoders for binary-to-text formats (Base16, Base32, Base64, Base45, Base58, Hex), digest and hash algorithms (MD5, SHA-1/2/3, MurmurHash, XXHash32, Blake3, CRC16/32), phonetic encoding (Soundex, Metaphone, Caverphone, Beider-Morse, Daitch-Mokotoff), and network codecs (URL encoding, Quoted-Printable, RFC 1522 MIME). The architecture is modular with clear package separation: `binary`, `digest`, `language`, `net`, and `cli`. Key design patterns include a builder pattern for configuring codecs (e.g., `Base64.builder()`), an abstract base class `BaseNCodec` with streaming support via `BaseNCodecInputStream`/`OutputStream`, and a `CodecPolicy` enum for strict vs. lenient decoding. The library has no production dependencies; only test dependencies on commons-lang3 and commons-io. It is widely used across the Java ecosystem, with extensive test coverage including RFC vectors and backward compatibility tests. However, some deprecated methods and known bugs (e.g., in MurmurHash3 legacy methods) are preserved for compatibility, and certain algorithms (SHAKE) require Java 25, introducing version drift.
ZXing (Zebra Crossing) is a mature, multi-format barcode image processing library written in Java. It provides both decoding and encoding capabilities for over 15 1D and 2D symbologies, including QR Code, Data Matrix, Aztec, PDF417, UPC/EAN, Code 128, and many more. The core library is platform-independent, with additional modules for Android (Barcode Scanner app), Java SE (command-line tools), and web applications (a decode servlet and a GWT-based generator). The architecture follows a clean Reader/Writer interface pattern, with format-specific implementations decoupled from common infrastructure like Reed-Solomon error correction, binarization, and perspective transformation. The library is in maintenance mode: no new features are planned, but bug fixes and minor enhancements from the community are accepted. The Android app is deprecated and does not work on Android 14. Despite its age, the codebase remains a reference implementation for barcode standards and is widely ported to other languages.
AntSword is an Electron-based desktop application for managing web shells on remote servers, primarily used by penetration testers and authorized security researchers. It provides a tabbed interface for shell management, file browsing, virtual terminal access, database querying, and plugin execution. The core engine in source/core generates HTTP requests from per-language templates (PHP, ASP, ASPX, JSP, etc.), applies configurable encoders/decoders for obfuscation, and parses responses using charset detection. Shell credentials and settings are persisted locally via nedb through modules/cache.js and modules/database.js.
Awesome Video is a curated resource catalog for streaming video technologies, maintained as structured JSON (contents.json) and rendered into both a README and a static documentation site (MkDocs Material) deployed to awesome.video. The catalog spans ~50 hierarchical categories covering HLS, DASH, FFmpeg, codecs (HEVC/VP9/AV1), transport protocols (RIST/SRT/RTMP), players, DRM, QoE, testing, CDN, HDR, subtitles, and learning resources. It is not a runtime application — it is a content curation pipeline: contents.json is the source of truth, convert.rb generates the README, database.json feeds the site's lunr search index, and loader.py imports bookmarks from Raindrop.io. The repo is hybrid in nature: primarily a curated data catalog with a static-site build system around it, rather than a software application or research pipeline. The build pipeline (GitHub Actions) validates the JSON against schema.json, checks external links with awesome_bot, and deploys to GitHub Pages. The curation quality is strong — entries include authoritative references (Netflix TechBlog, DASH-IF specs, Apple WWDC sessions, Xiph test media) — but the supporting code is simple utility scripting with notable weaknesses: hardcoded Raindrop.io credentials in loader.py, inconsistent category identifiers and malformed tag entries in the data, and aging CI dependencies (Python 3.7, jinja2 3.0.3). The repo is actively maintained and the data model (hierarchical categories + multi-tagged project records) is a clean, portable schema for any awesome-list-style content site.