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.
This is a mature Rust library for parsing and serializing RSS feeds (versions 0.90 through 2.0). It provides a complete data model for RSS channels, items, categories, enclosures, and other elements, with support for common extensions like iTunes, Dublin Core, Syndication, and Atom. The library uses quick-xml for efficient XML processing and offers optional builder patterns, validation against the RSS 2.0 specification, and serde serialization. The codebase is well-structured, with clear separation of concerns across modules, comprehensive test coverage (including round-trip read/write tests), and active maintenance with regular dependency updates. It is a solid, production-ready library for any Rust project needing RSS feed handling.
This repository provides a Python library for creating, reading, and writing AUTOSAR XML (ARXML) files, targeting Classic AUTOSAR platforms from R19-11 to R22-11. It covers a broad range of AUTOSAR elements—software components, port interfaces, data types, constants, compu methods, service needs, and more—through an object-oriented model with full XML serialization. The library is not an end-user application but a tool for automotive engineers and tool integrators to programmatically generate ARXML artifacts for import into commercial AUTOSAR toolchains. It also includes an early-stage code generator that produces C type definitions (Rte_Type.h) from the XML model. The architecture follows a layered design: an XML model layer (autosar.xml) with element classes, enums, and references; a workspace abstraction that manages packages, documents, and template application; and a generator layer that transforms the XML model into an intermediate representation for code generation. A notable design pattern is the template system (ElementTemplate/GenericTemplate) that decouples high-level element recipes from their serialization, enabling config-driven generation of entire projects from TOML configuration files. The library is supported by a comprehensive test suite that exercises round-trip XML serialization for hundreds of element types. The codebase shows good craftsmanship—clean separation of concerns, consistent use of base classes (Identifiable, Describable), version-aware enum handling, and typed reference system. However, it is still in development (v0.5.7) with many planned releases and a roadmap that implies future breaking changes. Several AUTOSAR elements remain unimplemented, and the test suite relies on exact XML string comparisons, making it brittle. The project is maintained by a single contributor with no PyPI release, posing adoption and continuity risks. Overall, it is a solid, functional library for its domain but not yet production-ready for all use cases.
maltego-trx is the legacy Python SDK for building Maltego transforms (the OSINT/graph investigation platform), now explicitly archived and superseded by the actively maintained maltego-transforms SDK. In production it runs as a Flask HTTP server: the Maltego desktop client POSTs an XML transform request to /run/<transform_name>/, the server parses it into a MaltegoMsg, dispatches to a registered transform class, and serializes the resulting MaltegoTransform response back as XML. Transform classes are auto-discovered from the project's local `transforms` package (class name must match the filename and subclass DiscoverableTransform). The package also ships a CLI (`maltego-trx start`/`init`) that scaffolds new transform projects from a template directory, plus a project-level CLI (`project.py runserver/list/local`) implemented in handler.py.