PUGIXML_CHARCONV_FLOAT option can be enabled to switch floating point conversions to <charconv>; this requires C++17, makes the conversions locale-independent and can improve performance

Add xml_node::ensure_child and xml_node::ensure_attribute that return the child/attribute with the specified name, adding one if it does not exist

Improve performance of searching for nodes and attributes by name

Loading a document from an empty buffer no longer performs memory allocations

Improve performance of queries that evaluate or compare attribute values, like @attr > 5

Improve performance of queries that select nodes and attributes by name

Fix stack overflow when removing subtrees with extremely deep nesting

Fix integer overflows that could lead to crashes when loading very large (1+ GB) documents on 32-bit platforms in PUGIXML_WCHAR_MODE

Fix null pointer dereference when copying xpath_variable_set objects that contain string variables with unassigned values

Apple frameworks built with PUGIXML_BUILD_APPLE_FRAMEWORK now include framework headers

PUGIXML_INSTALL_SOURCE option can be used to install pugixml.cpp (useful for header-only mode)

Add project files and NuGet packages for Visual Studio 2026

Fix compatibility with C++20 modules when including pugixml.hpp in the global module fragment

Fix clang/gcc warnings -Wextra-semi-stmt, -Wsign-conversion, -Wuninitialized (GCC16)

Fix compilation for Embarcadero C++ XE5

Work around several static analysis false positives

Improve pkg-config file generation for NixOS

PUGIXML_BUILD_APPLE_FRAMEWORK CMake option can be used to build pugixml as .xcframework

PUGIXML_INSTALL CMake option can be used to disable installation targets

Fix clang/gcc warnings -Wzero-as-null-pointer-constant, -Wuseless-cast, -Wshorten-64-to-32

Fix unreferenced function warnings in PUGIXML_NO_STL configuration

Fix CMake 3.31 deprecation warnings

Stop using deprecated throw() when noexcept is available

xml_attribute::set_name and xml_node::set_name now have overloads that accept pointer to non-null-terminated string and size

Implement parse_merge_pcdata parsing mode in which PCDATA contents is merged into a single node when original document had comments that were skipped during parsing

xml_document::load_file now returns a more consistent error status when given a path to a folder

Fix assertion in XPath number→string conversion when using non-English locales

Fix PUGIXML_STATIC_CRT CMake option to correctly select static CRT when using MSVC and recent CMake

Fix GCC 2.95/3.3 builds

Fix CMake 3.27 deprecation warnings

Fix XCode 14 sprintf deprecation warning when compiling in C++03 mode

Fix clang/gcc warnings -Wweak-vtables, -Wreserved-macro-identifier

xml_attribute::set_value, xml_node::set_value and xml_text::set now have overloads that accept pointer to non-null-terminated string and size

Improve performance of tree traversal when using compact mode (PUGIXML_COMPACT)

Fix error handling in xml_document::save_file that could result in the function succeeding while running out of disk space

Fix memory leak during error handling of some out-of-memory conditions during xml_document::load

Fix exported symbols in CMake DLL builds when using CMake

Fix exported symbols in CMake shared object builds when using -fvisibility=hidden

Fix a bug in xml_document move construction when the source of the move is empty

Fix const-correctness issues with iterator objects to support C++20 ranges

Fix Cygwin support for DLL builds

Fix Windows CE support

Add NuGet builds and project files for VS2022

All CMake options now have the prefix PUGIXML_. This may require changing dependent build configurations.

Many build settings are now exposed via CMake settings, most notably PUGIXML_COMPACT and PUGIXML_WCHAR_MODE can be set without changing pugiconfig.hpp

Add xml_node::remove_attributes and xml_node::remove_children

Add a way to customize floating point precision via xml_attribute::set and xml_text::set overloads

Fix Visual Studio warnings when built using clang-cl compiler

Fix Wconversion warnings in gcc

Fix Wzero-as-null-pointer-constant warnings in pugixml.hpp

Work around several static analysis false positives

Tab characters (ASCII 9) in attribute values are now encoded as '	' to survive roundtripping

> characters are no longer escaped in attribute values

Add Visual Studio .natvis files to improve debugging experience

CMake improvements (USE_POSTFIX and BUILD_SHARED_AND_STATIC_LIBS options for building multiple versions and pkg-config tweaks)

Add format_skip_control_chars formatting flag to skip non-printable ASCII characters that are invalid to use in well-formed XML files

Add format_attribute_single_quote formatting flag to use single quotes for attribute values instead of default double quotes.

