Developer Express Inc.

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.

VCL — Year-End Roadmap (v26.2)

Dennis Garavsky (DevExpress) — Fri, 04 Sep 2026 11:00:00 Z

The following list outlines features/capabilities we expect to ship for our VCL UI Component Libraries - Delphi & C++Builder (expected release date: December 2026). As you will see below, accessibility (A11Y), developer productivity, and blazing fast pixel-perfect rendering for high-resolution displays remain cornerstones of our long‑term VCL product strategy. As always, our intent is also to reduce day‑to‑day development friction and help you build and maintain complex VCL applications more efficiently.

Before I detail our VCL Roadmap...if you have not yet done so, please take a moment to review What's New in v26.1 (our last major VCL update) and submit feedback using the inline survey. Your survey responses (both in the What's New and in Roadmap posts such as this) help us better understand your needs/concerns and allows us to make more informed development decisions. As always, thanks to everyone who has already submitted feedback/suggestions.

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 blog post and the features/products listed within it are subject to change. You should not rely or use this information to help make a purchase decision about Developer Express Inc products.

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.

With v26.2, we expect to ship DevExpress VCL SBOMs, and make them available to active license holders.

Accessibility — Microsoft UI Automation, and Keyboard Navigation Enhancements

As you may recall from previous announcements, accessibility (A11Y) support remains a primary focus area across all DevExpress product libraries. Our accessibility strategy continues to be driven by the following principles:

Make our UI components and related software libraries more accessible for people with visual impairments (via narrator/screen reader apps such as NVDA or Narrator).
Ensure that applications built with our UI components are easily testable using automated UI testing and enterprise-scale end‑to‑end frameworks powered by UIA (such as Ranorex).
Help our customers comply with existing A11Y-related regulations in regions such as the US and Europe (Section 508, EN 301 549, EAA).

Full VCL accessibility support is a large undertaking and requires a significant engineering investment. In 2026, we expect to finalize primary accessibility-related enhancements for the VCL platform. These will include, but are not limited to extended accessibility support in the following components (track our progress here):

Remaining data editors, navigation and utility components (such as TdxStatusBar/TdxRibbonStatusBar, TcxDateNavigator, TdxNavBarOfficeNavigationBar, TcxMRUEdit, TdxColorEdit, TdxTokenEdit, TcxImage, TdxBarCode, TcxPageControl/TcxTabControl, etc.)
Spreadsheet, Rich Text Editor, Vertical Grid, PDF Viewer, Scheduler, Reports (basic UI element voicing during navigation)

Accessibility and Compliance — PDF Engine Enhancements

We've begun a significant PDF engine refactoring initiative: changes that will impact the DevExpress VCL Printing System, TdxPDFViewer, TdxPDFDocument and other dependent components. This development will likely continue into 2027 and should address the following objectives:

Accessible/Tagged Document Export

Currently, VCL PDF controls export to PDF 1.4 - we will expand support to the PDF 1.7-2.0 family. We want our PDF engine to produce tagged PDF documents for those who use screen readers and other assistive technologies (similar to what is available in .NET).

With this change, VCL components can export documents that conform to the following standards: PDF/UA, PDF/A-1a, PDF/A-2a, PDF/A-3a. That is not an option for applications serving government agencies and regulated industries across the EU - they require accessible invoices and other PDF documents.

E-invoicing Standards

We also want our PDF engine and dependent components to fully support Germany’s ZuGFeRD e-invoicing standard (ZuGFeRD v2.3.2). With it, developers can attach ZuGFeRD v2.3.2 XML files to PDF documents (similar to the PdfDocument.AttachZugferdInvoice method in our .NET offerings).

AI — VCL Coding Skills

We are developing AI agent skills to help you build DevExpress VCL applications using AI coding agents. The skills will encode DevExpress best practices for popular VCL components and development tasks.

In the meantime, we recommend that you use DevExpress MCP documentation server with Embarcadero Kai for RAD Studio, GitHub Copilot in VS Code, or Claude Code.

VCL Reporting and BI Dashboard Enhancements

VCL v26.2 release plans include the following key initiatives for both ExpressReports and ExpressDashboards (a part of the new VCL Subscription +):

Additional VCL Template Kit Options

We will add new templates under the "Reporting & Data Analytics" category of our VCL Template Kit. As a result, it will be much easier to configure your reporting/data analytics application as a constructor (rather than copy code from multiple GitHub examples/docs manually).

VCL developers will be able to choose templates with different data sources, report layouts (table, master-detail, side-by-side subreport), layout storages (DFM/database table/file system), display modes (like Tabbed MDI or embedded) report viewer.

Extended Learning Materials

We expect to deliver additional examples/tutorials for both VCL Reports and Dashboards (data shaping, filtering, etc.). You may have already viewed new help topics under our Getting Started sections.

Additional AI-Powered Functions

DevExpress VCL Reports already includes multiple smart functions (like report generation from a prompt). We hope to derive even more from our DevExpress .NET Reports and BI Dashboard platforms to the VCL.

Performance and Usability Enhancements

We will refactor our VCL backend to optimize memory usage, startup time, and document rendering speed.

In document previews, we will also replace our legacy TdxActivityIndicator with the newest TdxSplashFormManager-based loading indicators (to help with perceived performance).

Fluent UI Support — Replicate Modern Microsoft Outlook and Teams User Interfaces

As you probably know from our v26.1 announcements, we continue our work to align DevExpress-powered VCL applications with modern UI standards inspired by Microsoft Fluent 2 and recent Outlook and Teams apps. Our v26.2 plans include the following:

Infrastructure/core changes to support our internal Icon Library and Fluent icon rendering (the engine should automatically select a suitable icon size based on rendering context/attributes).
Enhanced WYSIWYG design-time experience for Fluent Ribbon UI with the Office Navigation Bar, skin selector, and search toolbar.
Updated Image Picker design-time experience to better support Fluent icons with new sizes and attributes (check this sketch).
New project and form templates (for the VCL Template Kit).
Updated Mail Client demo.

VCL Template Kit — Additional Project and Form Templates

As you know, v26.1 includes our VCL Template Kit - designed to quickly create common application types and frequently used UI forms. The Template Kit ships with both project and form templates, allowing you to scaffold complete applications or add new forms and modules to existing projects.

With v26.2, we will add additional templates for many popular tasks (Fluent UI forms, splash forms, additional reporting app configurations). We will also support template-specific options in the right panel (like the reporting options I mentioned earlier - see our mockup below).

VCL Splash Screen Manager Enhancements

In v26.1, we introduced a VCL Splash Form Manager (CTP) designed to simplify the creation and management of loading forms (TdxSplashFormManager).

With v26.2, we will add more professionally designed Splash, Wait, and About forms (for VCL developers to choose from). We will also integrate these built-in forms into the VCL Template Kit (currently, splash form management is available under the DevExpress Application Settings menu).

VCL Demo Source Code on GitHub

All DevExpress VCL show-case / product demos will be available on GitHub (similar to what we did for .NET/JS). You no longer need to install our demos locally to explore these sample projects. This streamlines access to source code and unlocks numerous GitHub capabilities (such as repository search or forks,).

You can browse, clone, and run demo projects with your existing tools and workflows on any operating system. You can also use demo projects as reference materials for AI coding assistants.

Your Feedback Matters

As always, we welcome your feedback. Should you have specific questions related to our v26.2 release, please submit a support ticket via the DevExpress Support Center.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

Blazor — Year-End 2026 Roadmap (v26.2)

Alex Chuev (DevExpress) — Thu, 03 Sep 2026 09:00:00 Z

In this blog post, we'll outline Blazor features/capabilities we expect to ship in our year-end release (v26.2 — December 2026). Our key focus areas will be right-to-left support, official release of our Icon Library, and the first set of components for our new styling/layout foundation. As always, you can expect additional enhancements across our entire range of Blazor components.

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.

.NET 11 Support

In Development

We will support .NET 11 across our Blazor component suite (v26.2 and v26.1) after November 2026. We will also add support for .NET 11 previews for v26.1 (for early adopter testing). If you'd like to learn more about Blazor-specific enhancements in .NET 11, please review the following Microsoft document: What's New in ASP.NET Core 11.

.NET 10 will be the Minimum Supported Version for DevExpress Libraries in v26.2

Coming in v26.2

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.

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.

DateTimeOffset Support

In Development

We will introduce support for DateTimeOffset values across DevExpress Blazor UI components. Our components will preserve the original offset when displaying, filtering, and grouping these values.

A new global option will allow you to apply or disregard offset values across all Blazor components.

