xmlutil is a Kotlin Multiplatform XML library that provides three layers: a streaming pull-parser/writer abstraction (XmlReader/XmlWriter with a pure-Kotlin KtXmlReader and platform StAX/Android backends), a portable DOM Level 2 implementation with JVM/JS/Native/Wasm wrappers, and an XML serialization format for kotlinx.serialization (the XML.v1 codec with annotations such as @XmlSerialName, @XmlValue, @XmlPolyChildren and policy-based configuration). It is a library, not an application: there are no servers or CLIs, only published Maven artifacts (core, serialization, xmlschema, serialutil, testutil) plus examples, benchmarks, and a Gradle plugin used for building/publishing the library itself. It targets JVM, Android (deprecated module), JS, Native, and Wasm. The architecture is strictly modular: core/base holds platform-independent streaming, DOM, namespaces, and entity handling; core/jdk and core/android are platform backends; serialization implements the kotlinx.serialization format including type/descriptor caching, polymorphic parent handling, and compact-fragment support; xmlschema is a near-complete XML Schema 1.0/1.1 parser/resolver with a custom XPath expression engine and a purpose-built regex engine for XSD pattern facets; serialization-io and core/kxio bridge kotlinx-io sinks/sources; testutil ships cross-platform XML assertion helpers. The dominant data flow is: XML text -> streaming events (XmlReader) -> DOM or direct object deserialization, and the reverse for output, with XmlSerializationPolicy controlling naming, lists, maps, namespaces, and encoding/decoding behavior. The engineering depth is genuinely high: a hand-written XSD regex engine with Unicode decomposition and surrogate set classes, flat-array namespace stacks with O(1) depth operations, DTD/entity expansion logic, an LRU format cache with recursion detection, and binary-compatibility validation (API and klib .api files) on every build. Test coverage is extensive, including regression tests for dozens of numbered GitHub issues, a W3C XML Schema test-suite harness, and JVM benchmarks. The main weaknesses are an intentionally large experimental API surface (@ExperimentalXmlUtilApi), some boilerplate near-duplication in schema facet classes, and platform-source-set sprawl that multiplies maintenance cost. Maintenance is active: recent commits (Aug 2026), GitHub Actions CI (runTests, publish-snapshot, upload_release), zero Dependabot alerts, and modern tooling (Gradle version catalog, BOM, Gradle wrapper validation). Some legacy artifacts remain (stale .travis.yml, deprecated core-android and xmlserializable modules), but they are explicitly marked deprecated rather than silently rotting. Technical drift is low; the codebase deliberately tracks fast-moving kotlinx.serialization APIs and documents Kotlin compiler workarounds, indicating a maintained rather than abandoned project.
xmlquery is a Go library for querying XML documents using XPath expressions. It provides functions to parse XML from various sources (string, file, URL, etc.), execute XPath queries, and manipulate the resulting node tree. The library features a caching mechanism for compiled XPath expressions to improve query performance and supports streaming parsing for large XML files to minimize memory usage. The architecture is modular, with separate concerns for parsing, querying, and node manipulation, and it relies on external dependencies for XPath expression handling and LRU caching.
Colly is a mature, high-performance web scraping framework for Go, providing a clean, callback-based API for crawling and extracting structured data from HTML and XML. It handles HTTP requests, session management, caching, robots.txt compliance, proxy rotation, rate limiting, and parallel scraping out of the box. The library is built around a Collector object that orchestrates configurable callbacks (OnRequest, OnResponse, OnHTML, OnXML, OnError, OnScraped) and supports chaining, context propagation, and request queueing for large-scale scraping jobs. The codebase is well-structured, thoroughly tested, and follows Go idioms, making it a reliable choice for production scraping tasks. It is not a data research project; it is a general-purpose scraping library.
node-feedparser is a streaming RSS/Atom/RDF feed parser for Node.js. In production, it consumes XML from any readable stream and emits normalized feed metadata and article objects through a Transform stream. Consumers use the `meta` event for feed-level data, the `readable`/`data` events for individual items, or async iteration via `for await...of`. The parser handles real-world feed quirks: XML namespaces, CDATA, xml:base URL resolution, embedded HTML in content, duplicate enclosures, malformed XML, and SAX errors that can optionally be resumed past. A small CLI wrapper (`bin/feedparser.js`) allows piping feeds directly to JSON output. The architecture is a classic Node.js library rather than a service or pipeline. The core is `lib/feedparser.js`, which wires SAX events into a normalized model, with `lib/utils.js` providing URL resolution, HTML stripping, and namespace helpers, and `lib/constants.js` mapping namespaces to prefixes. There is no database, API server, or analytics layer. The library depends only on small utility packages (`sax`, `readable-stream`, lodash helpers, `mri` for the CLI), making it embeddable and portable. The repository includes an extensive Mocha test suite with realistic feed fixtures, TypeScript type definitions, and CI coverage across multiple Node.js versions. This is not a data-research repository; it is a general-purpose parsing utility with strong attention to edge cases in syndicated XML. The codebase is mature and actively maintained, with recent commits addressing parser edge cases and type definitions. Technical drift is moderate: some dependencies and code patterns (readable-stream v2, lodash v4, `var` usage) reflect an older Node.js baseline, though the package is still tested against modern Node versions.
ruby-nmap is a Ruby library that provides programmatic access to the nmap network scanning tool. It consists of two main components: 1) A command-line interface builder (Nmap::Command) that allows Ruby programs to configure and execute nmap scans with full access to nmap's options through a Ruby DSL, and 2) An XML parser (Nmap::XML) that converts nmap's XML output into navigable Ruby objects representing hosts, ports, services, OS detection results, and script output. The library acts as a bridge between Ruby applications and the nmap executable, handling the complexity of command-line argument construction and XML parsing while providing an idiomatic Ruby interface. The project is actively maintained with recent commits, comprehensive test coverage, and support for multiple Ruby versions.