XPath union now results in a stable order that doesn’t depend on memory allocations; crucially, this may require sorting the output of XPath query operation if you rely on the document-ordered traversal

Improve performance of XPath union operation, making it ~2x faster

Fix Visual Studio warnings when built in a DLL configuration

Fix static analysis false positives in Coverity and clang

Fix Wdouble-promotion warnings in gcc

Add Visual Studio 2019 support for NuGet packages

xml_document::load(const char*) (deprecated in 1.5) now has deprecated attribute; use xml_document::load_string instead

xml_node::select_single_node (deprecated in 1.5) now has deprecated attribute; use xml_node::select_node instead

Add move semantics support for xml_document and improve move semantics support for other objects

CMake build now exports include directories

CMake build with BUILD_SHARED_LIBS=ON now uses dllexport attribute for MSVC

Rework parser/evaluator to not rely on exceptional control flow; longjmp is no longer used when exceptions are disabled

Improve error messages for certain invalid expressions such as .[1] or (1

Minor performance improvements

Fix Texas Instruments compiler warnings

Fix compilation issues with limits.h for some versions of gcc

Fix compilation issues with Clang/C2

Fix implicit fallthrough warnings in gcc 7

Fix unknown attribute directive warnings in gcc 8

Fix cray++ compiler errors

Fix unsigned integer overflow errors with -fsanitize=integer

Fix undefined behavior sanitizer issues in compact mode

Added parse_embed_pcdata parsing mode in which PCDATA value is stored in the element node if possible (significantly reducing memory consumption for some documents)

Added auto-detection support for Latin-1 (ISO-8859-1) encoding during parsing

Added format_no_empty_element_tags formatting flag that outputs start/end tags instead of empty element tags for empty elements

Fixed compilation issues for Borland C++ 5.4

Fixed compilation issues for some distributions of MinGW 3.8

Fixed various Clang/GCC warnings

Enabled move semantics support for XPath objects for MSVC 2010 and above

Introduced a new tree storage mode that takes significantly less memory (2-5x smaller DOM) at some performance cost.

The mode can be enabled using PUGIXML_COMPACT define.

Functions that convert from and to integers (e.g. as_int/set_value) do not rely on CRT any more.

New implementation is 3-5x faster and is always correct wrt overflow or underflow. This is a behavior change - where previously as_uint() would return UINT_MAX on a value "-1", it now returns 0.

XPath objects (xpath_query, xpath_node_set, xpath_variable_set) are now movable if your compiler supports C++11. Additionally, xpath_variable_set is copyable.

Added format_indent_attributes that makes the resulting XML friendlier to line diff/merge tools.

Added a variant of xml_node::attribute function with a hint that can improve lookup performance.

Custom allocation functions are now allowed (but not required) to throw instead of returning a null pointer.

Fix Clang 3.7 crashes in out-of-memory cases (C++ DR 1748)

Fix XPath crashes on SPARC64 (and other 32-bit architectures where doubles have to be aligned to 8 bytes)

Fix xpath_node_set assignment to provide strong exception guarantee

Fix saving for custom xml_writer implementations that can throw from write()

Attribute/text values now use more digits when printing floating point numbers to guarantee round-tripping.

Text nodes no longer get extra surrounding whitespace when pretty-printing nodes with mixed contents

Fixed translate and normalize-space XPath functions to no longer return internal NUL characters

Fixed buffer overrun on malformed comments inside DOCTYPE sections

DOCTYPE parsing can no longer run out of stack space on malformed inputs (XML parsing is now using bounded stack space)

Adjusted processing instruction output to avoid malformed documents if the PI value contains ?>

xml_document::load(const char_t*) was renamed to load_string; the old method is still available and will be deprecated in a future release

xml_node::select_single_node was renamed to select_node; the old method is still available and will be deprecated in a future release.

Added xml_node::append_move and other functions for moving nodes within a document

Added xpath_query::evaluate_node for evaluating queries with a single node as a result

Optimized XML parsing (10-40% faster with clang/gcc, up to 10% faster with MSVC)

Optimized memory consumption when copying nodes in the same document (string contents is now shared)

Optimized node copying (10% faster for cross-document copies, 3x faster for inter-document copies; also it now consumes a constant amount of stack space)

Optimized node output (60% faster; also it now consumes a constant amount of stack space)

Optimized XPath allocation (query evaluation now results in fewer temporary allocations)

Optimized XPath sorting (node set sorting is 2-3x faster in some cases)

Optimized XPath evaluation (XPathMark suite is 100x faster; some commonly used queries are 3-4x faster)

Fixed xml_node::offset_debug for corner cases

Fixed undefined behavior while calling memcpy in some cases

Fixed MSVC 2015 compilation warnings

Fixed contrib/foreach.hpp for Boost 1.56.0

Adjusted comment output to avoid malformed documents if the comment value contains --

Fix XPath sorting for documents that were constructed using append_buffer

Fix load_file for wide-character paths with non-ASCII characters in MinGW with C++11 mode enabled

Added XML fragment parsing (parse_fragment flag)

Added PCDATA whitespace trimming (parse_trim_pcdata flag)

Added long long support for xml_attribute and xml_text (as_llong, as_ullong and set_value/set overloads)

Added hexadecimal integer parsing support for as_int/as_uint/as_llong/as_ullong

Added xml_node::append_buffer to improve performance of assembling documents from fragments

xml_named_node_iterator is now bidirectional

Reduced XPath stack consumption during compilation and evaluation (useful for embedded systems)

Improved support for platforms without wchar_t support

Fixed several false positives in clang static analysis

Fixed several compilation warnings for various GCC versions

Fixed undefined pointer arithmetic in XPath implementation

Fixed non-seekable iostream support for certain stream types, i.e. Boost file_source with pipe input

Fixed xpath_query::return_type for some expressions

Fixed dllexport issues with xml_named_node_iterator

Fixed find_child_by_attribute assertion for attributes with null name/value

Added xml_text helper class for working with PCDATA/CDATA contents of an element node

Added optional header-only mode (controlled by PUGIXML_HEADER_ONLY define)

Added xml_node::children() and xml_node::attributes() for C++11 ranged for loop or BOOST_FOREACH

Added support for Latin-1 (ISO-8859-1) encoding conversion during loading and saving

Added custom default values for xml_attribute::as_* (they are returned if the attribute does not exist)

Added parse_ws_pcdata_single flag for preserving whitespace-only PCDATA in case it’s the only child

Added format_save_file_text for xml_document::save_file to open files as text instead of binary (changes newlines on Windows)

Added format_no_escapes flag to disable special symbol escaping (complements ~parse_escapes)

Added support for loading document from streams that do not support seeking

Added PUGIXML_MEMORY_* constants for tweaking allocation behavior (useful for embedded systems)

Added PUGIXML_VERSION preprocessor define

Parser does not require setjmp support (improves compatibility with some embedded platforms, enables /clr:pure compilation)

STL forward declarations are no longer used (fixes SunCC/RWSTL compilation, fixes clang compilation in C++11 mode)

Fixed AirPlay SDK, Android, Windows Mobile (WinCE) and C++/CLI compilation

Fixed several compilation warnings for various GCC versions, Intel C++ compiler and Clang

Fixed unsafe bool conversion to avoid problems on C++/CLI

Iterator dereference operator is const now (fixes Boost filter_iterator support)

xml_document::save_file now checks for file I/O errors during saving

XPath implementation is moved to pugixml.cpp (which is the only source file now); use PUGIXML_NO_XPATH if you want to disable XPath to reduce code size

XPath is now supported without exceptions (PUGIXML_NO_EXCEPTIONS); the error handling mechanism depends on the presence of exception support

XPath is now supported without STL (PUGIXML_NO_STL)

Introduced variable support

Introduced new xpath_query::evaluate_string, which works without STL

Introduced new xpath_node_set constructor (from an iterator range)

Evaluation function now accept attribute context nodes

All internal allocations use custom allocation functions

Improved error reporting; now a last parsed offset is returned together with the parsing error

Fixed memory leak for loading from streams with stream exceptions turned on

Fixed custom deallocation function calling with null pointer in one case

Fixed missing attributes for iterator category functions; all functions/classes can now be DLL-exported

Worked around Digital Mars compiler bug, which lead to minor read overfetches in several functions

load_file now works with 2+ Gb files in MSVC/MinGW

XPath: fixed memory leaks for incorrect queries

XPath: fixed xpath_node() attribute constructor with empty attribute argument

XPath: fixed lang() function for non-ASCII arguments

CDATA nodes containing ]]> are printed as several nodes; while this changes the internal structure, this is the only way to escape CDATA contents

