Developer Express Inc.

XAF (Cross-Platform .NET App UI & Web API Service) — June 2026 Roadmap (v26.1)

Dennis Garavsky (DevExpress) — Tue, 03 Mar 2026 07:18:00 Z

Thank you for choosing XAF (Cross-Platform .NET App UI & Web API Service) for your software development needs. This blog post outlines some of our XAF-related development plans for the first half of 2026 (v26.1, set for release in June 2026).

First, if you have not heard of XAF or are new to the DevExpress product line, XAF is a developer-centric .NET application framework designed to build feature-complete Office-inspired line-of-business apps (leveraging DevExpress Blazor and WinForms UI components via Entity Framework or XPO ORM). Feel free to review our XAF demos and compare our implementation with other software low-code, no-code (LCNC) and traditional development methodologies.

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.

Content Security Policy Enhancements

Together with our Blazor development team, we will eliminate the need to use the following content security policy (CSP) requirement: style-src: 'unsafe-inline'. For additional information in this regard please review Content Security Policy (CSP) in XAF Blazor Apps.

Template Kit Enhancements

We will add the following security and usability-related enhancements for newly created XAF projects via our new Template Kit:

Select multiple Middle Tier Security-based startup projects;
Enforce the Middle Tier Security option by default;
Migrate to the minimal API/simplified Blazor project format with no Startup.cs file (makes .NET Aspire integration much easier).

Entity Framework Core 10 for Data Access

We expect to ship official EF Core 10 support in our v26.1 release cycle (for our XAF Blazor/WinForms UI and Web API Service). EF Core 10 is the latest version of Entity Framework. For early testing, EF Core 10 support is already available in v25.2.5+. We also updated our EF Core 10 vs XPO performance benchmarks.

Our new Template Kit also uses EF Core 10 when .NET 10 is selected. Our MainDemo.NET.EFCore will also use EF Core 10 and .NET 10 in v26.1. NOTE: .NET 10 requires Visual Studio 2026, which is yet to be adopted by most users, so we have not done this for v25.2.

While EF Core 10 offers numerous advantages over its predecessor (performance and customization included), it also introduced a series of breaking changes that we needed to address. Not all EF Core database connection providers ship EF Core 10-compatible NuGet packages as of this post (like Pomelo.EntityFrameworkCore.MySql). XAF's Web API Service also uses older Swashbuckle.AspNetCore package versions with .NET 10.

DateTimeOffset Type Support for EF Core and XPO

Our dev team will implement the core in DevExpress.Data, DevExpress.Xpo and related XAF libraries (similar to what we did for DateOnly/TimeOnly in DataController, Server Mode data sources, Criteria Language, etc.). Based on this core, our data-aware UI controls (such as Data Grid, Tree List, Date Editors) for Blazor and other UI platforms will be able to do the remaining work.

If all goes according to plan, by v26.2 we will be able to support the DateTimeOffset data model properties in key XAF List and Property Editors. This synergy will simplify multiple customer use-cases where application users are spread across different time zones.

XAF Blazor Report Designer Enhancements

We will use ViewDataSource by default when creating a new report. We will also make it easier to customize XAF data source settings (data type, sorting, filtering, etc.) in the runtime Report Designer.

Filter Builder Enhancements and Pivot Grid Integration

With v26.1, we will replace our existing JS-based filter editor with the new DevExpress Blazor Filter Builder. The DevExpress Blazor Filter Builder offers simpler localization, better performance, and native Blazor theme/palette support. This change will also reduce maintenance costs for the XAF team. The following Filter Builder features are critical for XAF integration: collection operations, plain criteria text input/validation, good performance with complex data model structures.

In addition, we will improve XAF's WinForms Filter Editor when using advanced XAF and ORM-specific criteria functions (Upcasting, Free Joins, etc.).

