Was ist Xmloxide?

Xmloxide ist eine reine Rust-Neuimplementierung von libxml2, der weit verbreiteten C-Bibliothek zum Parsen, Erstellen und Bearbeiten von XML- und HTML-Dokumenten. Das Projekt wurde gestartet, nachdem libxml2 im Dezember 2025 offiziell als ungewartet eingestuft wurde und bekannte Sicherheitsprobleme aufwies. Der Entwickler nutzte Claude Code, um die Bibliothek nachzubauen, indem er den KI-Agenten an bestehenden Testsuites arbeiten ließ, bis diese bestanden wurden.

Wichtige Funktionen und Fähigkeiten

• Speichersicher – Arena-basierter Baum ohne unsicheren Code in der öffentlichen API
• Konform – 100% Bestehensrate bei der W3C XML Conformance Test Suite (1727/1727 anwendbare Tests)
• Fehlerbehebung – Parsen von fehlerhaftem XML und dennoch Erzeugen eines nutzbaren Baums, genau wie libxml2
• Mehrere Parsing-APIs – DOM-Baum, SAX2-Streaming, XmlReader-Pull, Push/inkrementell
• HTML-Parser – Fehlertolerantes HTML 4.01-Parsing mit automatischem Schließen und Void-Elementen
• XPath 1.0 – Vollständiger Ausdrucksparser und Evaluator mit allen Kernfunktionen
• Validierung – DTD-, RelaxNG- und XML-Schema-Validierung (XSD)
• Canonical XML – C14N 1.0- und Exclusive C14N-Serialisierung
• XInclude – Verarbeitung von Dokumenteinbindungen
• XML-Kataloge – OASIS XML-Kataloge für URI-Auflösung
• xmllint CLI – Kommandozeilenwerkzeug zum Parsen, Validieren und Abfragen von XML
• Zero-Copy wo möglich – String-Interning für schnelle Vergleiche
• Kein globaler Zustand – Jedes Dokument ist eigenständig und Send + Sync
• C/C++ FFI – Vollständige C-API mit Header-Datei (include/xmloxide.h) für die Einbettung in C/C++-Projekte
• Minimale Abhängigkeiten – Nur encoding_rs (die Bibliothek hat keine weiteren Abhängigkeiten; clap ist nur für die CLI)

Leistung und Kompatibilität

Die Leistung ist bei den meisten Parsing-Vorgängen ähnlich wie bei libxml2 und bei der Serialisierung besser. Die Bibliothek besteht sowohl die Kompatibilitätssuite als auch die W3C XML Conformance Test Suite.

Codebeispiele

Grundlegendes Parsing:

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");

Serialisierung:

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>");

XPath-Abfragen:

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);

SAX2-Streaming:

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();

HTML-Parsing:

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"));

Fehlerbehebung:

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);
}

CLI-Nutzung

Das xmllint CLI-Werkzeug bietet:

# Parsen und schön formatieren
xmllint --format document.xml

Gegen ein Schema validieren
xmllint --schema schema.xsd document.xml
xmllint --relaxng schema.rng document.xml
xmllint --dtdvalid

KI-Agenten-Entwicklungskontext

Der Entwickler experimentierte damit, dass Claude Code Redis und SQLite nachbaute, bevor er libxml2 ins Visier nahm. Der Ansatz bestand darin, den KI-Agenten an Projekten arbeiten zu lassen, bis bestehende Testsuites bestanden wurden. Dies zeigt, wie Code-Agenten bei Vorliegen einer Testsuite schnell iterieren können, was potenziell Wartungsprobleme von Legacy-Code angehen könnte.