Memory allocation errors during parsing now preserve last parsed offset (to give an idea about parsing progress)

If an element node has the only child, and it is of CDATA type, then the extra indentation is omitted (previously this behavior only held for PCDATA children)

Added xml_parse_result default constructor

Added xml_document::load_file and xml_document::save_file with wide character paths

Added as_utf8 and as_wide overloads for std::wstring/std::string arguments

Added DOCTYPE node type (node_doctype) and a special parse flag, parse_doctype, to add such nodes to the document during parsing

Added parse_full parse flag mask, which extends parse_default with all node type parsing flags except parse_ws_pcdata

Added xml_node::hash_value() and xml_attribute::hash_value() functions for use in hash-based containers

Added internal_object() and additional constructor for both xml_node and xml_attribute for easier marshalling (useful for language bindings)

Added xml_document::document_element() function

Added xml_node::prepend_attribute, xml_node::prepend_child and xml_node::prepend_copy functions

Added xml_node::append_child, xml_node::prepend_child, xml_node::insert_child_before and xml_node::insert_child_after overloads for element nodes (with name instead of type)

Added xml_document::reset() function

xml_node::root() and xml_node::offset_debug() are now O(1) instead of O(logN)

Minor parsing optimizations

Minor memory optimization for strings in DOM tree (set_name/set_value)

