Open XML Paper Specification

The Open XML Paper Specification (OpenXPS) is an international open standard for a page description language and fixed-document format, defined by Ecma International as ECMA-388 and first published in June 2009.^[1] It employs XML, along with technologies such as ZIP compression via the Open Packaging Conventions (OPC), Unicode, and the Markup Compatibility and Extensibility standard, to precisely describe the content, layout, and appearance of paginated electronic documents in a platform-independent manner.^[2] Designed as a final-form representation for viewing, printing, distribution, and archiving, OpenXPS encapsulates all necessary resources—including vector graphics, raster images (such as JPEG, PNG, and TIFF), fonts (including OpenType and subsets), and metadata—within a single, self-contained package, ensuring consistent rendering without dependency on the originating application.^[2] The format uses a hierarchical structure of FixedDocumentSequence, FixedDocument, and FixedPage elements to organize pages, supporting features like digital signatures for document integrity and accessibility tags for structured navigation.^[3] OpenXPS originated from Microsoft's proprietary XML Paper Specification (XPS), which was introduced in January 2007 with Windows Vista and integrated into Office 2007 and the .NET Framework 3.0 as a spool file format and printer driver technology.^[4] In September 2007, Microsoft submitted XPS to Ecma International's Technical Committee 46 (TC46) for standardization, leading to the creation of OpenXPS as a reorganized, royalty-free version that removes Microsoft-specific extensions while maintaining compatibility.^[2] This standardization effort aimed to promote interoperability across software and hardware systems, with ECMA-388 extending OPC (ECMA-376) to define the document package format.^[1] Since Windows 8 in 2012, OpenXPS (with the .oxps file extension) has served as the default output for the Microsoft XPS Document Writer and underlies the Windows "XPS print path," while XPS (.xps files) remains supported for legacy compatibility, with conversion tools available via the Windows Driver Kit.^[5][2] Key technical aspects of OpenXPS include its use of XML markup for elements like Path and Glyphs to handle vector paths, text rendering, and precise positioning, alongside support for advanced features such as 3D models via X3D embedding and high-dynamic-range imaging with JPEG XR.^[2] The format is licensed royalty-free under Ecma and Microsoft policies, with full documentation freely available, contributing to its sustainability despite limited adoption beyond Microsoft ecosystems.^[2] As a fixed-layout alternative to reflowable formats like PDF, OpenXPS emphasizes preservation of exact visual fidelity, making it suitable for high-quality printing and long-term digital archiving.^[4]

Format and Structure

Document Composition

The Open XML Paper Specification (OpenXPS) defines a fixed-document format as a ZIP-compressed package that conforms to the Open Packaging Conventions (OPC), which provide a standardized model for organizing content into discrete parts and relationships within a ZIP archive.^[6] This structure supports a parts-based document model, where the payload is fixed and hierarchical, consisting of at least one root FixedDocumentSequence part, one or more FixedDocument parts, and one or more FixedPage parts per document, ensuring a paginated layout that cannot be reflowed.^[6] At the core of an OpenXPS document's composition are key XML files that define its logical organization. The FixedDocumentSequence.xml file serves as the root part, using <DocumentReference> elements to sequence and reference multiple FixedDocument parts, establishing the overall document structure and print ticket associations.^[6] Each FixedDocument.xml file, in turn, indexes the pages within a single document via <PageContent> elements that link to individual FixedPage parts, including their order and any applicable print tickets.^[6] The content of each page is described in a Page.xml file, which employs Extensible Application Markup Language (XAML) to mark up visual elements such as paths, glyphs, and canvases, enabling precise rendering of the fixed layout.^[6] Resource parts, including images, fonts, and thumbnails, are stored separately within the package to promote modularity and reuse, linked through relationship files (RELS) that define required or optional dependencies.^[6] Images in formats like JPEG, PNG, TIFF, or JPEG XR are encapsulated as individual parts and referenced via Required Resource relationships in the RELS files of the consuming FixedPage or FixedDocument.^[6] Fonts, typically in OpenType format, are similarly stored and linked to ensure consistent typography across the document, while thumbnails provide preview representations tied through relationships for quick navigation.^[6] These relationships adhere to OPC standards, using XML to specify URIs and types, such as http://schemas.openxps.org/2009/relationships/image for image parts.^[6] OpenXPS incorporates Markup Compatibility and Extensibility (MCE) mechanisms to enable XML extensibility while maintaining backward compatibility, drawing from standards in the Office Open XML (OOXML) specification.^[6] MCE allows for versioning through namespace prefixes (e.g., mc: for markup compatibility attributes like mc:Ignorable), enabling processors to ignore or process unknown elements and attributes during validation, which supports third-party extensions without breaking core schema conformance.^[6] In the XAML-based Page.xml files, vectors are represented using <Path> elements with a Data attribute defining geometries via <PathGeometry>, <PathFigure>, and segments like <PolyLineSegment> or <ArcSegment>, complete with attributes such as FillRule and IsClosed for rendering control.^[6] Text is encoded through <Glyphs> elements, specifying UnicodeString for character data, FontUri for font references, and Indices for glyph positioning and bidi support, ensuring device-independent layout.^[6] Paths, as subsets of vectors, are constructed within <PathFigure> using segment types like <PolyBezierSegment>, integrated with transformations and styling attributes like Stroke and Fill for precise graphical composition.^[6]

