Office-Inspired Products

DevExpress Office & PDF File API for Java — Generate PDFs, PowerPoint Presentations, and Barcodes in Java Apps

Maria Nikulina (DevExpress) — Mon, 07 Sep 2026 00:00:00 Z

Building document-processing solutions on the JVM often means combining specialized libraries for different document formats and workflows.

DevExpress Office & PDF File API for Java gives Java developers API libraries for PDF and PowerPoint file processing and barcode generation. You can create, modify, and export documents directly in Java applications without Microsoft Office or Adobe Acrobat.

The product is available as a Community Technology Preview (CTP). Its API libraries are uploaded on Maven Central and support Maven and Gradle projects.

In this post, I’ll introduce the CTP, explain its cross-platform architecture, and write a sample Java application. I'll also examine an important architectural difference from many Java document libraries: DevExpress libraries use their own drawing primitives instead of java.awt and rely on a Skia-based rendering engine instead of the Java graphics stack.

DevExpress Office & PDF File API for Java is available today as a free Community Technology Preview (CTP). Register to receive technical support throughout the CTP period: Register Online. The commercial release (set for 2027) will be available as a separate subscription. It will not be included in the Office & PDF File API for .NET or Universal subscription.

What's Included in the CTP

Our CTP includes three API libraries:

PDF Document API: devexpress-docs-pdf
Create, modify, secure, and export PDF documents.
PowerPoint Presentation API: devexpress-docs-presentation
Create, modify, and export PPTX presentations.
Barcode Generation API: devexpress-docs-barcode
Generate 1D and 2D barcodes and export them as images or PDF.

All libraries share a consistent API design and cross-platform drawing types. You can use APIs independently or combine them in the same Java application.

Built for Cross-Platform Java Development

All three libraries are cross-platform and run across the following operating systems and deployment environments:

Operating systems — Windows x64, Linux x64, and macOS ARM64.
Containers — Docker images based on supported platforms.
Cloud — Microsoft Azure and Amazon Web Services (AWS).

The rendering stack does not depend on standard Java graphics APIs. DevExpress libraries use the Skia graphics engine, with ICU (International Components for Unicode) for text processing. Skia ships as a separate platform-specific dependency and allows you to deploy the same application across supported Windows, Linux, or macOS environments.

Our API libraries use their own cross-platform drawing types instead of java.awt:

com.devexpress.system.drawing — drawing primitives such as Color, PointF, SizeF, and RectangleF.
com.devexpress.drawing — imaging types such as DXImage and DXImageFormat.

The shared drawing model provides a consistent API across supported platforms, while the Skia-based rendering stack performs underlying graphics operations. This separation allows the same document-processing code to run in a desktop application, a headless Linux container, or a cloud service.

DevExpress resource-owning types (such as DXImage, PdfDocument, Presentation, and BarcodeGenerator) implement Java's Closeable. Use these objects with try-with-resources when your application no longer needs them:

import com.devexpress.system.drawing.*; 
import com.devexpress.drawing.*;        

try (PdfDocument document = new PdfDocument();
     DXImage image = DXImage.fromStream(inputStream)) {
    // Work with the document and image...
}

Get Started

For complete project setup, including all required dependencies and complete PDF, PowerPoint, and Barcode generation examples, please review the following: Get Started documentation.

Prerequisites

JDK 21 or later
Maven 3.9+ or Gradle 8.14+
IntelliJ IDEA, Eclipse, or VS Code with the Extension Pack for Java

Confirm your toolchain before you create a project. The following command displays the installed version of Java:

java -version

Add DevExpress Dependencies

Maven Central hosts all libraries under the com.devexpress group. Add each necessary dependency to your build file.

Maven

<dependencies>
    <dependency>
        <groupId>com.devexpress</groupId>
        <artifactId>devexpress-docs-pdf</artifactId>
        <version>26.2.1</version>
    </dependency>
    <dependency>
        <groupId>com.devexpress</groupId>
        <artifactId>devexpress-docs-presentation</artifactId>
        <version>26.2.1</version>
    </dependency>
    <dependency>
        <groupId>com.devexpress</groupId>
        <artifactId>devexpress-docs-barcode</artifactId>
        <version>26.2.1</version>
    </dependency>
</dependencies>

Gradle

dependencies {
    implementation("com.devexpress:devexpress-docs-pdf:26.2.1")
    implementation("com.devexpress:devexpress-docs-presentation:26.2.1")
    implementation("com.devexpress:devexpress-docs-barcode:26.2.1")
}

Add Native Dependencies

To resolve the platform-specific native libraries transitively, add the following native dependencies to your project:

Skija
LWJGL
LWJGL HarfBuzz

The following configuration targets Linux x64. For a platform-specific list of required artifacts, refer to our documentation.

Maven

<dependencies>
    <dependency>
        <groupId>com.devexpress</groupId>
        <artifactId>devexpress-docs-pdf</artifactId>
        <version>26.2.1</version>
    </dependency>
    <dependency>
        <groupId>io.github.humbleui</groupId>
        <artifactId>skija-linux-x64</artifactId>
        <version>0.119.6</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl</artifactId>
        <version>3.4.2</version>
        <classifier>natives-linux</classifier>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.lwjgl</groupId>
        <artifactId>lwjgl-harfbuzz</artifactId>
        <version>3.4.2</version>
        <classifier>natives-linux</classifier>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Gradle

dependencies {
    implementation 'com.devexpress:devexpress-docs-pdf:26.2.1'

    runtimeOnly 'io.github.humbleui:skija-linux-x64:0.119.6'
    runtimeOnly 'org.lwjgl:lwjgl:3.4.2:natives-linux'
    runtimeOnly 'org.lwjgl:lwjgl-harfbuzz:3.4.2:natives-linux'
}

Code Example — Generate Your First PDF

The following console application creates a Letter page, places a title and a paragraph, and writes the result to disk. It captures core PDF workflows: creates a PdfDocument, adds a page, adds text fragments, and saves the result.

import com.devexpress.docs.pdf.*;
import com.devexpress.drawing.*;
import com.devexpress.system.drawing.*;
import com.devexpress.drawing.printing.*;

import java.io.*;
import java.nio.file.*;
import java.nio.channels.*;

public class CreatePdfDocument {
    public static void main(String[] args) throws Exception {
        try (PdfDocument pdfDocument = new PdfDocument()) {

            // Add a Letter page to the document.
            Page page = pdfDocument.getPages().add(DXPaperKind.LETTER);

            // Add a title to the document.
            TextFragment textFragment = new TextFragment();
            textFragment.setText("Quarterly Sales Report");
            textFragment.setLocation(new PointF(50, 770));
            textFragment.setFont(new TextFont("DejaVu Sans", TextFontStyle.BOLD));
            textFragment.setFontSize(24);
            page.addFragment(textFragment);

            // Add a paragraph to the document.
            ParagraphFragment paragraphFragment = new ParagraphFragment();
            paragraphFragment.setText("This report summarizes sales data for Q1 2026.");
            paragraphFragment.setLocation(new PointF(50, 730));
            paragraphFragment.setWidth(200);
            paragraphFragment.setFont(new TextFont("DejaVu Sans"));
            paragraphFragment.setFontSize(12);
            page.addFragment(paragraphFragment);

            // Save the document to a PDF file.
            try (WritableByteChannel writableByteChannel =
                    FileChannel.open(Path.of("Result.pdf"),
                        StandardOpenOption.CREATE,
                        StandardOpenOption.WRITE,
                        StandardOpenOption.TRUNCATE_EXISTING)) {

                pdfDocument.save(writableByteChannel);
            }
        }
    }
}

The example saves the document to disk, but file I/O is optional. Each library reads and writes through java.io streams, NIO channels, or a byte[]. As a result, integration into web applications and services is straightforward:

try (PdfDocument document = new PdfDocument(request.getInputStream())) {
    // Edit the document...
    document.save(response.getOutputStream());
}

PDF Document API for Java

Our PDF Document API is the most extensive library in the CTP. It supports the entire PDF lifecycle. You can create documents from scratch, edit existing PDFs, secure and annotate files, work with interactive forms, and export pages to images. Everything runs in code. As a result, the library suits batch processing, report generation, and web services equally well.

Create Documents from Scratch

Create a PdfDocument, add pages, and populate them with content fragments — self-contained objects positioned with explicit coordinates. A page can contain:

Text with font and style formatting
Raster and vector images
Geometric shapes and paths
Embedded file attachments

For recurring layouts (such as invoices, certificates, or reports), create a reusable page template and apply it throughout the document.

One implementation detail is worth noting: PDF uses a coordinate system with its origin at the bottom-left corner of the page. PDF measures coordinates in points (72 points per inch), so larger Y values move content toward the top of the page.

Edit Existing PDFs

Load an existing PDF from a stream, channel, or byte array (optionally with a password) and modify contents. The API allows you to:

Merge multiple PDF documents into a single file or split a document across multiple files.
Search and replace text (configure search options).
Move or scale existing page content.
Read and edit bookmarks, form fields, attachments, annotations, comments, and the document structure tree.

Additional Capabilities

Beyond document creation and editing, the library includes APIs for:

Page management — insert, remove, duplicate, reorder, rotate, and resize pages.
Interactive forms (AcroForms) — create and edit form fields, organize and fill forms, and import or export form data.
Annotations — add text markup, links, drawings, file attachments, watermarks, and stamps.
Security — encrypt documents, apply user and owner passwords, and restrict printing, copying, or editing.
Accessibility & compliance — generate tagged accessible PDFs (both PDF/UA-1 and PDF/UA-2 compatible) and create ZUGFeRD-compliant invoices for electronic invoicing workflows.
Metadata & export — read and write document metadata and render PDF pages to images.