Memory optimization for string memory reclaiming in DOM tree (set_name/set_value now reallocate the buffer if memory waste is too big)

XPath: optimized document order sorting

XPath: optimized child/attribute axis step

XPath: optimized number-to-string conversions in MSVC

XPath: optimized concat for many arguments

XPath: optimized evaluation allocation mechanism: constant and document strings are not heap-allocated

XPath: optimized evaluation allocation mechanism: all temporaries' allocations use fast stack-like allocator

Removed wildcard functions (xml_node::child_w, xml_node::attribute_w, etc.)

Removed xml_node::all_elements_by_name

Removed xpath_type_t enumeration; use xpath_value_type instead

Removed format_write_bom_utf8 enumeration; use format_write_bom instead

Removed xml_document::precompute_document_order, xml_attribute::document_order and xml_node::document_order functions; document order sort optimization is now automatic

Removed xml_document::parse functions and transfer_ownership struct; use xml_document::load_buffer_inplace and xml_document::load_buffer_inplace_own instead

Removed as_utf16 function; use as_wide instead

Introduced encoding support (automatic/manual encoding detection on load, manual encoding selection on save, conversion from/to UTF8, UTF16 LE/BE, UTF32 LE/BE)

Introduced wchar_t mode (you can set PUGIXML_WCHAR_MODE define to switch pugixml internal encoding from UTF8 to wchar_t; all functions are switched to their Unicode variants)

Load/save functions now support wide streams

Fixed document corruption on failed parsing bug

XPath string/number conversion improvements (increased precision, fixed crash for huge numbers)

Improved DOCTYPE parsing: now parser recognizes all well-formed DOCTYPE declarations

Fixed xml_attribute::as_uint() for large numbers (i.e. 2³²-1)

Fixed xml_node::first_element_by_path for path components that are prefixes of node names, but are not exactly equal to them.

parse() API changed to load_buffer/load_buffer_inplace/load_buffer_inplace_own; load_buffer APIs do not require zero-terminated strings.

Renamed as_utf16 to as_wide

Changed xml_node::offset_debug return type and xml_parse_result::offset type to ptrdiff_t

Nodes/attributes with empty names are now printed as :anonymous

Optimized document parsing and saving

Changed internal memory management: internal allocator is used for both metadata and name/value data; allocated pages are deleted if all allocations from them are deleted

Optimized memory consumption: sizeof(xml_node_struct) reduced from 40 bytes to 32 bytes on x86

Optimized debug mode parsing/saving by order of magnitude

All STL includes except <exception> in pugixml.hpp are replaced with forward declarations

xml_node::remove_child and xml_node::remove_attribute now return the operation result

parse() and as_utf16 are left for compatibility (these functions are deprecated and will be removed in version 1.0)

Wildcard functions, document_order/precompute_document_order functions, all_elements_by_name function and format_write_bom_utf8 flag are deprecated and will be removed in version 1.0

xpath_type_t enumeration was renamed to xpath_value_type; xpath_type_t is deprecated and will be removed in version 1.0

Fixed translate(), lang() and concat() functions (infinite loops/crashes)

Fixed compilation of queries with empty literal strings ("")

Fixed axis tests: they never add empty nodes/attributes to the resulting node set now

Fixed string-value evaluation for node-set (the result excluded some text descendants)

Fixed self:: axis (it behaved like ancestor-or-self::)