File Extensions and Packaging

Open XML Paper Specification documents are packaged using the Open Packaging Conventions (OPC), a ZIP-based container format that organizes XML markup, resources, and relationships into a single file. The original Microsoft implementation uses the .xps file extension, while the standardized OpenXPS format employs .oxps to distinguish it as compliant with ECMA-388, which enforces stricter adherence to OPC requirements such as standardized namespace URIs and the exclusion of platform-specific features like Windows color management extensions. Both formats encapsulate all necessary components—including fixed XML pages, embedded fonts, and images—within the ZIP structure, ensuring self-contained documents suitable for archival and distribution.^[6] The MIME type for .xps files is application/vnd.ms-xpsdocument, registered by Microsoft for its proprietary XML Paper Specification documents. In contrast, .oxps files use the MIME type application/oxps, as defined for the ECMA-388 OpenXPS standard to promote interoperability across systems. Packages can be identified by extracting the ZIP archive and verifying the presence of core OPC files, such as [Content_Types].xml at the root (specifying content types like application/vnd.ms-package.xps-fixeddocument for pages) and the _rels/.rels relationship file, which outlines the document's internal structure. Compression within both .xps and .oxps packages relies on the DEFLATE algorithm, as specified in the ZIP File Format Version 6.2.0, to reduce file size while preserving XML readability and binary integrity. Text-based XML parts, such as page descriptions and metadata, are compressed efficiently, whereas binary resources like JPEG or PNG images are stored as separate entries with their native encoding to avoid unnecessary recompression, allowing direct extraction without loss of quality.^[6] Conversion between .xps and .oxps is facilitated by Microsoft's XpsConverter tool, a command-line utility included in the Windows Driver Kit, which transforms documents while adjusting for standard compliance, such as updating namespaces and removing non-standard elements. The tool supports single-file or recursive folder conversions; for example, the command XpsConverter /OpenXPS /InputFile=input.xps /OutputFile=output.oxps generates an ECMA-388-compliant .oxps file from a .xps input, with optional logging to track modifications. This process ensures backward compatibility for legacy .xps files in environments requiring OpenXPS adherence.^[5]

Features

Graphics and Layout Capabilities