PowerPoint Presentation API for Java

Our PowerPoint Presentation API is a cross-platform library that creates, loads, modifies, saves, and exports presentations without an installed copy of PowerPoint. It reads and writes PPTX, PPTM, POTX, and POTM files.

The following example loads a presentation, adds a title slide, sets title text, and saves the file while preserving PowerPoint compatibility:

import com.devexpress.docs.presentation.*;

import java.nio.file.*;
import java.nio.channels.*;

public class UpdatePresentation {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("presentation.pptx");
        try (Presentation presentation = new Presentation(Files.readAllBytes(path))) {

            Slide slide = new Slide(SlideLayoutType.TITLE);
            for (ShapeBase shapeBase : slide.getShapes()) {
                if (shapeBase instanceof Shape shape
                        && shape.getPlaceholderSettings().getType() == PlaceholderType.CENTERED_TITLE) {
                    shape.getTextArea().setText("DevExpress Presentation API for Java");
                }
            }
            presentation.getSlides().add(slide);

            try (WritableByteChannel channel = FileChannel.open(path,
                    StandardOpenOption.WRITE,
                    StandardOpenOption.TRUNCATE_EXISTING)) {
                presentation.saveDocument(channel);
            }
        }
    }
}

The presentation object model gives you programmatic access to the complete document tree:

Presentations — create, load from a stream or byte array, and merge multiple files into one.
Masters and layouts — apply predefined layouts or define your own for consistent slide structure.
Slides — add, reorder, duplicate, and remove slides.
Shapes and tables — add, remove, and modify presentation text boxes, images, geometric shapes, and tables with cell merge and split.
Themes and formatting — control colors, fonts, effects, sizes, and other appearance settings for all presentation elements.
Headers, footers, and notes — metadata, slide numbers, and presenter-only notes.
Export — render a presentation to PDF or export to per-slide images.

Barcode Generation API for Java

Our Barcode Generation API produces print-ready 1D and 2D barcodes. It supports common 1D symbologies (EAN, UPC, Code 128) and 2D symbologies (QR Code, DataMatrix, PDF417, Aztec), and exports to PNG, JPEG, SVG, or PDF.

The workflow is consistent across symbologies. Choose a barcode type, configure common settings (colors, DPI, module size), and then apply symbology-specific settings. Export to a stream or file as PNG, JPEG, SVG, or PDF. You can also call exportToImage() to generate a DXImage and embed the barcode directly into a PDF page or a slide. Fluent API builders configure everything with chained calls.

import com.devexpress.drawing.*;
import com.devexpress.docs.barcode.*;

import java.io.*;
import java.nio.file.*;

public class GenerateBarcode {
    public static void main(String[] args) throws Exception {

        byte[] logoBytes = Files.readAllBytes(Path.of("images/devexpress-logo.png"));
        try (DXImage logo = DXImage.fromStream(new ByteArrayInputStream(logoBytes))) {
            QRCodeOptions options = new QRCodeOptionsBuilder()
                .withCompactionMode(QRCodeCompactionMode.BYTE)
                .withVersion(QRCodeVersion.VERSION_10)
                .withErrorCorrectionLevel(QRCodeErrorCorrectionLevel.H)
                .withModuleSize(10)
                .withShowText(false)
                .withIncludeQuietZone(true)
                .withLogo(logo)
                .build();

            try (FileOutputStream pngStream = new FileOutputStream(
                    Path.of("qr-code.png").toFile());
                 BarcodeGenerator generator = new BarcodeGenerator(options)) {
                // Export the QR Code to a PNG image.
                generator.export("https://www.devexpress.com", pngStream, DXImageFormat.getPng());
            }
        }
    }
}

Evaluate the CTP

During the CTP period, all three DevExpress libraries are available on Maven Central. Add dependencies to a test project and evaluate our APIs against your app requirements.

The CTP also includes DevExpress technical support. Visit the product page and follow links to the CTP license registration form. Once registered, you can submit tickets through the DevExpress Support Center. Select Office & PDF File API for Java as the platform, then select the relevant product: Barcode Generation API, PDF Document API, or Presentation API.

Registration also gives you access to a ZIP package with all library JAR files through the DevExpress Download Manager. This option suits environments that use local dependencies instead of Maven Central.

To get started, add DevExpress packages to a new project, run the three examples above, and see whether the model fits your pipeline.

Product page & CTP license registration: DevExpress Office & PDF File API for Java
Documentation: Get Started with Office & PDF File API for Java
Demo projects: Demo repository on GitHub

After our official commercial release, you can continue using the CTP version in existing projects at no cost. However, the CTP version will no longer be updated. To access official releases, annual updates, and technical support, you will have to upgrade to a commercial subscription (official release is set for 2027 - pricing has not been set). Should you have questions about the CTP, feel free to submit a support ticket via the DevExpress Support Center.

What's Next

Our Office & PDF File API for Java CTP is just the first step. We are working towards feature parity with our File API libraries for .NET.

Extended PDF and PowerPoint Support

PowerPoint Presentation API: Chart API is in active development. With the Chart API, you will be able to create and modify native PowerPoint charts, update chart data, and preserve chart editability in Microsoft PowerPoint without conversion to images.
PDF Document API: We plan to add digital signature support (for PDF signing and electronic signature workflows).

Our plans, priorities, and timelines can change. Your feedback during the CTP will help us define future development objectives. Follow our blog for roadmap updates and upcoming milestones.

DevExpress Office & PDF File API — Year-End Roadmap (v26.2)

Maria Nikulina (DevExpress) — Thu, 03 Sep 2026 00:00:00 Z

In this blog post, I'll outline the DevExpress Office & PDF File API features and capabilities we expect to ship in our year-end release (v26.2 — December 2026). To discuss this roadmap in greater detail, or to share a business use case we have yet to address, please submit your feedback through the DevExpress Support Center. We are happy to follow up.

The information contained within this blog post details our current/projected development plans. Please note that this information is being shared for INFORMATIONAL PURPOSES ONLY and does not represent a binding commitment on the part of Developer Express Inc. This roadmap and the features/products listed within it are subject to change. You should not rely on or use this information to help make a purchase decision about Developer Express Inc products.

Roadmap Updates

Our roadmap will be updated regularly to reflect development progress. As we get closer to the release, we expect to add additional items and modify the status of planned features. Look for the following labels next to every feature:

Planned — Feature is scheduled but not yet in development.
In Development — Under active development.
Coming in EAP v26.2 — Will be available in our first v26.2 early access preview.
Coming in v26.2 — Will be included in the final v26.2 release.
Released in v26.2 — Fully implemented and available.

.NET 11 Support

DevExpress Office & PDF File API libraries will support .NET 11 (both v26.1 and v26.2) following Microsoft's official release.

Minimum Supported .NET and Visual Studio Versions

As you may know, .NET 8 and .NET 9 will reach end of support on November 10, 2026. We will therefore raise our minimum supported .NET version to .NET 10 once we release v26.2 in December. The minimum .NET Framework version will remain 4.6.2.

Visual Studio 2022 will be the minimum supported IDE version when v26.2 ships.

Automatically Re-target DevExpress-based Projects to .NET 10 and Update 3rd Party NuGet Packages

For .NET/.NET Core, we recommend using the DevExpress Project Converter to update all DevExpress-related and third-party project references, packages, and configurations automatically. See also a related Breaking Change notice.

Separate NuGet Packages for Different .NET Versions (.NET 10, .NET 11, etc.)