Fixed following:: and preceding:: axes (they included descendent and ancestor nodes, respectively)

Minor fix for namespace-uri() function (namespace declaration scope includes the parent element of namespace declaration attribute)

Some incorrect queries are no longer parsed now (i.e. foo: *)

Fixed text()/etc. node test parsing bug (i.e. foo[text()] failed to compile)

Fixed root step (/) - it now selects empty node set if query is evaluated on empty node

Fixed string to number conversion ("123 " converted to NaN, "123 .456" converted to 123.456 - now the results are 123 and NaN, respectively)

Node set copying now preserves sorted type; leads to better performance on some queries

Fixed xml_node::offset_debug for PI nodes

Added empty attribute checks to xml_node::remove_attribute

Fixed node_pi and node_declaration copying

Const-correctness fixes

xpath_node::select_nodes() and related functions now throw exception if expression return type is not node set (instead of assertion)

xml_node::traverse() now sets depth to -1 for both begin() and end() callbacks (was 0 at begin() and -1 at end())

In case of non-raw node printing a newline is output after PCDATA inside nodes if the PCDATA has siblings

UTF8 → wchar_t conversion now considers 5-byte UTF8-like sequences as invalid

Added xpath_node_set::operator[] for index-based iteration

Added xpath_query::return_type()

Added getter accessors for memory-management functions

Fixed deallocation in case of custom allocation functions or if delete[] / free are incompatible

XPath parser fixed for incorrect queries (i.e. incorrect XPath queries should now always fail to compile)

Const-correctness fixes for find_child_by_attribute

Improved compatibility (miscellaneous warning fixes, fixed <cstring> include dependency for GCC)

Fixed iterator begin/end and print function to work correctly for empty nodes

Added PUGIXML_API/PUGIXML_CLASS/PUGIXML_FUNCTION configuration macros to control class/function attributes

Added xml_attribute::set_value overloads for different types

Documentation fix in samples for parse() with manual lifetime control

Fixed document order sorting in XPath (it caused wrong order of nodes after xpath_node_set::sort and wrong results of some XPath queries)

Single quotes are no longer escaped when printing nodes

Symbols in second half of ASCII table are no longer escaped when printing nodes; because of this, format_utf8 flag is deleted as it’s no longer needed and format_write_bom is renamed to format_write_bom_utf8.

Reworked node printing - now it works via xml_writer interface; implementations for FILE* and std::ostream are available. As a side-effect, xml_document::save_file now works without STL.

Added unsigned integer support for attributes (xml_attribute::as_uint, xml_attribute::operator=)

Now document declaration (<?xml …​?>) is parsed as node with type node_declaration when parse_declaration flag is specified (access to encoding/version is performed as if they were attributes, i.e. doc.child("xml").attribute("version").as_float()); corresponding flags for node printing were also added

Added support for custom memory management (see set_memory_management_functions for details)

Implemented node/attribute copying (see xml_node::insert_copy_* and xml_node::append_copy for details)

Added find_child_by_attribute and find_child_by_attribute_w to simplify parsing code in some cases (i.e. COLLADA files)

Added file offset information querying for debugging purposes (now you’re able to determine exact location of any xml_node in parsed file, see xml_node::offset_debug for details)

Improved error handling for parsing - now load(), load_file() and parse() return xml_parse_result, which contains error code and last parsed offset; this does not break old interface as xml_parse_result can be implicitly casted to bool.

Fixed bug with loading from text-mode iostreams

Fixed leak when transfer_ownership is true and parsing is failing

Fixed bug in saving (\r and \n are now escaped in attribute values)

Renamed free() to destroy() - some macro conflicts were reported

Improved compatibility (supported Digital Mars C++, MSVC 6, CodeWarrior 8, PGI C++, Comeau, supported PS3 and XBox360)

PUGIXML_NO_EXCEPTION flag for platforms without exception handling

Added XPath

Added tree modification functions

Added no STL compilation mode

Added saving document to file

Refactored parsing flags

Removed xml_parser class in favor of xml_document

Added transfer ownership parsing mode

Modified the way xml_tree_walker works

Iterators are now non-constant

Support of several compilers and platforms

Refactored and sped up parsing core

Improved standard compliancy

Added XPath implementation

Fixed several bugs

Fixed child_value() (for empty nodes)

Fixed xml_parser_impl warning at W4

Introduced child_value(name) and child_value_w(name)

parse_eol_pcdata and parse_eol_attribute flags + parse_minimal optimizations

Optimizations of strconv_t