The Open XML Paper Specification (OpenXPS) employs Extensible Application Markup Language (XAML) to define vector graphics, enabling precise representation of paths, shapes, and text elements within documents. Vector graphics are constructed using the <Path> element, which specifies geometry through attributes such as Data for path commands (e.g., move, line, curve) and supports fills and strokes via brush properties. Paths can incorporate complex geometries defined by <PathGeometry> and segments like <ArcSegment>, <PolyBezierSegment>, <PolyLineSegment>, and <PolyQuadraticBezierSegment>, allowing for scalable, resolution-independent rendering of intricate designs. Shapes are similarly rendered as paths with applied brushes, while text rendering utilizes the <Glyphs> element to embed Unicode strings, glyph indices, or bidirectional text at specified origins (OriginX and OriginY), with support for OpenType fonts to ensure typographic fidelity across platforms.^[7] OpenXPS adopts a fixed-layout model for pagination, providing exact control over document structure and element placement to maintain consistent appearance regardless of viewing device or zoom level. Each page is encapsulated in a <FixedPage> element with fixed dimensions (e.g., width and height in 1/96-inch units), ensuring precise positioning through absolute coordinates and transformations like <RenderTransform>. Multi-page documents are organized via <FixedDocumentSequence> and <FixedDocument> containers, which reference individual <PageContent> resources, facilitating the assembly of paginated sequences without reflow. This zoom-independent rendering stems from its vector-based foundation, where elements scale smoothly without pixelation, preserving layout integrity during magnification or printing.^[7] Advanced visual effects in OpenXPS enhance layout flexibility through support for gradients, transparencies, clipping, and opacity masks. Linear gradients are implemented with <LinearGradientBrush>, specifying start and end points along with <GradientStop> collections for color transitions, while radial gradients use <RadialGradientBrush> with center, radius, and gradient stops for circular or elliptical fills. Transparencies are managed via the Opacity attribute (ranging from 0 to 1) on elements like paths or glyphs, allowing layered compositions. Clipping confines content to geometric boundaries using the <Clip> property, applicable to canvases, paths, and text elements, whereas opacity masks apply brush-based alpha modulation for per-pixel transparency effects, enabling sophisticated blending in layouts.^[7] OpenXPS includes optional integration of 3D graphics through X3D extensions, permitting the embedding of three-dimensional content as image sources. This is achieved via the <Brush3D> element, which references X3D files using Source3D attributes in the ST_UriImage3D type, with fallback mechanisms like <AlternateContent> for non-supporting renderers to ensure backward compatibility in mixed 2D/3D documents.^[7] For protected content, OpenXPS incorporates digital rights management features centered on integrity verification and limited resource obfuscation rather than full encryption. Digital signatures are applied to core document parts such as <FixedDocumentSequence>, <FixedPage>, and metadata via defined signing rules, supporting multiple signatures to authenticate origins and detect tampering, with types including compliant, valid, or broken states. Embedded fonts undergo obfuscation using a 128-bit GUID and XOR encryption on initial bytes to prevent unauthorized extraction, adhering to licensing restrictions like "print and preview" or "editable embedding" that mandate such protection while prohibiting subsetting or bitmap-only installs.^[7]

Imaging and Color Management

OpenXPS supports embedding raster images in several standard formats to enable high-fidelity reproduction within documents. These include JPEG, which must conform to ITU-T T.81 and supports lossy compression primarily for RGB and grayscale data, though CMYK is permitted but not recommended; PNG, adhering to the PNG specification with lossless compression and support for ancillary chunks like tRNS for transparency; TIFF, based on TIFF 6.0 with extensions for lossless LZW compression, lossy JPEG, and bilevel CCITT encoding, accommodating RGB, CMYK, grayscale, palette, and alpha data; and JPEG XR, compliant with its specification, offering both lossless and lossy compression options for RGB, scRGB, CMYK, grayscale, n-channel, and named color spaces.^[7] These formats allow raster images to be referenced via the ImageBrush element, with scaling and tiling capabilities to integrate seamlessly with vector graphics.^[7] Color management in OpenXPS ensures consistent color reproduction across devices by incorporating ICC profiles conforming to ICC.1:2001-04, which can be embedded in raster images (e.g., via JPEG's APP2 marker or TIFF's ICC tag 34675) or referenced as package resources for document-wide application.^[7] Supported color spaces encompass sRGB as the default for unprofiled RGB data, scRGB for extended dynamic range, standard RGB, CMYK with subtractive complementation, grayscale, and n-channel extensions for multi-tone images.^[7] Spot colors are handled through named color syntax in brushes and gradients or via ICC named color profiles, enabling precise specification for printing applications outside standard RGB or CMYK gamuts.^[7] If no ICC profile is present, defaults like sRGB apply based on pixel format, with blending and opacity computations occurring in the specified space, typically sRGB for mandatory support.^[7] Alpha channel transparency is integral to raster image handling in OpenXPS, with support for pre-multiplied or non-pre-multiplied alpha in formats like TIFF (via the ExtraSamples tag) and JPEG XR (e.g., 32bppPBGRA pixel format), while PNG utilizes the tRNS chunk for simpler transparency.^[7] Alpha values, ranging from 0.0 (fully transparent) to 1.0 (fully opaque), are clamped accordingly and combined multiplicatively with element opacity attributes in ImageBrush or other visual elements.^[7] Blending modes rely on alpha compositing for transparency effects, with mandatory sRGB alpha blending and optional support for scRGB or CMYK; gradients and images use the BLEND() function with interpolation modes like SRgbLinearInterpolation, and spread methods (Pad, Reflect, Repeat) influence edge blending.^[7] Temporary surfaces for transparent elements initialize to alpha 0.0, ensuring accurate per-pixel compositing during rendering.^[7] Font embedding in OpenXPS utilizes OpenType (ISO/IEC 14496-22:2007) and TrueType formats, including CFF-based fonts and TrueType Collections, to guarantee consistent text rendering without system dependencies.^[7] Fonts are embedded as obfuscated parts (with .odttf extension) using a 128-bit GUID and XOR on the first 32 bytes for security, referenced via the Glyphs element's FontUri attribute and linked through Restricted Font relationships.^[7] Subsetting is permitted to include only used glyphs, reducing file size while maintaining validity as Open Font Format files, though prohibited for fonts with "no subsetting" licensing restrictions; this optimization, combined with resource reuse across pages, minimizes redundancy and supports efficient parsing.^[7]