If time permits, we will also integrate the DevExpress Blazor Pivot Table (an early preview of XAF's DxPivotGridListEditor in v26.1). This integration is based on previous v25.2 research and close collaboration with our Blazor development team (who made required extension points/APIs and added features important for XAF customers). If all goes according to plan, v26.2 should mark the official release of DxPivotGridListEditor.

Built-In AI Module to Add Smart Functions in "1-Click"

If you are unfamiliar with our existing .NET AI-powered Extensions, please review these documents. XAF Blazor/WinForms v26.1 will simplify the following AI-related capabilities:

Semantic or Smart Search within DevExpress Data Grids and AI Chat Integration

AI-Powered Smart Paste within the Detail View Layout Control

AI-Powered Extensions in the Reporting, Filter Editor, Office (Rich Text Editor) Modules

Blazor List and Property Editor Enhancements

We expect to migrate XAF's DxGridListEditor to native Blazor DxGrid component context menus, which were added in a recent major update (much like in XAF WinForms below).

We will also make it easier to add custom buttons to Blazor Property Editors in code (via the new Buttons property):

private void Customize_EnumPropertyEditor(EnumPropertyEditor editor) {
    var customButtonModel = new DxEditorButtonModel() {
        Text = "Test",
        Click = EventCallback.Factory.Create<MouseEventArgs>(this,
             (e) => Application.ShowViewStrategy.ShowMessage("Click!"))
    };
    editor.Buttons.Add(customButtonModel);
}

What's Next / Our Main Focus

We Remain Focused on XAF Blazor Scalability

As many of you already know from my mid-2025 announcement, our core focus for the next few major release cycles will continue to be scalability (number of concurrent web users). At the end of 2026 (not yet in v25.2 or v26.1), we want future XAF Blazor apps and XAF core to be:

Scalable up to hundreds and even a thousand of web users reliably and predictably.
Require simpler configuration for high-load and multi-tenancy scenarios (without Kubernetes -k8s- or other complicated horizontal/scale out solutions).
Require much less compute resources (CPU/RAM).

As I noted earlier, this is especially important as scalable, cloud-hosted, multi-tenant/SaaS-based apps are becoming a standard requirement (for both internal and public LOB deployments). Achieving desired levels of XAF Blazor scalability will certainly help customers targeting hybrid desktop apps for both Windows and non-Windows environments (Electron.NET-powered). Better scalability will also drive the evolution of our Multi-Tenancy module (scalability is an "enabler" to add additional standard SaaS features later).

Migrate Your XAF Apps from .NET Framework (WinForms/WebForms) to .NET (WinForms/Blazor)

For this big and ambitious goal, we had to drop .NET Framework support and remove legacy APIs in v25.2. We also re-balanced our dev team internally to prioritize performance enhancements in XAF Core and Blazor UI above other features. Of course, we remain focused on security and continue to address usability and other framework-related issues (as you can see from the XAF Blazor/WinForms roadmap above).

To help with the migration to .NET from .NET Framework easier, we published semi-automatic converters and detailed migration guidelines (powered by AI, Roslyn, and our Project Converter). Please let us know if there is anything we can improve in this regard for you.

Blazor Model Editor in Your Web Browser (Postponed)

In January, we confirmed that it is technically feasible to have the same experience as in XAF WinForms Model Editor (see our Blazor prototype). While I would love to have the powerful runtime Blazor Model Editor today as much as you, we intentionally delayed it in favor of our main strategic focus (web scalability). We'll see whether we can revisit this task in our v26.2 release cycle.

This Application Model / UI structure customization will also require additional licensing/EULA considerations - as this powerful tool is primarily for "developers" (application structure/logic customizations are technically considered "development" tools).

First XAF Blazor Scalability Research Results

By v26.1, we will publish the first load-testing results along with related product enhancements (safely activated via feature flags). For example, our core dev team almost finalized planned Application Model enhancements, which will reduce memory usage and speed up critical code execution under high user load.

Our primary work from mid-2025 has been and still is to:

Analyze key bottlenecks from research;
Prioritize the most impactful changes for target scenarios (like 500+ users);
Plan required code changes in XAF core and DevExpress Blazor components.

Below you can see a screenshot from our internal dashboard for a few test runs in February. The bottom chart series displays the impact on response times from one of our recent code optimizations. Of course, we must also optimize for web server memory usage, database/SQL, and many other parameters. Challenges remain, but we are sure that our final implementation will deliver positive/noticeable business impact to XAF Blazor and its users.

DevExpress Blazor Component Enhancements (for XAF Blazor)

Learn more: Blazor — June 2026 Roadmap (v26.1)

DevExpress WinForms Component Enhancements (for XAF WinForms)

Learn more: WinForms — June 2026 Roadmap (v26.1)

Other DevExpress Component Enhancements (for XAF Blazor/WinForms)

Learn more:

Your Feedback Matters

As always, we welcome your feedback. Your response to the following questions will help us fine-tune/refine plans for our next major release:

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

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

New AiGen Functionality in CodeRush for Visual Studio

Mark Miller (DevExpress) — Thu, 26 Feb 2026 08:00:00 Z

CodeRush's AiGen is Faster and Smarter for Everyday Development

AI-assisted coding tools live or die by two factors: speed and quality of the code response. If an AI response takes too long, or if it regenerates more code than necessary, developers won't use it for small, focused changes.

With this release, CodeRush’s AiGen takes significant leaps forward on both fronts. The improvements are all about making AI genuinely fast and useful during day-to-day development -- where precision, latency, and context matter most.

We'll cover what’s new in this release using real world examples that you can easily try yourself (clone the sample project).

Improved Context Acquisition & Architectural Awareness

One of the challenges for AI coding assistants is how to get sufficient context for a correct code response, without exceeding the model's context window limits. Some AI tools solve this by placing the burden of specifying this additional context -- the files to include in a query -- on the user. This can get tedious when many files are involved. Simple AI tooling might see the file you’re editing, but miss surrounding architectural relationships -- interfaces, implementors, ancestors, descendants, helper classes, and corresponding test fixtures.

To meet this challenge, AiGen now starts each request with a lightweight context-acquisition pass which:

Identifies which related types matter for the request
Traverses the solution hierarchy as needed
Optimally packs a reasonable portion of the context window with only the most relevant information
Sends that optimized and packed context to the reasoning model

The result is higher quality code -- without you having to name (or worry about missing) related types to submit to the model explicitly.

Example: Consolidating Validation Logic Using the Type Hierarchy

In the sample project, open the ContextAcquisition folder and navigate to OrderValidator.cs.

Inside the ValidateCore() method, you’ll see some validation logic.

protected override void ValidateCore(Order order, ValidationResult result) {
    if (order is null) {
        result.Add("Order is required.");
        return;
    }

    // TODO: Ask AiGen to consolidate this based on what we have in the base class.

    var customer = order.Customer;

    if (customer is null) {
        result.Add("Customer is required.");
        if (StopOnFirstError) return;
    }

    if (customer?.BillingAddress is null) {
        result.Add("Billing address is required.");
        if (StopOnFirstError) return;
    }

    if (string.IsNullOrWhiteSpace(customer?.BillingAddress?.CountryCode)) {
        result.Add("Billing address country is required.");
        if (StopOnFirstError) return;
    }

    if (string.IsNullOrWhiteSpace(order.OrderId)) {
        result.Add("OrderId is required.");
    }
}

This logic duplicates some of the behavior already implemented in the ancestor class (BaseValidator<T> -- check out its RequireCustomer() method).

// Shared helpers that derived validators can (and should) reuse.
protected void RequireCustomer(Customer? customer, ValidationResult result) {
    if (customer is null) {
        result.Add("Customer is required.");
        if (StopOnFirstError)
            return;
    }

    if (customer?.BillingAddress is null) {
        result.Add("Billing address is required.");
        if (StopOnFirstError)
            return;
    }

    if (string.IsNullOrWhiteSpace(customer?.BillingAddress?.CountryCode)) {
        result.Add("Billing address country is required.");
    }
}

This kind of duplication can happen in systems that evolve over time.

Back in OrderValidator.cs, place your caret inside the ValidateCore()method, Rather than telling AiGen exactly how to fix it, we can talk to it the way we might speak to a human teammate.

Invoke AiGen (double-tap and hold the right Ctrl key if speaking or press Caps+G if you prefer to type -- see AiGen setup for more details). Then say something like (one of the following):

“Consolidate this logic with what we already have in the base class.”

“Take a look at the ancestor class and see if we can reuse any of that code here.”

Notice, the prompts are void of symbol or file names. They're just expressions of intent.

AiGen uses the hierarchy to discover the relevant base class, identifies the overlapping logic, and refactors the code so the shared behavior lives where it belongs -- in the base class -- while keeping order-specific checks local.

After applying this change, the AiGen Navigator will appear. You can click the "Show Difference View" button to see the before and after for the changes applied to this method:

”

Here, AiGen consolidates the duplicated validation logic into a single call to RequireCustomer(), while maintaining the existing StopOnFirstError behavior.

The AiGen navigator's status bar shows total in/out token counts for both the initial context pass ("Ctx in/out"), and the main reasoning model ("Reasoning in/out"). Output token counts are low, as they should be (only 67 output tokens were used by the reasoning model to produce the minimal, targeted change shown in the screenshot). Output tokens typically cost four times more than input tokens, so we want to keep the output token count low, The status bar also shows estimated cost (about 3 cents) and how long it took from request to integrated response (2.5 seconds, in this example). If you're interested to see how CodeRush stacks up against competing AI tooling solutions, note the AiGen completion time in the status bar, undo this last change and try the same prompt on the same code in any other competing AI coding assistance tool.

Speed Where It Matters: Fine-grained Deltas

Most AI coding assistants treat every change the same way: they regenerate large chunks of code, even when only a few lines actually need to change. This approach can break down quickly in real projects -- especially when methods are large and the requested change is small. With most AI tooling it just doesn't make sense to ask AI for small changes when you'll have to wait for an entire method or even a type to be regenerated.

CodeRush's AiGen takes a different approach.

Instead of regenerating entire members, AI works to produce only the smallest deltas to support fast surgical code integrations without manual copy/paste.

This impacts:

Speed — generating fewer output tokens (to support the fine grained delta) is faster than regenerating all the code that doesn't change.

Cost — output tokens are significantly more expensive than input tokens.

Precision — small, focused changes reduce churn and unintended side effects.

Example: Small Business Rule Change Inside a Large Method

In the sample project, open the FineGrainedDeltas folder and navigate to OrderTaxCalculator.cs. Notice the ComputeTaxes() method is non-trivial and could resemble real production code, with multiple early exits, counters, and guard clauses.

Inside the main loop, you’ll see a TODO describing a business rule:

// TODO: Apply the customer's discount tax policy when calculating taxableBase.

This is a subtle rule change. We don’t want to rewrite the method -- we just want to adjust how the taxable base is calculated under specific conditions.

Let's delete the TODO comment and invoke AiGen. You can double-tap the right Ctrl key and keep it held down while using a natural, descriptive prompt such as:

“Let's incorporate the customer discount policy.

AiGen should:

Change only the minimal code region required
Leave the rest of the method untouched
Apply the update directly in the editor (no manual copy/paste)

Turning this:

decimal taxableBase = order.Subtotal - order.DiscountAmount;

into something like this:

decimal taxableBase = customer.DiscountPolicy switch {
    Customer.Discounts.ReduceTaxableBase => order.Subtotal - order.DiscountAmount,
    Customer.Discounts.FullyTaxable => order.Subtotal,
    _ => order.Subtotal - order.DiscountAmount
};

Note both the size of the method and how little code AiGen needs to generate to apply the change.

The prompt doesn’t require exact symbol names or structured references — we describe intent, and AiGen resolves the implementation from surrounding context.

This example demonstrates fine-grained deltas in practice: smaller outputs, lower token usage, reduced latency, and a more immediate turnaround — especially when working inside large methods.

After AiGen applies the change, you can find evidence of the smaller delta in two places:

AiGen Navigator status bar: Check the Reasoning out token count and the elapsed time (114 output tokens and 3.2 seconds, respectively, in the screenshot below). Fine-grained deltas yield small output token counts — typically far smaller than the count required to regenerate an entire method.image
Editor selection: Selecting a change in the AiGen Navigator (e.g., "∆ selection") highlights the inserted/modified region, making the delta boundary immediately visible. In the screenshot below, the selection represents the small portion of the method that was regenerated. The rest of the method was untouched by AI.

This is why AiGen feels fast even when working inside large blocks of code: you’re not overpaying (in time or tokens) for code that isn’t changing.

What's also exciting about these optimized deltas, you are free to edit (or apply tooling to) surrounding code while waiting for AI to return.

Which brings us to our next topic....

Working While AI Is Running: In-Flight Changes & Conflict Navigation

One of the most frustrating aspects of modern AI-assisted coding tools is that they repeatedly block your flow. You ask for help, then you wait -- hands off the keyboard -- until the response finally returns.

AiGen removes that bottleneck.

When AiGen requests are launched, you’re free to continue coding. You can edit the same file, move elsewhere in the solution, or even launch additional coding agents. AiGen anchors each request to the code state at launch and safely validates those changes on return.

When changes are non-overlapping -- as they can be in intentional multi-agent workflows -- AiGen applies the results cleanly and without interruption.

For example, you can ask AiGen to modify one part of a C# method while you continue working in another part of the same method.

If in-flight edits overlap with part of a reasoning response's intended changes, AiGen withholds only the conflicting change and surfaces both the reason and the change it was prepared to apply. We'll see an example of this in a moment.

Scenario A: Non-Conflicting Changes -- AI + Human

Navigate to the InFlightEdits folder and open OrderSubmissionService.cs. The Submit() method contains several failure points -- exactly the kind of code where you might want better diagnostics. To prepare for this simultaneous edit demo, first, copy the following text to the clipboard:

> Logs any failures.

Next, place the caret anywhere inside the Submit() method and invoke AiGen with a request like:

“Add logging around failures in this method.”

While the AI request is running, move the caret to the XML documentation comment and paste the text from the clipboard to the end of the XML doc comment. The goal is to make this change before the AI response lands (if AI is faster, you can undo and try again -- you typically have 2-5 seconds to make the change while this logging request is in-flight).

When the AI response lands, you’ll see:

The logging changes are applied correctly.

Your manual documentation edit is preserved.

No manual merging is required.

AiGen doesn’t lock the editor or assume code is frozen while it works. It assumes you’re still working -- because you are.

Scenario B: Parallel, Non-Conflicting Changes -- Multiple AI Agents

Let's undo our recent changes and restore OrderSubmissionService.cs to its original cloned state.

For this next scenario, we'll launch two AI agents simultaneously to work on the same method.

The first agent will add logging (like we just did in the last scenario), and the second agent will add telemetry so we can track orders (using the TrackOperationAttribute declared in the Shared folder).

Start by opening TrackOperationAttribute.cs from the Shared folder and examining the class. This is the custom attribute we'll use for telemetry. Note that it includes properties for:

Name -- describes whatever we're tracking
Category -- groups related telemetry events

Next, switch back to OrderSubmissionService.cs and place the caret in the Submit() method. The next two steps should be performed back to back.

Launch the first agent with: “Add logging around failures in this method.”
Launch the second agent with: "Add the track operation attribute. Category is orders."

The goal here is to start up a second agent while the first is still inflight. If the first AI response lands before you can launch the second, perform an undo (close the AiGen Navigator) and then copy the second prompt to the clipboard. Then after launching the first agent by voice, invoke the second agent with Caps+G (plus a paste).

When multiple AI responses land, the AiGen Navigator shows multiple landings using tabs. In the screenshot below, notice the agents landed in reverse order from take-off, with the tracking attribute finishing first.

Notice AiGen correctly discovered the TrackOperationAttribute from the Shared folder and added it with appropriate values for both Name and Category. Also note the orange arrow in the screenshot above -- it points to the second AI landing ("Failure logging" in this example -- your tabs may have different tab titles and agents may complete in a different order than they were launched).

AiGen Navigator tabs may display one or more of the following icons:

⭐ Star -- the landing has not yet been viewed (typically a recent result).
✔️ Check -- all changes were successfully integrated (no conflicts)
❗ Exclamation -- one or more conflicts occurred on landing

Notice that:

One agent modifies the **method body** (logging)
The other modifies the **method metadata** (the attribute)

Because these changes target **different structural regions**, both land successfully without conflict.

Skilled developers can safely run multiple AI agents in parallel when:

The requested changes **do not overlap**, and
Each agent’s task can be completed **independently** of the others.

Note: When multiple in-flight AI agents complete their changes, undo follows landing order, not launch order — the most recently applied change is undone first. This mirrors standard Visual Studio editor behavior and keeps AI changes fully integrated into the undo stack.

Scenario C: Conflicting Changes

Now let’s look at what happens when a conflict does occur.

Start by undoing the previous edits to restore OrderSubmissionService.Submit()to its original state.

Note: When multiple in-flight AI agents complete their changes, undo follows landing order, not launch order -- the most recently applied change is undone first. This mirrors normal Visual Studio editor behavior and keeps AI changes fully integrated into the standard undo stack.

Next, we'll launch the same AI request as before:

“Add logging around failures in this method.”

While the request is in flight, make a meaningful overlapping change to one of the failure points. For example, replace a throw with an early return null;.

When the reasoning response lands, AiGen detects that one of the targeted code blocks has changed since the request was launched. Rather than guessing or overwriting your work, AiGen blocks only the conflicting integration while allowing all non-conflicting changes to apply normally.

In the screenshot below, notice that logging was successfully added around every remaining throw statement (the five "selection" entries marked with only the delta symbol). Only the single failure point we modified in our example was held back.

For the blocked change, AiGen shows:

The original code as it existed when the request was launched

The current code at apply time

The reasoning model's attempted replacement

This makes the conflict isolated,explicit, and safe to reason about. You can clearly see:

which change was blocked,
why it was blocked, and
exactly what AiGen was prepared to do.

Because AiGen typically produces **fine-grained deltas**, conflicts are isolated to the smallest possible change. A single overlapping edit does not invalidate the rest of the AI response — only the affected update is held back, while all other safe modifications are integrated.

The conflict report for the blocked delta shows the original code at request time and the current code at apply time, as well as the attempted replacement. You might see something like this:

The change for this member was skipped because the target code changed inflight.

Original code at request time:

if (order.Customer is null)
  throw new InvalidOperationException("Customer is required.");

Current code at apply time:

if (order.Customer is null)
  return null;

Attempted replacement:

if (order.Customer is null) {
  Console.Error.WriteLine($"[{nameof(OrderSubmissionService)}] Order submission failed: {nameof(order.Customer)} is required. OrderId='{order.OrderId ?? "<null>"}'.");
  throw new InvalidOperationException("Customer is required.");«Caret»
}

Original and current code blocks must match on landing.

This section demonstrates how AiGen behaves when the code changes while AI requests are in flight — including parallel agents and isolated conflicts.

Everything else proceeds as expected -- no rollback, no guesswork, and no silent overwrites.

Runtime State to Tests: Debug-Time Object Reconstruction

So far, all of the examples have focused on static code -- types, methods, and edits driven by what’s visible in the editor. The next capability goes a step further by incorporating runtime state.

When you invoke AiGen while stopped at a breakpoint, it can now inspect the live debug-time values in scope and include them (if appropriate) as part of the request. That allows the reasoning model to also work from actual execution data, not just source code.

This is especially powerful when the issue you’re investigating only becomes obvious at runtime.

Example: Turning a Debug-Time Bug into a Targeted Test

From the DebugRuntimeState folder open OrderAddressFormatter.cs. The BuildShippingLabel() method formats a shipping label from customer and address data.

Place a breakpoint on the final line of this method and run the program. When execution stops, inspect the values inside the Visual Studio debugging environment. In this scenario, you’ll notice that:

Region is empty or whitespace

The computed label (which includes cityRegionPostal) contains a dangling comma and extra spaces

The bug is subtle and data-dependent. You could fix it immediately -- but it’s a good idea to capture the behavior in a test first, so it doesn’t regress.

While still stopped at the breakpoint (with the caret inside the BuildShippingLabel() method), invoke AiGen and say:

“Create a test case for this method based on these debug-time parameter values.

Add asserts to make sure the label has no double spaces and no dangling comma when the region is blank.”

While waiting for the response, you might want to drill into the order parameter. It has a Customer property that in turn holds the BillingAddress with the empty region that led to this bug.

AiGen will:

Reconstruct the runtime object graph for the order parameter using live debug-time values
Locate the appropriate OrderAddressFormatterTests fixture
Generate a new xUnit test that reproduces the observed state and behavior
Add targeted assertions that detect the formatting defectUnderstand the object graph in scope (including nested properties/objects)

You should get a test case like this (note the object graph reconstruction at the top, which recreates the somewhat sophisticated debug-time state that exposed the bug):

    [Fact]
    public void BuildShippingLabel_RegionBlank_NoDoubleSpaces_AndNoDanglingComma() {
        // Arrange (debug-time values)
        var address = new Address {
            City = "Seattle",
            Region = " ", // blank/whitespace
            PostalCode = "98101",
            CountryCode = "US",
            Line1 = "123 Example St"
        };
        var customer = new Customer { DisplayName = "Ada Lovelace", BillingAddress = address, Id = "C-42" };
        var order = new Order {
            Customer = customer,
            DiscountAmount = 10m,
            Subtotal = 120m,
            OrderId = "DBG-1001",
            TaxAmount = 0m
        };

        var formatter = new OrderAddressFormatter();

        // Act
        string label = formatter.BuildShippingLabel(order);

        // Assert
        Assert.DoesNotContain("  ", label);       // no double spaces anywhere
        Assert.DoesNotContain(", ", label);       // no dangling comma + space
        Assert.DoesNotMatch(@",\s*(—|$)", label); // no comma before em-dash or end
        Assert.DoesNotMatch(@",\s+\d", label);    // no comma followed by spaces then digits (e.g., ",  98101")
        Assert.Contains("Seattle", label);
        Assert.Contains("98101", label);
    }

This workflow makes it practical to capture real-world edge cases in the moment they are discovered. Instead of manually attempting to duplicate observed state, you can promote live runtime data directly into a durable, repeatable test.

After creating the new test case, you can stop debugging and run the test case if you like (it should fail since the issue we discovered in the sample code hasn't been fixed yet).

Why This Matters

This capability closes a familiar gap in debugging workflows. Developers often discover bugs while stepping through code, but translating those live-data observations into tests is tedious and error-prone.

By grounding test generation in captured debug-time values, AiGen makes it practical to:

Easily capture real-world edge cases
Generate focused, high-signal tests
Preserve the conditions that exposed the issue

It’s a natural extension of pair programming: you identify the problem while debugging, and AiGen helps you lock it down with a test before you move on.

Large-Scale Architectural Changes: Evolving Interfaces Across Many Implementations

So far, we’ve focused on fast, fine-grained edits — the kind that make AI practical for everyday work. But AiGen is not limited to small changes. It can also perform broad, cross-cutting architectural updates that span multiple files, types, and layers of a solution.

This next example demonstrates AiGen’s ability to generate new types in bulk and then evolve an interface contract across all of its implementers.

Example: Generating and Evolving Order Rules

In the sample project, open the ArchitecturalEdits folder and navigate to IOrderRule.cs. You’ll see a minimal interface:

namespace CodeRush.AiGen.Main.ArchitecturalEdits;

public interface IOrderRule {
    RuleResult Apply(Order order);
}

Place your caret inside the interface and invoke AiGen with the following prompt:

“I need ten non-trivial implementers of this interface. Put them in the rules namespace.”

Unlike previous demos, this request generates multiple new classes, each implementing distinct business logic. Because the reasoning model is synthesizing several non-trivial implementations, this step may take longer than the earlier examples.

When the request completes, AiGen creates a new Rules namespace containing ten concrete implementations of IOrderRule — each reflecting realistic order-processing concerns such as fraud detection, pricing validation, eligibility checks, and fulfillment constraints.

This demonstrates AiGen’s ability to:

Generate multiple production-quality types in a single request
Maintain a shared contract across many implementations
Respect namespace organization and solution structure
Coordinate multi-file changes across a codebase

Evolving the Contract Across the Hierarchy

Now return to IOrderRule.cs and invoke AiGen again with:

“Add two properties — name and description — and update all implementers.”

AiGen updates the interface to include the new properties, then propagates those changes across all existing rule implementations — ensuring each class remains compliant with the updated contract.

Because this step modifies existing code rather than generating new types, it typically completes much faster than the bulk-creation step.

Together, these prompts demonstrate AiGen’s ability to perform:

Large-scale architectural refactorings
Contract evolution across many implementers
Coordinated multi-file updates without manual intervention
High-level structural changes (in addition to surgical edits)

Earlier examples highlighted AiGen’s speed and precision for small changes. This scenario shows the other side of the system — the ability to reshape architecture across an entire subsystem when needed.

Fixing Code Using Active Compiler Errors

Until now, we’ve focused on how AiGen understands source code, hierarchy, and runtime state. But AiGen can also reason over active compiler errors — both at the caret and across the Visual Studio Errors list.

This allows you to resolve broken code using short, natural prompts, without needing to restate what the error is or why it occurred.

Example: Fixing a Real Compiler Error with “Fix this”

In the sample project, open the ActiveErrorAnalysis folder and navigate to OrderQueryService.cs.

At the top of the file, you’ll see a demo toggle:

// Demo toggle:
// TODO: Uncomment the line below to intentionally introduce a compiler error on the `where` clause, below.
//#define DEMO_ACTIVE_ERRORS

Now place your caret on the Where() call in the broken LINQ query and invoke AiGen. Simply say:

“Fix this.”

There’s no need to explain the problem. AiGen inspects the active compiler diagnostics, analyzes the surrounding code, and determines the appropriate fix.

Here is a typical AiGen response to this error and surrounding code:

public async Task<int> GetHighValueOrderCountAsync(decimal minSubtotal) {
  var orders = await GetOrdersAsync().ConfigureAwait(false);
  return orders.Count(o => o.Subtotal >= minSubtotal);
}

The fix is driven by real compiler feedback, not by a manually described problem.

This demonstrates AiGen’s ability to:

Read live compiler diagnostics from the editor
Infer intent from the actual error, not just the source text
Generate a non-trivial corrective refactor with a minimal prompt
Resolve failures without requiring developers to restate what the compiler already knows

In practice, this makes AI useful not just for writing new code — but for repairing broken code quickly and contextually.

What This Update Unlocks

Taken together, these examples illustrate a shift in how AI assistance fits into everyday development.

AI Assistance is no longer something you reach for only when you’re willing to pause, wait, and review a large block of regenerated code. With faster/smarter context acquisition, fine-grained deltas, conservative integration, and awareness of both code and runtime state, it also becomes practical to use AI for small, precise tasks -- the kind that make up most real work.

In practice, this means:

You can ask for surgically precise changes inside large methods without paying or waiting for redundant regeneration.
You can continue working while AI requests are in-flight, or even launch multiple agents in parallel when tasks impact non-overlapping areas of code.
Individual conflicts -- caused by overlapping edits while AI requests are in-flight -- are isolated and surfaced in the UI, rather than forcing all-or-nothing outcomes.
Debug-time state observations can be turned into targeted tests, grounded in real execution data.

None of this requires verbose prompts, detailed instructions, or explicitly naming symbols or files. AiGen is designed to infer intent from context -- types, hierarchy, editor state, and runtime values -- so you can speak naturally and stay in flow.

If you’re an existing CodeRush user, these capabilities are available now in the latest release. If you’re new to CodeRush (it's free on the Visual Studio Marketplace), the sample project referenced in this post is a good place to start exploring how AiGen behaves in real scenarios.

AI tooling works best when it’s fast, precise, and respectful of the code you already have. This release is about moving closer to that ideal -- so AI becomes something you use routinely, not something you have to plan around.

Limitations

AiGen is optimized to work fast in C# files and XAML. However, as with any tooling involving AI models, AiGen has some limitations:

AiGen can generate new files in any programming language and add them to the active project, but it can only modify C# and XAML files.
Multi-agent support and editing while AI is in-flight is currently available in C# only, For XAML, wait for the AI response to land before making changes to the same XAML file.
Blazor support is pending
There are some reasonable depth limitations on reconstructing debug-time object graphs and on traversing class hierarchies for the context window.
AiGen cannot delete files or remove files from the project.
Aside from adding new files and installing NuGet packages, AiGen cannot modify the project file or the solution file (so there's currently no way to create or add new projects or add/modify project properties).
AiGen is not a chat window based tool, and there is no history/memory of previous actions. Context is derived entirely from your prompt, the editor view, surrounding code, the solution source, debug values, etc..
There are the usual limitations and disclaimers on the power of AI itself. Sometimes AI "hallucinates" (this is especially true when generating code based on frameworks that have changed or where API evolution has introduced breaking changes over time). Also, it is possible to have a request so complex AI has difficulty implementing it correctly.

DevExtreme — June 2026 Roadmap (v26.1 - Angular, React, Vue, jQuery & ASP.NET Core)

Svetlana Troitskaya (DevExpress) — Wed, 25 Feb 2026 00:38:00 Z

In this blog post, we'll review the major features we expect to ship in our mid-year release (v26.1 - June 2026). These features apply to both DevExtreme JavaScript components (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 to share feedback. 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 regularly updated to reflect development progress. As we get closer to the release, we expect to add more items and modify the status of planned features. 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.1 - Will be available in our v26.1 beta release.
Released in v26.1 - Fully implemented and available in v26.1.

DataGrid & TreeList — AI Assistant

All Platforms
Planned

With our v26.1 release, we will extend the AI-powered capabilities of both the DevExtreme DataGrid and TreeList. We plan to introduce a DevExtreme Chat-based AI assistant that will allow you to use natural language to interact with DataGrid/TreeList. The DataGrid/TreeList AI assistant will be able to complete the following actions:

Sort, filter, search, and group data.
Resize, reorder, fix/unfix, and show/hide columns.
Change pagination settings.

In our last release (v25.2), we introduced a standalone Speech To Text component. By incorporating this component into our Chat component (planned for 26.1), you will be able to add Speech to Text to your next DevExtreme-powered AI Assistant as well. This will eliminate the need for manual configuration and improve accessibility when working with DataGrid/TreeList (by offering an additional interface when interacting with UI elements).

This feature is particularly well suited for the following usage scenarios:

Large Datasets: Use the power of AI to browse large data sets. Apply complex filter values with natural language.
Complex Grid Configurations: Allow users to specify complex display preferences quickly.
Accessibility-first Applications: Allow users to interact with your application in a manner that is most appropriate for each specific situation: while at their desk, or on the go (when their hands are busy and they require voice commands to interact with your app).
Replicable Configurations: Apply the same prompt to recreate complex grid configurations across sessions. Reduce time spent on tedious layout adjustments.

DataGrid & TreeList — Persistent Validation Messages in Editors

All Platforms
Planned

We expect to introduce new APIs that will allow validation messages to remain visible even when data editors lose focus (similar to the validationMessageMode='always' in components such as our TextBox). These APIs will apply to all available editing modes.

Chat Enhancements

Speech To Text

All Platforms
In Development

We expect to integrate our new SpeechToText component into our Chat component's input area for faster, hands-free communication.

Message Streaming

All Platforms
Planned

We expect to add support for message streaming within DevExtreme Chat. The Chat component will be able display responses progressively as data arrives rather than after the request is fully completed. This feature will improve perceived performance and the overall user experience for DevExtreme-powered AI assistants, chatbots, and long-running operations, making conversations feel more dynamic and responsive.

Tool Call Visualization

All Platforms
Planned

We will introduce the ability to display AI tool/function calls in the message body. Such 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 AI response.

Scheduler Enhancements

Appointment Snap Modes

All Platforms
In Development

DevExtreme Scheduler will include a new appointment snap mechanism. The following modes will be available:

always - an appointment always stretches to cell borders.
auto - an appointment is stretched to cell border only if the distance from the cell border to the edge of an appointment is less than half of the cell width.
never - appointments are proportional to their duration.

Handle Appointment Time Overlapping

All Platforms
In Development

Managing appointment overlapping will be easier with our next release. We will add public APIs to obtain an array of appointments for a specific range. You will be able to implement the following scenarios using these APIs:

Prevent Time Conflicts: Notify users about a scheduling conflict. Restrict adding, editing, or moving appointments if the selected time slot is already occupied.
Suggest Available Time Slots: Automatically suggest the nearest available time when a selected slot is unavailable.
Handle Recurring Appointment Conflicts: Detect and manage conflicts for individual occurrences within recurring appointments.
Execute Overlap Rules: Apply different overlap rules depending on the appointment category.
Enforce Buffer Time Between Appointments: Require a configurable gap before and after appointments to avoid tight scheduling.

Hide Specific Days

All Platforms
Planned

You will be able to hide specific days in week and month views, for example, weekends or custom day sets.

UI/UX and API Enhancements

TreeView — Prevent Selection for Disabled Nodes

All Platforms
In Development

With v26.1, you will be able to prevent recursive selection state changes for disabled TreeView nodes.

We will also add the ability to expand/collapse disabled parent nodes.

Application-Wide Date Formats

All Platforms
Planned

We will introduce new APIs designed to specify a single date format for all DevExtreme components within your application.

Globalization — Separate Text and Date/Number Locales

All Platforms
Planned

In v26.1, 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:

DataGrid/TreeList

Scheduler

Form

Popup / Popover / Tooltip

RadioGroup

We will also improve color schema in our Material themes to comply with accessibility contrast requirements.

Additionally, in v26.1, we expect to introduce screen reader support for Rich Text Editor for ASP.NET Core.

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

Migration Away from CommonJS

All Platforms
Planned

As part of our ongoing modernization efforts, we will eliminate use of CommonJS. We plan to remove all CommonJS modules and imports in DevExtreme packages and source code. This change will optimize DevExtreme package size.

Please share your thoughts on this transition in the survey below. Your feedback will help us identify potential migration challenges and make the transition as smooth as possible.

Angular 22

Angular
Planned

The release of Angular 22 is planned for May 2026. As part of our commitment to same-day support for new versions, DevExtreme v26.1 will offer full compatibility once Angular 22 is available.

According to Angular's official support schedule, Angular 19 will reach end-of-support in May 2026. With v26.1, we will also update our minimum supported Angular version to 20.

ASP.NET Core

UI Template Kit Update

ASP.NET Core
In Development

DevExpress UI Template Kit includes application templates for ASP.NET Core. The templates help you start new projects quickly (templates address predefined application usage scenarios, which you can tailor to meet specific business requirements).

In our upcoming v26.1 release, ASP.NET Core application templates will be more flexible, with a built-in navigation area and a set of pre-configured views (with controls such as DataGrid).

Your Feedback Matters

Blazor — June 2026 Roadmap (v26.1)

Slava Khudyakov (DevExpress) — Tue, 24 Feb 2026 08:30:00 Z

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.

Blazor 2026 Strategy

As you will see below, we expect to continue extending the capabilities of individual components — but we also want to invest in larger initiatives that span multiple release cycles.

Many of these initiatives require foundational work (architecture, styling infrastructure, interaction layers, and design-system alignment) before we can commit to a specific release or prepare a complete feature list. Some of this work will not be delivered in the first half of the year (including v26.1).

Even with our evolving objectives, we want to be transparent about what we are focusing on, why some details are not available yet, and what direction we hope to move toward over time.

Styling and Layout Foundations

We want DevExpress Blazor components to address more UI needs out of the box, so you can build cohesive layouts with minimal custom CSS.

Historically, many apps relied on Bootstrap utility classes and layout patterns as the primary styling foundation. Bootstrap is still available, but it does not match modern theme requirements (for instance, misses runtime-configurable accent colors).

Our direction is to create theme-aware styling alternatives so you do not need to recreate these fundamentals yourself. We are exploring:

DevExpress CSS helper classes for common spacing/layout patterns.
Lightweight "primitive" components for element composition (for instance, Card, Badge, Avatar).

We also plan to reduce the amount of fine-tuning needed for complex layouts (alignment, consistent spacing, border/background treatments), especially when size mode can change at runtime. Our goal is to improve visual defaults and introduce new layout-focused settings. These settings will allow you to implement common layouts using component APIs, theme-aware patterns, and helper classes mentioned above.

Finally, we’ll build demos and project templates that recreate popular app layouts without custom styling.

Classic Theme Deprecation

Blazing Berry, Office White, Purple, Blazing Dark, and Bootstrap-based themes use an old architecture, are hard to maintain, and do not support new styling capabilities (accent colors, public CSS variables, and our UI Kit). We want to focus our efforts on new styling architecture and gradually move away from classic themes.

We plan to make this transition carefully. Before we deprecate any classic theme, we will prepare viable alternatives, publish clear migration guidance, and give you enough time to move at your own pace.

New Themes

We want to expand our modern theme lineup (starting with Fluent) and evolve our styling infrastructure. Theme directions that we are currently considering:

Material — a frequent request, and a good fit for teams building hybrid solutions that mix UI stacks (including DevExtreme).
A classic-inspired modern theme — a longer-term option for customers who prefer a look closer to our classic themes.

If you have strong preferences on one or the other, we would like to hear your thoughts (please submit a support ticket via the DevExpress Support Center at anytime).

Icon Library

We plan to make our DevExpress Icon Library available to Blazor developers and expand it with new icons. We also expect to introduce a new API that will simplify icon usage for built-in/custom icons, across multiple themes and size modes.

RTL Support

Right-to-left (RTL) support is an important direction for us and for many of you. We are researching RTL requirements across our Blazor component suite and do preliminary work so components behave more consistently in RTL mode (layout, alignment, and interaction patterns).

We do not expect RTL support to be available in v26.1, but we will work on it throughout this year.

Performance

We made significant performance improvements in 2025, and still performance remains an ongoing investment area. We plan to continue researching and testing optimizations across our Blazor component suite. Our focus areas include:

Memory throughput and performance under a large number of concurrent sessions.
Reducing Blazor logical and visual tree size.
Reducing the number of WebSocket messages per interaction.

Once new optimizations are ready, we will add more info to this roadmap.

Security

Security is a core requirement for our components. We already use secure development practices, including automated security scans/reviews. We plan to continue strengthening this process, conducting even more penetration tests, and publish a software bill of materials (SBOM) for DevExpress Blazor.

Accessibility

Accessibility is another key focus area for us. We will continue delivering fixes and improvements across DevExpress Blazor components (keyboard navigation, semantics/ARIA, and visual states).

We’d like your feedback on these strategic directions before we lock in detailed plans:

Which directions are most important for you in 2026?
Are we missing any strategic areas?
Do you have concerns about tradeoffs (for example, themes vs. component features)?
Any general comments on the strategy or where we should focus first?

Product Plans

Our mid-year Blazor 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.1 — Will be available in our first v26.1 early access preview.
Coming in v26.1 — Will be included in the final v26.1 release.
Released in v26.1 — Fully implemented and available.

Accessibility Enhancements

Improvements and fixes for our Blazor Data Editors
Screen reader support for the Blazor Rich Text Editor

Blazor Smart Paste

Planned

We expect to add AI-powered Smart Paste functionality in v26.1.

Smart Paste will analyze clipboard content and populate each form field with relevant data (to transform traditional copy-and-paste operations).

Blazor Grid & TreeList

Focus Cells

Planned

DevExpress Blazor Grid and TreeList components will support focused cell highlighting. While these components already display focus borders during keyboard navigation, this feature adds a new highlight layer for the active cell (both when users navigate with the keyboard or select a cell with the mouse).

We will also introduce APIs to identify the focused cell, move focus to a specific cell, and react to focused cell changes.

Planned

DevExpress Blazor Grid and TreeList components will display the total number of records in the Pager to improve data navigation clarity.

Planned

We expect to add built-in toolbar items to the DevExpress Blazor Grid and TreeList components. Built-in items will include:

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

Planned

We hope to introduce a Criteria Selector Menu for our Blazor Grid and TreeList Filter Row. This menu allows users to select filter conditions directly within the row editor and apply them to the entered value.

Filter Row — Bind Filter On Input Option

Planned

Filter Row Data Editors will support on‑input data binding mode. In this mode, DevExpress Blazor Grid and TreeList components apply filters as users type (no need to press Enter).

UI/UX Enhancements

Vertical Grid Line Visibility

Planned

We will add an option to hide column lines (vertical separators between adjacent columns) in our Blazor Grid and TreeList components.

Striped Rows

Planned

We plan to introduce an option to highlight alternating (odd) rows in our Blazor Grid and TreeList with a different style (to enhance readability).

Planned

DevExpress Blazor Grid and TreeList will support on‑hover display mode for Filter Menu buttons. When enabled, buttons will appear after users hover over column headers. This mode helps create a cleaner UI and avoid column caption truncation.

Custom Row Height

Planned

In v26.1, you will be able to specify a minimum row height for the DevExpress Blazor Grid and TreeList. This new option allows you to adjust visual density by increasing/decreasing row spacing and gives you more control over row appearance.

Blazor TreeList — Unbound Columns

In Development

We plan to introduce unbound column support for the DevExpress Blazor TreeList component. Unbound columns display values that are not stored in the underlying data source. Our TreeList can calculate these values on the fly or derive them from other fields. Use unbound columns to display supplementary/computed data without modifying the original data model.

Blazor Data Editors

TextBox — Password Button

Planned

v26.1 will include a built‑in button that displays/hides a password within the DevExpress Blazor TextBox editor. This button allows users to verify text they have entered.

SpinEdit & MaskedInput — Disable Arrow Keys

Planned

Both DevExpress Blazor SpinEdit and MaskedInput components will allow you to prevent a change to values when users press Up/Down arrow keys.

MaskedInput — Disable Mouse Wheel

Planned

Our Blazor MaskedInput will allow you to prevent a change to values when users scroll the mouse wheel. This option prevents accidental modifications during page/content scrolling.

Focusable Custom Buttons

Our Blazor Data Editors will include a new Focusable option for custom buttons. Once activated, users can interact with custom buttons using the keyboard.

Blazor FormLayout

New Caption Position Mode

Planned

We expect to extend the CaptionPosition property with a new Auto mode. In this mode, Form Layout will automatically switch the caption to a vertical position when horizontal space is insufficient. This behavior matches the current implementation of the Horizontal mode.

With this update:

Auto becomes the new default caption position and enables automatic switching based on available space.
Horizontal mode will no longer change caption position and will always display captions horizontally, regardless of layout constraints.

API Enhancements

Planned

The DevExpress Blazor FormLayout component will include the following new API members:

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

Blazor Dialog Service - Content Template

Planned

We hope to add a content template option for message dialogs displayed via the DevExpress Blazor Dialog Service. This option will allow you to customize the dialog body: format message text, add links, or display additional interactive elements.

private async Task OpenConfirmDialogAsync() {
    Result = await DialogService.ConfirmAsync(new MessageBoxOptions() {
        ContentTemplate = @<div>
            <p>Are you sure you want to delete this record?</p>
            <p><b>This action cannot be undone.</b></p>
        </div>,
        OkButtonText = "Yes",
        CancelButtonText = "No",
        RenderStyle = MessageBoxRenderStyle.Danger,
    });
}

Planned

We plan to extend Data Mapping APIs available for DevExpress Blazor TreeView, Accordion, Menu, and Toolbar components. New APIs will allow you to implement more business scenarios using data binding (instead of static Razor markup).

Use cases include:

Build navigation from a shared model (for instance, a sitemap or route list).
Display/hide items based on permissions/flags.
Generate hierarchical structures (groups, child items) based on data.

<DxTreeView Data="@Data">
    <DataMappings>
        <DxTreeViewDataMapping Text="Name"
                               Key="Id"
                               BadgeText="Badge"
                               ParentKey="CategoryId"/>
    </DataMappings>
</DxTreeView>

Accordion — Cache Collapsed Content

Planned

The DevExpress Blazor Accordion will allow you to cache collapsed group content. When caching is active, the Accordion retains collapsed content and does not need to recreate it once the group is expanded.

This feature is useful for groups containing complex UI content that is costly to re-initialize (for instance, Forms with validation, Charts, or Data Grids).

Blazor Pivot Table

Server Mode

In Development

We expect to support Server Mode in the DevExpress Pivot Table component. In this mode, the Pivot Table retrieves data on demand and executes grouping, filtering, and summary calculations on the server. Server‑side data processing optimizes performance when working with large datasets and complex filters.

Drill‑Down Support

Planned

We plan to support drill‑down scenarios in the DevExpress Blazor Pivot Table. Drill‑down allows you to retrieve the underlying records used to calculate a specific summary value. This capability is useful when you need to examine the data behind aggregated results.

New APIs will include:

CellClick — Provides access to the underlying data of the clicked cell.
CreateDrillDownDataSource(options) — Returns a drill‑down data source.

You will be able to bind underlying data to our Blazor Grid component and allow users to review detailed records within the same page.

Blazor Themes

Fluent Themes — High Contrast Mode

In Development

DevExpress Blazor Fluent themes will support high contrast mode in our June release. They will automatically modify colors if Windows high contrast mode is active.

Blazor Reporting

Learn more: Reporting & BI Dashboard — June 2026 Roadmap (v26.1)

Your Feedback Matters

WinForms — June 2026 Roadmap (v26.1)

Alexander Russkov (DevExpress) — Tue, 24 Feb 2026 04:00:00 Z

First and foremost – thank you for placing your trust in our component suite. We appreciate the opportunity to serve your development needs now and into the future. This blog post outlines some of our WinForms-related development plans for the second half of 2026 (v26.2). As always, you can expect other additions across our entire range of WinForms controls and components once we officially ship v26.1.

We welcome your feedback - Please feel free to share your thoughts in the survey at the end of this post or submit a support ticket via the DevExpress Support Center.

Security

Secure code starts with a safe development environment. In addition to static code analysis and on-going security reviews, we are expanding our internal security diagnostics (including custom analyzers) across our engineering workflows to further strengthen our security posture.

While these enhancements are not exposed as standalone features within the DevExpress component suite, they directly contribute to the reliability of our product libraries - a critical priority in today’s threat landscape.

Fluent Icons

With v26.1, we expect to introduce a comprehensive set of Fluent icons to our suite. To simplify migration to these new icons, you will be able to switch the icon set across all DevExpress controls via a single global setting. Our new collection will include thousands of Fluent icons which can be used in any UI element with SVG support.

Localization Tool Enhancements

In v25.2, we released a new Localization Tool as a Community Technology Preview (CTP). With v26.1, we plan to ship it officially. Our Localization Tool will offer enhanced collaboration capabilities, easier resource navigation and management, AI-powered translation services, support for multiple DevExpress products and platforms, and more.

We also expect to add the following enhancements:

Filter localization strings based on referenced DevExpress assemblies.
Automatically load base localization resources - you will no longer need to download them from a GitHub repository manually.

DateTimeOffset Core Support

We are initiating support for DateTimeOffset across our product line. We will start with core DevExpress classes, including criteria operators and data processing modules.

Our goal is to eliminate manual conversion of DateTimeOffset to DateTime when working with local time zones. You will be able to specify the required 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).

As a first step, DateTimeOffset support will allow you to use date/time-related functions (such as AddHours, GetDays, DateDiffDays, and others) in filter expressions and unbound columns.

We are not planning DateTimeOffset-related updates for UI components as a part of v26.1. Specifically, we do not expect to add date-specific filtering options to column filter popups or enable DateTimeOffset editing in Date Edit.

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

Microsoft documentation recommends DateTimeOffset instead of DateTime when representing a single point in time, performing date/time arithmetic, and preserving related times:

These uses for DateTimeOffset values are much more common than those for DateTime values. As a result, consider DateTimeOffset as the default date and time type for application development.

AI Agents API

We are building an abstraction layer over multiple AI engine implementations. You'll be able to use both IChatClient and Microsoft Agent Framework with DevExpress AI Chat Control.

Microsoft Agent Framework allows you to define agents with custom rules, instructions, and tools. Agents can then execute multi-step tasks based on user requests.

AI Chat Enhancements

We plan to introduce a set of small but useful APIs to help customize the DevExpress AI Chat Control. For example, new properties will allow you to specify the text displayed in an empty chat view and in an empty text input field.

MemoEdit — Automatic Scrollbar

The DevExpress MemoEdit control will automatically hide the scrollbar when text height does not exceed control bounds. You will be able to control this behavior via an option.

Monaco-Based Code Editor (Example)

As you may know, Monaco Code Editor is an open-source editor used in Visual Studio Code. It includes IntelliSense, supports multiple built-in languages, allows you to define custom syntax, and more.

We will create a comprehensive example of Monaco Editor integrated into a WinForms application with DevExpress Skins. The example will mirror the most important web APIs at the C# level, so you won't need to use JavaScript for common usage scenarios.

Spreadsheet — New Excel Functions

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

XLOOKUP
XMATCH
SORT
FILTER
UNIQUE

Reporting

Accessibility & Export Compliance

DOCX/HTML Export — AccessibleDescription Support

Organizations subject to WCAG 2.2 and Section 508 requirements will be able to include meaningful alternative text for all embedded images and graphical elements in exported Word documents and HTML pages. With v26.1, DevExpress Reports will apply a report control's AccessibleDescription property value to DOCX and HTML export output. This capability is especially relevant for controls exported as images, such as XRPictureBox, XRBarCode, XRShape, and XRChart, where assistive technologies rely on alternative text to describe visual content.

PDF/UA Export Enhancements

Government agencies and enterprises that must comply with PDF/UA standards will benefit from extended PDF export capabilities in v26.1:

XRRichText content will use proper semantic tagging and group continuous text into logical paragraphs instead of word-by-word <P> tags.
The AccessibleDescription property will apply to PDF signatures and AcroForm controls so that digitally signed or form-enabled PDF documents meet accessibility requirements.
XRPageInfo controls will support paragraph-level semantic markup.

Data Source Enhancements

DateTimeOffset Support

Applications that store time zone-aware timestamps (such as financial transaction logs, audit trails, and event scheduling systems) require DateTimeOffset support to preserve the original offset for accurate data representation. With v26.1, our Report Designer's Field List will display DateTimeOffset fields and allow data binding, filter, group, and sort operations across SqlDataSource, EFDataSource, and ObjectDataSource.

End-User Experience

WinForms End-User Report Designer — Startup Optimization

We will optimize the DevExpress WinForms End-User Report Designer's startup sequence to deliver a smoother and more responsive launch experience. Dock panels and UI elements will appear quickly on initial load, and transitions between the Design and Preview tabs will be rendered seamlessly.

XRLabel & XRPanel — Custom Border Styles Example

Invoice layouts, financial statements, and reports with visually distinct section separators often require independent border configuration per side. We will extend the How to Create a Custom DevExpress Report Control GitHub repository with a new example that demonstrates custom XRLabel and XRPanel controls. These custom controls will allow you to define distinct border styles and width for top, bottom, left, and right sides independently.

IDE Integration

DevExpress Report Designer for JetBrains Rider — .NET Projects Support

In v25.2, we introduced the DevExpress Report Designer for JetBrains Rider with .NET Framework support. In v26.1, we will extend this integration to .NET-based projects. We also expect to deliver property search and reset in the Properties panel and light/dark theme support to match the JetBrains Rider IDE.

AI-powered Enhancements

AI Prompt-to-Report Wizard — Optimization

We will optimize the AI Prompt-to-Report Wizard to allow users to input shorter prompts and achieve more consistent, production-ready report output. The updated implementation will use a multi-agent workflow and will also reduce token consumption per report generation request.

Report Designer — AI-powered Chat Assistant

Our DevExpress WinForms End-User Report Designer includes an AI Assistant panel that allows users to add, remove, and modify report elements, properties, and data bindings using natural language commands. In v26.1, we will extend this capability to our Web and WPF Report Designer components and add the following features:

Built-in tools that enable AI to search relevant end-user documentation
Wizards that can be launched via AI commands
Enhanced interaction with the designer environment

Stay tuned for updates as development continues.

AGENTS.md for AI Coding Assistants

Developers who use AI-powered code completion tools will obtain more accurate and context-aware suggestions when they work with DevExpress Reports. We will create an AGENTS.md file that equips AI coding assistants, such as GitHub Copilot and Cursor, with DevExpress Reports expertise. The file will contain API patterns, expression syntax rules, common report creation scenarios, troubleshooting guides, and best practices.

Your Feedback Matters

Reporting & BI Dashboard — June 2026 Roadmap (v26.1)

Dmitry Tokmachev (DevExpress) — Mon, 23 Feb 2026 23:30:00 Z

Thank you for choosing DevExpress Reports and DevExpress BI Dashboard for your software development needs. Our June 2026 release (v26.1) will include features designed to advance AI-powered report design workflows, extend accessibility and export compliance, strengthen security, and enhance BI Dashboard customization and platform integration.

Once you've had the opportunity to review our v26.1 roadmap, please share your feedback, requirements, and/or questions using the DevExpress Support Center discussion links below.

Roadmap Updates

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

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

Reporting

Accessibility & Export Compliance

DOCX/HTML Export — AccessibleDescription Support

All Platforms
In Development

PDF/UA Export Enhancements

All Platforms
In Development

Government agencies and enterprises that must comply with PDF/UA standards will benefit from the following extended PDF export capabilities in v26.1:

XRRichText content will use proper semantic tagging and group continuous text into logical paragraphs instead of word-by-word <P> tags.
The AccessibleDescription property will apply to PDF signatures and AcroForm controls so that digitally signed or form-enabled PDF documents meet accessibility requirements.
XRPageInfo controls will support paragraph-level semantic markup.

Web Reporting — Accessibility Improvements

Blazor ASP.NET Core Angular React
Planned

We will continue to enhance keyboard navigation and screen reader support in our DevExpress Web Report Viewer. Users who rely on assistive technologies will experience more consistent navigation, predictable focus management, and reliable interaction across DevExpress web-base Reporting components.

Data Source Enhancements

DateTimeOffset Support

All Platforms
Planned

End-User Experience

WinForms End-User Report Designer — Startup Optimization

WinForms
Planned

We will optimize the DevExpress WinForms End-User Report Designer's startup sequence to deliver a responsive launch experience. Dock panels and UI elements will appear quickly on initial load, and transitions between Design and Preview tabs will produce seamless panel rendering.

XRLabel & XRPanel — Custom Border Styles Example

All Platforms
Planned

Web Report Designer Overhaul

Blazor ASP.NET Core ASP.NET WebForms ASP.NET MVC Angular React
In Development

We will continue our comprehensive revamp of the DevExpress Web Report Designer to phase out the Knockout.js library and implement a new public API without KO. This transition will enhance performance and maintainability of the control, and aligns with our long-term plan to introduce native Angular and React components for seamless integration with modern web solutions.

Security Enhancements

All Platforms
In Development

We will continue to strengthen security across APIs and product components to ensure that both Reporting and BI Dashboard comply with the highest security standards. These updates align with current industry best practices and address evolving security requirements.

IDE Integration

DevExpress Report Designer for JetBrains Rider — .NET Projects Support

JetBrains Rider .NET
In Development

In v25.2, we introduced the DevExpress Report Designer for JetBrains Rider with .NET Framework support. In v26.1, we will extend this integration to .NET-based projects and deliver property search and reset in the Properties panel, along with light/dark theme support to match the JetBrains Rider IDE.

AI-powered Enhancements

WPF Report Designer — AI-powered Expressions

WPF
In Development

DevExpress WPF Report Designer will support expression generation via natural language queries, and will match the AI-powered expression capabilities already available in our WinForms and Web Report Designer. Report creators can describe the desired logic in plain text, and the AI assistant will generate appropriate expression syntax. This update will deliver AI-powered expression parity across all supported desktop and web platforms.

AI Prompt-to-Report Wizard — Optimization

WinForms WPF ASP.NET Core Blazor
In Development

We will optimize the AI Prompt-to-Report Wizard so that users can input shorter prompts and produce more consistent, production-ready report output. Our updated implementation will use a multi-agent workflow and reduce token consumption per report generation request.

Web and WPF Report Designer — AI-powered Chat Assistant

WinForms WPF ASP.NET Core Blazor
Planned

Our WinForms End-User Report Designer includes an AI Assistant panel that allows users to add, remove, and modify report elements, properties, and data bindings using natural language commands. In v26.1, we will extend this capability to our Web and WPF Report Designer components and add the following new features:

Built-in tools that enable AI to search relevant end-user documentation
Wizards that can be launched via AI commands
Enhanced interaction with the designer environment

Stay tuned for updates as development continues.

AGENT.md for AI Coding Assistants

Visual Studio Code Cursor GitHub Copilot Claude Code
Planned

Developers who use AI-powered code assistant tools will receive more accurate and context-aware answers when they work with DevExpress Reports. We will create an *.agent.md file that equips AI coding assistants, such as GitHub Copilot in Visual Studio and Cursor, with DevExpress Reports expertise. The file will contain API patterns, expression syntax rules, common report design examples, troubleshooting guides, and best practices.

BI Dashboard

Accessibility

ASP.NET Core ASP.NET WebForms ASP.NET MVC Blazor Angular React
Planned

We will continue to improve accessibility across BI Dashboard components. v26.1 will introduce color-blind friendly palettes for chart visualizations, adjusted spacing between pie/donut elements for better visual separation, and continued fixes for keyboard navigation and screen reader support across dashboard item content, toolbar button states, and interactive elements.

Data Source Enhancements

DateTimeOffset Support

All Platforms
Planned

DevExpress BI Dashboard will support DateTimeOffset field types so that dashboard creators can bind widgets to DateTimeOffset data fields, apply filter, group, and sort operations, and display these values correctly in the Field List. This extends the DateOnly and TimeOnly support introduced in v25.1 and makes the BI Dashboard compatible with data sources that store time zone-aware timestamps.

Customization

Cards — Text and Icon Customization

All Platforms
Planned

KPI cards and summary panels will deliver richer visuals with custom text and icon settings. Dashboard creators will be able to customize text appearance within Card items, including font style and size. Cards will also support icon display. For example, a KPI card will be able to display a custom icon alongside a metric value with a specific font size to match organizational branding guidelines.

Dashboard Items — Margin and Padding Control

All Platforms
Planned

Fine-grain spacing control allows dashboard creators to achieve tighter or more spacious layouts for each individual item. We will add item-level padding and margin properties to dashboard items, with support for both uniform and individual side settings. Kiosk displays that require maximum data density and executive dashboards that benefit from generous whitespace can use these controls to achieve the desired layout.

Platform Integration

Blazor Dashboard — SignalR Transport

Blazor
Planned

Developers who register custom scoped services (such as multi-tenant data filters or user-specific security providers) will benefit from consistent service lifetimes across both Blazor pages and Dashboard backend operations. We plan to transition the Blazor Dashboard from traditional HTTP requests to SignalR-based transport for server communication. This change will allow scoped Blazor services registered within a SignalR circuit to function correctly with Dashboard controllers.

Your Feedback Counts

We value your input and encourage you to share your thoughts on these upcoming features. Your feedback will help us prioritize development efforts and ensure that our products continue to meet your evolving needs.

Contact us via the DevExpress Support Center at your convenience. We'll be happy to follow up and discuss how these enhancements can benefit your specific use case.

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

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

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

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

Roadmap Updates

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.1 — Will be available in our first v26.1 early access preview.
Coming in v26.1 — Will be included in the final v26.1 release.
Released in v26.1 — Fully implemented and available.

Safe Word & Excel Document Processing

In Development

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

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

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

Document Processing Libraries for JAVA

In Development

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

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

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

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

PDF Processing

New PDF Processing API

In Development

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

These new capabilities will allow you to:

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

PDF/UA-2 Export

Planned

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

PDF/A-4 Export

Planned

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

Excel Spreadsheet API

Excel to PDF/UA Conversion Enhancements

Planned

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

New Excel Functions

In Development

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

XLOOKUP
XMATCH
SORT
FILTER
UNIQUE

Presentation API

Charts

In Development

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

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

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

Export Slides to Images

Coming in EAP v26.1

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

BMP
PNG
JPEG
EMF
SVG
And more

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

Your Feedback Counts

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

WPF — June 2026 Roadmap (v26.1)

Alexander Russkov (DevExpress) — Mon, 23 Feb 2026 02:00:00 Z

Thank you for choosing DevExpress and for your on-going support. We value your business.

In this blog post, I’ll highlight WPF-related features/capabilities we expect to ship in our upcoming mid-year release (v26.1, June 2026).

As always, if you have questions or suggestions, feel free to share your thoughts in the survey at the end of this post or submit a ticket via the DevExpress Support Center.

New WPF Fluent Theme (CTP)

We are working on a new Fluent Theme built on a flexible design token–based architecture. This foundation is designed to unlock a number of key benefits across our WPF product line, including:

Enhanced appearance
Support for Mica material
Flexible resource management and built-in palette customization
Multiple UI density modes
System high-contrast support
Centralized global font settings

Not all of the features listed above will be available in v26.1, and final scope may change as development progresses. In v26.1, we plan to introduce the new Fluent Theme for a subset of WPF controls as part of an initial Community Technology Preview (CTP).

By adopting a design token–driven approach, we can deliver new themes more efficiently in the future and ensure a unified visual language across multiple product lines. For example, in DevExpress-powered Blazor Hybrid applications, Blazor and WPF views will share a "common" look and feel based on the same Fluent theme.

WPF Fluent Icons

With v26.1, we expect to ship a comprehensive set of Fluent icons. To simplify migration to these new icons, you will be able to switch the icon set across all DevExpress controls using a single global setting. Our new collection will include thousands of Fluent icons which can be used in any UI element with SVG support.

WPF Grid Control

Column Drag & Drop Customization Events

We expect to introduce a new event to control which drag-and-drop operations are permitted for WPF Grid Control columns. This capability will address the following usage scenarios:

Prevent a column from being dropped at specific positions
Disable column reordering while still allow columns to be dragged out of the Grid or into the Column Chooser
Enforce fixed grouping order (for example, ensuring a specific column always has GroupIndex = 0)

You will be able to customize any column drag operation based on comprehensive information about the dragged column and the target area:

private void TableView_ColumnDragOver(object sender, ColumnDragOverEventArgs e) {
    if (e.TargetArea == HeaderArea.ColumnHeader) {
        e.Cancel = true;
    }

    // e.TargetArea
    // e.TargetIndex
    // e.SourceColumn
    // e.SourceIndex
    // e.SourceArea
    // ...
}

Expression Editor Support for Custom Format Conditions

With v26.1, users will be able to create advanced conditional formatting rules via custom expressions. This enhancement will allow users to define complex logic (such as [Created Date] > AddDays(LocalDateTimeToday(), -3) ) as requirements dictate (as you would expect, this feature/capability will offer increased flexibility when constructing formatting rules that rely on calculated values, functions, or advanced comparisons).

Dependency Injection Enhancements

With v26.1, we hope to enhance Dependency Injection (DI) support in our MVVM framework. We will introduce a new XAML markup extension that instantiates view models using a globally configured DI container:

var host = RegisterServices().Build();
IocServiceProvider.Default.ConfigureServices(host.Services);

<Window DataContext="{dxmvvm:Ioc Type={Binding ViewType}}" />

In addition, DevExpress MVVM services will automatically resolve views from the DI container during navigation. For example, in code below, HomeView will be created with IDataService and ILogger dependencies if they are registered in the container:

public class MainViewModel {
    private INavigationService NavigationService {
        get { return this.GetService<INavigationService>(); }
    }

    public void OnViewLoaded() {
        NavigationService.Navigate("HomeView", null, this);
    }
}

public class HomeView {
    public HomeView(IDataService dataService, ILogger logger) {
        //...
    }
}

Prompt to Expression in Filter Editor and Expression Editor

We will add AI-powered expression generation to our WPF controls to help users create filter and unbound column expressions for data-aware WPF controls using natural language prompts. Instead of writing complex expressions, users describe the desired logic in plain text. The system will send the prompt to the configured AI service, which will generate an expression for the control.

WPF Charts – DateOnly / Time Only Support

The DevExpress WPF Chart Control will support .NET DateOnly and TimeOnly data types. You’ll be able to use these types to specify arguments, values, workday/work time options, strips, constant lines, and scale breaks, as well as to apply data filters, sorting, and summaries.

WPF Pivot Grid

DateOnly / TimeOnly Support

The DevExpress WPF Pivot Grid will support DateOnly and TimeOnly data types (in .NET applications). You'll be able to use these types with for all data operations, including: filtering, grouping, calculating summaries etc.

Filter Panel Navigation

We plan to enhance the Pivot Grid’s Filter Panel to support keyboard navigation when filters are applied. Users will be able to navigate to the Filter Panel to remove individual filter nodes or modify the entire filter.

This enhancement will help applications that use DevExpress Pivot Grid meet WCAG Keyboard (Level A) accessibility requirements.

Template Kit Enhancements

We plan to extend DevExpress Template Kit support to include Visual Basic templates:

In addition, we expect to introduce usability updates (such as search) to simplify navigation across our extensive template library.

WPF TreeList – Performance Optimization

The DevExpress WPF TreeList will operate much faster when data is updated with a custom filter applied (via the CustomNodeFilter event). We have identified a performance bottleneck in this usage scenario and found a way to eliminate it. Internal testing demonstrates speed gains of up to ~85%.

WPF AI Chat Control Enhancements

WPF Spreadsheet

Screen Reader Support

To help meet accessibility standards, we’re beginning work on screen reader for the DevExpress Spreadsheet. As you'd expect, this feature will allow users to access document content via screen readers, such as Narrator and NVDA.

New Excel Functions

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

XLOOKUP
XMATCH
SORT
FILTER
UNIQUE

WPF Reporting

Accessibility & Export Compliance

DOCX/HTML Export — AccessibleDescription Support

PDF/UA Export Enhancements

Government agencies and enterprises that must comply with PDF/UA standards will benefit from the following PDF export capabilities in v26.1:

XRRichText content will use proper semantic tagging and group continuous text into logical paragraphs instead of word-by-word <P> tags.
The AccessibleDescription property will apply to PDF signatures and AcroForm controls so that digitally signed or form-enabled PDF documents meet accessibility requirements.
XRPageInfo controls will support paragraph-level semantic markup.

Data Source Enhancements

DateTimeOffset Support

Applications that store time zone-aware timestamps, such as financial transaction logs, audit trails, and event scheduling systems, require DateTimeOffset support to preserve the original offset for accurate data representation. With v26.1, the Report Designer's Field List will display DateTimeOffset fields and allow data binding, filter, group, and sort operations across SqlDataSource, EFDataSource, and ObjectDataSource.

XRLabel & XRPanel — Custom Border Styles Example

IDE Integration

DevExpress Report Designer for JetBrains Rider — .NET Projects Support

In v25.2, we released the DevExpress Report Designer for JetBrains Rider with .NET Framework support. v26.1 will extend this integration to .NET-based projects. We also expect to deliver enhancements such as property search and reset in the Properties panel, along with light/dark theme support to match the Rider IDE.

AI-powered Enhancements

WPF Report Designer — AI-powered Expressions

The DevExpress WPF Report Designer will support expression generation via natural language queries, and will match the AI-powered expression capabilities already available in WinForms and Web Report Designer components. Report creators can describe the desired logic in plain text, and the AI assistant will generate the appropriate expression syntax. This update achieves AI-powered expression parity across all supported desktop and web platforms.

AI Prompt-to-Report Wizard — Optimization

We will optimize the AI Prompt-to-Report Wizard so that users can input shorter prompts and generate more consistent, production-ready report output. Our updated implementation will use a multi-agent workflow and will also reduce token consumption per report generation request.

Your Feedback Matters

VCL – June 2026 Roadmap (v26.1)

Dennis Garavsky (DevExpress) — Wed, 04 Feb 2026 10:22:00 Z

The following list outlines features/capabilities we expect to ship for our VCL UI Component Libraries - Delphi & C++Builder (expected release date: June 2026). As you will see, 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 friction in day‑to‑day development tasks 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 v25.2 (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.

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. As you may also know, Embarcadero introduced their own Microsoft UI Automation (UIA) support recently. DevExpress VCL efforts in this area began in 2024 (track our current progress).

Our accessibility strategy continues to be driven by the following principles:

Make our UI components and related software libraries more accessible to 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 significant engineering investment. In 2026, we plan to finalize our main accessibility enhancements for the VCL platform. It may include, but is not limited to better accessibility support in the following components:

Remaining Data Editors and Forms (such as Shells, ListBoxes, Printing System dialogs, etc.) and Data Grid use-cases (like summaries)
Spreadsheet, Rich Text Editor, PDF Viewer, Scheduler
Designers in the ExpressReports/ExpressDashboards products
Pivot Grid, Vertical/Property Grid, Charts, Maps

VCL Reporting and BI Dashboard Enhancements

Following the introduction of the new ExpressReports Suite/VCL Subscription + in mid-2025 and our ExpressDashboards Suite preview in v25.2, VCL v26.1 release plans include the following key initiatives for both Delphi and C++Builder developers:

Expanded Demo and Project Template Coverage

For our customers, this will help everyone get started and improve confidence for production use. For us, it will reduce regressions via additional automated tests. For example, imagine using our new predefined templates/wizards to create a BI-powered application for various data analytics scenarios (master-detail reports, dashboards with charts, gauges, and maps) in a single click. Or you want to create a workflow/scheduled job (a Windows Service or Console application) to export reports to PDF silently, print or email dashboard documents, modify documents (split, merge, filter, Mail Merge, etc.) without any user interaction... We want to have a project template for that too.

Extended Learning Materials

We plan to deliver 10+ additional examples/tutorials for our VCL Reports and Dashboards. If you follow our FAQ updates, you might already see multiple new help topics recently. NOTE: our new v26.1 project templates will simplify database access in general and our getting started tutorials in particular (like VCL Reports - Create a Table Report Using the Report Wizard).

Additional AI-Powered Functions

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

Additional Delphi/C++Builder APIs and Related Usability Enhancements

This will help VCL developers configure/customize dashboards and reports in code easier. A few examples:

Our upcoming v25.2.5 update already includes related enhancements that made non-GUI workflow automation/distributed scenarios possible (a GitHub example: VCL Reports - Generate and Export Report Documents in a Headless / non-GUI Service Application).
Also in v25.2.5+, it is more natural to use TDataSource and its DataSet (a common Delphi-way) with TdxBackendDataSetJSONConnection for ORM-based integrations like RemObjects' Data Abstract (thanks to customer feedback).
In v26.1, we will introduce new OnViewer/DesignerFormShow, OnExport, and other events into TdxReport/TdxDashboard to help developers customize the End-User Report Designer and Print Preview forms easier (for example, to resize forms or make forms non-modal for MDI-based apps).

Some initiatives (especially AI and distributed/workflow service scenarios) depend on cross-team alignment and technical validation to ensure the final experience meets DevExpress quality standards.

High DPI Rendering and Performance Enhancements

VCL v25.2.5+ (and v26.1) introduces noticeable performance-related enhancements for VCL apps running on 4K+ displays.

Form resize performance on Windows 11 and WXI Compact is now 30-35% better for TdxRibbonForm (with rounded corners and other default settings).
Other optimizations to skinned forms and vector‑based UI elements. For example, you may notice that our Mail Client demo forms are rendered 10-20% faster.
Form shadow rendering enhancements. We made a new shadow (TdxWindowFrame), which behaves like the native/system OS shadow, but is 10x faster than our shadow. The new shadow also has a bigger "resize zone" and different display for active/inactive forms. The new shadow is always used on Windows 11 (and on Windows 10 when the form has square corners). Once again, we thank you for your feedback in this regard.

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

In v26.1, we will start our work on modern Fluent UI support, bringing VCL applications closer to contemporary Windows UI standards inspired by Microsoft Fluent 2 Design System and "new" Microsoft Outlook and Teams apps. Our goal is to allow VCL developers to adopt a more modern visual language progressively, without forcing large‑scale rewrites or breaking existing UI layouts.

Our work will likely continue into v26.2 due to its scope (it also took two majors for our .NET WinForms and WPF platforms - learn more from the roadmap). Planned areas of v26.1 investments include:

Refinements to existing VCL visual elements to better align with Microsoft Fluent UI principles (for example, Outlook-inspired Side Panel, Rounded Skin Panel, Ribbon and Layout control enhancements).
New project and form templates (for the VCL Template Kit)
Updated Mail Client demo or a new Outlook-Inspired Demo (like in WinForms/WPF below).
New Fluent icons with SVG Icon Colorization support

VCL Template Kit - Cut Time to Market with Project and Form Templates

In v26.1, we will introduce a VCL Template Kit designed to quickly create common VCL application types and frequently used UI forms. This new Template Kit will include both project templates and form templates, allowing you to scaffold complete applications or add new forms and modules to existing projects in just a few steps. Very similar to its DevExpress .NET counterpart, the VCL Template Kit is intended to address typical business app usage scenarios (such as data‑centric forms, master‑detail layouts, and common navigation patterns) and will evolve over time based on customer feedback throughout 2026.

Our goal with this initiative is to:

Reduce time spent on repetitive project and form setup (for example, 1-2 clicks instead of minutes-hours).
Encapsulate DevExpress VCL best practices introduced in recent releases (for example, accessibility, a global Skin Controller and vector skins, a single SVG image list for menu and navigation vs multiple images lists with duplicate images, modern Fluent UI layouts).
Improve onboarding for new VCL developers while boosting productivity for experienced teams (for example, get started with our VCL Reporting and BI Dashboard platforms or DevExpress AI-powered smart functions).

Initial list of templates includes, but is not limited to the following:

Outlook-inspired application (powered by our new Fluent UI Design System and inspired by the "new" Microsoft Outlook)
Reporting Application, BI Dashboard application (with options to select Designer, Viewer and also a file system/database/embedded layout storage, whether to use a separate or embedded backend service, whether to enable AI functions, etc);
Ribbon-based and Toolbar-based application (with options to select a Classic or single-lined ribbon, icon size, etc.);
Data-aware application (options to select data grid, treelist, pivot, chart, etc.).
JavaScript Hybrid VCL application (for example, to integrate an HTML Editor or Syntax Editor components using popular DevExpress or free/open-source JS libs).
Tabbed MDI, Tile, and Wizard application
Middle-Tier Security application (no direct database connection)
Office-inspired application (Word Processing, Spreadsheet, PDF Viewer, Scheduling, Mapping component integrations)
Splash Screens/Wait and Overlay Forms/Loading Panels

VCL Splash Screen Manager - Repeatable and Error-Prone Development Tasks Made Easy

In v26.1, we plan to introduce a VCL Splash Screen Manager (TdxSplashScreenManager) designed to simplify the creation and management of loading forms (aka splash screens, loading panels, wait and overlay forms). This new component will provide a centralized and consistent way to display splash screens during application startup or long‑running operations. As you'd expect, TdxSplashScreenManager API and capabilities will be similar to its .NET WinForms/WPF counterpart (see example code below). Of course, our new VCL Template Kit will include customizable splash form templates, to get started in a few clicks.

The VCL Splash Screen Manager will also reduce boilerplate code and improve maintainability while delivering a polished user experience in data‑centric applications. Even with AI coding assistants today, generating splash screen screens yourself across your application can easily go wrong due to Win32 API or known VCL multi-threading quirks (a real community example). With our new component, VCL developers will no longer deal with low-level window lifecycle (such as main UI thread message loop) and repeatable ad‑hoc logic (such as fade-in and fade-out animations) - they will focus on top-level design and business logic only.

Key goals for the VCL Splash Screen Manager include:

Simplified splash screen design, invocation, progress update and shutdown (with support for background operations/threads)
Better integration with modern VCL rendering in high‑DPI environments (vector skins, animations, multiple appearance options)
Improved consistency across applications that require startup or progress UI (reusable form templates and RAD Studio integration)

BBCode-Inspired Rich Text Formatting for Additional UI Elements

In v26.1, we plan to extend BBCode support across a wider range of VCL UI elements and captions:

Column headers in Data Grid, TreeList, and PivotGrid controls;
Form captions and window headers;
Captions and labels in charts, buttons, and other UI elements;
Screentips and other tooltip‑style UI surfaces.

The goal is to improve visual expressiveness and clarity in data‑centric and information‑dense applications (without introducing custom drawing logic or breaking existing layouts). As with other BBCode‑enabled features, formatting will remain optional and fully backward‑compatible with applications that rely on plain text captions.

RAD Studio vNEXT Support

We will continue to track Embarcadero’s RAD Studio roadmap closely. As new IDE versions and updates become available, v26.1 will include the necessary testing, build pipeline updates, and installer changes required to ensure a smooth development experience for active subscribers. For example, we've already researched the new cool features introduced for Windows desktop development in the latest version of RAD Studio 13.1 (Beta).

VCL Localization Reimagined - Research DevExpress Localization Tool Integration

In v26.1, we will evaluate how modern localization workflows and tooling can be applied to VCL applications. Ideal or final destination is to potentially deprecate the existing VCL Localizer Editor in favor of a new and better DevExpress Localization Tool by v26.2 or so.

Our research goals include:

Assess integration scenarios between VCL controls and the new tool (one and better tool to rule/localize all DevExpress platforms)
Simplify localization workflows and improve translation accuracy and consistency (reuse strings between similar .NET and VCL UI elements)
Ensure long‑term maintainability and backward compatibility for existing customer apps (make an adapter between INI files and the new format)

VCL Office File API - Research User Demand and Technical Feasibility

As you might know, we have a powerful .NET Office File API library for non-visual PDF, Word, Excel, and PowerPoint document processing. These non‑visual Office file format processing APIs are also at the core of many DevExpress Office-inspired UI components such as .NET Rich Text Editors.

For us (internally), it is interesting to further isolate and enhance non-visual VCL Office File APIs (TdxRichEditDocumentServer, TdxPDFDocument, and something from our VCL Spreadsheet component) based on our existing .NET code. Especially when C# to Delphi conversion is now easier with AI. This would potentially simplify visual component maintenance (VCL Rich Text Editor, PDF Viewer, Spreadsheet).

For customers (externally), it can help expand support beyond Windows desktop application types to macOS/Linux/mobile/web ("Hi again, FMX!"). Even for Windows OS only, we are aware of multiple customer requests where non-visual document processing APIs would be helpful in non-GUI/service applications (very similar to what we discussed for VCL Reporting/BI Dashboard above). I hope to finalize this research by the end of 2026.

Your Feedback Matters

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

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

DevExpress Blazor AI Chat — Agent2Agent (A2A) Protocol Integration

Dmitry Tokmachev (DevExpress) — Thu, 08 Jan 2026 01:10:00 Z

Modern AI-powered applications increasingly implement automated functions through specialized AI agents. The statistics show impressive growth: in 2025, 85% of organizations have integrated AI agents into at least one workflow. Users now expect conversational interfaces for various business tasks: customer service automation, personalized shopping assistance, financial transaction management, content creation, and streamlined workflow coordination.

The key distinction between AI agents and working with standard large language models lies in a simple formula: an agent equals LLM plus instructions and tools it can invoke, representing an autonomous system.

Source/Credit: Microsoft Developer YouTube channel.

While LLMs can only generate text, agents extend these capabilities into actionable intelligence by integrating external APIs, accessing databases, managing files, and connecting with enterprise systems. This transforms them from passive text generators into autonomous systems capable of executing complex, multi-step tasks. One of the first agents that was introduced in the industry were ChatGPT plugins that added web browsing and code interpreter capabilities (allowing the LLM to search the Web and execute code while replying to a user query).

In April 2025, Google introduced its Agent2Agent (A2A) protocol — an open standard for standardizing communication between agents. The protocol has gained support from over 150 organizations, including tech giants like Microsoft, Salesforce, SAP, ServiceNow, and Amazon Web Services. The protocol's advantage lies in enabling agents developed by different teams on various platforms to seamlessly exchange information and coordinate actions, creating essentially an "internet of agents" or "agentic web" — similar to how HTTP allowed websites to interact with each other.

The benefits notwithstanding, integrating agents with user interface components presents technical challenges. Agents use structured data exchange formats and support complex task lifecycles, while chat components expect simple text messages and streaming responses. In this article, I describe how to connect the DevExpress Blazor AI Chat component to A2A protocol-compliant agents with a small adapter. The implementation hosts four agents in separate ASP.NET Core servers and switches agents at runtime within a single chat UI. The sample also includes a Researcher agent from the official Microsoft A2A .NET SDK samples to show compatibility with existing agents.

This example focuses on agent connectivity rather than orchestration. The A2A protocol supports advanced inter-agent patterns such as routing, delegation, and task handoffs, but this sample does not implement them. Any A2A-compliant agent can connect to the Blazor AI Chat component with the approach documented here.

Architecture Overview

The solution uses a distributed layout. A shared library defines all agent classes and base types. Four ASP.NET Core projects host Poem, Shakespearean Style, Task, and Researcher agents. Each server runs on its own port and exposes a single A2A endpoint at /agent. A Blazor Server app embeds the DevExpress AI Chat component and talks to agents through IChatClient-based adapters.

Agent Server Apps

Each agent server follows the same pattern. The example below shows a minimal setup that maps the A2A pipeline to /agent and wires an agent to a task manager.

using A2A;
using A2A.AspNetCore;
using Azure;
using Azure.AI.OpenAI;
using A2AAgents.Shared;
using A2AAgentsServer.Agents;
using Microsoft.Extensions.AI;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

TaskManager taskManager = new TaskManager();

var settings = builder.Configuration.GetSection("AzureOpenAISettings").Get<AzureOpenAIServiceSettings>();
if (settings == null || string.IsNullOrEmpty(settings.Endpoint) || string.IsNullOrEmpty(settings.Key) || string.IsNullOrEmpty(settings.DeploymentName))
    throw new InvalidOperationException("Specify Azure OpenAI endpoint, key, and deployment name in appsettings.json.");
var chatClient = new AzureOpenAIClient(new Uri(settings.Endpoint), new AzureKeyCredential(settings.Key))
    .GetChatClient(settings.DeploymentName)
    .AsIChatClient();

var agent = new PoemAgent(chatClient, taskManager);

app.UseHttpsRedirection();
app.MapA2A(taskManager, "/agent");
app.Run();

Shakespearean Style, Task, and Researcher servers use the same structure. They differ by agent type and the port configured in each project's launch settings.

Protocol Compliance Validation with a2a-inspector

All agents pass validation with the a2a-inspector tool. The inspector checks Agent Card metadata, message format, and streaming support, task state signaling for task agents, and protocol version compatibility.

Bridging A2A to IChatClient

The key to this integration is a lightweight adapter that translates between A2A protocol messages and the IChatClient interface used by DevExpress Blazor AI Chat to interact with LLMs. This adapter maintains conversation context, converts chat messages to A2A protocol format, and streams responses back to the UI:

public sealed class MessageAgentChatClient : DelegatingChatClient {
    private readonly A2AClient _agentClient;
    private readonly string _contextId;

    public MessageAgentChatClient(IChatClient innerClient, A2AClient agentClient, string contextId) 
        : base(innerClient) {
        _agentClient = agentClient ?? throw new ArgumentNullException(nameof(agentClient));
        _contextId = $"{contextId}-{Guid.NewGuid()}";
    }

    public override async IAsyncEnumerable<ChatResponseUpdate> GetStreamingResponseAsync(
        IEnumerable<ChatMessage> messages, 
        ChatOptions? options = null,
        [EnumeratorCancellation] CancellationToken cancellationToken = default) {

        var sendParams = new MessageSendParams { 
            Message = CreateA2AMessage(messages) 
        };

        await foreach (var item in _agentClient.SendMessageStreamingAsync(sendParams, cancellationToken)) {
            if (item.Data is AgentMessage message && message.Parts.FirstOrDefault() is TextPart textPart) {
                yield return new ChatResponseUpdate(ChatRole.Assistant, textPart.Text);
            }
        }
    }
    
    private AgentMessage CreateA2AMessage(IEnumerable<ChatMessage> messages) {
            return new AgentMessage() {
                Role = MessageRole.User,
                ContextId = _contextId,
                Parts = [new TextPart() { Text = messages.Last().Text }]
            };
        }
}

Runtime Agent Selection

The app registers each agent as a keyed IChatClient service and switches between them at runtime through a simple dropdown.

// Register each A2A agent as a keyed IChatClient service
builder.Services.AddKeyedScoped<IChatClient>(AgentsEndpoints.PoemAgent, (provider, key) =>
    new MessageAgentChatClient(chatClient, 
        new A2AClient(new Uri(AgentsEndpoints.PoemAgent)), 
        AgentsEndpoints.PoemAgent));

builder.Services.AddKeyedScoped<IChatClient>(AgentsEndpoints.ShakespeareanStyleAgent, (provider, key) =>
    new MessageAgentChatClient(chatClient, 
        new A2AClient(new Uri(AgentsEndpoints.ShakespeareanStyleAgent)), 
        AgentsEndpoints.ShakespeareanStyleAgent));

builder.Services.AddKeyedScoped<IChatClient>(AgentsEndpoints.TaskAgent, (provider, key) =>
    new TaskAgentChatClient(chatClient, 
        new A2AClient(new Uri(AgentsEndpoints.TaskAgent)), 
        AgentsEndpoints.TaskAgent));

builder.Services.AddKeyedScoped<IChatClient>(AgentsEndpoints.ResearcherAgent, (provider, key) =>
    new TaskAgentChatClient(chatClient, 
        new A2AClient(new Uri(AgentsEndpoints.ResearcherAgent)), 
        AgentsEndpoints.ResearcherAgent));

The ChatClientServiceKey property (available with DevExpress v25.1.4) enables runtime switching between multiple IChatClient services.

<DxAIChat @ref="_dxAIChat" 
          UseStreaming="true" 
          ChatClientServiceKey="@CurrentServiceKey"
          CssClass="chat-container" />

<DxComboBox Data="@AgentOptions"
            TextFieldName="nameof(AgentOption.Text)"
            ValueFieldName="nameof(AgentOption.Value)"
            @bind-Value="@CurrentServiceKey" />

Welcome Chat Screen

The EmptyMessageAreaTemplate shows agent descriptions and instructions when the chat is empty. This helps users understand each agent and start a conversation quickly.

<EmptyMessageAreaTemplate>
        <div class="empty-message-area">
            <h4>🤖 Multi-Agent AI Chat</h4>
            <p>Welcome to the Agent-to-Agent communication platform! Choose your specialized AI agent and start chatting.</p>

            <div>
                <h5>Available Agents:</h5>
                <ul class="agents-list">
                    <li><strong>🎭 Poem Agent:</strong> Enter 2-5 keywords and I'll generate a short lyrical poem</li>
                    <li><strong>📜 Shakespearean Style Agent:</strong> Transform your text into William Shakespeare's style</li>
                    <li><strong>📋 Task Agent:</strong> Help plan and execute task descriptions</li>
                    <li><strong>Researcher Agent:</strong> Agent from https://github.com/a2aproject/a2a-dotnet/blob/main/samples/AgentServer/ResearcherAgent.cs </li>
                    <li><strong>💬 Default Chat Client:</strong> Standard AI conversation</li>
                </ul>
            </div>

            <div>
                <p><strong>Current Agent:</strong> <span class="current-agent-badge">@AgentOptions.FirstOrDefault(x => x.Value == CurrentServiceKey)?.Text</span></p>
            </div>

            <p class="help-text">
                <small>💡 Select an agent from the dropdown above, then type your message to start the conversation!</small>
            </p>
        </div>
    </EmptyMessageAreaTemplate>

User Experience

Users can select Poem, Shakespearean Style, Task, or Researcher agents via a dropdown, utilize manual handoffs by copying output between agents to simulate composition workflows, and enjoy streaming responses that preserve the responsive feel of AI interactions. The video below demonstrates project functionality in action:

Your browser does not support the video tag.

Download the Complete Example

To get started with this integration, clone the Blazor AI Chat — Communicate with Agents That Implement Agent2Agent (A2A) Protocol repository from GitHub and configure your AI service provider in appsettings.json:

{
  "AzureOpenAISettings": {
    "Endpoint": "https://your-instance.openai.azure.com/",
    "Key": "your-api-key",
    "DeploymentName": "your-model-name"
  }
}

Configure Agent Endpoints

The AgentsEndpoints class centralizes agent URLs. The app uses HTTP by default and includes HTTPS alternatives as comments.

public static class AgentsEndpoints {
    public const string PoemAgent = "http://localhost:5003/agent";
    public const string ShakespeareanStyleAgent = "http://localhost:5005/agent";
    public const string TaskAgent = "http://localhost:5007/agent";
    public const string ResearcherAgent = "http://localhost:5009/agent";
    // HTTPS alternatives:
    // public const string PoemAgent = "https://localhost:5004/agent";
    // public const string ShakespeareanStyleAgent = "https://localhost:5006/agent";
    // public const string TaskAgent = "https://localhost:5008/agent";
    // public const string ResearcherAgent = "https://localhost:5010/agent";
}

Start the four agent servers first (PoemAgentServer on http://localhost:5003, ShakespeareanStyleAgentServer on http://localhost:5005, TaskAgentServer on http://localhost:5007, ResearcherAgentServer on http://localhost:5009). Wait until each reports that it is listening on its port. Then start the Blazor Server app, select an agent in the UI, and start chatting. You can switch agents at runtime. The implementation supports Azure OpenAI, OpenAI API, and local runtimes like Ollama with minimal changes.

Your Feedback Matters

We're gathering feedback to prioritize future enhancements to our AI agent integration capabilities. Please take a moment to share your experience and help us shape future AI integration features:

Developer Express Inc.

XAF (Cross-Platform .NET App UI & Web API Service) — June 2026 Roadmap (v26.1)

Content Security Policy Enhancements

Template Kit Enhancements

Entity Framework Core 10 for Data Access

DateTimeOffset Type Support for EF Core and XPO

XAF Blazor Report Designer Enhancements

Filter Builder Enhancements and Pivot Grid Integration

Built-In AI Module to Add Smart Functions in "1-Click"

Semantic or Smart Search within DevExpress Data Grids and AI Chat Integration

AI-Powered Smart Paste within the Detail View Layout Control

AI-Powered Extensions in the Reporting, Filter Editor, Office (Rich Text Editor) Modules

Blazor List and Property Editor Enhancements

What's Next / Our Main Focus

We Remain Focused on XAF Blazor Scalability

Migrate Your XAF Apps from .NET Framework (WinForms/WebForms) to .NET (WinForms/Blazor)

Blazor Model Editor in Your Web Browser (Postponed)

First XAF Blazor Scalability Research Results

DevExpress Blazor Component Enhancements (for XAF Blazor)

DevExpress WinForms Component Enhancements (for XAF WinForms)

Other DevExpress Component Enhancements (for XAF Blazor/WinForms)

Your Feedback Matters

New AiGen Functionality in CodeRush for Visual Studio

Improved Context Acquisition & Architectural Awareness

Example: Consolidating Validation Logic Using the Type Hierarchy

Speed Where It Matters: Fine-grained Deltas

Example: Small Business Rule Change Inside a Large Method

Working While AI Is Running: In-Flight Changes & Conflict Navigation

Scenario A: Non-Conflicting Changes -- AI + Human

Scenario B: Parallel, Non-Conflicting Changes -- Multiple AI Agents

Scenario C: Conflicting Changes

Runtime State to Tests: Debug-Time Object Reconstruction

Example: Turning a Debug-Time Bug into a Targeted Test

Large-Scale Architectural Changes: Evolving Interfaces Across Many Implementations

Example: Generating and Evolving Order Rules

Evolving the Contract Across the Hierarchy

Fixing Code Using Active Compiler Errors

Example: Fixing a Real Compiler Error with “Fix this”

What This Update Unlocks

Limitations

DevExtreme — June 2026 Roadmap (v26.1 - Angular, React, Vue, jQuery & ASP.NET Core)

Roadmap Updates

DataGrid & TreeList — AI Assistant

DataGrid & TreeList — Persistent Validation Messages in Editors

Chat Enhancements

Speech To Text

Message Streaming

Tool Call Visualization

Scheduler Enhancements

Appointment Snap Modes

Handle Appointment Time Overlapping

Hide Specific Days

UI/UX and API Enhancements

TreeView — Prevent Selection for Disabled Nodes

Application-Wide Date Formats

Globalization — Separate Text and Date/Number Locales

Accessibility

Migration Away from CommonJS

Angular 22

ASP.NET Core

UI Template Kit Update

Your Feedback Matters

Blazor — June 2026 Roadmap (v26.1)

Blazor 2026 Strategy

Styling and Layout Foundations

Classic Theme Deprecation

New Themes

Icon Library

RTL Support

Performance

Security

Accessibility

Share Feedback on the Strategy

Product Plans

Accessibility Enhancements

Blazor Smart Paste

Blazor Grid & TreeList

Focus Cells

Total Number of Records in Pager

Built-in Toolbar Items