Note: We do not plan to support DateTimeOffset within the DevExpress Blazor Scheduler v26.2. To display appointments in a specific time zone, you can set DataStorage.TimeZone to that zone and convert time values back in the AppointmentUpdating event handler.

Security — SBOMs and CRA Readiness

In Development

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.

New Blazor App Bar

In Development

Much like the command bar in modern Microsoft Office applications, our new Blazor App Bar will serve as an application's "top bar." The App Bar will offer quick access to global commands such as search, account, settings, and theme selection.

Key features will include:

A title area able to display text, image, or custom content.
An optional hamburger button.
Standard items with text, icons, images, tooltips, and enabled/visible states.
A search item that can expand/shrink within specified width limits.
An avatar item designed to display an image, initials, or fallback icon (with a dropdown).
Built-in adaptivity (moves items to an overflow menu when space is limited).

App Bar — Global command strip

Planned

Applications often include top-level areas with frequently used commands, such as Mail, Calendar, and Contacts. Our new Blazor Side Bar will offer a vertical, icon-based navigation strip inspired by Microsoft Office applications.

Side Bar — Vertical navigation strip

RTL Support (CTP)

In Development

Right-to-left (RTL) support will ship as a Community Technology Preview in v26.2. As with any CTP, functional limitations will apply. We encourage you to test RTL support in your applications and share your feedback as we continue to refine our implementation.

Our initial implementation will address three use cases:

Switch an entire application to right-to-left layout.
Build custom RTL UI blocks alongside DevExpress components.
Keep individual UI blocks (such as phone number and email editors) in left-to-right mode within an RTL application.

We expect to support RTL across most of the DevExpress Blazor suite, including Grid, TreeList, Charts, Pivot Table, Filter Builder, Data Editors, Form Layout, AI Chat, and HTML Editor. The initial scope will also include navigation, layout, and popup components: Menu, Context Menu, Toolbar, Ribbon, Tabs, TreeView, Drawer, Popup, Window, Toast, Flyout, and Drop-Down Buttons.

RTL support will have two important limitations:

Fluent themes only. RTL support relies on styling capabilities not available in our Classic themes. If you need RTL support, please use a Fluent theme.
Rich Text Editor excluded. The Blazor Rich Text Editor will not support RTL in v26.2, and RTL support for this component is not currently planned.

RTL — Application localized for Arabic

Blazor Icon Library — Official Release

In Development

The DevExpress Blazor Icon Library (introduced as a CTP in v26.1) will be ready for production use in v26.2. We expect to introduce the following new features and enhancements.

Icon Library Support Across the Suite

You will be able to use library icons across all DevExpress Blazor components with user-defined icon support. We will add the IconUrl parameter to the following components and UI elements:

Editor Buttons
Progress Bar
Toast
Scheduler Forms

Flexible Icon API

We will extend our icon API so you can specify any combination of icon parameters (style, set, and size). The API will determine unspecified values based on current theme and size mode.

@* finds the most appropriate Delete icon for the current theme / size mode *@
<DxRibbonItem IconUrl="@Icon.Delete" /> 
@* same as above, but ensures that the Filled icon style is used *@
<DxRibbonItem IconUrl="@Icon.Delete.Filled" /> 
@* looks for the Fluent icon regardless of the current theme *@
<DxRibbonItem IconUrl="@Icon.Delete.Fluent.Filled" />

Note: The API above is a work in progress and may change before release.

Additional Fluent Icons

We will expand the library's Fluent icon set with 400+ icon metaphors currently available only in our Desktop Classic set.

Public CSS Variable Rework

Coming in v26.2

Our Fluent theme exposes its design system as --dxds-* CSS variables. You can override them to restyle DevExpress components, or reference them in your own CSS to align custom styles with the theme.

With v26.2, we plan to rework this variable set with two goals: prepare the design system for future themes (such as Material) and introduce clearer variable names with broader coverage.

Role-Based Names

Variable names will clearly indicate purpose. We will also add variables for surface levels not covered by the current set. The following table lists examples of upcoming changes:

Current Variable	New Variable	Description
`--dxds-color-surface-neutral-default-rest`	`--dxds-color-bg`	Default surface background
`--dxds-color-content-neutral-default-rest`	`--dxds-color-content`	Default text color
`--dxds-color-surface-neutral-subdued-rest`	`--dxds-color-bg-canvas`	Application background behind content surfaces
`--dxds-color-border-neutral-subdued-rest`	`--dxds-color-border-subtle`	Low-contrast border color
`--dxds-color-content-utility-blue-subdued-on-surface-rest`	`--dxds-color-content-on-subtle-blue`	Text color on a subtle blue surface
—	`--dxds-color-bg-high`	Background for surfaces above the base level (badges, alternating rows, and chat bubbles)
—	`--dxds-color-bg-highest`	Background for highest-level surfaces

Design Tokens Preview

Automatic Migration

The DevExpress Project Converter will update CSS variable names to their new form automatically when you upgrade to v26.2.

Blazor AI Chat

Built-in Reasoning Visualization

In Development

The DevExpress Blazor AI Chat component will automatically display reasoning from supported AI models (no custom template or extra work required). Users can review the model's reasoning, verify that it followed required steps, and identify potential errors before acting on the response.

AI Chat — Reasoning visualization

Built-in Tool Approval Visualization

Planned

With v26.2, our Blazor AI Chat will include a built-in confirmation interface for human-in-the-loop tool calls (no custom template required). Users can review and approve/reject an operation before it executes — for instance, before an AI agent updates a CRM record or sends a marketing email.

AI Chat — Tool approval visualization

Pre-Attached Resources

Coming in v26.2

You will be able to pre-attach AIChatResource items to DevExpress Blazor AI Chat in code (so they are available as AI context when the chat session starts). Pre-attached resources will appear alongside manually selected items, and users will be able to add additional resources via the picker or file upload.

Clear History API

Coming in v26.2

A new ClearHistoryAsync method will allow you to clear DevExpress Blazor AI Chat history from code. You can use it to replace the built-in header button with a custom Clear button placed anywhere in your UI.

UI/UX Enhancements

Available in v26.1.4

When using DevExpress Fluent themes, our Blazor AI Chat will use fully circular icon buttons and a redesigned Send button. We will refine corner radii for input and prompt areas and introduce more consistent spacing between messages and input elements. Classic themes will remain unchanged.

AI Chat — UI/UX enhancements

Blazor Grid & TreeList

Planned

We expect to add a built-in Criteria Selector Menu to both DevExpress Blazor Grid and TreeList components. This menu will allow users to select a filter condition (Contains, Equals, Greater Than, and others) directly in the Filter Row, next to the filter value.

Grid — Filter Row criteria selector menu

Filter Row — On-Input Filter Binding

Planned

Filter Row Data Editors will support on-input data binding. In this mode, our Blazor Grid will apply filters as users enter text (no need to press Enter). We expect to add the same capability to the DevExpress Blazor TreeList component.

Planned

We expect to add the following toolbar items to our Blazor Grid and TreeList:

Column Chooser
Export Buttons (CSV, PDF, XLS, and XLSX)
Search Box

Continuous Cell Editing

Available in v26.1.4

Our new Grid/TreeList EditNextCellOnEnter property activates editing of the next cell on Enter (one fewer keystroke to enter edit mode). This option is available when the EnterKeyDirection property is set to Column or Row.

Combine the property with EnterKeyDirection to choose whether Enter moves across a row or down a column. Activate EditOnKeyPress to allow users to start editing by typing.

Striped Rows

Planned

We plan to introduce an option that highlights alternating (odd) rows in DevExpress Blazor Grid and TreeList components with a different style.

Grid — Striped rows

Custom Row Height

In Development

We expect to add a minimum row height setting for our Blazor Grid and TreeList UI components. Use it to increase/decrease row spacing and adjust visual density.

Blazor TextBox — Password Button

Planned

The DevExpress Blazor TextBox will include a built-in button to display/hide a password. Users will be able to verify the value they entered.

Blazor Form Layout

New Caption Position Mode

Planned

Our Blazor Form Layout will include an option to always display captions horizontally, regardless of available space.

Tab Management API

Planned

New API members will allow you to position tab headers and manage tab pages in the DevExpress Blazor Form Layout at runtime:

TabsPosition — Specifies tab header position.
AllowClose, AllowTabReorder — Allow users to close and reorder tabs.
TabClosing, TabReordering — Allow you to handle tab closing/reordering actions.
TabPageEnabled — Allows you to disable a tab page.

Localization / Globalization

Improved Localization Support with AI-powered Translations

We expect to ship complete built-in localizations for a selected set of languages in the new DevExpress Localization Tool. Professional translators have already translated and reviewed approximately 80% of our German localization. To broaden language coverage while maintaining translation quality, we plan to leverage AI-powered translation workflows. The workflow will not rely on direct translation alone - it will also consider additional context:

Usage context - how each string is used, collected from our source code.
Established Microsoft terminology (obtained from the Microsoft Terminology Collection).

Web Localization Service — Supported Versions Limited to v23.2+

User translations for v23.1 and earlier releases will no longer be available through the Localization Service UI (view, edit, download, create). These translations will be retained by DevExpress should you require them. You can request your old translation archives via the DevExpress Support Center.

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-blazor directory to locate Blazor-specific AI Agent Skills coding assistants with built-in knowledge of Blazor components, its capabilities, related APIs, best practices, and code examples.

Blazor 2026 Strategy — Status Update

Our v26.1 roadmap outlined several strategic directions for 2026, including areas where we needed additional groundwork before committing to a specific release.

Icon Library

The first phase shipped in v26.1, when we introduced the DevExpress Blazor icon library as a CTP. In v26.2, the library will ship officially with a more flexible API, broader component coverage, and an expanded Fluent icon set.

RTL Support

RTL support did not ship in v26.1, but remained part of our 2026 plans. It will ship as a Community Technology Preview in v26.2.

Styling and Layout Foundations

The App Bar and Side Bar will address application-level navigation, while the CSS variable rework will make customization and styling more flexible. DevExpress CSS helper classes and the lightweight primitive components we described earlier this year (Card, Badge, Avatar) will not ship in v26.2. We plan to revisit them in a future release.

In the meantime, you can use public CSS variables from the DevExpress Design System to create custom CSS classes that match our Fluent theme. The following example demonstrates this approach: Blazor — Create Primitive CSS Classes Using Public CSS Variables.

New Themes

Our v26.1 roadmap discussed two options for new modern themes: Material and a classic-inspired theme for customers who prefer a look and feel closer to Blazing Berry. We plan to start with Material and currently target 2027 for its release.

Material will not ship in v26.2 because it depends on the CSS variable rework described above. Once we complete this work, we will be able to build Material — and future themes — on the same foundation.

Classic Themes

Blazing Berry, Office White, Purple, Blazing Dark, and our Bootstrap-based themes will remain available. We will not deprecate or remove them until our modern theme lineup offers a suitable range of alternatives. Fluent already offers an alternative in some cases, and we plan to introduce additional modern themes in future releases. Classic themes will not receive new styling capabilities or support right-to-left layout.

Pivot Table & Pivot Grid

We plan to start working on chart integration and drill-down support for the DevExpress Blazor Pivot Table. While we cannot yet commit to either feature for v26.2, we will continue to ship our older Pivot Grid component. Once our Blazor Pivot Table supports both these features, we will deprecate the older Pivot Grid component.

Security

Our v26.1 roadmap included plans to introduce SBOMs for DevExpress Blazor packages. We released these as a preview in May 2026 and plan to make them generally available in v26.2.

We continue to monitor third-party dependencies for vulnerabilities and apply updates promptly. We are also improving how we audit and manage these dependencies and conduct security testing throughout development. Our security documentation describes these practices in detail.

Accessibility

v26.1 delivered over 45 accessibility enhancements across our Blazor components, including Windows high-contrast mode support in our Fluent themes, screen reader support for the Rich Text Editor, and broader ARIA support and keyboard navigation across the suite. v26.1 What's New includes the full list.

For v26.2, both our Blazor App Bar and Side Bar will include keyboard navigation support, ARIA roles, and high-contrast mode in their first release.

Performance

v26.1 delivered performance improvements across our Blazor component libraries, including significant optimizations to the DevExpress Blazor Grid. The performance demo now handles one million rows and one thousand columns. v26.1 What's New lists these optimizations.

We plan additional performance improvements in v26.2 but do not have specific details to share as of the date of this post.

Your Feedback Matters

If you have questions or suggestions about the plans outlined above, feel free to share your thoughts in the survey below or submit a support ticket via the DevExpress Support Center.

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

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

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.

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

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

WPF — Year-End Roadmap (v26.2)

Alexander Russkov (DevExpress) — Thu, 27 Aug 2026 03:01:00 Z

Thank you for your continued support and for sharing your WPF development needs with us. In this blog post, I'll outline the WPF features and enhancements we expect to ship in our year-end release (v26.2 — December 2026).

The roadmap focuses on two areas: a modern, Fluent-based look and feel for WPF applications, and broader AI-assisted development capabilities. We also plan to deliver enhancements across other WPF controls and features, including native DateTimeOffset support and new Data Grid customization options.

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.

.NET 11 Support

DevExpress WPF controls will support .NET 11 (both v26.1 and v26.2) following Microsoft's official release.

Minimum Supported .NET and Visual Studio Versions

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

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

Security — SBOMs and CRA Readiness

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.

WCF Dependency Will Be Removed from XPO and Printing Core Libraries

Fluent Theme and Modern Application UI

A major focus for our next major release (v26.2) is a modern, Windows 11-based appearance for all DevExpress-powered WPF applications. Our implementation involves a new Fluent Theme, Mica material support, modernized Accordion Control, and a Fluent icon set.

WPF Fluent Theme (CTP)

With v26.2, we will add Fluent Theme support to our WPF Grid Control, WPF Property Grid, Dock Layout Manager, Themed Window, and other major DevExpress WPF component libraries.

Mica Window Support

Our ThemedWindow will support Mica material. Navigation controls and Ribbon tabs will render transparently to reveal the window's Mica effect and reproduce the look and feel of Microsoft Office applications.

Accordion Control — A Modern Appearance

The DevExpress WPF Accordion Control will ship with a modern appearance designed to match layouts found in Microsoft Teams, Microsoft Store, and other apps. Capabilities will include:

Teams-like compact view mode.
Badge support in both expanded and collapsed states.
Filled or custom glyphs for selected and hovered states.
Item switch animation.

These capabilities will be available in our Template Kit.

Fluent Icons

We will continue to extend our Fluent Icon set and integrate it across our WPF control library.

Global Switch

You will be able to switch to the Fluent Icon set across all DevExpress WPF controls. A public API will let you control the SVG image used for each icon, and a global option will switch the icon set app-wide. The new icons will be used in our demos and the Template Kit.

Comprehensive Icon Library

The DevExpress Icon Library includes more than 13,000 icons, and we'll continue expanding it with additional Fluent assets to support additional usage scenarios. To simplify navigation, we will group icons by the following attributes:

Set — Fluent, Desktop Classic, Blazor
Style — Regular, Filled
Color — Monochrome, Multicolor
Size — 16, 20, 24, 28, 32, and 48 (different sizes ensure that lines aren't too thick when SVG icons are scaled)

These icons and settings will be available at design time in our enhanced Image Picker.

Size-Based Image Selection

SVG images scale to any size but scaling changes line thickness. To maintain line consistency in framed Fluent icons, our designers are drawing separate small and large versions rather than scaling a single image. To simplify usage, we hope to automate icon selection based on element size. For example, RibbonControl will choose a dedicated SVG for large, medium, and small bar items.

AI Chat Control

Workflow Visualization Support

Beyond single-agent chat, we hope to introduce built-in visualizations for multi-step workflows when using our WPF AI Chat control. A single workflow can include multiple agents, parallel steps, tool calls, and tool-approval requests. The visualization will display details for each step, so users can follow the process.

AG-UI Demos

Agent–User Interaction (AG-UI) is an event-based contract between an AI agent and the user interface. Beyond plain text, it carries tool calls, state snapshots, state deltas, approvals, and activity events.

We will ship a set of WPF demos you can use as a starting point for your own application. The demos will highlight the following capabilities of our WPF AI Chat Control when connected to an AG-UI backend:

Visualized tool-call results — backend tool-call results appear as structured UI instead of raw text.
Interactive multi-step flows — the agent guides the user through a multi-step process and renders interactive elements at each step.
Human-in-the-loop actions — the agent prepares an action, such as placing an order, but runs it only after the user approves, edits, or rejects it.
Interaction with view components — the agent reads and updates the state of view components outside the chat control.

Appearance Customization

Currently, WPF styles cannot modify our AI Chat Control's internal elements. With our next release, the control will expose an API to override appearance resources.

Agent Skills

We are developing enhanced AI agent skills to help you build DevExpress WPF applications using AI coding agents (such as Claude Code and GitHub Copilot). The skills will encode DevExpress best practices for architecture, performance, accessibility, and other common development tasks. Our initial skill catalog will include:

Appearance Customization — modify a control's appearance using built-in APIs or overridden theme resources.
UI Automation Test Creation — write UI Automation tests.
Accessibility Remediation — audit a view and apply accessibility fixes.
Performance Optimization — apply performance best practices.
Dependency Injection Integration — introduce DI into a project.
MVVM Framework Implementation — implement MVVM design patterns using the DevExpress MVVM Framework.

DateTimeOffset Support

We will support DateTimeOffset in core DevExpress controls to eliminate manual conversion of DateTimeOffset to DateTime when working with local time zones. You will be able to specify the time zone and conversion to a local date will occur automatically. In this mode, users will see a simple date/time value without the offset portion (as if it were a DateTime object).

DateTimeOffset offers the following advantages compared to DateTime:

Local and global time support: Suitable for usage scenarios that require both local machine time and UTC (such as logging systems).
Clear semantics: The DateTime.Kind property is not serialized (which can lead to incorrect usage). DateTimeOffset always includes an offset (for example, 6/10/2025 5:30:00 PM -07:00).
Web service compatibility: Many services return dates as DateTimeOffset. Once supported, conversion to DateTime will no longer be required.

WPF Data Grid

Validation Icon Customization

Data Grid cells/rows can display error icons when values fail validation. New customization properties will allow you to replace the validation icon or modify its size and margin.

Separator Customization

Our Data Grid will expose dedicated brush and thickness properties for cell separators. You will be able to set specific columns apart with a distinct separator or match separator appearance to your application's visual style.

WPF Tree List Indent Highlighting

Once you enable indent-highlight, the DevExpress WPF Tree List will highlight the node indent region when focused. This visual cue makes the active node easier to track in a deep hierarchy.

Duplicate Conditional Formatting Rules

When our WPF Data Grid includes many columns, applying similar conditional formatting rules to multiple columns is time-consuming. We will add a Duplicate command to Conditional Formatting Rules Manager (to simplify rule reuse without recreating them from scratch).

DXTabControl — Delayed Tab Caching

Interfaces with many tabs often require a tradeoff between startup time and tab-switch performance. Caching all tabs at once slows initial startup, while caching each tab on first use delays the first switch to that tab. We'll add delayed caching to load and cache remaining tabs asynchronously after the first tab appears on-screen.

Localization / Globalization

Improved Localization Support with AI-powered Translations

Usage context - how each string is used, collected from our source code.
Established Microsoft terminology (obtained from the Microsoft Terminology Collection).

Web Localization Service — Supported Versions Limited to v23.2+

Your Feedback Matters

DevExtreme — Year-End Roadmap v26.2 (React, Angular, Vue, jQuery & ASP.NET Core)

Svetlana Troitskaya (DevExpress) — Tue, 25 Aug 2026 02:05:00 Z

The features/capabilities we expect to ship in our next major update apply to both DevExtreme JavaScript component libraries (Angular, React, Vue, jQuery) and DevExtreme-based ASP.NET MVC/Core controls.

To help us fine tune our release plans, please respond to the survey questions embedded within this post. Alternatively, submit a support ticket via the DevExpress Support Center. We will be happy to follow up.

The information contained within this Roadmap 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

This roadmap will be updated regularly to reflect development progress. As we near our official release, we expect to add additional items and modify the status of planned features as necessary. Look for the following labels next to each feature:

Planned - Feature is scheduled but not yet in development.
In Development - Under active development.
Released in Beta v26.2 - Will be available in our v26.2 beta release.
Released in v26.2 - Fully implemented and available in v26.2.

DevExtreme AI Agent Skills — Planned Enhancements

All Platforms
In Development

In v26.1, we published a set of AI Agent Skills for DevExtreme. These skills help AI coding agents generate higher-quality code that adheres to DevExtreme APIs, patterns, and best practices.

We expect to improve these skills in upcoming release cycles. Planned updates include:

Improvements to existing skills
New skills for additional components and usage scenarios
ASP.NET Core support

Security — SBOMs and CRA Readiness

All Platforms
Planned

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.

DataGrid Enhancements

Semantic Search

All Platforms
In Development

v26.2 will introduce a new DevExtreme DataGrid Semantic Search option – one that integrates the component with an AI-powered semantic search backend. Semantic search uses AI embeddings to locate data records based on meaning rather than exact wording. To filter date, the backend processes the context and intent behind a question or phrase.

Semantic search is perfect for unprocessed/uncategorized data sets (where configuring filters for exact values may be tedious). By using longer/specific queries, this option can help users locate records more effectively. To control search precision, users will be able to fine-tune search results using a similarity factor.

Semantic search requires resource-intensive data vectorization. This process is best suited for the server-side, especially for large data sets with records in the tens of thousands. We will demonstrate how to implement semantic search using an ASP.NET Core backend that is tailored to the DevExtreme DataGrid. The UI component itself will require minimal configuration on the client side.

AI-powered Detail View

All Platforms
In Development

We expect to add AI-driven data analysis for those using our DataGrid's master-detail view. This new option will allow users to interrogate individual records using natural language.

In v25.2, we added an AI column to our DataGrid. This feature helped analyze component data using an AI prompt. While valuable, certain usage scenarios do not require generated data for every row. Instead, users may need on-demand data generation for specific rows. Our new AI detail scenario will offer this capability, which can significantly reduce AI token consumption and enhance data generation performance.

Our new AI master-detail feature will also display generated content in a format better suited to longer, more in-depth insights. This option will include a prompt-driven data analysis UI within the DataGrid’s master-detail interface, spanning the full width of the component.

Within the detail row, users will be able to ask questions about the active record and receive AI-generated insights. The AI assistant will be able to summarize record data, clarify complex values, highlight notable patterns, and obtain contextual information specific to the active record.

This option is particularly valuable for data-intensive applications where records contain many fields or complex business information. Instead of searching through multiple columns and analyzing data manually, users can obtain necessary information using a natural-language prompt. This will improve both user productivity and your application's overall user experience.

DevExtreme Chat — Tool Call Visualization

All Platforms
In Development

We expect to add the ability to display AI tool/function calls in the DevExtreme Chat message body. These tools/functions can be declared locally within the app or available via MCP servers.

This visualization will increase clarity and transparency. Chat users will be able to see which tools were used, their order, and parameters alongside the AI response.

DevExtreme Scheduler — Hierarchical Resource Grouping

All Platforms
In Development

DevExtreme Scheduler currently supports appointment grouping at a single resource level. With v26.2, we will extend this behavior with hierarchical (multi-level) resource grouping based on direct parent-child relationships in your resource data source.

Planned capabilities will include:

Multi-level (parent-child) resource grouping with unrestricted nesting depth
Nested row headers for Timeline view and nested column headers in Day/Week views (both vertical and horizontal grouping)
Appointment rendering in the correct leaf resource while preserving existing appointment drag-and-drop behavior

This capability is especially valuable for applications that schedule appointments across layered resource hierarchies, such as departments and employees, buildings and rooms, or teams and equipment. You will be able to define parent-child relationships between resources and control which child resources belong to each parent, creating a clear and intuitive hierarchy.

DevExtreme Map — OpenStreetMap (OSM) Support

All Platforms
In Development

We expect to add OpenStreetMap (OSM) support to the DevExtreme Map component. The new provider will allow you to connect the Map to OSM-compatible tile, geocoding, and routing services, including commercial providers and self-hosted infrastructure.

Planned capabilities will include:

Support for core Map features, including markers, routes, and tooltips
Additional configuration options for OSM-based services
Greater control over service selection, deployment model, and mapping infrastructure

Globalization – Separate Text and Date/Number Locales

All Platforms
In Development

With v26.2, you will be able to specify different locales for application text values and dates/numbers. You will be able to change languages without affecting date/number formatting and vice versa.

Accessibility

All Platforms
In Development

We expect to improve accessibility for the following DevExtreme UI components:

Our long-term goal is to address all limitations identified in our DevExtreme Accessibility Conformance Reports (ACRs).

DevExtreme PivotGrid — Keyboard Navigation and ARIA Attribute Updates

All Platforms
In Development

With v26.2, we expect to improve PivotGrid keyboard navigation and ARIA semantics to support a more accessible interaction model.

Planned enhancements include:

Consistent arrow-key navigation across column headers, row headers, and area items
Keyboard access for expand icons and column sort operations
Keyboard-accessible Field Chooser content with visible focus states
Focus returned to the trigger button when a popup closes
Header filter activation from keyboard input with an aria-label that includes column context
ARIA grid semantics alignment, including header-to-data associations and aria-rowindex/aria-colindex metadata for clearer screen reader announcements
Keyboard access for scrollable regions and keyboard commands for context menus

DevExtreme Toolbar — Enhanced Keyboard Navigation

All Platforms
In Development

We expect to align "focus management" in the DevExtreme Toolbar with W3C Toolbar pattern recommendations.

Keyboard users will navigate the Toolbar with a single Tab stop and arrow keys between items, instead of tabbing through each item individually — a faster, less error-prone path through the toolbar. Items containing other components (for example, a search box) will support the same model:

Arrow keys reach the item.
Enter or Space moves focus inside the item.
Esc returns to the toolbar.

A visible outline on the focused item will allow users to track keyboard focus.

The same navigation model will extend to built-in toolbars in the following DevExtreme components:

DataGrid
File Manager
HTML Editor
Scheduler
TreeList
Rich Text Editor for ASP.NET Core
Spreadsheet for ASP.NET Core

We will also add an option to preserve behaviors within applications that require our previous implementation.

Globalize — Deprecation Plans

All Platforms
Planned

DevExtreme supports two localization/internationalization libraries: Intl and Globalize.

Globalize is currently in maintenance mode and may introduce long-term security and reliability risks. We plan to deprecate Globalize support in our next two major release cycles (v26.2 and v27.1) and remove support in subsequent releases.

We will publish migration guidance to help you transition with minimal disruption.

If you currently use Globalize, we would appreciate your feedback. Your input will help us understand real-world usage scenarios and assess the impact of this change.

ASP.NET Core

.NET 11 Support

ASP.NET Core
Planned

DevExpress ASP.NET Core controls will support .NET 11 (both v26.1 and v26.2) following Microsoft's official release.

Minimum Supported .NET and Visual Studio Versions

ASP.NET Core
Planned

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

ASP.NET Core
Planned

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

ASP.NET Core
Planned

WCF Dependency Will Be Removed from XPO and Printing Core Libraries

ASP.NET Core
Planned

Improved Localization Support with AI-powered Translations

ASP.NET Core
Planned

Usage context - how each string is used, collected from our source code.
Established Microsoft terminology (obtained from the Microsoft Terminology Collection).

Web Localization Service — Supported Versions Limited to v23.2+

ASP.NET Core
Planned

Your Feedback Matters

XAF (Cross-Platform .NET App UI & Web API Service) — Year-End Roadmap (v26.2)

Dennis Garavsky (DevExpress) — Mon, 24 Aug 2026 06:00:00 Z

Thank you for your continued support and for sharing your XAF development requirements with us via product surveys, Support Center tickets, email, and social media engagements. This post outlines features and capabilities we expect to ship in our year-end release (v26.2 - Dec 2026).

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.

Security and Dependency Updates

.NET 11 Support

DevExpress XAF Blazor/WinForms, Web API Service, and XPO ORM library 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. Visual Studio 2026 will be the minimum supported IDE version when XAF Blazor/WinForms/Web API Service v26.2 ships.

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

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.

Entity Framework Core 11 for Data Access

v26.2 will add official support for the most recent version of Entity Framework (EF Core 11) to our XAF Blazor/WinForms UI and Web API Service. We will also update our performance benchmarks - comparing EF Core 11 with XPO.

While EF Core 11 introduces performance and customization improvements, it also includes breaking changes that require updates on our side. Not all EF Core database providers offer compatible NuGet packages (for instance, we had to remove Pomelo.EntityFrameworkCore.MySql support in v26.1.5+).

Middle-Tier Security — Stricter Application Model Permissions

XAF applications that store Application Model differences in a database must currently grant pre-login read/write access to ModelDifferenceXXX types for the Middle-Tier application server. We plan to narrow these pre-login permissions in v26.2. This will help customers with strict security requirements or when XAFML exposes sensitive Application Model settings before a user authenticates.

WCF Dependency Will Be Removed from XPO and Printing Core Libraries

XPO ORM - Connection Provider Updates

We plan to support the most recent versions of the following database engines (for both .NET and .NET Framework) in XPO v26.2.

PostgreSQL
Microsoft SQL Server
SAP HANA 8
Oracle 26ai
etc.

Documentation

XAF Blazor

Scalability & Performance Optimizations

As you know, XAF Blazor scalability remains a top priority at DevExpress (number of concurrent web users). For information on our initial implementation (load test conditions, hardware, latency comparisons between versions, etc.), please follow our Technical FAQ updates.

By the end of 2026, we expect to publish the first production-ready version (Beta or RC) of our scalability-related enhancements:

"Crowd/Peak Load” (ALL users execute commands simultaneously), “Activity" (average user work day), and “Requests Per Second" (RPS) tests.
Additional enhancements based on ALL tests (XAF Core speed/memory usage and Blazor component rendering optimizations).
Published test results, load tests, configs, important considerations, and limitations for public review.

List Editor Context Menu Enhancements

We will switch to the native Blazor context menu within the XAF Grid, TreeList, and Pivot Grid list editors. The default menu will include standard grid commands: Column Chooser, Filter Editor, sorting and grouping controls, Find Panel, Best Fit, and others. A concise API for customizing the default menu items will also be available (for example, previously missing DxTreeListModel.CustomizeContextMenu and DxTreeListModel.ContextMenus APIs).

We will also ship basic runtime total/group summary customization in v26.2 (including the DXGridModelBase.TotalSummary and DevExpress.ExpressApp.Blazor.Editors.DxGridSummary APIs).

Blazor Pivot Grid Module — Official Release

The XAF Blazor Pivot Grid module will officially ship in our v26.2 release cycle. The official release will include updated demos, documentation, and full test coverage.

DevExpress Icon Library Integration

XAF WinForms and XAF Blazor will leverage the new DevExpress Icon Library as the default icon source for v26.2 -- giving both platforms access to the entire DevExpress Fluent icon set. A global toggle between classic and Fluent icon styles will be available at the application level. XAF's built-in Image Picker (in the Model Editor) will also be updated to present and save icons from the new library. Existing image and icon references in your applications will continue to work without modification.

Template Kit Enhancements and New GitHub Examples

XAF Template Kit: We will migrate to the ASP.NET Core Minimal API and simplify Blazor project files (for example, no Startup.cs file, less code, etc.).
Electron.NET example: We expect to introduce an example for cross-platform desktop applications built atop XAF Blazor with Middle-Tier Security, and Electron.NET, supporting Windows and macOS deployment from a single codebase. We previously delayed this task and dropped Template Kit integration due to the new ElectronNET.Core.API library.
.NET Aspire example: We will update our existing Aspire-based example with Microsoft Aspire 13.5. Aspire support simplifies database configuration and cloud deployment setup for XAF Blazor and Web API Service apps.

Artificial Intelligence (AI)

AI Integration Module — Official Release

Our AI Integration Module should be ready for production use in v26.2. The biggest new feature is certainly native AI Chat integration for both XAF Blazor/WinForms. Although it is already possible today with custom code, built-in form templates and other harnesses will save time for those using XAF.

Related community examples (with our AI Chat integration):

XafRag — RAG Sample for DevExpress XAF (GitHub.com)
AI Chat Integration between XAF and n8n (GitHub.com)
AI-powered SQL Chat for DevExpress XAF Blazor (GitHub.com)
GitHub Copilot SDK in a DevExpress XAF app (GitHub.com)
More on GitHub.com

Accurate XAFML Generation with AI Assistants

AI coding assistants currently struggle to generate correct XAF Application Model (XAFML) code. That is because XAF documentation includes very few XAFML code samples for individual model options. We plan to add XAFML snippets alongside online documentation and to publish a machine-readable XML schema for the Application Model. This will make contextual info available to the DevExpress MCP Documentation server and make AI-generated XAFML more accurate when using AI coding assistants.

Community Discussion

Product-Tailored AI Skill Updates

The repository includes folders for different DevExpress products. Navigate to the dx-xaf directory to locate XAF-specific AI Agent Skills coding assistants with built-in knowledge of XAF, its capabilities, related APIs, best practices, and code examples.

General MCP Server-related Updates

Our installer will now register the DevExpress MCP Documentation Server automatically (you can opt out via a checkbox), because it is a must-have feature when using AI coding assistants. NOTE: Our AI Skills already register the MCP Server by default (without conflicts). Our MCP server will also support additional AI tools: to search Breaking Change listings (to improve your project upgrade experience).

Localization / Globalization

Blazor UI — Right to Left (RTL) Support (CTP)

DevExpress Blazor components and XAF Blazor will better support Right-to-Left (RTL) layouts in v26.2. Teams building applications for Arabic, Hebrew, and other RTL languages will be able to activate RTL across XAF Blazor UI elements, including our grids, editors, navigation, and form layouts (using a project-level option, without CSS or other workarounds).

New Localization Tool Integration

In our last release cycle (v26.1), the new DevExpress Localization Tool was updated to load strings from standard XAF modules (learn more). This change notwithstanding, XAF-specific strings customized in the Model Editor could not be transferred. We plan to close this gap in v26.2. XAF developers will be able to export Application Model strings and import them into the Localization Tool for translation, without manual file editing.

The deprecated Localization command in the Model Editor toolbar will also be removed in v26.2.

Improved Localization Support with AI-powered Translations

Usage context - how each string is used, collected from our source code.
Established Microsoft terminology (obtained from the Microsoft Terminology Collection).

Web Localization Service — Supported Versions Limited to v23.2+

Postponed to 2027:
While we confirmed that it is technically feasible to create a Blazor Model Editor (see our January prototype), we dropped its further development from our plans - we will have to re-think this completely after v26.2. AI chats greatly changed how users now manage even advanced application settings/tasks (like generate/modify complex reports or criteria expressions from natural language prompts). Our 15-year old and developer-centric Model Editor GUI (a tree list + property grid) may be simplified or replaced (see also a related Community Discussion).

We also postponed Fluent UI form template fine-tuning (app bar, side navigation bar, Tabbed MDI layout changes, etc.) as well as DateTimeOffset support (in data model properties) for key XAF List and Property Editors until the DevExpress WinForms and Blazor Component teams finalize this in v26.2. and our main strategic focus (web scalability).

DevExpress Blazor Component Enhancements (for XAF Blazor)

Learn more: Blazor — Year-End Roadmap (v26.2)

DevExpress WinForms Component Enhancements (for XAF WinForms)

Learn more: WinForms — Year-End Roadmap (v26.2)

Other DevExpress Enhancements (for XAF Blazor/WinForms)

Learn more:

Your Feedback Counts

If you have questions or suggestions about XAF v26.2, please share your thoughts in the survey below or submit a ticket via the DevExpress Support Center.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

DevExpress Agent Skills — Recent Updates

Dmitry Tokmachev (DevExpress) — Mon, 24 Aug 2026 00:55:00 Z

DevExpress Agent Skills help your favorite AI coding assistant to write accurate DevExpress code. Supported assistants include the following:

GitHub Copilot (VS Code, Visual Studio 2026, and CLI)
Claude Code
Cursor
Codex CLI
JetBrains Junie
JetBrains AI Assistant

In this post, I'll summarize our most recent update including: 14 new WinForms skills, a repository-wide review of every skill we've shipped previously, and plugin installation for Codex CLI and Cursor.

New WinForms Skills

WinForms developers are familiar with the convention: form controls belong in *.Designer.cs, generated by InitializeComponent(), not in constructor code. Using this approach, the form remains editable in the Visual Studio designer. AI assistants often miss this distinction. The code compiles and runs, but the designer surface breaks for the next developer who opens the form.

We created our first set of DevExpress WinForms Agent Skills to teach coding assistants WinForms-specific development patterns and best practices. Each skill leads with the designer-file pattern for the associated control. An assistant therefore treats this pattern as the default choice rather than the exception, and recommends runtime code only for dynamic or data-driven usage scenarios.

Our 14 new agent skills apply to the following UI controls and features::

These skills cover the most common usage scenarios for DevExpress WinForms controls, with every API reference verified against the product. When a skill covers a task, a coding agent solves it without querying the MCP server to reduce the latency and token usage. When a skill does not include enough detail to finish a task, the agent queries the MCP server for the missing details. Each skill lists the areas where this fallback is expected.

We evaluated every skill the way we test a shipping product feature: against real, multi-step prompts rather than synthetic "hello world" checks. Each prompt ran twice, once with the skill installed and once without. We repeated this comparison across different models/capability levels. The following prompts come from our test set, and they also illustrate what you can ask for once you install these skills, from a single data-entry form to a complete application:

"Build a Visual Studio-like shell application with a docked, central area and side/tool windows using the Dock Manager."
"I want to use DevExpress XtraScheduler in this project to display meeting schedule and tracking meeting location. Data source is Meeting.All."
"Build an app from scratch where DevExpress TreeList is the primary UI element."
"Two view models need to communicate without holding a direct reference to each other."
"Given a raw CREATE TABLE users (...) statement, build me a form to edit this data."

I encourage you to install our new skills and share your feedback so we can further improve our implementation. This is the first WinForms Skills release. We plan to cover more usage scenarios per control in future updates.

Also in This Update

We updated every skill we already ship to improve reliability and ensure assistants follow instructions from the skill. The updates includes:

Enhanced how a skill calls the DevExpress Documentation MCP Server, so an assistant reliably consults documentation when unsure of an API instead of skipping the step.
Refined elicitation: how a skill prompts you for missing details before it generates code, instead of guessing.
Verified and updated the minimum .NET version for each skill (.NET 8 for v26.1).
Applied additional accuracy-related fixes for Office File & PDF API and DevExpress Reports skills.

Plugin Support for Codex CLI and Cursor

Plugin installation now works with Codex CLI and Cursor, in addition to GitHub Copilot CLI and Claude Code. If you use either tool, install skills through the plugin marketplace rather than copying skill folders manually. Review the following documentation topics for plugin installation guidelines:

Get the Update

A plugin is the simplest way to stay current. Once you install plugins, most agents and IDEs check the marketplace for updates automatically, so these changes reach you without manual intervention.

If you copied skill folders directly into .github/skills/, .claude/skills/, or a different agent's skill folder, download fresh copies from our GitHub repository and replace those local folders.

Try a skill and tell us how it went. Open a ticket in the DevExpress Support Center and describe what worked well and what didn't. Flag issues in the AI-generated code a given skill produced: a wrong API call, a missed step, anything you had to fix manually afterward. Feedback such as this helped shape our update and will shape future updates as well.

WinForms — Year-End Roadmap (v26.2)

Alexander Russkov (DevExpress) — Thu, 20 Aug 2026 02:30:00 Z

First and foremost - thank you for choosing DevExpress and for your on-going support. In this blog post, I'll review the major features we expect to ship in our year-end release (v26.2 - December 2026). As always, you can expect other additions across our entire range of WinForms controls once we officially ship v26.2.

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.

.NET 11 Support

DevExpress WinForms controls will support .NET 11 (both v26.1 and v26.2) following Microsoft's official release.

Minimum Supported .NET and Visual Studio Versions

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

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

Security — SBOMs and CRA Readiness

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.

WCF Dependency Will Be Removed from XPO and Printing Core Libraries

Fluent Icons

We continue to extend our Fluent Icon set and integrate it across our control library.

Global Switch

You will be able to switch to the Fluent Icon set across all DevExpress WinForms controls. A public API will let you control the SVG image for each icon, and a global option will switch the icon set application-wide. Our new icons will also appear across our demos and the DevExpress Template Kit.

Extensive Library

The DevExpress Icon Suite already includes more than 13,000 icons, and we'll continue expanding it with additional Fluent assets to support even more usage scenarios. To maintain ease of use, we will group icons by the following attributes:

Set — Fluent, Desktop Classic, Blazor
Style — Regular, Filled
Color — Monochrome, Multicolor
Size — 16, 20, 24, 28, 32, and 48 (different sizes ensure that lines are not too thick when SVG icons are scaled)

These icons and settings will be available at design time in our enhanced Image Gallery.

Size-Based Image Selection

SVG images scale to any size, however scaling also changes line thickness. To maintain consistency in framed Fluent icons, our designers are drawing separate small and large versions rather than scaling a single image.

To simplify usage with these sizes, we are exploring automatic icon selection based on element size. For example, RibbonControl will use a dedicated SVG for large, medium, and small bar items.

AI Coding Skills

We are developing AI agent skills to help you build DevExpress WinForms applications using AI coding agents (such as Claude Code and GitHub Copilot). The skills will encode DevExpress best practices for the following development requirements:

Appearance Customization. The skill will select the most appropriate technique for the target control based on the specified task.
UI Automation Test Authoring. You will be able create UI Automation tests for WinForms views with DevExpress controls.
Form Code Structuring. The skill will help AI agents to properly add code to *.designer.cs files without losing design-time capabilities.

The final list of skills is subject to change as we continue to collect user feedback.

AI Chat Control

Workflow Visualization Support

Beyond single-agent chat, we are researching built-in visualization options for multi-step workflows in our AI Chat control. A single workflow can include multiple agents, parallel steps, tool calls, and tool-approval requests. The visualization will display details for each step, so users can follow the process.

AG-UI Demos

We will ship a set of WinForms demos you can use as a starting point for your own application. The demos will highlight the following capabilities of our WinForms AI Chat Control when connected to an AG-UI backend:

Visualized tool-call results — backend tool-call results appear as structured UI instead of raw text.
Interactive multi-step flows — the agent guides the user through a multi-step process and renders interactive elements at each step.
Human-in-the-loop actions — the agent prepares an action, such as placing an order, but runs it only after the user approves, edits, or rejects it.
Interaction with view components — the agent reads and updates the state of view components outside the chat control.

Localization / Globalization

Improved Localization Support with AI-powered Translations

Usage context - how each string is used, collected from our source code.
Established Microsoft terminology (obtained from the Microsoft Terminology Collection).

Web Localization Service — Supported Versions Limited to v23.2+

DateTimeOffset Support

Applications that store time-zone-aware timestamps (financial transaction logs, audit trails, event schedules) often need to preserve the original offset to record each value accurately. DevExpress WinForms Data Editors and Data Grid will support DateTimeOffset natively. Both will convert the offset to the user's time zone automatically. Users will see each date-time value in their own local time, in a format they already expect.

Data Grid

Our Data Grid will convert DateTimeOffset values to local time in every element that displays a date. Support will cover every grid feature that works with dates:

Filtering (including Filter Editor, Auto Filter Row, and filter popups).
Sorting and grouping.
Summary calculation.

EF Core Server Mode will also support DateTimeOffset columns.

Date Editor

Our Date Editor will accept DateTimeOffset values. An optional mode will display them in the user's local time zone. When a user edits a value, the editor will apply the offset that the local zone uses on that date. A daylight saving transition will not shift the result.

Server Mode over Web API

As you may know, DevExpress Server Mode allows you to work with millions of rows while maintaining UI responsiveness. With our next update, you will be able to connect Server Mode to ASP.NET Core endpoints without implementing OData.

Authentication, authorization, and the data you expose will remain entirely under your control:

You will be able to supply your own HTTP client, so any scheme (bearer tokens, API keys, or cookies) will travel with the request untouched.
Row-level rules will stay on the server: you will pass a pre-filtered collection to the registration call. Grouping and filtering will execute on top of that collection.
The endpoint will deserialize only known DevExpress query types (to reduce the attack surface a public-facing API exposes).
You will also be able to send data transfer objects (DTOs) instead of entity classes. Traffic will drop, and the data surface exposed to the client will narrow.

We expect to ship the data source and its server-side API as a GitHub example. We’ll refine our solution in future release cycle based on user feedback.

Accordion Control — Compact Mode

With v26.2, a compact layout will be easier to implement in the DevExpress WinForms Accordion Control. A single design-time action will transform a classic accordion control into a navigation panel that matches the appearance of modern Microsoft products (such as Teams, Outlook, and Microsoft Store).

Our WinForms Accordion Control will also support the following capabilities:

Separate item icons for hover and pressed states, with no custom draw handler.
Optional removal of the control's outer padding.
Adjustable item padding.

Template Kit — UI Templates Migration

At present, our WinForms UI Templates ship in a separate Visual Studio extension. We expect to move the templates into the DevExpress Template Kit - a single entry point for every new project and item.

Your Feedback Matters

Migrating WinForms & WPF from .NET Framework to .NET 10

Paul Usher (DevExpress) — Sun, 12 Jul 2026 22:05:00 Z

What This Guide Covers

I've hand-migrated more legacy codebases than I care to count, back when "modernisation" meant a fortnight of find-and-replace, a wall of compiler errors, and a knot in your stomach every time you hit Build. So when I recently took a fifteen-year-old WinForms line-of-business app from .NET Framework 4.8 to .NET 10 in a matter of days, with an AI agent doing the grunt work and me keeping my hands on the decisions, I paid attention to what actually worked. This guide is that method, written up as steps you can follow.

It assumes a real codebase: a non-SDK project, packages.config, a commercial control suite referenced the old way, and a decade of dependencies that were sensible in 2012 and a bit embarrassing now. If you've worked on real enterprise software, you've met this codebase. Odds are you maintain one. The app I'll keep referring to is WinForms, so the specifics lean that way, but the process is the same for WPF and I'll flag where the two part company.

The migration is rarely hard. It's vast and fiddly: thousands of small mechanical changes where one wrong move turns a working app into a non-compiling mystery you'll spend a day unpicking. It's tedious and easy to get wrong, which is exactly the kind of work worth automating, as long as you keep checking what it produces. Follow the steps below in order, commit after each one, and a job that's sat in the "someday" pile for years turns into this week's work.

Before you start: you need Visual Studio 2026 (or Visual Studio 2022 17.14.17+), your source in Git so every step is reversible, access to your DevExpress and NuGet feeds, and a paid GitHub Copilot plan if you want to run the modernization agent. With DevExpress v26.2 setting .NET 10 as the minimum supported target, this is the version to aim at.

Step 0: Pick the Right Target (LTS vs STS)

Decide the target framework before you touch anything, because it's one line in a project file that decides whether you do this again next year. Microsoft alternates its releases. The even-numbered ones (8, 10, 12) are Long-Term Support with a three-year window; the odd numbers in between are Standard-Term Support and shorter-lived (24 months now).

The first useful thing the AI did on my migration wasn't code. My obvious target was .NET 8. It pointed out that 8's support window was nearly up (November 2026), while .NET 10 was the current LTS with years of runway ahead of it. That's one line in a project file standing between "done" and "doing this again next year," and most juniors wouldn't have raised it. For an app that has to sit stable for years, you want the LTS. Right now that's .NET 10, which also happens to be the minimum DevExpress sets in v26.2 for .NET / .NET Core apps (learn more).

Since .NET 10 and Visual Studio 2026 will be minimally supported versions for .NET/.NET Core-based DevExpress libraries in v26.2, we are also planning to update the DevExpress Project Converter accordingly: it will re-target .NET versions in DevExpress-based projects and update 3rd party NuGet packages to the latest compatible versions (optionally and very similar to what we did for .NET 6 to 8 migration in 2024).

Step 1: Run an Assessment

Before changing code, get an honest picture of what stands between you and .NET 10. This is the job of GitHub Copilot app modernization for .NET, the Copilot agent that took over from the old Microsoft .NET Upgrade Assistant. In Visual Studio, right-click the solution in Solution Explorer and choose Modernize, or open Copilot Chat and invoke the agent:

@Modernize upgrade this solution to .NET 10

In VS Code or the Copilot CLI the agent is @modernize-dotnet. However you start it, the first thing it produces is an assessment.md in your repo: outdated NuGet packages, APIs with no modern equivalent, and the likely blockers. Read it before you agree to anything. That's the difference between planning a migration and discovering one.

Two caveats. Running the agent needs a paid GitHub Copilot plan, and if the Modernize option isn't there you'll need the GitHub Copilot app modernization component from the Visual Studio installer, so factor both in. And treat the assessment as a briefing, not a verdict: it's very good at finding the mechanical work, but the judgement calls are still yours.

Step 2: Review and Edit the Plan

Once the assessment's done, the agent writes a plan.md that sequences the upgrade into steps. The thing that matters about this file is that it's yours to edit. Reorder it, pull out steps you'd rather do by hand, and split anything that looks too big into smaller moves.

This is where you impose the one rule that keeps migrations safe, and I've learned it the hard way: never do it as a big bang. Work in small, reversible, committed steps, so a bad change is a git revert away rather than an afternoon of unpicking. A sensible plan for a DevExpress desktop app usually runs in this order:

Convert the project to SDK-style, targeting net10.0-windows.
Move dependencies from packages.config to PackageReference.
Prove the restore works against your feeds before attempting a build.
Fix what modern .NET rejects, then clear the build, then clear the warnings.

Approve the plan only when it reads like something you'd have written yourself. Then let the agent start executing, one step at a time.

Step 3: SDK-Style, PackageReference and CPM

The first executed step converts the old project format and moves your references. A couple of things are worth watching, because they catch you out.

If your .NET Framework project relied on assembly references, DevExpress assembly names do not match the DevExpress NuGet package names (for example, for the DevExpress.XtraGrid assembly there is a DevExpress.Win.Grid NuGet package). If you do not want to trust AI for this important conversion, we recommend that you use our Project Converter and its deterministic Convert DevExpress assembly references to NuGet packages option before you trigger actual project conversion.

If the project sits at the repository root, default file-globbing in an SDK-style project can hoover up source from other projects nearby. This is one the AI caught that I'd have walked straight into: my project sat at the repo root, so the default globbing would've pulled in source from the projects around it. It turned globbing off and carried the explicit file lists across. Keep an eye out for it, because it's easy to miss and a pain to debug.

If your solution has more than one project, this is the moment to adopt Central Package Management (CPM), so every project shares one set of versions. Drop a Directory.Packages.props at the repository root:

<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <PackageVersion Include="DevExpress.Win" Version="26.2.*" />
  </ItemGroup>
</Project>

That example pins the WinForms meta-package; for a WPF app you'd use DevExpress.Wpf instead. Individual projects then reference the package without a version, and your DevExpress and framework versions stop drifting apart across the solution. Prove dotnet restore succeeds against your component feed before you try to compile. Get restore green first and you skip a whole category of confusing build errors.

For more information on how your projects can benefit from CPM, please also review a related article Application Security — Project Dependency "Version Bumps" Demystified or Modern Security Realities in .NET / NuGet Ecosystem.

Step 4: Fix What Modern .NET Rejects

Now the code itself. On my migration the first compile threw 36 errors and roughly 1,795 warnings. That sounds alarming, and mostly it isn't: the errors collapsed to a handful of root causes, and the warnings came down to one. Clear them in that order, errors first and then warnings, committing as you go. These are the ones you're most likely to meet on a DevExpress desktop app.

Retire APIs with no modern equivalent

Swap out the usual suspects: an old zip library for System.IO.Compression, LINQ-to-SQL screens for a supported data path, dead app.config sections for their modern equivalents. The assessment will have flagged most of them.

Watch for namespace clashes

A properly sneaky one on my app: a bare Windows.Forms… reference stopped resolving on the new framework, thanks to a namespace collision that didn't exist on Framework. Fully qualify it and the error vanishes. One line, but a baffling one until you spot it.

The screens look wrong: fix DPI awareness

The app compiled and launched, but the forms came up subtly wrong: controls a touch out of place, spacing not quite right. That's the DPI-awareness default changing between frameworks, and it's the sort of thing you can stare at for a while before the penny drops. The AI worked it out from a screenshot and a description, pointed me at the DevExpress high-DPI docs to back it up, and one setting put the screens back exactly as they were. That trap is a WinForms one; WPF scales differently and won't hit it, though it has its own breaking changes to watch for, the removal of BinaryFormatter being the one that bites most often (learn more).

Collapse the warning storm

The warning count after a big migration can look terrifying and usually is anything but. Two moves cleared most of mine: declaring the assembly's supported-platform attribute to keep the compatibility analyser happy, and pinning a data-access package to the last version before it was marked obsolete. That second change alone dropped 500-plus warnings without touching a line of generated code.

Step 5: Lean on Compatibility Shims

You don't have to migrate everything before you can run. I'd assumed I would need to move my two in-house .NET Framework libraries first. I didn't. The modernised app compiled and ran on .NET 10 while still referencing those libraries through the .NET Framework compatibility shim. One thing to be clear about: that only holds while those libraries stick to APIs modern .NET still provides. You'll get a build warning, and any code path that calls an API .NET 10 has dropped will fail at runtime rather than at compile time, so exercise the paths that go through them before you call it done. Even so, if you've got in-house libraries pinned to Framework, leave them where they are for now. Get the main application onto .NET 10 first, confirm it runs, and book the deeper library work as a separate job that blocks nothing.

This is the single biggest reason these migrations stall for no good reason. Teams assume every dependency has to move first, and give up. It doesn't, and they don't. You don't have to boil the ocean. Get a working, current-LTS application in place, then chip away at the rest without holding the whole project hostage.

Where AI Fits, and Where You Stay in Charge

The reason this workflow holds up is that the agent proposes and you dispose. The assessment.md and plan.md aren't decoration; they're your checkpoints. You read the assessment, you edit the plan, you approve each step, and every change lands as a described commit you can review or revert. The AI carries the vast, repetitive sweep across dozens of files with no fatigue and no typos. The judgement and the checking stay with you. I never once typed "trust me," and that's the whole point.

Assess, plan, execute. The agent does the work; you sign off each stage.

Keep the Component Code Current: AI Skills and the MCP Server

The modernization agent is built to move your framework, not to know your component vendor's latest API surface. That gap does the most damage during a migration, because a migration is when you touch the most component code in the shortest time. Ask a general-purpose model to update a DevExpress grid or report and it'll often reach for an older namespace it saw more of in training. The code looks right, compiles, and sits there on a superseded API. Two DevExpress tools close that gap, and they're worth adding to the same IDE for the fix-up work.

DevExpress AI Skills hand the assistant current DevExpress namespaces, entry points and configuration patterns before it writes a line. They install into the coding assistant you already use (GitHub Copilot, Claude Code, Cursor or JetBrains), they work even without a live documentation connection, and they keep the component code on supported APIs rather than remembered ones. On a migration that pays off directly: fewer convincing-but-stale suggestions to catch in review, and a first answer you can build on instead of unpick. Call the relevant skill explicitly at the start of a task rather than trusting auto-detection, with # in Copilot or / in Cursor and Claude Code.

The DevExpress MCP Server adds the other half: live access to current documentation and version-sensitive detail when a task gets specific. Where a Skill sets the right starting point, the MCP Server supplies the authoritative reference to finish the job, so the assistant spends its lookups on real implementation questions instead of working out which API it should've used in the first place. Adding it is a one-line job in most assistants; in Claude Code, for example:

claude mcp add --transport http dxdocs https://api.devexpress.com/mcp/docs

Put them together and the split is clean: the modernization agent carries the framework move, the Skills keep your DevExpress code correct, and the MCP Server fills in the detail on demand. It's the same partnership principle as the rest of this guide, pointed at your component layer. I went deeper on why this matters, and how the two work together, with worked before-and-after examples in an earlier post: Beyond Prompts: Teaching AI How to Build with DevExpress. If you haven't read it, that's the companion piece to this guide.

Step 6: Verify You Are Actually Done

"It compiles" isn't the finish line. Before you call it migrated, confirm the app launches and the main workflows behave, the screens render correctly at your users' DPI settings, the warning count is down to something you actually understand, and each step is a clean commit in history. Only then start building new features on the modern foundation, which you can now do this week rather than someday.

The Takeaway

The blocker on most legacy migrations isn't capability. It's the sheer volume of small changes, and the fear of breaking an app that's quietly worked for years. This workflow deals with both. The modernization agent carries the tedium and surfaces the landmines as an assessment you approve, DevExpress AI Skills keep the component code on current APIs, compatibility shims stop a single old dependency holding everything hostage, and small reversible commits keep the risk low at every step.

With DevExpress v26.2 aiming to make .NET 10 the minimum for .NET / .NET Core apps, now is the time to plan this migration, not a reason to panic. The app I did this on was fifteen years old and threw 36 errors and getting on for 1,800 warnings on its first .NET 10 compile. It was running clean within days, and I was building new features on it the same week. The migration is the part everyone dreads. Worked in small steps, with the tooling doing the legwork and you making the calls, it turns out to be the manageable bit.

Developer Express Inc.

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

VCL — Year-End Roadmap (v26.2)

Security — SBOMs and CRA Readiness

Accessibility — Microsoft UI Automation, and Keyboard Navigation Enhancements

Accessibility and Compliance — PDF Engine Enhancements

Accessible/Tagged Document Export

E-invoicing Standards

AI — VCL Coding Skills

VCL Reporting and BI Dashboard Enhancements

Additional VCL Template Kit Options

Extended Learning Materials

Additional AI-Powered Functions

Performance and Usability Enhancements

Fluent UI Support — Replicate Modern Microsoft Outlook and Teams User Interfaces

VCL Template Kit — Additional Project and Form Templates

VCL Splash Screen Manager Enhancements

VCL Demo Source Code on GitHub

Your Feedback Matters

Blazor — Year-End 2026 Roadmap (v26.2)

.NET 11 Support

.NET 10 will be the Minimum Supported Version for DevExpress Libraries in v26.2

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

DateTimeOffset Support

Security — SBOMs and CRA Readiness

New Blazor App Bar

New Blazor Side Bar

RTL Support (CTP)

Blazor Icon Library — Official Release

Icon Library Support Across the Suite

Flexible Icon API

Additional Fluent Icons

Public CSS Variable Rework

Role-Based Names

Automatic Migration

Blazor AI Chat

Built-in Reasoning Visualization

Built-in Tool Approval Visualization

Pre-Attached Resources

Clear History API

UI/UX Enhancements

Blazor Grid & TreeList

Filter Row — Criteria Selector Menu

Filter Row — On-Input Filter Binding

Built-in Toolbar Items

Continuous Cell Editing

Striped Rows

Custom Row Height

Blazor TextBox — Password Button

Blazor Form Layout

New Caption Position Mode

Tab Management API

Localization / Globalization

Improved Localization Support with AI-powered Translations

Web Localization Service — Supported Versions Limited to v23.2+

Product-Tailored AI Skill Updates

Blazor 2026 Strategy — Status Update

Icon Library

RTL Support

Styling and Layout Foundations

New Themes

Classic Themes