Comparisons

With PDF

The Open XML Paper Specification (OpenXPS) employs an XML-based markup language, leveraging XAML for describing page layouts and content, which allows for human-readable and structured representation of fixed documents. In contrast, PDF relies on the Content Stream syntax (COS), a PostScript-derived object-based language that enables a more compact, binary-oriented description of document elements as defined in ISO 32000-1. This fundamental difference in syntax affects parsing and editing: OpenXPS's XML structure facilitates easier programmatic manipulation and validation against schemas, while PDF's COS supports complex object relationships for advanced rendering.^[8][9] A key feature gap between OpenXPS and PDF lies in text handling and interactivity. OpenXPS maintains a strictly fixed layout with no support for reflowable text, ensuring precise positioning but limiting adaptability to different screen sizes or reading modes. PDF, however, incorporates optional tagging for reflowable content, allowing text to adapt while preserving structure for accessibility. Similarly, OpenXPS does not natively support interactive forms or fields, focusing instead on static presentation; PDF includes robust capabilities for fillable forms, dynamic content via JavaScript actions, and structured tagging for screen readers under standards like PDF/UA. These omissions in OpenXPS stem from its emphasis on print fidelity over editable or responsive documents.^[2][10][11] Regarding file size and compression, OpenXPS packages its components using the ZIP-based Open Packaging Conventions (OPC), which provides inherent compression and modularity for resources like images and fonts, promoting portability across systems. PDF, by comparison, often achieves smaller file sizes through highly optimized stream compression techniques, including Flate and LZW algorithms tailored to content types, resulting in more efficient storage for complex documents without sacrificing fidelity. While OpenXPS's OPC enhances interoperability in packaged formats, PDF's stream-level optimizations make it preferable for bandwidth-sensitive applications.^[8][9] In terms of interoperability, OpenXPS was engineered primarily for printing and spooling workflows, integrating seamlessly with Windows print paths to deliver device-independent output with high resolution independence. PDF, however, excels in broader versatility, supporting seamless web embedding, collaborative editing in tools like Adobe Acrobat, and universal viewing across platforms via widespread reader software. This design focus positions OpenXPS as a specialized alternative for print-centric tasks, while PDF's ecosystem enables diverse uses from digital publishing to archival sharing.^[12][13]

With Other Page Description Languages

Open XML Paper Specification (OpenXPS) differs fundamentally from PostScript, a procedural page description language developed by Adobe Systems that operates as a stack-based programming language to instruct printers on rendering operations through sequential commands.^[14] In contrast, OpenXPS employs a declarative approach, using XML markup to specify the static structure, layout, and visual elements of a document without requiring an interpreter to execute programmatic steps, thereby simplifying rendering and reducing dependency on complex processing engines.^[8] This declarative model enables direct, application-independent reproduction of content, avoiding the interpretive overhead inherent in PostScript's dynamic execution model.^[15] Compared to Printer Command Language (PCL), a command-oriented protocol developed by Hewlett-Packard primarily for controlling printer hardware and basic page formatting, OpenXPS offers more advanced graphics capabilities.^[16] PCL relies on printer-specific escape sequences for tasks like text placement and simple raster graphics, which limit its support for sophisticated features such as vector paths, transparency, and gradients.^[16] OpenXPS, however, natively incorporates XML elements like <Path> for scalable vector graphics, <Opacity> attributes for transparency blending (ranging from 0.0 to 1.0), and <LinearGradientBrush> for smooth color transitions, providing richer, device-independent visual fidelity that surpasses PCL's hardware-dependent constraints.^[8] A key advantage of OpenXPS lies in its openness, leveraging standardized web technologies such as XML for content description and ZIP-based Open Packaging Conventions for file structure, which promote interoperability and extensibility without proprietary dependencies common in older PDLs like PostScript and early PCL versions.^[8] This design facilitates compact representation, unambiguous rendering across platforms, and features like digital signatures and resource sharing, contrasting with the more closed or device-tied elements in legacy formats.^[15] As a result, OpenXPS enhances portability, scalability, and accessibility, including support for screen readers via structured markup, while maintaining high color fidelity through ICC profiles.^[8] In terms of use cases, OpenXPS is optimized for digital distribution, such as e-books, web archiving, and cross-platform sharing, where its fixed-layout format ensures consistent viewing and interactivity like hyperlinks without alteration.^[8] PostScript and PCL, by comparison, are geared toward direct printing workflows, with PostScript excelling in professional graphics production via its programmable precision and PCL suiting efficient, high-volume office printing through streamlined commands.^[14][16]

