¿Qué es Xmloxide?

Xmloxide es una reimplementación en Rust puro de libxml2, la biblioteca C ampliamente utilizada para analizar, crear y manipular documentos XML y HTML. El proyecto se creó después de que libxml2 quedara oficialmente sin mantenimiento en diciembre de 2025 con problemas de seguridad conocidos. El desarrollador utilizó Claude Code para reproducir la biblioteca haciendo que el agente de IA trabajara contra las suites de pruebas existentes hasta que pasaran.

Características y capacidades clave

• Seguro en memoria — árbol basado en arena sin código inseguro en la API pública
• Conforme — tasa de aprobación del 100% en la Suite de Pruebas de Conformidad XML del W3C (1727/1727 pruebas aplicables)
• Recuperación de errores — analizar XML mal formado y aún así producir un árbol utilizable, al igual que libxml2
• Múltiples API de análisis — árbol DOM, transmisión SAX2, extracción XmlReader, inserción/incremental
• Analizador HTML — análisis tolerante a errores de HTML 4.01 con cierre automático y elementos vacíos
• XPath 1.0 — analizador de expresiones completo y evaluador con todas las funciones principales
• Validación — validación DTD, RelaxNG y Esquema XML (XSD)
• XML canónico — serialización C14N 1.0 y C14N Exclusiva
• XInclude — procesamiento de inclusión de documentos
• Catálogos XML — Catálogos XML OASIS para resolución de URI
• CLI xmllint — herramienta de línea de comandos para analizar, validar y consultar XML
• Sin copia donde sea posible — internamiento de cadenas para comparaciones rápidas
• Sin estado global — cada Documento es autónomo y Send + Sync
• FFI C/C++ — API C completa con archivo de encabezado (include/xmloxide.h) para integración en proyectos C/C++
• Dependencias mínimas — solo encoding_rs (la biblioteca tiene cero otras dependencias; clap es solo para CLI)

Rendimiento y compatibilidad

El rendimiento es similar al de libxml2 en la mayoría de las operaciones de análisis y mejor en la serialización. La biblioteca pasa la suite de compatibilidad, así como la Suite de Pruebas de Conformidad XML del W3C.

Ejemplos de código

Análisis básico:

use xmloxide::Document;

let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
let root = doc.root_element().unwrap();
assert_eq!(doc.node_name(root), Some("root"));
assert_eq!(doc.text_content(root), "Hello");

Serialización:

use xmloxide::Document;
use xmloxide::serial::serialize;

let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
let xml = serialize(&doc);
assert_eq!(xml, "<root><child>Hello</child></root>");

Consultas XPath:

use xmloxide::Document;
use xmloxide::xpath::{evaluate, XPathValue};

let doc = Document::parse_str("<library><book><title>Rust</title></book></library>").unwrap();
let root = doc.root_element().unwrap();
let result = evaluate(&doc, root, "count(book)").unwrap();
assert_eq!(result.to_number(), 1.0);

Transmisión SAX2:

use xmloxide::sax::{parse_sax, SaxHandler, DefaultHandler};
use xmloxide::parser::ParseOptions;

struct MyHandler;
impl SaxHandler for MyHandler {
    fn start_element(&mut self, name: &str, _: Option<&str>, _: Option<&str>, _: &[(String, String, Option<String>, Option<String>)]) {
        println!("Element: {name}");
    }
}
parse_sax("<root><child/></root>", &ParseOptions::default(), &mut MyHandler).unwrap();

Análisis HTML:

use xmloxide::html::parse_html;

let doc = parse_html("<p>Hello <br> World").unwrap();
let root = doc.root_element().unwrap();
assert_eq!(doc.node_name(root), Some("html"));

Recuperación de errores:

use xmloxide::parser::{parse_str_with_options, ParseOptions};

let opts = ParseOptions::default().recover(true);
let doc = parse_str_with_options("<root><unclosed>", &opts).unwrap();
for diag in &doc.diagnostics {
    eprintln!("{}", diag);
}

Uso de CLI

La herramienta CLI xmllint proporciona:

# Analizar y formatear
xmllint --format document.xml

Validar contra un esquema
xmllint --schema schema.xsd document.xml
xmllint --relaxng schema.rng document.xml
xmllint --dtdvalid

Contexto de desarrollo del agente de IA

El desarrollador experimentó haciendo que Claude Code reprodujera Redis y SQLite antes de apuntar a libxml2. El enfoque consistió en encargar al agente de IA que trabajara en proyectos hasta que las suites de pruebas existentes pasaran. Esto demuestra cómo los agentes de codificación pueden iterar rápidamente dada una suite de pruebas, abordando potencialmente problemas de mantenimiento de código heredado.