Today, third-party dependencies are automatically patched after a detected vulnerability (for example, a vulnerability in System.Security.Cryptography.Xml) only for the minimally supported .NET version (today it's .NET 8). Today (with v26.1, v25.2, v25.1, v24.2), manual version pinning (Solutions #1 or #2 from this article) may still be required for .NET 9/10-based projects depending on their exact TFM and project SDK. We will provide .NET-specific dependency groups in DevExpress NuGet packages, which will simplify use of v26.2.

Security — SBOMs and CRA Readiness

If you deliver software in the EU, the Cyber Resilience Act (CRA) will require a Software Bill of Materials (SBOM – an inventory of every component inside your solution) as part of your conformity documentation. The CRA and its associated regulatory regime will go into effect on December 2027. Each software application/solution manufacturer must fulfil SBOM-related obligations. DevExpress-authored SBOMs will help customers document/inventory DevExpress libraries used within a DevExpress-powered app.

Most dependency scanners and SBOM generation tools read what a NuGet package declares (its dependencies on other NuGet packages) and stop there, which leaves two gaps we fill:

Components embedded inside a package. Some DevExpress NuGet packages bundle fonts and third-party JavaScript libraries. Package metadata has no way to declare them, so a scanner never reports them — even though their licenses and vulnerabilities are as real as those of any declared dependency.
Developer dependencies. Libraries we use to build our products never reach users, so we mark them with scope: "excluded". We list these libraries regardless, because all vulnerabilities should be documented.

We released a preview version of DevExpress-authored SBOMs in May 2026 (for our .NET NuGet packages). SBOMs for CRA Compliance in DevExpress-powered Apps describes what the files contain and how to feed them into tools such as Dependency-Track, Trivy, and Grype. With v26.2, we expect to extend coverage to NPM packages and DevExpress VCL libraries, take our SBOMs out of preview and make them available to every customer.

WCF Dependency Will Be Removed from XPO and Printing Core Libraries

These core libraries currently include references to WCF (Windows Communication Foundation), a standard library with a well-documented history of vulnerability disclosures in its dependencies ("thanks" to System.Security.Cryptography.Xml). We will remove these WCF references from DevExpress.Xpo core and DevExpress.Printing.Core libraries in v26.2. .NET Framework users will use the new DevExpress.Xpo.Services and DevExpress.Printing.Remote libraries instead (if you need this advanced and rarely used WCF functionality). The Project Converter will update project references automatically, so you should not encounter upgrade-related issues.

Product-Tailored AI Skill Updates

We expect to extend and update the DevExpress AI Agent Skills repository based on user feedback (for multiple implementation tasks and AI coding assistants, such as GitHub Copilot, Claude Code, Cursor, and JetBrains AI Assistant).

The repository includes folders for different DevExpress products. Navigate to the dx-office-file-api directory to locate AI Agent Skills for Office/PDF File API coding assistants with built-in knowledge of Office/PDF File API libraries, their capabilities, related APIs, best practices, and code examples.

New Document Processing Libraries for .NET and Java

As you may already know, our new PDF and Presentation APIs are object-based document processing libraries. In upcoming release cycles, we will extend the same object-based approach to our Word Processing and Spreadsheet APIs. Both APIs will share the same design objectives: a modern, idiomatic object model built upon concrete, cloneable objects, with a consistent developer experience for both .NET and Java. Moving forward, we expect to design future APIs from ground up for both platforms, so developers can use the same concepts and document workflows regardless of their technology stack.

New Word Processing Document API

.NET — In Development Java — Planned

The new Word Processing Document API will replace the current interface-based API with a concrete, tree-like object model. You will work directly with document objects that can be created, configured, and composed before they are added to a document. Built upon DevExpress.RichEdit.Core, it will be backend-oriented and run cross-platform on .NET 10+.

For the CTP (Community Technology Preview) version, we plan to address core document-generation and editing workflows:

Generate a complete document (an invoice, report, technical documentation) from scratch
Examine and edit the document object tree, including text runs, paragraphs, shapes, fields, and other elements
Apply styles and formatting
Insert tables and images
Replace placeholders, calculate fields, and initiate mail merge
Search, edit, and format document elements using an advanced range-based API
Convert documents across different Word-like formats, including HTML
Export documents to PDF
Encrypt or protect a document
And more

We expect to deliver the same feature set for our Java-based APIs. The new library will ship as a dedicated NuGet/JAR package — independent of DevExpress.Document.Processor.

New Spreadsheet Document API

.NET — In Development Java — Planned

The new Spreadsheet Document API will offer the same object-based design for workbook processing, built on the existing DevExpress.Spreadsheet engine and calculation infrastructure. You will work with concrete objects through a clean, range-based model. The same API and feature set will be available across both .NET and Java.

For the first release, we expect to support the following workbook usage scenarios:

Generate a workbook from scratch
Convert workbooks across formats, and split and merge workbooks
Edit worksheets, rows, columns, and cells
Apply styles and formatting
Insert tables, charts, and shapes
Read, write, and calculate formulas
Sort and filter data
Export to PDF
Encrypt or protect a workbook
And more

Like our new Word Processing API, this library will ship as a dedicated package.

Safer Document Processing API

Server-based applications increasingly process documents from untrusted sources, be they user uploads, email attachments, or third-party integrations. To help mitigate these risks, we are adding Safer Document Processing APIs to our PDF and Presentation libraries so you can protect your application against malicious input before processing begins. Both APIs will follow the same model: enforce loading limits, strip active or dangerous content on import, and sanitize sensitive data on demand.

PDF Document API — Secure Loading and Sanitization

Planned

The DevExpress PDF Document API will add a secure loading and sanitization layer for untrusted documents with three lines of defense:

Secure loading — reject dangerous documents before or during parsing. You will be able to set limits for file size, indirect-object count, and page count, and activate a strict loading mode that disables heuristic recovery for malformed PDFs.
Active content sanitization — remove executable and interactive content, including embedded JavaScript, document actions (JavaScript, Launch, URI, GoTo, and SubmitForm), and embedded files or attachments.
Privacy and data-leakage prevention — sanitize external links and annotations, strip document metadata, and inspect document content before removal, so sanitization remains under your control.

Presentation API — Security and Privacy

Coming in EAP v26.2

Our Presentation API will add its own Safer Document Processing API with three lines of defense against malicious or oversharing presentations:

Security loading limits — enforced during import to guard against decompression and resource-exhaustion attacks. You will be able to cap the slide count and the number of shapes per slide, along with file size and XML element count/nesting depth. When a limit is exceeded, the API will allow you to handle, log, or throw an error, based on your configuration.
Dangerous content removal — applied during import, before content is loaded into the document model. You will be able to strip external images, links, and chart-data references (removing these prevents tracking and IP leakage), macros, OLE objects, ActiveX controls, and custom XML parts.
Privacy sanitization — an Inspect/Sanitize API applied on demand to a loaded document. Inspect detects sensitive content; Sanitize removes or neutralizes it, covering document metadata (author, organization, description), hidden slides, unrecognizable text, speaker notes, and embedded objects.

New PDF Document API

We continue to expand our new, dedicated PDF Document API (DevExpress.Docs.Pdf) with the following features:

Bookmark API

Coming in EAP v26.2

Our PDF Document API will introduce a Bookmark API for the document outline. You will be able to create, read, and modify the bookmark tree that forms a document's navigation pane. Readers can then jump directly to sections in long or generated PDFs.

Incremental Updates — Research Stage

In Progress

We are researching broader incremental update support for the PDF Document API. Our goal is to save supported changes as revisions, without rewriting the entire file. We expect this approach to append only modified PDF objects and preserve the original bytes whenever possible.

Our current research focuses on change tracking for PDF objects and collections, and we plan to expand coverage in phases. The following changes are in scope:

Update document metadata
Apply digital signatures
Change page size, boxes, or rotation
Add, modify, or remove attachments
Insert pages or overlay content on existing pages

Final capabilities will depend on our ongoing research. If a particular change cannot be written as an incremental update, the API will fall back to the standard full-save workflow.

Digital Signature API

In Development

Our PDF Document API will allow you to digitally sign PDF documents natively using your own certificates. The API will cover the full signature-related workflow:

Create signature fields and customize associated appearance, including signer name, reason, location, date, labels, fonts, colors, and images.
Sign documents with a digital signature and associated metadata such as reason, location, contact information, and signing time, together with a certification level and change permissions.
Inspect existing signatures, including the signer, reason, location, signing time, certification level, and permitted document changes.

The API will choose the appropriate save mode automatically. When adding signatures, it will use incremental updates to preserve existing signatures whenever possible; otherwise, it will fall back to the standard full-save workflow.

You will also be able to add multiple signatures to a document, stored in their own signature field, and reuse the same certificate across signatures. A single signature field displayed on multiple pages will produce one signature that remains visible throughout the document.

Form Field and Annotation Flattening

Coming in EAP v26.2

You will be able to flatten interactive form fields and annotations. Flattening renders associated visual appearance directly into page content. Values remain visible but are no longer editable — useful when you finalize a completed form for distribution or archival.

PDF/A and PDF/UA Compliant API

Planned

Organizations subject to archival (PDF/A) or accessibility (PDF/UA) requirements will be able to produce compliant documents through a single, built-in API. We plan to address three compliance scenarios:

Generate PDF/A- and PDF/UA-compliant documents directly during document generation.
Convert loaded or newly generated documents to a target compliance standard.
Validate compliance before distributing a document.

OCR API

In Development

We will introduce a built-in OCR (Optical Character Recognition) for the PDF Document API so you can turn scanned documents and raster page content into searchable, extractable, and AI-ready text. Our scope centers on the core recognition workflow:

Recognize text in scanned pages, page regions, and multi-page documents.
Generate a searchable PDF text layer while preserving original page graphics.
Extract recognized text as a structured model of blocks, lines, and words, each with its own text, bounds, and confidence level.
Preserve page reading order and text positioning.

Our API will allow you to build a recognition pipeline that feeds directly into existing PDF text, search, and accessibility workflows.

Presentation API

Hyperlink Support

Planned

Our Presentation API will support hyperlinks for full compatibility with presentations created in Microsoft PowerPoint. You will be able to create, inspect, modify, and remove hyperlinks on both individual text runs and entire shapes (images, charts, text boxes, and more).

Hyperlinks will support the following targets:

External web URLs
Email addresses (mailto:)
Local files
Other slides within the same presentation

Existing hyperlinks will round-trip on import and export, and you will be able to inspect and edit every related property, including display text, target URI, and tooltips.

Word Document Processing

PDF Export / Rendering — Floating-Point Layout Calculation

In Development

The document layout engine will calculate positions using floating-point coordinates (System.Single, RectangleF, PointF, and SizeF) instead of integers. The change will start with font metrics and extend to the layout model. This shift will enhance positioning precision and fidelity for rendered and exported documents (PDF and image formats). You can expect more precise text and object positioning, improved table and paragraph accuracy, and closer compatibility with Microsoft Word's rendering engine.

A feature toggle will allow you to switch between float-based and integer-based rendering, so existing output that relies on integer layout continues to work as expected.

PDF/UA-2 Export — PDF Structure Destinations & Field Tagging

Coming in EAP v26.2

We will enhance the accessibility and navigation throughb PDF/UA-2 files generated from Word documents. Our Word Processing tools will resolve navigational targets to PDF structure destinations. Supported targets include those that map to bookmarks — explicit bookmarks, Table of Contents entries, and cross-reference fields. As a result, links and navigation in the exported PDF will point to the correct structural location rather than a raw page coordinate. The export will also tag AcroForm fields for PDF/UA-2, so Word documents that use content controls will convert to accessible PDF forms.

Spreadsheet Processing

ODS Format Support — Research Stage

In Progress

We are working towards OpenDocument Spreadsheet (ODS) format support and investigating available opportunities. Demand for OpenDocument Format (ODF) interoperability is rising sharply across the public sector. In March 2026, Germany's Deutschland-Stack mandated ODF — alongside PDF/UA — as a standard document format for federal public administration at every level of government. Implementation is planned by 2028, and suppliers to the German public sector will need ODF support. Other EU member states building compatible infrastructure may follow.

We are currently at the research stage, but we will evaluate how to load and save ODS documents while preserving worksheet structure, cell values and formulas, formatting, merged cells, named ranges, and document settings. We will prioritize complete implementation separately, based on the research results.

Your Feedback Counts

Have questions or suggestions about our year end DevExpress Office & PDF File API (.NET or Java) roadmap? Please share your thoughts in the survey below or submit a ticket through the DevExpress Support Center. Your feedback is always welcome.

v26.1 - What’s New

And before I let you go - If you have yet to review the features/capabilities introduced in our most recent major update, please visit the following webpage and let us know what you think of our June release by responding to our online survey: Explore Our Newest Features (v26.1).

Office File & PDF Document Processing APIs — June 2026 Roadmap (v26.1)

Maria Nikulina (DevExpress) — Mon, 23 Feb 2026 04:20:00 Z

We thank you for your continued support and for sharing your document processing needs and requirements with us. In this blog post, I’ll outline our development and release plans for the first half of 2026.

If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File & PDF API library does not currently address, feel free to submit your feedback via the DevExpress Support Center. We’ll be happy to follow up.

Roadmap Updates

Planned — Feature is scheduled but not yet in development.
In Development — Under active development.
Coming in EAP v26.1 — Will be available in our first v26.1 early access preview.
Coming in v26.1 — Will be included in the final v26.1 release.
Released in v26.1 — Fully implemented and available.

Safe Word & Excel Document Processing

Released in v26.1

Our Office File API libraries will include new APIs to securely load and sanitize Microsoft Office(r) files (Word, Excel). These APIs will ship with the following capabilities:

Remove potentially harmful or malicious content (macros, embedded objects, links, scripts).
Remove sensitive, hidden, or private data (metadata, comments, tracked changes, optional content, and more).
Limit file size, complexity, or structure depth when uploading or saving files.

These enhancements will help ensure documents are safe to share and compliant with internal data protection policies.

Document Processing Libraries for JAVA

Released in v26.2 (CTP)

As part of our cross-platform expansion, we are broadening the footprint of DevExpress Office & PDF APIs (moving to the Java platform).

Important note: Once our Java Document Processing Library is released, it will be available as a separate/independent subscription. Java libraries will not be included in our .NET Office & PDF File API library.

The following libraries are expected to be available as an early beta in our v26.1 release cycle (and enhanced incrementally):

Barcode Generation API — A comprehensive library for generating barcodes (1D and 2D formats) within Java applications. This API will support common symbologies and image output formats making it suitable for labeling and scanning.
PowerPoint Presentation API — A non-visual PowerPoint processing API that parallels our .NET offering and allows Java developers to programmatically create, modify, and export PPTX files. Early support will focus on slide management, text and shape manipulation, and basic chart support.
PDF Document API — Core PDF file processing capabilities will be extended to Java and enable automated workflows for PDF generation, manipulation, data extraction, and export. Planned features include document creation, merging, form filling, annotating, and text management.

PDF Processing

New PDF Processing API

Released in v26.1 (CTP)

We will introduce new high-level APIs for PDF document generation and content management. These new APIs aim to significantly reduce the complexity of PDF document creation/editing and enable more fluent and flexible text-processing.

These new capabilities will allow you to:

Work with high-level document objects such as paragraphs, text fragments, images, shapes, interactive forms, and annotations.
Insert, read, search, remove, and format text using semantic PDF elements with full control over font, size, and style properties.
Work with RTL documents.
Automatically reflow content when text fragments are inserted/deleted.
Manually tag document objects.
Сopy and reuse high-level objects across PDF documents.

PDF/UA-2 Export

Released in v26.1

To further extend accessibility compliance in automated document workflows, we plan to introduce export options that target the PDF/UA-2 accessibility conformance level. With this capability, developers will be able to create PDFs with appropriate tags, semantics, and structural metadata required for accessibility tools (screen readers, assistive technologies).

PDF/A-4 Export

Postponed

In v26.1, we expect to extend our PDF Document API’s export capabilities with PDF/A-4 compliance so that you can generate archival PDFs that meet current retention and regulatory requirements.

Excel Spreadsheet API

Excel to PDF/UA Conversion Enhancements

Released in v26.1

We’ll enhance our Excel to PDF/UA conversion engine to address accessibility issues related to graphical object tagging and artifact generation (for decorative content).

New Excel Functions

Released in v26.1

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions, including functions like:

XLOOKUP
XMATCH
SORT
FILTER
UNIQUE

Presentation API

Charts

Released in v26.1

In v26.1, the DevExpress Presentation API library will natively support Office/PowerPoint charts. New APIs will allow you to create, manipulate, and customize chart objects inside PowerPoint presentations (PPTX) programmatically. This includes support for:

Common MS Office chart types
Chart data initialization and binding
Data series and axis configuration
Visual format settings (titles, legends, colors, and more)

You will also be able to open, edit, and export existing PowerPoint presentations that contain charts without content loss.

Export Slides to Images

Released in EAP v26.1

v26.1 will add the ability to export individual slides to raster and vector image formats:

BMP
PNG
JPEG
EMF
SVG
And more

This feature will allow you to generate thumbnail previews, create image-based slide wrappers for web or mobile consumption, and integrate slides into non-PPTX workflows in both Windows and Unix-based systems.

Your Feedback Counts

We appreciate your continued support. As I mentioned at the beginning of this post, if you have Office/PDF File API-related suggestions or requests, please submit a support ticket via the DevExpress Support Center — we'll be happy to review your feedback and follow up.

File & Document Processing APIs (Office/PDF File APIs) — Year-End Roadmap (v25.2)

Maria Nikulina (DevExpress) — Thu, 14 Aug 2025 06:30:00 Z

Thank you for your continued support and for sharing your document processing needs and requirements with us. In this blog post, I'll share our development/release plans for the second half of 2025. If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File API product does not currently address, feel free to submit your feedback via the DevExpress Support Center. We’ll be happy to follow up.

Roadmap Updates

Our year-end roadmap will be updated regularly to reflect development progress. As we get closer to the release, we expect to add additional items and modify the status of planned features. Look for the following labels next to every feature:

Planned — Feature is scheduled but not yet in development.
In Development — Under active development.
Coming in EAP v25.2 — Will be available in our first v25.2 early access preview.
Coming in v25.2 — Will be included in the final v25.2 release.
Released in v25.2 — Fully implemented and available.

DevExpress MCP Server for AI-Powered Documentation Access

All Platforms
Available in Preview

We will introduce an MCP server that connects GitHub Copilot Chat, Cursor, and other MCP-compatible AI tools directly to our comprehensive documentation database. The server will provide instant access to over 300,000 help topics through natural language queries within your IDE. This will allow you and AI coding agents such as Claude Code to access current DevExpress documentation directly within the AI assistant's context.

Safe Document Processing (Discuss This Feature)

Postponed to v26.1

Our Office/PDF File API libraries will include new APIs to securely load and sanitize PDF and Office files (Word, Excel, and PowerPoint formats). These APIs will ship with the following capabilities:

Remove potentially harmful or malicious content (macros, embedded objects, links, scripts, etc).
Remove sensitive, hidden, or private data (metadata, comments, tracked changes, optional content, etc).
Limit file size, complexity, or structure depth when uploading or saving files.

These enhancements will help ensure documents are safe to share and compliant with internal data protection policies.

AI-powered Document Processing (Discuss This Feature)

Released in v25.2

We will introduce a new set of AI-powered file and document APIs designed to enhance productivity/streamline document workflows across the entire DevExpress Office/PDF File API suite.

These intelligent services will allow you to integrate advanced language models directly into document processing scenarios and leverage capabilities such as:

Summarization – Automatically generate concise summaries of Word, PDF, Excel, or PowerPoint documents.
Translation – Translate content between languages and preserve original document formatting and structure.
Proofreading – Detect and correct grammar, spelling, and style issues across document content.
Contextual Q&A – Ask questions about the content of a document and receive targeted responses.
And more.

Key capabilities:

Supports Word (DOCX), Excel (XLSX), PowerPoint (PPTX), and PDF file formats.
Seamless integration with the document object model (DOM) and structured document elements (paragraphs, shapes, cells, etc).
Real-time document editing and updates based on AI-generated suggestions.

Document Accessibility & Compliance

PDF/A Processing Enhancements (Discuss This Feature)

Released in v25.2

With v25.2, we will enhance PDF/A file processing capabilities (import, edit, and save) when using our PDF Document API. These improvements will help ensure that files remain PDF/A-compliant after modifications. We will also introduce APIs to read a document’s PDF/A conformance level and reset compliance status as needed.

Word to PDF/UA Conversion — Form Field Tagging

Released in v25.2

With our next release, DevExpress Word-processing tools will automatically add accessible tags for PDF form fields when users export Word documents with Content Controls to PDF/UA.

Excel to PDF/UA Conversion Enhancements (Discuss This Feature)

Postponed

We’ll enhance our Excel to PDF/UA conversion engine to address accessibility issues related to graphical object tagging and artifact generation (for decorative content).

PDF 2.0 & PDF/UA-2 Support (Research Phase)

Research Complete

During our v25.2 release cycle, we will begin work to support PDF 2.0 and PDF/UA-2 formats across the entire DevExpress Office File API product line.

Once our research phase is complete, we'll prioritize implementation steps to align our document processing libraries with modern standards and regulatory requirements.

Presentation API

Document Rendering Enhancements

Released in v25.2

We will refine our internal document layout engine to offer precise rendering of PowerPoint presentation content. This includes enhancements in how text, shapes, and layout elements are measured and drawn when you print or export presentations to PDF.

Tables (Discuss This Feature)

Released in v25.2

We plan to support PowerPoint table elements and introduce APIs to programmatically create and format structured tables inside slides.

This feature will include the following capabilities:

Insert tables with a specified number of rows and columns.
Manage table, row, column, and cell operations (insert, delete, resize, format).
Fill, modify, and clear table data.
Merge and split table cells.
Apply table styles and format individual cells (borders, shading, text alignment, background fills and more).

Themes (Discuss This Feature)

Released in v25.2

To improve presentation design consistency, we will support PowerPoint themes. This will include the ability to:

Apply and manipulate built-in or custom themes programmatically.
Modify a theme's color scheme.
Reset theme formatting.

OpenXml-based File Formats (Discuss This Feature)

Released in v25.2

We'll expand the range of supported PowerPoint file formats with the following OpenXml-based extensions:

POTX — PowerPoint Template
POTM — PowerPoint Macro-Enabled Template
PPTM — PowerPoint Macro-Enabled Presentation

PDF Document API

PDF Compression & Optimization

Image Compression Enhancements (Discuss This Feature)

Released in v25.2

We'll introduce support for additional image compression options. This will include settings for grayscale conversion to reduce file size when color fidelity is not required.

Combine & Compress PDF Object Streams (Discuss This Feature)

Released in v25.2

With v25.2, our PDF Processing API will include functionality to merge and compress PDF object streams to remove redundancy in internal data structures and reduce file overhead.

This capability will optimize both output file size and PDF load performance. Additionally, this will address file size growth issues when you merge multiple PDFs with pre-compressed streams into a single file.

Use Custom Fonts for PDF AcroForm Fields (Discuss This Feature)

Released in v25.2

We'll introduce the ability to use custom fonts (not registered in the system) for PDF fields (text boxes, signatures, etc) when using the DevExpress PDF Document API library for document generation or modification. Custom fonts registered in the DXFontRepository will be embeddable at runtime and applied to newly created or existing fields via the document model.

Word Document API

Enhanced Master-Detail Mail Merge (Discuss This Feature)

Released in v25.2

We will extend our Word Processing APIs and support mail merge operations based on hierarchical (master-detail) data sources. This feature will allow developers to bind nested collections directly to Word templates using standard merge field syntax. With this enhancement, you will be able to:

Define repeatable detail sections using region-based merge fields.
Use a single template to generate multi-level reports, invoices, or personalized documents.
Perform complex document generation from hierarchical business objects (for example, Customer → Orders, Order → Items).
Integrate with custom data sources.

Spreadsheet Document API

OLE Object Support Enhancements (Discuss This Feature)

Released in v25.2

In our end-of-year release, we will give you the capability to manage OLE Objects (load, modify, and save) in binary file formats:

XLS
XLSB

New Excel Functions (Discuss This Feature)

Postponed to v26.1

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions, including functions like:

XLOOKUP
XMATCH
FILTER
UNIQUE
And more

Your Feedback Counts

v25.1 - What’s New

If you have yet to review the features/capabilities introduced in our most recent major update, please visit the following webpage and let us know what you think of this release by responding to our online survey: Explore Our Newest Features (v25.1).

File & Document Processing APIs — New PowerPoint Presentation API Library

Maria Nikulina (DevExpress) — Wed, 13 Aug 2025 00:30:00 Z

We are happy to announce the CTP release of our new .NET PowerPoint Presentation API library (available with v25.1.4+). This library was designed to help you create, read, edit, convert, merge, split, and print Microsoft PowerPoint files within .NET apps.

In this blog post, I’ll describe the key features available in this Community Tech Preview, share product architecture insights, and demonstrate how you can create an application to manage presentation files in code.

Note: The DevExpress Presentation API Library is currently available as a Community Technology Preview (CTP).

Presentation API Overview

Cross-platform PowerPoint File Processing

The DevExpress Presentation API is built atop .NET and supports a broad range of platforms and operating systems out of the box. Whether you’re developing a traditional desktop application, a web backend, or a cross-platform solution, you can seamlessly integrate PowerPoint file processing without any dependency on Microsoft Office or PowerPoint installations.

Supported frameworks, operating systems, and environments include:

NET 8/9, .NET Framework 4.6.2+
Windows, Linux, macOS
Azure, AWS, Docker

Supported Formats and Document Elements

The current version (v25.1.x) of our PowerPoint Presentation API library allows you to import and save presentation files using the PPTX file format (and of course to print/export files to PDF).

The DevExpress Presentation library includes a comprehensive set of APIs and settings to create/manage presentation elements programmatically. You can add, access, modify, or remove the following PowerPoint document elements and customize associated settings:

Slides, Slide Layouts, Slide Master
Slide Notes, Note Master
Shapes, Connectors, Text Boxes, Images
Shape Text, Paragraphs, and Placeholders
Bullet and Numbered Lists
Presentation Header and Footer
Built-in and Custom Document Properties
Presentation View Properties

Code Example — Convert a Presentation to PDF

using DevExpress.Docs.Presentation;
//...
// Load a presentation
Presentation presentation = new Presentation(File.ReadAllBytes("mypresentation.pptx"));
// Export to PDF
presentation.ExportToPdf(new FileStream(@"D:\exported-document.pdf", FileMode.Create));

Key Features Designed to Manage Presentations

The DevExpress Presentation API gives you the power to programmatically create and organize presentation content. It supports the following usage-scenarios:

Add, clone, rearrange, resize, hide, or delete presentation slides.
Create, customize, and apply different slide layouts.
Access and update slide master content.
Merge multiple presentations or copy slides from one presentation to another.
Split one presentation to multiple presentations (slide-by-slide).
Extract or assign text to a specific paragraph, shape, slide, speaker note, or entire presentation.
Format text, paragraphs, shapes, and slide backgrounds.
Manage presentation metadata.

Code Example — Merge Two Presentations

using DevExpress.Docs.Presentation;
//...
// Load presentations
Presentation presentation1 = new Presentation(File.ReadAllBytes("presentation1.pptx"));
Presentation presentation2 = new Presentation(File.ReadAllBytes("presentation2.pptx"));
// Merge presentation slides
foreach (Slide slide in presentation2.Slides) { 
    presentation1.Slides.Add(slide);
}
// Save the merged document to the PPTX file
FileStream outputStream = new FileStream(@"D:\merged_presentation.pptx", FileMode.Create);
presentation.SaveDocument(outputStream);

Object-based Document Model

Unlike other PowerPoint-processing libraries that rely on interface-based document model, the DevExpress Presentation API library uses the concrete Object-oriented model. This architectural choice is designed to offer a cleaner, more flexible, and developer-friendly experience.

Using our Presentation API library, you can work directly with intuitive classes — Slide, Shape, TextParagraph, and so on. You can initialize document objects and configure all necessary settings prior to adding new elements to a presentation. This offers a natural and structured approach to flow-based document generation.

Additionally, you can reuse document elements and configuration settings across multiple slides and presentations. For example, you can add the same slide to multiple presentations or apply the same formatting to multiple slides or shapes (as illustrated in the example below).

// Create and apply the custom background to multiple slides in two different presentations
SolidFill fill = new SolidFill(Color.LightCyan);
CustomSlideBackground background = new CustomSlideBackground(fill);
presentation1.Slides[0].Background = background;
presentation1.Slides[1].Background = background;
presentation2.Slides[0].Background = background;

Our approach allows you to make changes in presentation documents with minimal code. At the same time, if you need unique instances to prevent unintentional changes, you can create independent clones of document elements and settings.

We’d appreciate your feedback on the object model we’ve chosen for this new library. Please feel free to share your thoughts via the survey at the end of this page.

Get Started with PowerPoint Presentation API

To start using the DevExpress Presentation API in your project, you need to:

1. Install the DevExpress.Docs.Presentation NuGet package (v25.1.4+) from Nuget.org.

dotnet add package DevExpress.Docs.Presentation --version 25.1.4

Alternatively, use the Local/Personal DevExpress NuGet feed: Use NuGet Packages to Install Office File API Components.

2. Add the DevExpress.Docs.Presentation namespace to your project file.

3. Create a Presentation instance.

Use the parameterless constructor to create a new presentation with one blank slide.
Use the constructor with a byte array or stream parameter to load an existing PPTX file.

4. Use APIs to build or modify the presentation (generate presentation content, apply formatting, update metadata, or reorganize slides).

5. Generate output.

Use Presentation.SaveDocument to save the presentation to PPTX .
Use Presentations.ExportToPdf to generate a PDF file.
Use Presentation.Print to print the presentation.

Code Example — Create a New Presentation from Scratch

using DevExpress.Docs.Presentation;
//...
// Create a presentation with a single empty slide
Presentation presentation = new Presentation();
        
// Configure Slide Master
SlideMaster slideMaster = presentation.SlideMasters[0];
slideMaster.Background = new CustomSlideBackground(new SolidFill(Color.FromArgb(194, 228, 249)));
        
// Add a new slide with content
presentation.Slides.Clear();
Slide slide1 = new Slide(slideMaster.Layouts.Get(SlideLayoutType.Title));
foreach (Shape shape in slide1.Shapes) {
    if (shape.PlaceholderSettings.Type is PlaceholderType.CenteredTitle) {
        shape.TextArea = new TextArea("Daily Testing Status Report");
    }
    if (shape.PlaceholderSettings.Type is PlaceholderType.Subtitle) {
        shape.TextArea = new TextArea($"{DateTime.Now: dddd, MMMM d, yyyy}");
    }
}
presentation.Slides.Add(slide1);
    
// Save Presentation to PPTX
FileStream outputStream = new FileStream(@"D:\mypresentation.pptx", FileMode.Create);
presentation.SaveDocument(outputStream);

Learn More

Documentation:

Demos & Examples:

Licensing

The PowerPoint Presentation API library is included in the DevExpress Office File API and DevExpress Universal subscriptions. A valid license is required to use this library in production code. For additional information, please visit our Buy page.

Your Feedback Matters

Since this is a CTP version, features are still in development. We’d love your input on what to prioritize next. Please take a moment to complete the short survey below.

You’re also welcome to share your thoughts and questions via the DevExpress Support Center.

Document Processing (Office File API) — Early Access Preview (v25.1) — Redaction API, Export Enhancements and More

Polina Fedorova (DevExpress) — Fri, 25 Apr 2025 01:40:00 Z

This post outlines what’s inside our current Early Access Preview build (v25.1), which is available for download for our Universal and DXperience subscribers.

Early Access and CTP builds are provided solely for early testing purposes and are not ready for production use. This build can be installed side by side with other major versions of DevExpress products. Please back up your project and other important data before installing Early Access and CTP builds. This EAP may not include all features/products we expect to ship in our v25.1 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months.

For additional information on new Document Processing/Office File API capabilities we expect to ship in June, please refer to our v25.1 roadmap.

PDF Redaction API (Discuss This Feature)

v25.1 will include new APIs to create and manage redaction annotations in PDF documents. This new capability makes it possible to completely remove sensitive or private content from your documents and add a colored overlay with text over the redacted area.

The redaction process includes two steps: create a redaction annotation with the required appearance in the PDF page area, and apply the redaction annotations by clearing the content in the redacted area and applying the overlay from the appearance settings. These steps are independent so you can implement the following usage scenarios:

Review workflow: Create redaction annotations, save the document, and send it for review. The recipient can approve or comment on the redactions before applying them.
On-demand redaction: Load a document with redaction annotations, inspect redacted areas and comments, and apply redactions if necessary.
Direct redaction: Create and apply all redaction annotations in your PDF document at once.

Below I'll describe how you can implement these usage scenarios in code.

Create a Redaction Annotation

The Redaction functionality is available via the PDF Facade API. To create a redaction annotation, obtain the PdfDocumentFacade instance, retrieve the required PDF page from the PdfDocumentFacade.Pages collection and call the PdfPageFacade.AddRedactAnnotation method. The AddRedactAnnotation method returns the PdfRedactAnnotationFacade object, which you can use to adjust the appearance settings for the redaction annotation. The appearance includes the overlay text, text font settings (font name, color, size, and style) and additional settings like text repeating, alignment and background color.

PdfDocumentProcessor pdfProcessor = new PdfDocumentProcessor();
pdfProcessor.LoadDocument("Demo.pdf");

PdfDocumentFacade documentFacade = pdfProcessor.DocumentFacade;
PdfRectangle pageCropBox = pdfProcessor.Document.Pages[0].CropBox;
PdfRectangle redactBounds =
	new PdfRectangle(0, pageCropBox.Height-50, 200, pageCropBox.Height);

// Add a redaction annotation at the top left corner of the first document page
PdfRedactAnnotationFacade redactAnnotation =
	documentFacade.Pages[0].AddRedactAnnotation(redactBounds);
redactAnnotation.Author = "Jane Doe";
// Setup the redaction annotation appearance
redactAnnotation.FillColor = new PdfRGBColor(0, 0, 0);
redactAnnotation.FontColor = new PdfRGBColor(1, 1, 1);
redactAnnotation.FontName = "Calibri";
redactAnnotation.FontSize = 0; // enables font auto-size
redactAnnotation.OverlayText = "Classified";
redactAnnotation.TextJustification = PdfTextJustification.Centered;
redactAnnotation.RepeatText = false;

// Save the document with the redaction annotation and send it for review
pdfProcessor.SaveDocument("output_to_review.pdf");

Apply Redaction Annotations

The new API allows you to apply a single redaction annotation, all annotations for a specific page, or all redaction annotations in the entire document. To complete, use the PdfRedactAnnotationFacade.Apply, PdfPageFacade.ApplyRedactAnnotations or PdfDocumentFacade.ApplyRedactAnnotations method respectively.

Additionally, it is possible to use PdfClearContentOptions to specify the type of the content that should be removed (text, graphics, images, or annotations) when you apply the redaction.

PdfDocumentProcessor pdfProcessor = new PdfDocumentProcessor();
pdfProcessor.LoadDocument("Demo.pdf");

PdfDocumentFacade documentFacade = pdfProcessor.DocumentFacade;
// Review redaction annotations and apply
foreach (var page in documentFacade.Pages)
{
    var redactionAnnotations =
    	page.Annotations.Where(annotation => annotation is PdfRedactAnnotationFacade).ToList();
    foreach(PdfRedactAnnotationFacade annotation in redactionAnnotations)
    {
        if (annotation.Author == "Jane Doe")
            annotation.Apply();
    }
}
// Apply redaction annotations for a page
documentFacade.Pages[0].ApplyRedactAnnotations();
// Apply redaction annotations for the whole document
documentFacade.ApplyRedactAnnotations();
// Specify the clear content settings and apply redaction annotations
documentFacade.ApplyRedactAnnotations(new PdfClearContentOptions()
{
     ClearAnnotations = true,
     ClearImages = true,
     ClearText = true,
     ClearGraphics = false
});

Usage in WinForms and WPF PDF Viewer Controls

Of course, it is also possible to enhance your WinForms or WPF PDF Viewer application with the new redaction functionality. Once you obtain the PdfDocumentFacade instance using the PdfViewer.GetDocumentFacade extension method, you will be able to create and apply redaction annotation using the APIs I described above.

Note: The PdfDocumentFacade class is defined in the DevExpress.Docs.v25.1.dll assembly. Add this assembly to your project or install the DevExpress.Document.Processor Nuget Package from the Offline Package source to use PdfDocumentFacade members. You need a license for the DevExpress Office File API Subscription or DevExpress Universal Subscription to use this class in production code.

We prepared the code example that illustrates how to select an area in a PDF document opened in a PDF Viewer application and apply the redaction annotation to this area. Here is the link for your reference: PDF Viewer for WinForms - Add Redaction Annotations Using Viewer Coordinates

AI-powered Behaviors in WinForms PDF Viewer (Discuss This Feature)

You can now integrate AI-powered Summarize, Translate and Ask AI features into our WinForms PDF Viewer. These functionalities allow you to summarize, translate to chosen languages and ask custom questions about the PDF content from the whole PDF document, active page or document selection. The target mode can be selected from the AI dialogs available via the PDF Viewer context menu.

AI MainDemo — Pdf Viewer

AI-powered behaviors for WinForms PDF Viewer use the same prerequisites and integration mechanisms as other AI extensions in our WinForms product line. You can learn more about the AI usage and integration in our documentation: DevExpress AI-powered Extensions for WinForms

Word Processing Document API and Rich Text Editors for WinForms and WPF

DOC Format Export Enhancements

During the last release cycle, we received feedback related to the DOC format export in our word processing components. After a particular update, Microsoft Word started to interpret DOC files generated from other documents with complex structures as invalid. Considering the popularity and importance of the DOC file format in word-processing usage scenarios, we made it our primary goal to address this limitation in the upcoming release.

Good news—in v25.1, we redesigned our DOC format export engine and successfully addressed these limitations. Now, all of the documents and usage scenarios with DOC format conversion you shared with us are working as expected and provide valid DOC output.

We would appreciate your feedback on this matter. If you have experienced issues with DOC format conversion and subsequently opening documents in Microsoft Word, please take a moment to evaluate our update (these changes are also available for v24.2) and leave your feedback here: Ticket Discussion

Right-to-Left (RTL) Engine Enhancements

We enhanced our Right-to-Left text rendering engine in the Word Processing Document API library and WinForms and WPF Rich Text components. This functionality enables correct text order in paragraphs, numbering lists, tables and shapes with bi-directional text (mixed Right-to-Left and Left-to-Right text blocks). The enhanced behavior applies when you preview or edit bi-directional text in visual Rich Text controls, or when you generate a PDF or image output (in the User Interface or code).

Convert Word Content Controls to PDF AcroForms Fields (Discuss This Feature)

We enhanced the Word Document to PDF export engine and supported the built-in conversion of Word content controls to PDF AcroForm fields. With this functionality, you can now create fillable PDF forms from your Word documents with ease.

Our Word-processing tools automatically convert the following content control types:

Plain Text;
Rich Text;
Picture;
Check Box;
Combo Box;
Drop-Down List;
Date Picker.

Note: Building Block and Repeating Section content controls are exported as regular text.
Due to PDF format specifics, PDF text fields generated from Rich Text content controls use formatting from the first word of the original Rich Text content control. Rich Text content controls that split between pages or contain complex objects (like tables) are exported as regular text.

To enable this feature, load your Word file with content controls or generate content controls in your document using the Word Processing Document API library or WinForms/WPF Rich Text Editor. Then, create a PdfExportOptions instance, enable the PdfExportOptions.ExportEditingFieldsToAcroForms property and call the ExportToPdf method with this PdfExportOptions object as a parameter. For visual controls, you can also enable this functionality from the User Interface using the Print Preview -> PDF Export Options dialog.

using DevExpress.XtraPrinting;
using DevExpress.XtraRichEdit;

using(RichEditDocumentServer wordProcessor = new RichEditDocumentServer())
{
    wordProcessor.LoadDocument("input_content_controls.docx");
    PdfExportOptions options = new PdfExportOptions();
    options.ExportEditingFieldsToAcroForms = true;
    wordProcessor.ExportToPdf("output_with_acroform.pdf", options);
}

Your Feedback Matters

As always, we value your feedback. Please take a moment to respond to the feature discussion tickets linked above and let us know how we can best serve your needs. Should you encounter an issue while using this Early Access Preview build (v25.1), please submit a support ticket via the DevExpress Support Center.

Document Processing Libraries (Office File API) — June 2025 Roadmap (v25.1)

Maria Nikulina (DevExpress) — Thu, 20 Feb 2025 21:00:00 Z

We thank you for your continued support and for sharing your document processing needs and requirements with us. In this blog post, I'll share our development/release plans for the first half of 2025.

If you’d like to discuss this roadmap in greater detail or share a business use case that our Office File API product does not currently address, feel free to submit your feedback via the DevExpress Support Center. We’ll be happy to follow up.

New PowerPoint API Presentation Library (Discuss This Feature)

Office File API
Coming in v25.1.4+

We expect to extend the capabilities of the DevExpress Office File API library with a new Presentation library for .NET.

This non-visual library will allow developers to generate, modify, print, and export PowerPoint presentations to different formats in code. We expect to support the following PowerPoint-related usage scenarios programmatically:

Create new presentations from scratch.
Save presentations using the PPTX (OpenXml) document format.
Merge multiple presentations into a single file.
Add, remove, and extract presentation slides; modify slide settings.
Add, remove, and customize slide elements (shapes, texts, tables and more).
Apply formatting to slide elements.
Print and export presentations to PDF.

Note: The CTP (Community Technology Preview) version of our PowerPoint Presentation Library is expected mid-year. As in any CTP, functional limitations will apply.

PDF Document API

PDF Document Compression (Discuss This Feature)

Office File API
Coming in v25.1

To reduce file size when saving PDF documents using DevExpress PDF Document APIs, we will introduce a compression engine for the PDF object streams. This engine will optimize PDFs for more efficient storage/sharing options. New compression mechanisms will apply to various document structures, including PDF forms, fonts, and graphics.

Redaction API (Discuss This Feature)

Office File API
Coming in v25.1

We’ll introduce a new Redaction API that allows users to secure PDF documents and permanently remove sensitive information. This feature will allow you to:

Erase personal or confidential data from a PDF document and prevent end-users from accessing, viewing or copying it.
Apply overlays with custom text or graphics over redacted areas.

WinForms and WPF PDF Viewers

AI-powered Behaviors (Discuss This Feature)

WinForms WPF
Coming in v25.1

We will integrate AI-powered features into our WinForms and WPF PDF Viewer components. These enhancements will allow users to quickly understand the underlying essence of individual documents via Generative AI summaries and translate documents to a preferred language using AI-powered translations.
Additionally, users will be able to interact with an AI-powered assistant directly within their applications and ask questions about PDF documents.

Note: Our implementation is based on the functionality provided by the Microsoft.Extensions.AI library. To access these features, you will need to register the IChatClient implementation in your app (based on the desired AI services provider: OpenAI, Azure Open AI, Google Gemini or local open-source models powered by Ollama).

Spreadsheet Document API and Spreadsheet Controls for Winforms & WPF

OLE Objects (Discuss This Feature)

Office File API WinForms WPF
Coming in v25.1

Spreadsheet components will support embedded and linked objects (OLE objects) within Excel documents. You will be able to import and save documents with OLE Objects to supported Excel formats without content loss. OLE Object icons will be properly displayed when you preview the document, print, or export it to PDF.
Additionally, we’ll introduce APIs to create, remove, and manage OLE objects in code.

New Excel Functions Support (Discuss This Feature)

Office File API WinForms WPF
Postponed to v25.2

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions. In v25.1, we will introduce functions like:

XLOOKUP
XMATCH
UNIQUE
And more

These functions will improve data lookup, filtering, and transformation capabilities across our Spreadsheet components.

Word Processing Document API and Rich Text Editors for Winforms & WPF

CJK (Chinese, Japanese and Korean) Text Wrapping (Discuss This Feature)

Office File API WinForms WPF
Coming in v25.1

To enhance document rendering and readability, our Word Processing library and Rich Text Editors will support CJK text wrapping and line breaking rules. This feature applies correct line breaks between characters for Chinese, Japanese, and Korean (CJK) text. Documents using these wrapping rules will be displayed, printed, and exported to PDF with appropriate formatting.

RTL (Right-to-Left) Engine Enhancements

Office File API WinForms WPF
Coming in v25.1

In our mid-year release v25.1, we will extend our RTL rendering engine for Rich Text components. This functionality will ensure correct rendering and PDF export for document paragraphs, tables and shapes containing bi-directional text (mixed Right-to-Left and Left-to-Right text blocks).

Export Word Content Controls to PDF AcroForm Fields (Discuss This Feature)

Office File API WinForms WPF
Coming in v25.1

We will enhance our Word-to-PDF export engine and support the conversion of Word content controls into PDF AcroForm fields. With this capability, you'll be able to import or generate Word documents with content controls in our Rich Text document editing tools, export these documents to PDF, and automatically generate corresponding AcroForm fields in PDF output. This feature will apply to the following content control types:

Plain Text Boxes
Check Boxes
Popups

Compare Word Documents (Discuss This Feature)

Office File API
Coming in v25.1

We will introduce new APIs to compare Word documents. This capability will allow you to:

Identify changes between two document versions.
Generate revision-based output highlighting.

Note: These new APIs will focus on detecting changes and making revisions for the visible document content only.

Your Feedback Counts

v24.2 - What’s New

Spreadsheet Control for WinForms and WPF – Sort and Filter by Color via the User Interface

Polina Fedorova (DevExpress) — Mon, 14 Oct 2024 00:20:00 Z

In a recent minor update (v24.1.4), we introduced new UI elements for both our WinForms and WPF Spreadsheet component libraries. These enhancements allow users to sort and filter spreadsheet data by color.

The following video showcases this new capability:

Should you encounter an issue while using these new user interface elements, please submit a support ticket via the DevExpress Support Center. We'll be happy to follow up.

PDF Document API — Using Layers (Optional Content Groups) to Control Visibility of PDF Graphics Objects (v24.1)

Margarita (DevExpress) — Wed, 28 Aug 2024 02:05:00 Z

Complex PDF documents such as CAD drawings, technical construction plans, layered artwork, maps, or multi-language documents are full of visual information. PDF layers are often used to simplify these documents and improve overall readability (layers allow you to selectively view/hide sections).

In this blog post, I'll introduce a couple of straightforward layer-related usage scenarios and show you how to use the DevExpress PDF Viewer and PdfDocumentProcessor (PDF Document APIs) to control layer visibility in your DevExpress-powered app (layer visibility support was introduced in v24.1).

Control Layer Visibility

You can set PDF layer visibility by using the PdfOptionalContentGroupVisibility.Visible property for the appropriate layer or within the Layers panel of the DevExpress PDF Viewer. To display a layer, click its associated check box (visible layers are signified with an "eye" icon).

You can also manage layer visibility through the Document Facade API. When a layer is added to a document, a user must specify the default configuration (layer settings based on state). For example, your configuration can specify that a given layer is hidden when viewed, but visible when printed. When you load a document, you can obtain the default layer configuration (PdfOptionalContentProperties.DefaultConfiguration property value) and specify the category used to enable layer settings:

View - settings applied to the layer in a view state (when you display a document in a viewer).
Print - settings applied to the layer in print preview mode or when you print the document.
Export - settings applied to the layer when you export a document.
Zoom - settings applied to the layer based on zoom level.
Language - language culture settings applied to the layer.

For example, if you set ActiveUsages to PdfOptionalContentUsageCategories.Print, only print settings from the default configuration are applied to layers when you print the document. Other default settings are automatically disabled. You can set ActiveUsages to none to disable all default settings and only apply current settings.

IMPORTANT NOTE: A PDF document only stores default content configuration. This means that layer visibility is not preserved when you save the document. Visibility settings are applicable when you preview the document in a PDF Viewer component, print the document, or export it to an image.

Use Case 1: Analyze Report Data from Different Perspectives

In this example, a PDF report with sales metrics includes multiple layers with comments for different people. You can control layer visibility within the PDF viewer when viewing the document. This allows you to display appropriate comments without increasing the number of report pages.

Use Case 2: Display Details when Zooming

In this instance, a PDF file with a map uses a different layer at 200% zoom (displays additional data).

Use Case 3: Label Documents when Printing

In this instance, the DevExpress logo is added to the printed document. The logo is placed on a separate layer and includes the following configuration settings:

it is hidden when you view the document but rendered when you print/export this document.

For this scenario, we enabled print usage for the configured layer:


using DevExpress.Pdf;
using System;
using System.Linq;
using DevExpress.Drawing;

static void Main(string[] args) {
    using (PdfDocumentProcessor processor = new PdfDocumentProcessor()) {
        processor.LoadDocument("PdfLayers.pdf");
        // Specify which settings from the default configuration will be applied for each layer contained in a document.
        processor.DocumentFacade.OptionalContentVisibility.ActiveUsages = PdfOptionalContentUsageCategories.Print;
        // Print the document.
        DXBitmap bitmap = processor.CreateDXBitmap(1, 1000);
        PdfPrinterSettings pdfPrinterSettings = new PdfPrinterSettings();
        processor.Print(pdfPrinterSettings);
    }
}

Output is as follows:

As I mentioned earlier, layer support was introduced in our v24.1 release cycle. Should you have any questions about this post or our PDF APIs/PDF Viewer components, please submit a support ticket via the DevExpress Support Center at your convenience.

Extending Excel Calculations with AI: Implementing User-Defined Formulas using the DevExpress WinForms Spreadsheet

Maria Nikulina (DevExpress) — Tue, 20 Aug 2024 04:10:00 Z

Overview

Standard Excel formulas address a variety of business requirements. Of course, like anything else in life, there are times when your enterprise will require additional capabilities to address a specific use case.

When it comes to spreadsheet calculations, user-defined formulas offer a variety of options for those who wish to introduce custom, task-specific calculations within Excel documents. User-defined formulas allow you to automate repetitive tasks, analyze data more efficiently, and execute advanced calculations not possible with built-in functions.

By integrating AI services, we can take Excel formula calculations to a whole new level. We can analyze large datasets more efficiently, incorporate pattern recognition, make predictions, and so much more.

In this blog post, I will incorporate a user-defined formula using the DevExpress WinForms Spreadsheet Control and illustrate how to utilize AI for advanced calculations.

Implementing User-Defined Formulas within the DevExpress WinForms Spreadsheet Control

In the following sections, I'll create a user-defined formula that uses AI services for spreadsheet calculations. Feel free to use my example as a starting point and if you encounter issues, please submit a ticket via the DevExpress Support Center. We'll be happy to follow up.

Note: I will be using the OpenAI service in the example below. Before you incorporate this solution in your app, please be sure to read and understand OpenAI’s license agreement and terms of use.

Step 1: Setting Up the DevExpress WinForms Spreadsheet Control

First, I'll need to add the DevExpress WinForms Spreadsheet Control to my project. If you are new to our WinForms product line (or the Spreadsheet Control), please follow our Spreadsheet: Getting Started guide.

Step 2: Setting Up the OpenAI Client

Once I've added the Spreadsheet Control to my project, I can install the Azure.AI.OpenAI NuGet package and create a class to register OpenAIClient. This client will be used in the custom formula class (to send requests to the AI service).

public static class AIFormulaClient
{
    public static OpenAIClient Client;
    static AIFormulaClient() => Client = new OpenAIClient("your OpenAI key");
}

Step 3: Creating a User-Defined Function

Next, I'll create a user-defined function (UDF) within my sample WinForms application. For purposes of this example, I'll define a function called AISummary. This function uses the AI service to generate a summary for a selected cell range.

The AISummaryFunction class implements the custom function and provides two parameters:

the first is a required parameter (specifies source cell range for the summary)
the second is an optional parameter used to set summary length in words.

The IFunction.Evaluate method retrieves parameter values and sends cell data (in CSV format) and the word count to the GetSummary method. This method generates a request using OpenAIClient and returns the response. The returned value (AI-generated summary) is used as the result of the formula evaluation.

public class AISummaryFunction : ICustomFunction
{
    const string functionName = "AISummary";
    readonly ParameterInfo[] functionParameters;

    public AISummaryFunction()
    {
        this.functionParameters = new ParameterInfo[] { 
                new ParameterInfo(ParameterType.Reference, ParameterAttributes.Required), 
                new ParameterInfo(ParameterType.Value, ParameterAttributes.Optional) };
    }

    public string Name { get { return functionName; } }
    ParameterInfo[] IFunction.Parameters { get { return functionParameters; } }
    ParameterType IFunction.ReturnType { get { return ParameterType.Value; } }
    bool IFunction.Volatile { get { return false; } }

    ParameterValue IFunction.Evaluate(IList<ParameterValue> parameters, EvaluationContext context)
    {
        int wordCount = 40;
        if (parameters.Count > 1)
            wordCount = (int)parameters[1].NumericValue;
        IWorkbook workbook = context.Sheet.Workbook;
        workbook.Options.Export.Csv.Range = parameters[0].RangeValue.GetReferenceA1();
        byte[] cellDataBytes = workbook.SaveDocument(DocumentFormat.Csv);
        string value = GetSummary(Encoding.UTF8.GetString(cellDataBytes), wordCount);
        return value;
    }
    string GetSummary(string cellRangeData, int wordCount)
    {              
        ChatCompletionsOptions chatCompletionsOptions = new ChatCompletionsOptions()
        {
            DeploymentName = "gpt-4-vision-preview",
            Messages =
        {
            new ChatRequestSystemMessage("You are a helpful assistant."),
            new ChatRequestUserMessage(
                new ChatMessageTextContentItem(string.Format("Please create summary in {0} words for the following excel data", wordCount)),
                new ChatMessageTextContentItem(cellRangeData))
        },
            MaxTokens = 300
        };

        Response<ChatCompletions> chatResponse = AIFormulaClient.Client.GetChatCompletions(chatCompletionsOptions);
        ChatChoice choice = chatResponse.Value.Choices[0];
        return choice.Message.Content;

    }
    string IFunction.GetName(CultureInfo culture)
    {
        return functionName;
    }
}

Step 4: Registering the Custom Function

In this step, I'll register the custom function.

public Form1()
{
    InitializeComponent();

    AISummaryFunction aiSummaryFunction = new AISummaryFunction();
    var globalFunctions = spreadsheetControl.Document.Functions.GlobalCustomFunctions;
    if (!globalFunctions.Contains(aiSummaryFunction.Name))
        globalFunctions.Add(aiSummaryFunction);
}

Step 5: Using the Custom Function within the Spreadsheet

I can now use the AISummary function in my spreadsheet (just like any other formula). I'll load my Excel file in the WinForms Spreadsheet Control or I can enter data for the summary into a cell range then apply the AISummary function to obtain my AI-generated summary.

Worksheet worksheet = spreadsheetControl.ActiveWorksheet;
worksheet["E2"].Formula = "AISummary(A2:D10, 50)";

Step 6: Testing

Of course, we can't forget testing...I'll test my new user-defined formula and ensure my AI integration/custom formulas work as expected.

Your Feedback Matters

As always, your feedback is very important. Please let us know whether additional AI-related samples/solutions are of interest to you and how you expect AI to change your development strategies in the next 12-months.

Office-Inspired Products

DevExpress Office & PDF File API for Java — Generate PDFs, PowerPoint Presentations, and Barcodes in Java Apps

What's Included in the CTP

Built for Cross-Platform Java Development

Get Started

Prerequisites

Add DevExpress Dependencies

Add Native Dependencies

Code Example — Generate Your First PDF

PDF Document API for Java

Create Documents from Scratch

Edit Existing PDFs

Additional Capabilities

PowerPoint Presentation API for Java

Barcode Generation API for Java

Evaluate the CTP

What's Next

More Document APIs

Extended PDF and PowerPoint Support

DevExpress Office & PDF File API — Year-End Roadmap (v26.2)

Roadmap Updates

.NET 11 Support

Minimum Supported .NET and Visual Studio Versions

Automatically Re-target DevExpress-based Projects to .NET 10 and Update 3rd Party NuGet Packages

Separate NuGet Packages for Different .NET Versions (.NET 10, .NET 11, etc.)

Security — SBOMs and CRA Readiness

WCF Dependency Will Be Removed from XPO and Printing Core Libraries

Product-Tailored AI Skill Updates

New Document Processing Libraries for .NET and Java

New Word Processing Document API

New Spreadsheet Document API

Safer Document Processing API

PDF Document API — Secure Loading and Sanitization

Presentation API — Security and Privacy

New PDF Document API

Bookmark API

Incremental Updates — Research Stage

Digital Signature API

Form Field and Annotation Flattening

PDF/A and PDF/UA Compliant API

OCR API

Presentation API

Hyperlink Support

Word Document Processing

PDF Export / Rendering — Floating-Point Layout Calculation

PDF/UA-2 Export — PDF Structure Destinations & Field Tagging

Spreadsheet Processing

ODS Format Support — Research Stage

Your Feedback Counts

v26.1 - What’s New

Office File & PDF Document Processing APIs — June 2026 Roadmap (v26.1)

Roadmap Updates

Safe Word & Excel Document Processing

Document Processing Libraries for JAVA

PDF Processing

New PDF Processing API

PDF/UA-2 Export

PDF/A-4 Export

Excel Spreadsheet API

Excel to PDF/UA Conversion Enhancements

New Excel Functions

Presentation API

Charts

Export Slides to Images

Your Feedback Counts

File & Document Processing APIs (Office/PDF File APIs) — Year-End Roadmap (v25.2)

Roadmap Updates

DevExpress MCP Server for AI-Powered Documentation Access

Safe Document Processing (Discuss This Feature)

AI-powered Document Processing (Discuss This Feature)

Document Accessibility & Compliance

PDF/A Processing Enhancements (Discuss This Feature)

Word to PDF/UA Conversion — Form Field Tagging

Excel to PDF/UA Conversion Enhancements (Discuss This Feature)

PDF 2.0 & PDF/UA-2 Support (Research Phase)

Presentation API

Document Rendering Enhancements

Tables (Discuss This Feature)

Themes (Discuss This Feature)

OpenXml-based File Formats (Discuss This Feature)