Tools and Support

Viewing and Rendering Software

The primary software for viewing and rendering Open XML Paper Specification (OpenXPS) documents on Windows is the XPS Viewer, a native application that displays both .xps and .oxps files with support for zooming, page navigation, and printing.^[17] However, XPS Viewer is no longer installed by default in Windows 10 version 1803 and later, including Windows 11, where it must be added as an optional feature via Settings > Apps > Optional features > Add a feature > XPS Viewer.^[17][18] Microsoft Edge browser also provides built-in support for opening and rendering .xps files directly, allowing users to view, zoom, and print them without additional software.^[19] Several third-party tools offer cross-platform support for viewing and rendering OpenXPS documents. MuPDF, a lightweight open-source viewer and toolkit, natively handles XPS and OpenXPS formats alongside PDF and other document types, emphasizing high-performance rendering on desktop environments like Windows, Linux, and macOS.^[20][21] Okular, the KDE document viewer for Linux, supports XPS through its dedicated backend plugin, enabling display of fixed-layout documents with features like annotations and search.^[22][23] Ghostscript, an interpreter and rendering engine, includes an XPS interpreter for converting and rendering OpenXPS content to formats like PDF or raster images, commonly used in server-side processing or integration with other tools.^[24] For web-based viewing, libraries like those integrated in online services (e.g., Aspose XPS Viewer) allow browser rendering of .xps and .oxps files without installation, though they may require file uploads.^[25] In the Windows printing pipeline, XPS serves as the default spool format for enhanced rendering, where printer drivers process OpenXPS data to produce output on physical devices, improving fidelity for complex graphics and layouts compared to earlier EMF spooling.^[26] Compatibility for .oxps files, the standardized OpenXPS variant, requires Windows 8 or later for native viewing in XPS Viewer or Edge, as earlier versions lack direct support and necessitate converters like those based on Ghostscript.^[27] Mobile support remains limited, with dedicated apps such as XPSView for iOS and various Android viewers providing basic rendering, but lacking the full feature set of desktop tools.^[28][29]

Creation and Conversion Tools

Microsoft provides several built-in tools for creating Open XML Paper Specification (OpenXPS) documents, primarily through the XPS Document Writer, a virtual printer driver that allows any Windows application to generate XPS or OpenXPS files by selecting it as the output device during printing.^[30] This driver captures print jobs in the standardized OpenXPS format, supporting features like fixed layouts and high-fidelity rendering without requiring additional software installation on Windows systems.^[30] Applications in the Microsoft Office suite, including Word, Excel, PowerPoint, and Publisher, offer direct export functionality to the XPS format (.xps) via the File > Export > Create PDF/XPS Document menu, enabling users to produce paginated documents with embedded fonts, images, and vector graphics while preserving the original layout.^[31] These exports leverage the underlying XPS Document API to serialize content into the XPS package structure.^[32] Third-party tools for OpenXPS creation are limited, with Adobe Acrobat providing indirect support through printing to the Microsoft XPS Document Writer, though it lacks native export options and focuses primarily on PDF workflows.^[33] LibreOffice does not support direct export to XPS or OpenXPS formats, relying instead on system-level printing to virtual XPS drivers for conversion.^[34] Developer-focused third-party libraries, such as Aspose.Page for .NET, allow programmatic creation of OpenXPS documents in custom applications, handling tasks like adding pages, graphics, and metadata. Conversion utilities facilitate transforming existing files into OpenXPS, with Microsoft's XpsConverter tool specifically designed to upgrade legacy Microsoft XPS (.xps) files to the standardized OpenXPS (.oxps) format via command-line execution, ensuring compliance with ISO/IEC 29500 extensions.^[35] For PDF-to-XPS conversions, tools like Apryse PDF2XPS provide high-quality command-line processing that maintains layout fidelity, color management, and embedded resources across platforms including Windows, macOS, and Linux.^[36] Bullzip PDF Printer, when configured with its XPS driver option, enables PDF generation and subsequent routing to OpenXPS output, supporting batch operations and integration with document workflows.^[37] Programming interfaces for OpenXPS creation are centered on Microsoft's XPS Document API, a native Windows library that supports building, editing, and saving documents in both XPS and OpenXPS formats using C++ for high-performance applications.^[32] In .NET environments, the System.Windows.Xps namespace, part of WPF, offers the XpsDocumentWriter class for generating OpenXPS packages programmatically, allowing developers to compose fixed documents with visual elements, hyperlinks, and digital signatures through managed code.^[32] This API abstracts the OpenXPS packaging conventions, enabling custom creation in scenarios like automated reporting or content serialization.^[3]

History and Standardization

Development Origins

The Open XML Paper Specification (OpenXPS), originally known as the XML Paper Specification (XPS), originated in 2003 when Microsoft commissioned Global Graphics Software to provide consultancy and proof-of-concept development services for a new page description language intended as the spool format for future Windows versions.^[38] This collaboration aimed to define a fixed-document format that would enable high-fidelity printing and viewing while being platform-independent and suitable for electronic document exchange.^[4] The primary goals of the project were to develop an open alternative to Adobe's Portable Document Format (PDF) for document archiving and printing, emphasizing the use of XML-based structures and web standards to ensure interoperability and accessibility across devices.^[39] XPS was designed to preserve document layout and content integrity without relying on proprietary technologies, leveraging XML for markup and incorporating color-managed vector graphics to support device independence.^[4] Key influences included the Extensible Application Markup Language (XAML), developed as part of the Avalon project (later known as Windows Presentation Foundation or WPF), which provided the foundational XML-based framework for describing visual elements and print paths in XPS.^[3] A preliminary specification (version 0.7) was released in May 2005, followed by version 0.75 in October 2005 under a royalty-free license. The format saw its initial public release and integration as the default spool format in Windows Vista in January 2007, alongside .NET Framework 3.0 and Microsoft Office 2007, marking its debut as a native component of the Windows printing architecture.^[4][40]

Ecma and ISO Standardization

In September 2007, Microsoft submitted the XML Paper Specification to Ecma International's Technical Committee 46 (TC46) for consideration as an international standard.^[4] This submission initiated a review process to refine the format into an open specification, focusing on enhancing interoperability while aligning with established standards like the Open Packaging Conventions (OPC).^[7] Following deliberations and revisions by TC46, the specification was adopted as ECMA-388, titled Open XML Paper Specification (OpenXPS), on June 16, 2009, marking its first official edition.^[1] This edition defined OpenXPS as a fixed-layout, XML-based document format suitable for paginated content, emphasizing platform independence and support for features such as vector graphics, raster images, and digital signatures.^[7] Subsequent updates to ECMA-388 have been limited to working drafts, such as version 1.6 in April 2009, which introduced minor clarifications on packaging, markup extensibility, and conformance without altering core functionality.^[8] No major revisions have occurred since the 2009 adoption, preserving the standard's stability.^[1] Key differences from the original Microsoft XPS include stricter adherence to OPC requirements for package structure and relationships, removal of proprietary extensions such as the Microsoft Print Schema and Windows Color System, adoption of the .oxps file extension with the content type application/oxps, and updated namespace URIs (e.g., http://schemas.openxps.org/oxps/v1.0).[](https://www.loc.gov/preservation/digital/formats/fdd/fdd000513.shtml) These changes aimed to eliminate vendor-specific elements, promoting broader adoption while maintaining backward compatibility for essential XPS features.^[7] OpenXPS has not been advanced to ISO/IEC adoption as a standalone standard, though it shares foundational elements like OPC with the Office Open XML (OOXML) family under ISO/IEC 29500.^[2]

Licensing and Adoption

Licensing Terms

The Open XML Paper Specification (OpenXPS), standardized as ECMA-388, is governed by an open licensing model that promotes royalty-free implementation and distribution. Microsoft issued the Open Specification Promise in 2005, complemented by the specific Community Promise for the XPS specification, under which it irrevocably covenants not to assert any Microsoft Necessary Claims—patents essential for implementing required portions of the specification—against third parties for making, using, selling, offering for sale, importing, or distributing conformant implementations.^[41][42] This royalty-free arrangement extends to copyrights, allowing unrestricted use of the specification for compliant software and hardware development without licensing fees.^[42] As an Ecma International standard, ECMA-388 is freely available for download and implementation, with no compliance fees or royalties required from adopters.^[1] The standard's copyright is held by Ecma International, but its terms permit broad reuse in line with Ecma's policy for open standards, ensuring accessibility for developers worldwide.^[6] The licensing scope encompasses both the original XML Paper Specification (XPS) and the OpenXPS format defined in ECMA-388, focusing on core elements such as XML structure, packaging via the Open Packaging Conventions (OPC), and fixed-document rendering.^[42][2] It explicitly excludes non-standard extensions, proprietary Microsoft features, or implementations that deviate from mandatory provisions, such as those involving third-party patents or restricted font embedding.^[42][4] These terms facilitate third-party development of viewing, rendering, and conversion tools without financial barriers, provided implementations strictly adhere to OPC requirements and avoid patent infringement suits against Microsoft's own conformant products.^[42] This model underscores OpenXPS's design as an interoperable, extensible format while limiting protections to standard-compliant uses.^[6]

Current Usage and Deprecation

As of 2025, the Open XML Paper Specification (OpenXPS) maintains limited adoption primarily in niche technical and legacy contexts, with declining relevance in mainstream computing environments.^[2] It continues to be used internally in the Windows printing pipeline for spooling documents, including in Windows 11, where XPS-based formats facilitate efficient rendering and job processing through the spooler.^[26] Certain CAD applications, such as SOLIDWORKS 2025, support exporting designs to XPS files for viewing in compatible tools like eDrawings or legacy XPS viewers, enabling fixed-layout sharing of technical drawings.^[43] It is also utilized in some universal print drivers (UPDs) for enterprise environments, as noted in industry analyses from 2025.^[44] Additionally, OpenXPS is recognized by the Library of Congress as a suitable format for digital preservation due to its open standardization and XML-based structure, though the institution reports no active documents in its collections using this format.^[2] Microsoft has made OpenXPS tools, such as the XPS Viewer, optional features since Windows 10 version 1803 (2018) and is now only available as an optional feature, often requiring manual enabling via Windows settings.^[17] In Windows 11, support persists but is increasingly unreliable, with users reporting difficulties accessing the viewer through optional features as of late 2025.^[45] Microsoft has shifted emphasis toward PDF as the preferred fixed-document format, integrating native PDF support in Microsoft Edge for viewing and printing, while deprecating XPS-specific workflows in favor of universal PDF compatibility. OpenXPS file handling (.oxps) remains supported in Windows 8 and later versions through the v4 print driver model, but this integration shows signs of decline, with reduced promotion in documentation and fewer updates to related APIs.^[46] The dominance of PDF as a cross-platform standard has overshadowed OpenXPS, limiting its adoption to specialized scenarios such as printer drivers from manufacturers like Canon and Xerox, where XPS support enables direct printing of fixed-layout jobs without intermediate conversion.^[47][48] For instance, Xerox devices often require optional XPS kits for handling these files, positioning OpenXPS as a niche option in enterprise printing environments rather than a general-purpose format.^[49] No major updates to the OpenXPS specification have occurred since its standardization as ECMA-388 in June 2009, leaving it stable but largely neglected by developers and standards bodies. Legacy support is preserved through third-party converters that enable migration to PDF or other formats, ensuring accessibility for older XPS/OpenXPS documents without native viewers.^[50] This reliance on conversion tools underscores OpenXPS's transition to archival and backward-compatibility roles rather than active development.^[51]

Security Considerations

Known Vulnerabilities

The Open XML Paper Specification (OpenXPS) is based on the ZIP archive format via Open Packaging Conventions and XML markup. While this structure allows for the inclusion of non-standard parts that could potentially conceal malicious payloads and bypass some antivirus scans focused on common file extensions, standard OpenXPS parsers and viewers do not extract or execute arbitrary embedded files, such as executables. Instead, security risks primarily arise from flaws in parsing malformed XML, embedded resources, or document elements, which can lead to memory corruption or code execution if not properly validated. Several specific vulnerabilities have been identified in OpenXPS parsers, particularly those handling malformed XML or embedded resources. For example, CVE-2022-42397 involves a buffer over-read in PDF-XChange Editor versions prior to 9.5.366.0 during XPS file parsing, where crafted data triggers a read past the end of an allocated buffer, potentially leading to information disclosure or, when combined with other flaws, remote code execution; user interaction, such as opening the file, is required.^[52] Similarly, CVE-2020-0605 affects .NET Framework versions 4.5.2 through 4.8, enabling remote code execution through insecure deserialization of XPS files that fail to validate source markup properly.^[53][54] Attack vectors often exploit embedded media or resources in OpenXPS documents to trigger memory corruption. CVE-2017-11209, for instance, causes an exploitable memory corruption in Adobe Acrobat Reader DC versions 2017.012.20098 and earlier when processing a JPEG image embedded within an XPS file, allowing attackers to potentially execute arbitrary code via a crafted document.^[55] More recent flaws include CVE-2023-51566, a stack-based buffer overflow in Kofax Power PDF versions prior to 11.1.0.4012 during OXPS parsing due to insufficient validation of user-supplied data lengths, which can result in arbitrary code execution with user interaction.^[56] Additionally, fonts or images in OpenXPS files have been used to induce heap-based buffer overflows, as seen in CVE-2023-39494 affecting PDF-XChange Editor, where improper bounds checking during OXPS resource handling leads to remote code execution.^[57] In 2024, CVE-2024-9762 was disclosed as an out-of-bounds read in Tungsten Automation Power PDF during OXPS file parsing, potentially leading to information disclosure with user interaction.^[58] These vulnerabilities primarily impact the Windows XPS processing pipeline and third-party viewers supporting OpenXPS, such as PDF editors, due to the format's integration with Microsoft technologies. However, the limited adoption of OpenXPS beyond niche printing and document archival use cases has constrained the overall attack surface and prevalence of exploits.^[2]

Mitigation Strategies

To mitigate security risks associated with handling Open XML Paper Specification (OpenXPS) files, organizations and users can implement several technical and procedural measures focused on restricting exposure and validating content. One effective approach involves disabling unnecessary XPS-related features in Windows environments to limit potential attack surfaces. For instance, the Microsoft XPS Document Writer (MXDW) print queue and driver can be removed during system deployment using the RemoveMXDW setting in unattended installation scripts, which prevents the creation of XPS files via printing and reduces the risk of spooler-based exploits.^[59] Additionally, the Print Spooler service, which handles XPS job processing, can be disabled via the Services management console (services.msc) or by setting the Start registry value to 4 under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Spooler, thereby blocking XPS rendering through the spooler pipeline. For viewing, employing sandboxed environments—such as Microsoft Defender Application Guard integrated with Windows—is recommended to isolate XPS rendering from the host system, ensuring that any malicious content in untrusted files does not compromise the broader environment.^[60] Content validation forms a core defense layer, given OpenXPS's ZIP-based structure that can embed executable or malicious payloads. Before processing, files should be scanned for malware by extracting the ZIP archive using tools like 7-Zip and subjecting contents to antivirus analysis, as this reveals hidden threats not detectable through superficial inspection.^[61] For parsing, leveraging updated libraries such as Ghostscript (version 10.03.1 or later) is advisable, as it supports secure XPS input with hardening options like the -dSAFER flag to restrict unsafe operations during interpretation, though users must apply patches for known Ghostscript vulnerabilities to avoid introducing new risks.^[62] This approach prioritizes libraries with active maintenance and sandboxing capabilities over deprecated native Windows components. As an alternative to direct OpenXPS handling, converting files to PDF format enhances security for distribution, since PDF parsers in modern applications often include more robust isolation features and are less prone to legacy XPS-specific flaws. Tools like the built-in Microsoft Print to PDF driver can perform this conversion offline, stripping potential XPS exploits while preserving layout fidelity.^[63] Complementing this, applying vendor patches for known vulnerabilities—such as those in .NET Framework and WPF components used for XPS rendering—is essential; for example, security updates like KB5022083 enforce restricted parsing modes to block code execution in untrusted contexts.^[64] Adopting general best practices further strengthens defenses against OpenXPS threats. Users should avoid opening XPS attachments from untrusted email sources, verifying sender legitimacy and scanning files with endpoint protection before interaction, as phishing campaigns have exploited XPS for credential theft.^[65] In Microsoft Office environments, enabling Protected View for documents from the internet or email provides an additional barrier, though for XPS specifically, this integrates via Edge browser isolation when viewing embedded files.^[64] These combined strategies—disabling features, validating inputs, converting formats, patching systems, and enforcing cautious handling—collectively reduce the attack surface without requiring complete abandonment of the format.