DEV Community: Syncfusion, Inc.

Less Custom Code, Smarter Scheduling: What’s New in Pure React Scheduler 2026 Volume 2

Lucy Muturi — Mon, 13 Jul 2026 11:11:03 +0000

TL;DR: Essential Studio 2026 Volume 2 brings powerful updates to the Pure React Scheduler, including a mobile-friendly Agenda View, time zone support, load-on-demand data loading, resource grouping, and recurring event management. These enhancements help developers build faster, more scalable scheduling applications with less custom code.

Scheduling is one of those features that looks simple at first glance. In reality, once you start dealing with recurring appointments, multiple resources, users across different time zones, or thousands of events, things become significantly more challenging.

The latest enhancements in the Syncfusion^® Pure React Scheduler component are designed to simplify these challenges. Whether you’re building an appointment booking platform, a healthcare scheduling system, a workforce management solution, or an educational calendar application, these updates help reduce custom development effort while improving scalability, usability, and performance.

Let’s explore what’s new in the Essential Studio 2026 Volume 2 release for the Pure React Scheduler and see how these additions can help you create scheduling experiences that are easier to maintain, perform well at scale, and deliver a better experience for users.

See upcoming events faster with agenda view

Traditional calendar layouts work well on large screens, but they can become difficult to navigate on mobile devices or when multiple appointments overlap. Finding the next event often requires zooming, scrolling, or switching between views.

The new agenda view takes a different approach by presenting upcoming appointments as a clean, date-grouped list. Events are arranged chronologically, making it easy to scan what’s coming next without the visual complexity of a traditional calendar grid.

This view is especially useful when users care more about event details than calendar placement.

Designed for everyday scheduling

If you’ve built mobile scheduling screens before, you’ve likely encountered situations where a month or week view becomes cluttered. Agenda view solves that problem by prioritizing readability.

A healthcare application, for example, can display a doctor’s appointments for the day in a simple schedule. Likewise, a sales manager can quickly review meetings without navigating between multiple calendar views.

Why you’ll appreciate it

Optimized for mobile screens and compact layouts.
Displays upcoming events clearly with full details.
Displays appointments in chronological order, grouped by date and sorted by time.
Makes overlapping events easier to review.
Supports configurable date ranges to view single or multiple days.
Supports recurring events seamlessly.
Includes full keyboard accessibility support.

Example

App.tsx

import { Scheduler, EventSettings, AgendaView } from '@syncfusion/react-scheduler'; 
import { fifaEventData } from './dataSource'; 
//Event data imported from the data source file.

export default function App() {
const eventSettings: EventSettings = { dataSource: fifaEventData };
  return (
    <div>
        <Scheduler
            defaultSelectedDate={new Date(2026, 5, 11)}
            eventSettings={eventSettings}
        >
            <AgendaView />
        </Scheduler>
    </div>
  );
}

Refer to the following image.

Agenda view in Pure React Scheduler

Schedule confidently across time zones

Time zones seem straightforward until users begin joining events from different regions. Hard-coded conversions and custom date calculations can quickly become difficult to maintain.

The Scheduler now supports both global scheduler-level time zones and appointment-specific time zones, ensuring events display accurately regardless of users’ locations.

Once configured, time conversions happen automatically, reducing the amount of custom logic developers need to implement.

A practical example

Imagine a product team scheduling a meeting from New York while participants join from London, Singapore, and Sydney. Each attendee sees the meeting in their local time without any manual conversion.

This removes one of the most common sources of scheduling mistakes in distributed teams.

What does this simplify?

Automatically converts appointments between time zones.
Displays accurate start and end times for users worldwide.
Reduces scheduling confusion across regions.
Supports both scheduler-wide and appointment-level configurations.
Simplifies global application development.

Example

App.tsx

import { Scheduler, DayView, EventSettings, MonthView, WeekView } from '@syncfusion/react-scheduler';
import { fifaEventData } from './dataSource';

export default function App() {
    const timezone = 'UTC';
    const eventSettings: EventSettings = {
          dataSource: fifaEventData,
    };
  return (
   <div>
     <Scheduler
      defaultSelectedDate={new Date(2026, 5, 15)}
      eventSettings={eventSettings}
      timezone={timezone}
     >
      <DayView />
      <WeekView />
      <MonthView />
     </Scheduler>
    </div>
  );
}

Pure React Scheduler displaying different time zone options

Keep large schedules responsive with load-on-demand

As scheduling applications grow, performance can quickly become a challenge. Loading large volumes of appointments upfront increases payload size, slows rendering, and consumes unnecessary resources.

The new load-on-demand capability solves this by loading only the events needed for the currently visible date range. As users navigate between dates and views, the Scheduler fetches only the relevant data, keeping the experience fast and responsive.

Two ways to implement it

1. Manual data loading with onDataRequest

The onDataRequest event provides the active view’s start and end dates, allowing you to fetch and return only the events within that range.

2. Automatic loading with DataManager

The Syncfusion DataManager can automatically handle data requests during navigation, view changes, and CRUD actions. It sends the active date range to the server, enabling efficient server-side filtering.

Real-world use case

Consider a university scheduling system containing thousands of classes across multiple departments. Instead of loading the entire schedule, only the events for the current week or month are retrieved, helping the UI remain responsive as data grows.

Performance benefits

Reduces API payload sizes.
Improves rendering speed.
Minimizes memory usage.
Handles large datasets efficiently.
Delivers a faster, more responsive user experience.

Example

App.tsx

import { WeekView, Scheduler, EventSettings } from '@syncfusion/react-scheduler';
import { DataManager, WebApiAdaptor } from '@syncfusion/react-data';

export default function App() {
        const data = new DataManager({
            url: 'https://ej2services.syncfusion.com/react/hotfix/api/schedule',
            adaptor: new WebApiAdaptor(),
            crossDomain: true
        });

        const eventSettings: EventSettings = {
            dataSource: data
        };
        return (
           <div>
            <Scheduler eventSettings={eventSettings}>
                <WeekView />
            </Scheduler>
           </div>
        );
}

Read the full blog post on the Syncfusion Website

Building Smarter .NET MAUI Apps? See What’s New in Syncfusion 2026 Volume 2

Lucy Muturi — Fri, 10 Jul 2026 15:45:05 +0000

TL;DR: The 2026 Volume 2 release brings major enhancements to .NET MAUI, including multi-agent AI AssistView experiences, conversation management, advanced chart visualization, DataGrid productivity improvements, built-in filtering, and TreeView checkbox support. These updates help you build more intelligent, data-driven, and user-friendly cross-platform applications with less custom code and better user experiences.

Modern applications are evolving rapidly, with growing demand for AI-powered experiences, interactive data visualization, and productivity-focused user interfaces. To help you meet these expectations, the Essential Studio^®2026 Volume 2 release for .NET MAUI introduces enhancements across AI experiences, data management, and visualization.

This release brings new capabilities that make it easier to build intelligent applications, work with data more effectively, and deliver richer user experiences. From improved AI interactions and conversation management to enhanced charting and productivity-focused data features, these updates help you create modern cross-platform applications with less effort.

Area	Highlights
AI AssistView	Multi-agent support, conversation management, and chat experience enhancements.
Cartesian Charts	Point color mapping and multilevel labels.
DataGrid	Multi-row dragging, built-in search, and undo/redo operations.
ListView	Built-in filtering UI
TreeView	Easier hierarchical item selection

Let’s explore the highlights of the 2026 Volume 2 release.

AI AssistView

AI-powered applications continue to evolve, and this release expands AI AssistView with features that make it easier than ever to build sophisticated conversational experiences.

Agent picker

Today’s applications often rely on multiple AI agents, each tailored for a specific task such as document summarization, coding assistance, customer support, or translation. With the new Agent Picker, users can switch between agents directly from the prompt editor without interrupting their workflow.

The selected agent appears as a compact chip with an icon and label, making it easy to identify the active assistant at a glance.

Agent Picker support in AI AssistView

Conversation management

As AI applications grow, managing conversations becomes just as important as generating responses. The new Conversation Management support enables developers to provide a dedicated conversation panel where users can:

Pin important conversations
Rename chats for easier identification
Filter conversations
Remove conversations that are no longer needed

This creates a familiar experience similar to modern AI chat platforms while keeping conversation history organized and accessible.

Conversation Management support in AI AssistView

AI chat experience enhancements

Several usability improvements have also been added to make AI interactions more seamless:

Image Preview allows users to open attached images in a larger view for easier inspection of screenshots, diagrams, and other visual content.

Image Preview support in AI AssistView

Time-based Message Grouping automatically organizes conversations into sections such as Today, Yesterday, and earlier dates, making long chat histories easier to navigate.

Time-based Message Grouping support in AI AssistView

Resizable Prompt Input provides additional editing space for longer prompts, detailed instructions, and code snippets.

Resizable Prompt Input support in AI AssistView

Together, these enhancements create a more natural and productive chat experience without requiring additional customization.

Cartesian Charts

The Cartesian Charts control gains new visualization capabilities that help developers present complex information more effectively.

Point color mapping

Data often needs visual differentiation to highlight categories, trends, or exceptions. Point Color Mapping allows colors to be assigned directly from the data source using brushes, color values, or hexadecimal color codes.

This makes it simple to create more expressive charts while keeping configuration straightforward.

Point Color Mapping support in Cartesian Charts

Multilevel labels

Large datasets frequently contain multiple layers of categorization. Multilevel Labels help organize axis labels into hierarchical groups, making complex information easier to interpret.

This enhancement is especially useful for dashboards, scheduling applications, financial reports, and business analytics solutions.

Multilevel Labels support in Cartesian Charts

DataGrid

This release introduces several DataGrid enhancements focused on improving productivity and reducing the effort required to work with large datasets.

Undo and redo support

Data entry mistakes are inevitable, especially when working with large collections of records. Undo and Redo support allows users to quickly reverse or reapply changes, providing greater confidence during editing operations.

Undo and redo support in DataGrid

Read the full blog post on the Syncfusion Website

Still Building Custom Chart Builders? Build Runtime Charts with Blazor Chart Wizard

Lucy Muturi — Fri, 10 Jul 2026 14:09:12 +0000

TL;DR: Building configurable dashboards usually means creating custom chart builders, field selectors, and persistence logic. Learn how the new Blazor Chart Wizard eliminates that work by letting users configure, save, and export charts directly at runtime.

A dashboard that starts with a simple column chart rarely stays that way.

Business users eventually ask to switch chart types, compare different metrics, save personalized layouts, and export visualizations without waiting for another development cycle.

Supporting these requests often requires developers to build configuration panels, field selectors, chart customization interfaces, persistence mechanisms, and export workflows. In many projects, maintaining the chart configuration experience becomes almost as much work as building the dashboard itself.

The Syncfusion^® Blazor Chart Wizard, a new component introduced in Essential Studio^® 2026 Volume 2 release, takes a different approach.

Instead of developers defining every chart configuration at design time, Chart Wizard provides a guided runtime experience that allows users to create, customize, save, restore, print, and export charts directly within a Blazor application.

In this article, you’ll build an Olympic medal dashboard using the Chart Wizard component. Along the way, you’ll learn how to:

Bind business data to Chart Wizard
Enable runtime chart customization
Allow users to save and restore chart layouts
Configure export functionality
Understand when Chart Wizard is a better choice than a traditional chart component

By the end, you’ll have a practical understanding of how Chart Wizard can reduce development effort while delivering more flexibility to end users.

Why not just use Syncfusion Chart?

Many Blazor applications already use the SfChart component to render charts. So why introduce another charting component? The answer comes down to who controls the visualization.

With the standard chart component, developers define:

Chart type
Series configuration
Axis settings
Data mappings
Styling options

Users interact with the finished chart, but typically cannot modify its structure without changes to the application.

When should you use Chart Wizard?

A standard chart component works well when developers control every aspect of the visualization.

Our Blazor Chart Wizard shines when users need flexibility after deployment.

Scenario	Standard Chart	Chart Wizard
Fixed chart configuration	Yes	No
Users switch chart types	No	Yes
Runtime field mapping	No	Yes
Dashboard personalization	No	Yes
Save and restore chart layouts	No	Yes
Lightweight visualization only	Yes	No

Think of Chart Wizard as a chart-authoring experience rather than a chart control.

What you will build

The completed sample includes:

An SfChartWizard component.
Medal data from the Paris 2024 Olympic Games.
Runtime chart configuration.
Chart layout persistence using serialization.
Built-in export capabilities.

The result is a dashboard where users can experiment with visualizations without requiring application updates.

Interactive Chart Wizard Visualization of Paris 2024 Olympic Medal Standings

How Chart Wizard fits into a dashboard

In a typical analytics solution, your application remains responsible for retrieving, securing, and validating data.

Chart Wizard sits on top of that data and provides a user-friendly configuration layer.

                   **Database / API**  
                           ↓  
                 **Application Services**  
                           ↓  
                    **SfChartWizard**  
                           ↓  
                      **End User**

This separation keeps business logic inside your application while giving users freedom to explore data visually.

New to Chart Wizard? The official Getting Started guide walks you through the complete setup process.

Building an Olympic medal dashboard with Chart Wizard

Let’s build an interactive Olympic medal dashboard that supports chart customization, layout persistence, and export.

Define the data model

Chart Wizard works with standard .NET objects, making it easy to integrate with existing business data. We’ll use a simple model representing Olympic medal standings.

public class OlympicMedalData 
{ 
    public string Country { get; set; } = string.Empty; 
    public int GoldMedals { get; set; } 
    public int SilverMedals { get; set; } 
    public int BronzeMedals { get; set; } 
}

Prepare sample Olympic medal data

In this example, we’ll use medal data from the Paris 2024 Olympics.

private readonly List<OlympicMedalData> MedalRecords = new() 
{ 
    new()
    {
        Country = "United States",
        GoldMedals = 40,
        SilverMedals = 44,
        BronzeMedals = 42
    },
    …
    new()
    {
        Country = "France",
        GoldMedals = 16,
        SilverMedals = 26,
        BronzeMedals = 22
    }
};

Configure category and series fields

Next, choose the category and series fields. The Chart Wizard uses category fields for labels and numeric fields for series, helping it determine the best way to visualize your data.

private readonly List<string> CategoryFields = new()
{
    "Country"
};
private readonly List<string> SeriesFields = new()
{
    "GoldMedals",
    "SilverMedals",
    "BronzeMedals"
};

Add the Chart Wizard component

We’ll add the SfChartWizard component to your Blazor page and bind it to the Olympic medal data.

razor

@using Syncfusion.Blazor.ChartWizard 

<SfChartWizard Width="100%" Height="600px"> 
    <ChartSettings DataSource="@MedalRecords" 
                   CategoryFields="@CategoryFields" 
                   SeriesFields="@SeriesFields" 
                   SeriesType="ChartWizardSeriesType.Column"> 
    </ChartSettings> 
</SfChartWizard>

What happens next?

After deployment, users can:

Switch chart types.
Modify series mappings.
Reconfigure the visualization.
Explore the data from different perspectives.

Without Chart Wizard, supporting these capabilities typically requires building custom interfaces.

You can use the SeriesType property to set the initial chart type, while the wizard allows configuration changes to supported chart types at runtime.

Interactive Chart Wizard Visualization of Paris 2024 Olympic Medal Standings

Enhance the Chart Wizard with advanced features

Save and restore chart configuration

Users often spend time configuring charts exactly the way they want. Serialization allows those configurations to be saved and restored later.

Two methods make this possible:

SaveChart(): Serializes the current chart state and returns it as a JSON string.
LoadChartAsync(string data): Loads a chart configuration from a JSON string produced by SaveChart().

Use the following example to wire save and restore buttons.

razor

<div class="toolbar" style="margin-bottom: 12px;">
    <button class="btn btn-primary" @onclick="SaveChartAsync">Save layout</button>
    <button class="btn btn-secondary"
            @onclick="LoadChartAsync"
            disabled="@string.IsNullOrWhiteSpace(serializedChart)">
        Restore layout
    </button>
</div>
@code
{
    //……
    private Task SaveChartAsync()
    { 
        if (ChartWizard is null)
        {
            statusMessage = "Chart Wizard is not ready yet.";
            return Task.CompletedTask;
        }
        serializedChart = ChartWizard.SaveChart();
        statusMessage = "Chart layout saved for this session.";
        return Task.CompletedTask;
    }

    private async Task LoadChartAsync()
    {
        if (ChartWizard is null || string.IsNullOrWhiteSpace(serializedChart))
        {
            statusMessage = "No saved chart layout is available.";
            return;
        }

        await ChartWizard.LoadChartAsync(serializedChart);
        statusMessage = "Saved chart layout restored.";
    }
    //…
}

The serialized output can be stored in:

Databases
Browser storage
Files
Cloud storage

This makes it possible to provide personalized dashboards that survive between sessions.

Chart Wizard with Serialization

Persist saved chart layouts

When storing chart configurations, remember that applications evolve.

Field names may change.
Data models may be reorganized.
Users may load configurations created months earlier.

For that reason, consider storing:

public class SavedChartLayout
{
    public int Id { get; set; }
    public string UserId { get; set; } = string.Empty;
    public string LayoutName { get; set; } = string.Empty;
    public string ChartStateJson { get; set; } = string.Empty;
    public string DataSchemaVersion { get; set; } = "v1";
    public DateTime UpdatedUtc { get; set; }
}

Save operation

var layout = new SavedChartLayout
{
    UserId = userId,
    LayoutName = "My Medal Dashboard",
    ChartStateJson = ChartWizard.SaveChart(),
    UpdatedUtc = DateTime.UtcNow
};

dbContext.ChartLayouts.Add(layout);
await dbContext.SaveChangesAsync();

Load operation

var layout = await dbContext.ChartLayouts
    .FirstOrDefaultAsync(x => x.Id == layoutId);
await ChartWizard.LoadChartAsync(layout.ChartStateJson);

Store a schema version with the layout. If you later rename GoldMedals to Gold, an old, saved layout may reference a field that no longer exists.

Handling invalid saved layouts

Saved layouts can become invalid if fields are renamed, removed, or reorganized after deployment.

Before calling LoadChartAsync(), consider validating:

Layout ownership
Schema version compatibility
Required fields
JSON format integrity

If validation fails, notify the user and fall back to a default chart configuration rather than attempting to restore the layout.

Read the full blog post on the Syncfusion Website

Need Faster Document Processing? See What's New in Document SDK 2026 Volume 2

Lucy Muturi — Wed, 08 Jul 2026 14:48:47 +0000

TL;DR: Struggling with complex document automation or AI integration? Syncfusion Document SDK 2026 Volume 2 introduces AI Agent Tools, Markdown conversion, enhanced OCR, and performance improvements across PDF, Word, Excel, and PowerPoint libraries to help you build faster, smarter, and more reliable document solutions.

If you’ve ever spent hours maintaining PDF parsers, fixing document conversion issues, or trying to make AI understand complex document content, you’re not alone. Document-heavy applications often become difficult to maintain as requirements grow across formats, platforms, and automation scenarios.

Syncfusion Essential Studio^® 2026 Volume 2 for Document Processing addresses these challenges with AI agent tools, Markdown conversion, and enhancements across PDF, Word, Excel, and PowerPoint libraries.

Here’s what’s new and why it matters in real-world applications.

Deterministic Document Processing for AI Agents

AI-powered document processes often break down at the same point: document structure. Large language models don’t natively understand PDFs, Word files, or spreadsheets. Teams end up stitching together prompts, parsers, converters, and validators, creating pipelines that are hard to maintain and easy to break.

AI Agent Tools for the Document SDK

The Syncfusion AI Agent Tools library addresses this by providing AI agents with direct access to reliable, production-ready document operations via callable tools powered by the Syncfusion Document SDK.

Instead of asking an LLM to “figure out” document structure, agents can now invoke deterministic operations such as:

PDF: Create, convert, redact, sign, merge, and compress PDFs.
Word: Perform mail merge, track changes, and convert documents.
Excel: Create charts, work with formulas and pivot tables, and export data.
PowerPoint: Merge, split, and convert presentations.
Office-to-PDF: Convert Word, Excel, and PowerPoint files to PDF.
Smart Data Extraction: Extract tables, forms, text, and scanned-image content as structured JSON.

The library runs entirely within your infrastructure on-premises or private cloud and integrates with OpenAI, Azure OpenAI, Claude, or custom orchestration systems. Documents never leave your environment.

Execution can be handled entirely in memory for low-latency operations or through cloud-backed storage (Azure Blob Storage or Amazon S3) for scalable, stateless processing.

Real-world example: An insurance claims application can use AI Agent Tools to extract data from uploaded documents, generate reports, convert files, and archive records without relying on custom parsing logic for each document type.

Download the AI Agent Tools NuGet package and extend it with your own custom AI agent tools by cloning the open-source repository for the real-world use cases.

Document SDK AI Tools

Agent Skills: Accurate SDK code inside your IDE

Alongside AI Agent Tools, Document SDK Agent Skills focus on developer productivity.

Agent Skills ground AI coding assistants in verified Syncfusion APIs, eliminating outdated or hallucinated code suggestions. When installed, supported IDEs and assistants can generate accurate, production-ready code using the correct NuGet packages and platform-specific patterns.

Agent Skills support:

Word, PDF, Excel, PowerPoint, Markdown, data extraction, and calculation libraries
.NET, Java, Flutter, and JavaScript platforms
Works with GitHub Copilot, Visual Studio Code, Code Studio, Cursor, Claude, and more.
Two operating modes: Generate code (Mode 1), Execute via csx script (Mode 2)
One-command installation and granular skill selection
Auto loaded by supported agents

Depending on the prompt style, developers can either generate ready-to-use code snippets or execute document actions directly via temporary scripts.

Real-world example: A development team building a document management system can generate SDK-specific code directly inside their IDE, reducing time spent searching documentation and correcting AI-generated code suggestions.

Stop building fragile LLM-to-document pipelines from scratch! Explore Syncfusion AI Agent Tools documentation and Document SDK Agent Skills documentation to get started.

Markdown as a first-class enterprise format

Markdown has become the preferred authoring format for developers and content teams, but most enterprise delivery still happens in Word, Excel, PowerPoint, and PDF. Bridging that gap manually slows everything down.

.NET Markdown Library (Preview)

The Syncfusion .NET Markdown Library introduces a structured document object model for Markdown, allowing developers to create, read, and edit Markdown programmatically without external dependencies.

What you can build and format

Document creation with DOM: Create Markdown documents programmatically using a structured, intuitive object model for clean, maintainable code.
Rich content support: Add and organize Headings, paragraphs, block quotes, thematic breaks, tables, lists, and checkboxes.
Advanced text formatting: Apply rich formatting including bold, italic, strikethrough, inline code, subscript, and superscript.
Media and linking: Insert images and hyperlinks to enhance document interactivity.
Code block support: Easily include formatted code blocks for technical documentation.

Supported conversion:

Seamlessly convert Markdown to and from multiple popular file formats using Syncfusion libraries:

Word documents: Convert Markdown to Word and text formats such as .doc, .docx, .xml, .html, and .rtf, and convert Word documents to Markdown.
Excel documents: Convert Excel files to and from Markdown.
PowerPoint presentations: Convert PPTX files to Markdown and generate PPTX files from Markdown.
PDF documents: Convert Markdown to PDF format and convert PDF documents to Markdown.

Markdown File Format Conversions in .NET Markdown Library

The Syncfusion .NET Markdown Library covers more conversion targets than any comparable lightweight Markdown library, making it the practical choice for teams that need Markdown as a bridge between authoring and enterprise delivery formats.

Real-world example: A documentation platform can store content in Markdown and automatically publish it as Word, PDF, PowerPoint, and Excel files for different audiences without maintaining separate versions of the same content.

PDF enhancements across platforms

.NET PDF Library: HTML-to-PDF security update

HTML-to-PDF remains a core process for invoices, dashboards, and reports. In this release, the Blink binaries used for HTML-to-PDF conversion have been updated to version 147.0.7727.56, which addresses known security vulnerabilities and improves conversion reliability.

JavaScript PDF Library: Layout and metadata control

The JavaScript PDF Library now offers deeper layout-level control, enabling more complex client-side PDF generation.

New capabilities include:

Layout-aware text elements with styling, alignment, and automatic pagination.

Layout‑Aware Text Elements in JavaScript PDF Library

Reusable header and footer templates with static content and dynamic fields such as page numbers and dates.

Reusable Headers & Footers in JavaScript PDF Library

XMP metadata embedding for standardized document indexing, searchability, and archival procedures.

For more details, check our JavaScript PDF library documentation.

Real-world example: A reporting application can generate secure, metadata-rich PDF invoices and statements directly from HTML while improving document traceability and searchability.

Smarter Data Extraction and OCR control

.NET Data Extraction Library updates

Accuracy in document extraction often depends on how much control you have over OCR and image handling. This release adds two practical improvements to the Syncfusion .NET Data Extraction Library:

Custom image handling: Access extracted images as streams and choose whether to embed them directly in Markdown as base64 or reference them via URLs in cloud storage.
Configurable OCR settings: Fine-tune language selection, OCR engine version, image preprocessing, page segmentation, and multi-language handling before extraction begins.

These controls are especially valuable in healthcare, logistics, and financial processes where extraction accuracy directly affects downstream systems.

Real-world example: A healthcare provider can extract information from scanned patient records using customized OCR settings, improving recognition accuracy before the data is routed to downstream systems.

If your extraction pipeline is losing accuracy because OCR settings are locked down, this release gives you the control you’ve been missing. Explore the .NET Data Extraction Library documentation.

Excel, Word, and PowerPoint improvements

.NET Excel Library

Place images directly inside cells so they move and resize naturally with cell changes.

Images Inside Cells in .NET Excel Library

Convert Excel files to clean Markdown for documentation or publishing.

Convert Excel to Markdown in .NET Excel Library

Convert Markdown back into structured Excel data for reporting and analysis.

Convert Markdown to Excel in .NET Excel Library

Real-world example: A financial reporting application can convert spreadsheet data into Markdown for review, then regenerate structured Excel reports from updated content when publishing final results.

.NET Word Library

Up to 70% faster clone and merge operations, ideal for high-volume document generation
Improved HTML parsing with better support for attributes across paragraph and heading tags

This update delivers immediate, measurable gains for high-volume Word processing workloads. See the Syncfusion .NET Word Library documentation.

Real-world example: Organizations that generate thousands of personalized contracts or customer letters each day can reduce processing time by accelerating document cloning and merging.

Read the full blog post on the Syncfusion Website

From Faster PDFs to AI-Powered Spreadsheets: See What’s New in Syncfusion 2026 Volume 2

Lucy Muturi — Tue, 07 Jul 2026 11:34:15 +0000

TL;DR: Syncfusion 2026 Volume 2 delivers performance and usability upgrades across document processing:

PDF Viewer SDK: Up to 92% faster annotation processing, partial ink erasing, comment filtering, and improved bookmark rendering.
DOCX Editor SDK: Accurate bidirectional (RTL/LTR) text formatting and modern hashing for reliable document protection.
Spreadsheet Editor SDK: AI-powered natural language operations, quicker bulk updates with suspend/resume APIs, subscript/superscript support, ribbon customization, conditional formatting, export options, and quick auto-aggregation.

Built to fix real production bottlenecks so that large documents, multilingual content, and data-heavy spreadsheets behave reliably at scale.

Ever watched a PDF with 500+ annotations slow to a crawl? Opened a multilingual Word document only to find the text direction completely off? Or worked with a spreadsheet that seemed fine until a bulk update turned the UI unresponsive?

These aren’t the kind of problems you see in demos; they only show up in production.

Document-heavy apps tend to accumulate a specific kind of technical debt:

Performance drops only when file size and complexity grow.
Formatting breaks in multilingual or edge-case content.
Missing controls force you to build custom workarounds just to ship.

The Syncfusion^® 2026 Volume 2 release is built around fixing those exact issues without adding noise. It delivers practical, high-impact improvements across three core SDKs: PDF Viewer, DOCX Editor, and Spreadsheet Editor , targeting real bottlenecks in Web, Blazor, and .NET MAUI platforms.

Whether you’re building:

A document review tool handling annotation-heavy PDFs,
A content editor with mixed-language support, or
A data-heavy spreadsheet interface,

these changes are designed to remove the friction you’ve likely already run into.

Let’s break down what’s changed, and more importantly, see where it makes your development experience smoother.

PDF Viewer SDK

The 2026 Volume 2 release brings meaningful improvements to the PDF Viewer SDK across Web, Blazor, and .NET MAUI platforms.

Web PDF Viewer

Let’s first explore the latest improvements in the Web PDF Viewer:

1. Erase specific portions of ink annotations

A small mistake in an ink annotation used to mean deleting the entire stroke and starting over.

The new ink eraser tool lets users erase only the part that needs fixing while keeping the rest intact.

For developers, it’s flexible too. The eraser appears when users interact with ink annotations, can be controlled programmatically, and fits easily into custom setups, such as enabling it only in review mode or for specific user roles.

Ink eraser tool in the Web PDF Viewer

2. Filter annotation comments for focused review

Once documents start accumulating feedback, the real problem isn’t adding comments; it’s navigating them.

The new comment filtering option enables you to:

Filter annotation comments based on specific criteria and
See those filtered results reflected directly in the document.

Instead of building and synchronizing your own comment filtering logic with the document view, the behavior is already built in and consistent.

It’s one of those features that directly improves usability without adding complexity to your implementation.

Filtering annotation comments in Web PDF Viewer

3. Up to 92% faster downloads for annotation-heavy PDFs

Downloads often stay fast at first, but as annotations grow, performance starts to drop. With hundreds of comments, even simple updates can feel slow.

The Web PDF Viewer now makes download performance more predictable by improving annotation handling, especially in large, heavily annotated PDFs.

What does that mean in simple terms:

Small files → Slightly faster, smoother updates.
Medium-sized documents → Noticeably quicker response.
Large, heavily annotated PDFs → Massive speed improvement.

The following table shows the annotation download performance before and after optimization.

Scenario	Previous performance	Current performance
Document with 1 annotation (updating 1 annotation)	24.88 ms	19.63 ms
Document with 30 annotations (updating 1 annotation)	54.53 ms	26.72 ms
Document with 400 annotations (updating 1 annotation)	1,649.25 ms	152.79 ms

For large documents, that’s up to 92% faster, while smaller ones see around 35% improvement.

Blazor PDF Viewer

While the Web PDF Viewer improvements focus on annotations and performance, the Blazor PDF Viewer addresses a different challenge: making large documents easier to navigate.

When users rely on bookmarks to move through lengthy reports or technical documents, formatting helps reinforce the document hierarchy. With 2026 Volume 2, bookmark styling is now preserved in view-only mode.

Preserve original bookmark styling, including bold text.
Maintain document structure and hierarchy.
Improve navigation in large PDF files.

Preserving bookmark formatting in Blazor PDF Viewer’s view-only mode

.NET MAUI PDF Viewer

The .NET MAUI PDF Viewer includes the following practical improvements:

1. Disable or enable double-tap zoom programmatically

On mobile devices, gestures can sometimes compete with each other. While double-tap zoom is useful in many scenarios, it may not fit apps that use custom navigation or selection interactions.

You can now enable or disable double-tap zoom behavior programmatically, giving you more control over the viewing experience.

Disable double-tap zoom when using custom navigation or selection gestures.
Enable it when document zooming is a priority.
Integrate the behavior directly into your app’s functionality.

Double-tap toggle button in .NET MAUI PDF Viewer

2. Mark all form fields read-only using a single setting

Not every document is meant to stay editable. For review, approval, or finalized documents, you can now mark all form fields as read-only using a single setting.

Prevent accidental edits.
Avoid field-by-field configuration.
Keep form behavior consistent across the document.

This makes it easier to protect data and maintain document integrity.

Read-only form fields feature in .NET MAUI PDF Viewer

DOCX Editor SDK

The DOCX Editor SDK receives major improvements across Web and Blazor platforms.

1. Bidirectional character formatting for RTL/LTR documents

For apps that generate legal contracts, government forms, or multilingual business documents, mixed RTL and LTR content can quickly lead to formatting inconsistencies and manual cleanup.

The DOCX Editor lets you control text direction at the character level, making mixed-language editing more predictable and easier to manage.

Set RTL or LTR formatting for specific text ranges.
Edit RTL content without disrupting layout or cursor flow.
Reduce manual fixes and styling workarounds.

Bi-directional text formatting in Web and Blazor DOCX Editor

2. Enhanced hash computation with Algorithm SID

If you’ve worked with protected Word documents, you’ve probably run into cases where password validation fails for no obvious reason, especially when files come from newer Word versions. Most of the time, it comes down to outdated hashing behavior.

This update brings that layer up to date.

The ComputeHash API now supports Algorithm SID, enabling the use of modern hashing algorithms such as SHA-1 and SHA-256:

More reliable password validation when opening or verifying documents.
Better compatibility with documents generated by newer Word clients.
Fewer edge-case failures in protection and unprotection scenarios.

With text handling and document security tightened up, the next set of updates shifts focus toward handling large datasets more efficiently in the Spreadsheet Editor.

Spreadsheet Editor SDK

The Spreadsheet Editor SDK also receives major improvements across Web and Blazor platforms.

Web Spreadsheet Editor

1. Spreadsheet operations via natural language with AI Assist

The Web Spreadsheet Editor includes AI Assist with natural language capabilities, making common spreadsheet tasks much easier.

Instead of repeating routine tasks like writing formulas or cleaning data, you can simply describe what you need.

Type your request in plain language and see it applied instantly.
Handle editing, formatting, analysis, and visualizations from a single prompt.
Stay in control with built-in prompt suggestions and full undo/redo support.

No need to switch between menus or write formulas; just ask and get it done.

Web Spreadsheet Editor SDK with AI Assist support

Read the full blog post on the Syncfusion Website

What’s New in Syncfusion Essential Studio 2026 Volume 2: AI Features, New SDKs, and Faster Components

Lucy Muturi — Mon, 06 Jul 2026 13:22:20 +0000

TL;DR: Syncfusion Essential Studio 2026 Volume 2 marks one of our biggest releases yet, featuring AI-powered developer tools, dedicated SDK packages, new UI controls, and major performance improvements across web, desktop, mobile, and document-processing platforms. Whether you’re building intelligent applications, enterprise dashboards, or document automation solutions, this release gives you everything you need to build smarter, faster, and with greater confidence.

Syncfusion Essential Studio 2026 Volume 2 is now available, bringing new controls, AI-powered enhancements, performance upgrades, and productivity improvements across web, mobile, desktop, and document processing platforms.

This release arrives at a time when developers are expected to build smarter applications, automate more document workflows, support multiple platforms, and still deliver fast, polished user experiences. Essential Studio 2026 Volume 2 is designed to help with exactly that: giving teams practical tools that reduce repetitive work and make modern application development easier.

From AI-assisted user experiences and smarter document processing to front-end framework improvements and performance-focused updates, this release helps you build powerful applications with more speed and flexibility.

Here is a closer look at what is new in this release.

Release highlights

Essential Studio 2026 Volume 2 focuses on helping developers build faster, smarter, and more capable applications across web, mobile, desktop, and document processing scenarios.

New .NET Markdown Library in preview
New Inline AI Assist component for Blazor
AI-powered Agent Tools for Document SDK
Expanded Pure React Components ecosystem
Production-ready Sankey Diagram
Major Blazor productivity enhancements
AI-powered Spreadsheet editing
Significant PDF Viewer performance improvements

New dedicated SDK packages

This release also introduces a new generation of dedicated Syncfusion SDK packages. These focused offerings give teams more flexibility to choose the capabilities they need, such as Grid SDK, Chart SDK, Scheduler SDK, Gantt SDK, File Manager SDK, Rich Text Editor SDK, and Diagram SDK, instead of purchasing a larger component suite when a focused SDK is a better fit.

Explore our dedicated SDK announcement blog to learn more about choosing the right SDK for your development needs.

New controls

Essential Studio 2026 Volume 2 introduces new controls built for emerging development scenarios, including AI-assisted applications, intelligent content generation, and automated document processing.

.NET Markdown Library (Preview)

The new .NET Markdown Library allows developers to create, edit, and convert Markdown documents programmatically without relying on external dependencies.

With this library, you can:

Create Markdown documents using a structured DOM, making content generation easier to manage in code.
Add headings, lists, tables, checkboxes, images, and hyperlinks for dynamic content creation systems.
Apply formatting such as bold, italic, strikethrough, superscript, and subscript.
Insert code blocks and formatted content for technical documentation and automated publishing workflows.

The library also includes document conversion capabilities, including:

Markdown to Word for editable document outputs.
Markdown to Excel for converting structured content into spreadsheet-based documents.
Markdown to PowerPoint for generating presentation-ready content.
Markdown to PDF for creating final, shareable document outputs.

.NET Markdown Library

Inline AI Assist for Blazor

The new Inline AI Assist for Blazor helps you bring AI-powered interactions directly into your application experience, without forcing users into a separate chat interface.

Key capabilities include:

Inline and pop-up AI interaction modes for flexible placement across application layouts.
Streaming AI responses for more natural, real-time AI experiences.
Prompt-based intelligent interactions for contextual AI-powered workflows.
AI-assisted content generation for writing assistants, copilots, and productivity tools.

This makes it easier to build AI-native applications where assistance appears naturally within the user workflow.

Inline AI Assist for Blazor

Markdown Viewer for WinUI

The new Markdown Viewer control for WinUI makes it easier to render rich Markdown content directly inside desktop applications, without external rendering libraries or manual formatting.

Key features include:

Rich Markdown rendering for headings, lists, links, images, tables, code blocks, and other content elements.
Support for loading Markdown content from strings, files, or URLs.
Hyperlink navigation and content customization options for documentation, help systems, and content-driven desktop applications.

WinUI Markdown Viewer

Feature enhancements across platforms

Along with new controls, this release brings meaningful improvements across multiple platforms and development frameworks.

Web

For React, JavaScript, Angular, Vue, ASP.NET Core, and ASP.NET MVC, this release delivers richer interactions, better customization, and improved performance for modern front-end applications.

Better theming architecture

Theme management is easier to maintain in large front-end applications with the latest theming architecture improvements. Updates include:

Modular theme architecture for simpler long-term styling maintenance.
Centralized theme packages for improved consistency across projects.
Dedicated index.css and index.scss entry points for cleaner stylesheet management.
Sass 1.100.0 upgrade for better compatibility and modern styling support.

These updates help teams manage design systems more cleanly at scale.

Expanded Pure React Components ecosystem

The Pure React Components ecosystem continues to expand, giving React developers more framework-native components and greater flexibility.

New additions include:

Menu component for advanced navigation and contextual menus.
Switch component for modern toggle-based interactions.

Several Pure React components are now production-ready, including:

Chart for advanced data visualization.
Data Grid for enterprise-grade data management interfaces.
Buttons, Forms, Inputs, and Dropdowns for richer application interactions.
Toolbar, Dialog, Tooltip, Toast, Spinner, and Skeleton for building interactive applications.

Additional support now includes Tailwind CSS integration and Bootstrap support, helping teams work faster with popular styling approaches.

More web component improvements

Data Grid: Adds grouping and master-detail views, infinite scrolling, conditional selection, context menus, row and column spanning, PDF export, and print support for advanced enterprise data applications.
AI AssistView: Adds response regeneration, reasoning-process visibility, text-to-speech, dynamic generative UI components, and tool invocation through system prompts for more adaptive AI-powered interfaces.
Chart: Adds inline tooltip formatting, multi-level donut charts, and new stock chart series types such as Spline, Spline Area, and Column for richer data visualizations.
Pivot Table: Adds native CRUD operations, Top N and Bottom N filtering, incremental filtering, and percentage running totals for faster, more flexible analysis.
Sankey Diagram: Now production-ready for process mapping, resource tracking, energy flow diagrams, and financial analysis visualizations.

JavaScript Sankey Diagram

Blazor

This release includes major Blazor enhancements that help you build smarter AI-powered applications, improve developer productivity, and deliver richer enterprise experiences.

AI AssistView: Adds speech-to-text support, response regeneration with navigation controls, and text-to-speech support, making AI-powered chat experiences more interactive and accessible.

Speech-to-text conversion in Blazor AI AssistView

DataGrid: Introduces single-click batch editing for faster data entry and an adaptive filter bar that adjusts based on text, numeric, date, and Boolean column types.

Single-click batch edit feature in Blazor DataGrid

Diagram: Adds support for UML class diagrams, annotation interactions such as dragging, resizing, and rotation, and hyperlink support for advanced visual modeling applications.
Rich Text Editor: Adds image wrap support directly from the quick toolbar and chunk message handling for efficiently processing large HTML content.

Together, these updates help teams build richer Blazor applications with less effort.

.NET MAUI

The .NET MAUI updates in this release help developers build richer cross-platform applications across mobile and desktop environments.

AI AssistView: Adds agent switching, multi-line input, image previews, and time-based conversation grouping for Copilot-style experiences inside your applications.

.NET MAUI AI AssistView with agent picker in editor

Charts: Adds per-point color mapping and real-time updates through property change listening, giving you more control over analytics and visualization scenarios.

Per-point color mapping in .NET MAUI Charts

DataGrid: Adds undo and redo support, multi-row drag-and-drop, row resizing, and built-in search UI to improve enterprise data management and large dataset handling.

Multi-row drag-and-drop feature in .NET MAUI DataGrid

Scheduler and Rich Text Editor: Adds improvements for scheduling, event management, calendar interactions, rich content editing, formatting, and customization.

These improvements help you deliver better experiences across devices while keeping cross-platform development efficient.

Read the full blog post on the Syncfusion Website

Introducing Standalone UI SDKs: Choose Only What Your Application Needs

Lucy Muturi — Mon, 06 Jul 2026 09:31:18 +0000

TL;DR: Syncfusion Essential Studio 2026 Volume 2 introduces Standalone UI SDKs, giving you the flexibility to license focused UI toolkits such as Grid, Chart, Scheduler, File Manager, Diagram, Gantt, and Rich Text Editor SDKs. Whether you need a specialized SDK or the complete UI Component Suite, you can choose the option that best fits your application’s architecture while continuing to build with the same trusted Syncfusion components, APIs, documentation, and support.

Modern applications are no longer built with one-size-fits-all requirements.

Some teams are building data-heavy enterprise portals. Others are creating analytics dashboards, file management systems, scheduling platforms, workflow designers, project planning tools, or rich content editing experiences.

While many development teams still need a complete UI component suite, some projects are focused on one specific capability. In those cases, purchasing a broad component suite may not always be the most efficient path.

To give developers more flexibility, Syncfusion is introducing a new set of Standalone UI SDKs with the Essential Studio^® 2026 Volume 2 release.

These focused SDK packages allow teams to choose the UI capabilities their applications need, while continuing to build with the same trusted Syncfusion components, consistent APIs, documentation, performance, and professional support.

What’s new in this release?

Starting with the 2026 Volume 2 release, Syncfusion now offers the following Standalone UI SDKs:

These SDKs are designed to complement the Syncfusion UI Component Suite. You can choose a focused SDK when your application has a specific requirement, or choose the UI Component Suite when your project needs a broader collection of enterprise-ready UI components.

Note: Existing Syncfusion customers are not affected. Current product entitlements remain unchanged, and existing customers will continue to receive the products included with their subscription.

Why Standalone UI SDKs?

Every application has a different center of gravity.

For a business intelligence application, charts and dashboards may be the core experience.
For an ERP system, data grids and pivot tables may matter most.
For a booking platform, scheduling is the priority.
For a workflow automation tool, diagrams may be essential.

Standalone UI SDKs make it easier to choose a product based on what your application is actually built around.

Choose a Standalone UI SDK when your application focuses on a specific UI capability.
Choose the UI Component Suite when your application requires a broader set of components across multiple functional areas.

This gives development teams more control over product selection, licensing, and long-term scalability without changing the Syncfusion development experience.

Meet the new Standalone UI SDKs

Each Standalone UI SDK is built around a focused application scenario and includes the components commonly required for that type of solution.

Grid SDK

The Grid SDK is designed for applications that need to display, manage, edit, and analyze structured data.

Includes:

DataGrid
TreeGrid
Pivot Table

Ideal for: ERP systems, CRM platforms, financial applications, inventory management systems, admin portals, reporting interfaces, and data-heavy enterprise applications.

Grid SDK

Chart SDK

The Chart SDK is built for dashboards, analytics applications, and interactive data visualization experiences.

Includes:

2D and 3D Charts
Circular Charts
Stock Chart
Sankey Diagram
HeatMap
TreeMap
Maps
Gauges
Sparkline
Barcode Generator
Range Selector
Smith Chart
Bullet Chart
Dashboard Layout

Ideal for: Business intelligence dashboards, analytics platforms, monitoring systems, financial dashboards, reporting tools, and data visualization applications.

Chart SDK

Scheduler SDK

The Scheduler SDK is designed for applications that need calendar, appointment, and resource scheduling capabilities.

Includes:

Scheduler

Ideal for: Healthcare appointment systems, booking platforms, workforce management tools, education portals, event management applications, and calendar-based business solutions.

Scheduler SDK

Gantt SDK

The Gantt SDK is designed for project planning, timeline management, and task tracking applications.

Includes:

Gantt Chart
Kanban

Ideal for: Project management systems, agile planning tools, resource management applications, task tracking platforms, and work planning solutions.

Gantt SDK

Rich Text Editor SDK

The Rich Text Editor SDK helps developers build modern content creation and editing experiences.

Includes:

Rich Text Editor
Block Editor

Ideal for: Content management systems, blogging platforms, documentation tools, knowledge bases, email composition experiences, and collaborative content editing applications.

Rich Text Editor SDK

Diagram SDK

The Diagram SDK helps developers create interactive diagramming, visualization, and workflow design experiences.

Includes:

Diagram

Ideal for: Flowcharts, BPMN diagrams, organizational charts, workflow builders, network diagrams, process visualization tools, and visual modeling applications.

Diagram SDK

File Manager SDK

The File Manager SDK helps developers build secure and intuitive file and folder management experiences.

Includes:

File Manager

Ideal for: Document management systems, digital asset management platforms, cloud storage applications, enterprise portals, and internal file operation tools.

File Manager SDK

Read the full blog post on the Syncfusion Website

How to Add Custom Filtering, Sorting, and Grouping Logic in WPF DataGrid

Lucy Muturi — Fri, 03 Jul 2026 11:14:18 +0000

TL;DR: Learn how to implement custom filtering, sorting, grouping, and column visibility in a WPF DataGrid using the MVVM pattern. Using a school grade management application as an example, this guide demonstrates how to build a responsive, data-driven interface that helps users efficiently organize, analyze, and manage large datasets.

Modern desktop applications often need more than just displaying data. Users expect powerful capabilities such as filtering records, sorting information, grouping related data, and customizing column visibility to quickly analyze large datasets.

Rather than building these features from scratch, you can leverage the WPF DataGrid together with the MVVM pattern to create rich and interactive data-management experiences.

In this guide, we’ll use a school grade management system as a practical example to demonstrate how to implement sorting, filtering, and grouping in a Syncfusion^® WPF DataGrid and a clean MVVM approach.

Let’s get started.

Step 1: Define data model

Start by creating a model that represents individual student records, as shown in the following code example.

public class Grade : INotifyPropertyChanged
{
    private int _id;
    private string _studentName;
    private string _subjectName;
    private double _assignmentScore;
    private double _quizScore;
    private double _examScore;
    private double _projectScore;
    private string _comments;

    public int ID
    {
        get
        {
            return _id;
        }
        set
        {
            _id = value;
            OnPropertyChanged(nameof(ID));
        }
    }

    …
    …

    public event PropertyChangedEventHandler? PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public double CalculateFinalGrade()
    {
        // Simple example calculation. Real-world grading systems often use weighted score calculations based on academic requirements.
        return (AssignmentScore + QuizScore + ExamScore + ProjectScore) / 4;
    }
}

Step 2: Create the ViewModel

The ViewModel ties everything together by storing data, defining grid columns, and handling user interactions. In this step, we’ll create the GradeSheetViewModel class to populate the Grades collection for ItemsSource binding, configure column definitions, and implement data manipulation logic.

public class GradeSheetViewModel : INotifyPropertyChanged
{
    private ObservableCollection<Grade> grades;

    public ObservableCollection<Grade> Grades
    {
        get
        {
            return grades;
        }
        set
        {
            grades = value;
            OnPropertyChanged(nameof(Grades));
        }
    }    
}

To populate the grades collection with default student data, refer to the code example below.

private void PopulateCollection()
{
    Grades = new ObservableCollection<Grade>();
    //Add sample data here
}

Configure DataGrid columns

Instead of auto-generating columns, explicitly defining them gives you full control over how data is displayed.

private void InitializeColumns()
{
    columns = new Columns();
    var studentNameIdUnboundColumn = new GridUnBoundColumn
    {
        MappingName = "StudentID",
        HeaderText = "Student ID"
    };
    …
    …
    columns.Add(gradeColumn);
    var commentsColumn = new GridTextColumn
    {
        MappingName = "Comments",
        HeaderText = "Comments"
    };
    columns.Add(commentsColumn);
}

You can add columns to the Columns collection using specialized objects like GridTextColumn and GridNumericColumn, chosen based on your data type requirements.

Each column requires two key properties:

MappingName: Specifies which data source property the column binds to.
HeaderText: Defines the column’s display title.

Step 3: Design the UI

Bind the XAML UI to the ViewModel and use the Columns property to connect the DataGrid with column definitions, ensuring it updates dynamically.

XAML

<syncfusion:SfDataGrid ItemsSource="{Binding Grades}"
                       Columns="{Binding Columns}"
                       AutoGenerateColumnsMode="None"
                       AllowTriStateSorting="True"
                       AutoExpandGroups="True"
                       ColumnSizer="SizeToHeader">
    <behaviors:Interaction.Behaviors>
        <local:DataGridBehavior/>
    </behaviors:Interaction.Behaviors>
</syncfusion:SfDataGrid>

What’s happening here?

ItemsSource binds your student data
Columns ensure your custom column definitions are applied
Sorting and grouping options are enabled out of the box

With just a few properties, the grid becomes highly interactive.

Step 4: Add data operations

A grading system isn’t complete without methods for analyzing and manipulating data. Let’s add support for filtering, sorting, grouping, and column visibility.

public class GradeSheetViewModel : INotifyPropertyChanged
{
    // Commands for opening a pop-up to handle columns and data manipulation.
    public ICommand HideColumns { get; set; }
    public ICommand HideAllColumns { get; set; }
    public ICommand ShowAllColumns { get; set; }
    public ICommand FilterColumns { get; set; }
    public ICommand ClearFilter { get; set; }
    public ICommand GroupColumns { get; set; }
    public ICommand ClearGroup { get; set; }
    public ICommand SortColumns { get; set; }
    public ICommand ClearSort { get; set; }

    private void InitializeCommands()
    {
        HideColumns = new RelayCommand(_=>ExecuteHideColumns());
        ShowAllColumns = new RelayCommand(_=>ExecuteShowAllColumns());
        HideAllColumns = new RelayCommand(_=>ExecuteHideAllColumns());
        FilterColumns = new RelayCommand(_=>ExecuteFilterColumns());
        ClearFilter = new RelayCommand(_=>ExecuteClearFilter());
        GroupColumns = new RelayCommand(_=>ExecuteGroupColumns());
        ClearGroup = new RelayCommand(_=>ExecuteClearGroups());
        SortColumns = new RelayCommand(_=>ExecuteSortColumns());
        ClearSort = new RelayCommand(_=>ExecuteClearSorts());
    }
}

In the above code example,

The HideColumns, ShowAllColumns, and HideAllColumns commands manage column visibility in the DataGrid.
HideColumns and ShowAllColumns are linked to UI buttons or actions, toggling visibility.
The ExecuteHideAllColumns and ExecuteShowAllColumns methods iterate through the column collection to set the IsHidden property.

Column visibility

You can easily toggle columns using the code example:

private void ExecuteHideColumns()
{
    IsOpenForHideColumns = true;
    // which will open the show/hide all columns popup.
}

private void ExecuteHideAllColumns()
{
    foreach (var item in columns)
    {
        item.IsHidden = true;                
    }
}

private void ExecuteShowAllColumns()
{
    foreach (var item in columns)
    {
        item.IsHidden = false;                
    }
}

Show/Hide column in WPF DataGrid

Sorting

The SortColumns command manages the DataGrid’s sorting behavior through its associated ExecuteAddSorting method, which performs two key operations.

Clears all existing sort descriptions
Applies new sorting based on user input.

The SortColumnDescriptions collection property will be used from the ViewModel to handle this operation, as shown in the code example below:

private void ExecuteAddSorting()
{
    if (SelectedSortColumn != null)
    {
        SortColumnDescriptions.Clear();
        var sortColumnDescription = new SortColumnDescription()
        {
            ColumnName = this.SelectedSortColumn.Name,
            SortDirection = IsOnState
                ? ListSortDirection.Ascending
                : ListSortDirection.Descending
        };

        var tempCollection = new SortColumnDescriptions();
        tempCollection.Add(sortColumnDescription);
        SortColumnDescriptions = tempCollection;
    }
}

Sorting in WPF DataGrid

Read the full blog post on the Syncfusion Website

Reduce XAML Boilerplate with .NET MAUI Global/Implicit Namespace + Source Generator

Lucy Muturi — Thu, 25 Jun 2026 11:25:55 +0000

TLDR: What if your XAML didn’t need all that boilerplate? Use .NET MAUI global/implicit namespaces and source generator to reduce XAML boilerplate code and simplify your UI layer. By defining namespaces once in GlobalXmlns.cs and letting the XAML source generator compile your UI into C# at build time, you eliminate repeated xmlns: clutter, catch errors earlier, and get a faster, more predictable debug and startup experience, especially when working on complex or frequently updated screens.

You open a simple page to add one control, and suddenly you’re staring at a wall of xmlns declarations as shown below.

XAML

xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
xmlns:controls="clr-namespace:MyApp.Controls"
xmlns:viewModels="clr-namespace:MyApp.ViewModels"

It’s one of those things we’ve all gotten used to, but never really liked. It works, but it’s repetitive, noisy, and easy to mess up when you’re moving fast.

There are two user-friendly features in .NET MAUI that quietly reduce the XAML boilerplate code:

Global + implicit XML namespaces
Source generator

They may seem like small changes, but they significantly improve the experience of working in XAML.

Why does this actually matter while building UI

Before diving into these details, here’s what matters from a developer’s perspective:

Less boilerplate in every XAML file.
Fewer runtime surprises (More compile-time feedback).
Faster startup and navigation.
Easier debugging (You can actually see what XAML becomes).

It’s not just cleaner code; it’s less friction while building UI.

Global/implicit XML namespaces: Keep your XAML focused on UI, not setup

Let’s start by simplifying how XAML namespace declarations are handled in .NET MAUI.

1. Stop repeating xmlns everywhere, declare them globally

Instead of declaring namespaces in every XAML file, you can define them globally in .NET MAUI using assembly attributes.

You map them to the global MAUI URI: http://schemas.microsoft.com/dotnet/maui/global.


[assembly: XmlnsDefinition("http://schemas.microsoft.com/dotnet/maui/global", "MyApp.Controls")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/dotnet/maui/global", "MyApp.Views")]

Most teams will place this in a file named GlobalXmlns.cs. Once that’s in place, those namespaces are automatically available across your entire app.

No need for:

XAML

xmlns:controls="clr-namespace:MyApp.Controls"

… on every single page. You can define your namespaces once and forget about them.

2. Go one step further with implicit namespaces

Global mappings are helpful. But implicit namespaces are where things really get interesting.

You can tell MAUI:

“ Assume this global namespace by default.”

We can enable implicit namespaces in the .csproj file as follows:

XAML

<PropertyGroup>
 <DefineConstants>$(DefineConstants);MauiAllowImplicitXmlnsDeclaration</DefineConstants>
 <EnablePreviewFeatures>true</EnablePreviewFeatures>
</PropertyGroup>

Now, your XAML becomes dramatically simpler.

Before (Typical XAML clutter)

XAML

<ContentPage
   xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
   xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
   xmlns:controls="clr-namespace:MyApp.Controls">

 <controls:BigControl />
</ContentPage>

After (Clean Xaml code)

XAML

<ContentPage x:Class="MyApp.MainPage">
 <BigControl />
</ContentPage>

That’s it. No prefixes. No repeated namespace declarations. Just the UI.

The only thing that sticks around is xmlns:x, which is still required for core XAML features.

Real-world scenario: Managing XAML at scale in .NET MAUI

If you’ve worked on a mid-to-large .NET MAUI app, you’ve likely seen this pattern:

Shared UI libraries,
Internal control packages, and
Multiple teams touching UI layers.

Every team ends up adding slightly different namespace mappings. Over time, XAML becomes inconsistent and harder to read.

With global + implicit namespaces:

Everyone uses the same “global language” in XAML.
Refactoring namespaces becomes centralized.
New developers ramp up faster (Less ceremony to understand).

It’s especially useful in enterprise setups where UI code gets reused across multiple apps.

Read the full blog post on the Syncfusion Website

Better Auth: Framework-Agnostic Authentication Solution for TypeScript Apps

Lucy Muturi — Wed, 24 Jun 2026 11:44:58 +0000

TL;DR: Designing authentication that survives framework changes is hard. This article explains how Better Auth enables framework-agnostic authentication for TypeScript apps, covering its architecture, performance, trade-offs, and real-world use cases, including Next.js, Remix, and SvelteKit. You’ll see how a self-hosted auth stack with small bundles, fast session validation, and full data ownership can improve maintainability, scalability, and long-term flexibility without framework lock-in.

Modern web teams rarely sit still. A product might start with Next.js, later experiment with Remix, or grow an Express API alongside the frontend. Frameworks change, architectures evolve, but authentication tends to stick around long after the original decisions were made.

That’s where things usually get painful.

Authentication is often tightly coupled to a framework or outsourced to a managed service, which can become expensive and inflexible over time. Migrating frameworks means rewriting the auth logic. Scaling users means scaling costs. And gaining deeper control usually means more work than teams expect.

Better Auth approaches this problem differently.
Instead of treating authentication as a framework feature, it treats it as infrastructure you own : portable, TypeScript-first, and designed to survive framework changes.

In this article, we’ll look at how Better Auth works, where it fits well, and when it might not be the right choice.

Why framework-agnostic authentication matters

At the start of a project, most authentication solutions feel fine. They’re easy to set up, tightly integrated, and well-documented. The trade-offs only surface later.

Teams usually run into trouble when:

A frontend framework migration is needed
Multiple frameworks coexist in the same system
User growth triggers unexpected pricing models
Deeper control over sessions or data becomes necessary

In these situations, authentication becomes an anchor. The tighter it’s bound to one framework or vendor, the harder it is to move.

Better Auth is built for teams that expect change and want authentication to be portable by design, not something that must be rewritten every time the stack evolves.

How Better Auth works (Core concepts and architecture)

Better Auth is a TypeScript‑first authentication library designed around HTTP and databases, not frameworks.

At its core, it connects three layers:

Database layer: Stores users, sessions, credentials, and verification data in your own database.
Authentication core: Handles password hashing, session creation, validation, and security logic.
Framework adapters: Translate framework requests into auth operations without embedding framework logic into the auth layer.

The result: One authentication configuration that works across Next.js, Remix, SvelteKit, and Express. Frameworks pass requests through; Better Auth handles the rest.

What you gain by owning the auth layer

This architectural shift comes with some clear benefits.

Framework portability: Authentication is no longer tied to a single framework’s lifecycle. You can migrate or experiment without rewriting the auth from scratch.
Type safety end-to-end: Because schemas generate TypeScript types, your authentication logic stays consistent across the stack.
Full data ownership: Users, sessions, and credentials live in your database, not inside a third-party system. That gives you control over behavior, retention, and performance.
Predictable costs: There’s no per-user pricing. Costs scale with infrastructure, not with user count.

For teams that have felt boxed in by framework-specific auth or rising managed-service costs, this alone can be compelling.

Performance and trade‑offs

Better Auth is designed to be lightweight and fast, but it’s also transparent about what you’re taking on.

In typical setups:

The auth bundle is relatively small, often in the ~10-15 kB gzipped range, depending on configuration
Session validation can often complete in tens of milliseconds with proper indexing and low-latency database access Sessions are database-backed, keeping memory usage predictable

That said, owning authentication also means owning its responsibilities.

You’re responsible for:

Database migrations and cleanup
Monitoring session tables
Email delivery and rate limiting
Security hardening beyond the defaults

Better Auth favors control over convenience. For teams comfortable with backend infrastructure, that’s a reasonable trade. For teams looking for zero-maintenance auth, it may not be.

Note: Performance metrics are estimates and vary based on infrastructure, database location, connection quality, and load. Always benchmark in your specific environment.

What a minimal Better Auth setup looks like

To understand how Better Auth works in practice, it helps to look at a minimal setup. Instead of walking through commands or file-by-file instructions, let’s break this into the core layers and how they interact.

At a high level, the setup has three parts:

A data layer that stores users and sessions
An authentication layer that handles login and session logic
A thin UI layer that interacts with the auth system

The key difference is that these layers remain independent of the framework.

The stack (and why it stays minimal)

This example uses Next.js, SQLite, and Drizzle ORM, not because Better Auth requires them, but because they keep the setup lightweight and easy to reason about.

Better Auth itself is framework-agnostic. The framework simply acts as a transport layer for requests, while authentication logic lives independently.

The data layer: owning your auth data

Let’s start with the foundation: the data layer. This is where Better Auth changes the usual approach.

Instead of storing authentication data inside a managed service or hiding it behind a framework, everything lives directly in your database.

In practice, this typically translates into a small set of core tables:

user: stores profile information
session: tracks active sessions and expiration
account: manages credentials or provider accounts
verification: handles temporary tokens like email verification

The exact structure can vary, but the important shift is ownership. Authentication data is no longer abstracted away. It becomes part of your application’s data model.

This also means it evolves with your product. Schema changes, indexing, and performance tuning become part of your responsibility, not something delegated to a third-party system.

The authentication layer: where everything connects

Once the data layer is in place, the next piece is the authentication layer, where everything comes together.

This is where Better Auth becomes the center of the system. Instead of spreading authentication logic across routes, controllers, or framework-specific APIs, everything is defined in one place.

The database connects through an adapter, and authentication methods such as email and password are enabled declaratively. From that point on, the same logic handles every request, regardless of where it originates.

That consistency is what makes the approach powerful. Whether a request comes from Next.js, Remix, or an Express API, it flows through the same authentication layer. This separation is what enables true framework portability.

Read the full blog post on the Syncfusion Website

Real-Time Angular Gantt Chart with SignalR: Multi-User Project Sync Without Refresh

Lucy Muturi — Tue, 23 Jun 2026 11:20:28 +0000

TLDR: Concurrency issues don’t break your Gantt chart UI; they break trust in the data. The moment multiple users start editing, timelines drift, updates get missed, and teams fall back to manual coordination. This approach changes that. By integrating SignalR into your Angular Gantt Chart, wiring a lightweight backend hub, real-time client listeners, and event-driven updates, you turn a static timeline into a live, shared system. No polling, no refreshes, no guesswork; just instant updates and a consistent view for every user, exactly when it matters.

In most project management tools, things start breaking the moment multiple users start editing at the same time.

One person updates a task.
Another modifies dependency.
Someone else shifts a timeline.

Before long, everyone looks at a slightly different version of the same data.

A Gantt Chart helps organize all of this; it visualizes dependencies, timelines, and resources clearly. But by default, it’s still just a local snapshot. Once multiple users are involved, keeping everyone in sync becomes the real problem.

This is where real-time updates change the behavior completely.

Instead of relying on refreshes or polling, SignalR keeps a persistent connection and pushes updates instantly to all connected clients.

The result is simple: everyone sees the same timeline, in real time, without second-guessing whether their view is up to date.

In this guide, we’ll walk you through integrating SignalR into the Syncfusion^® Angular Gantt Chart setup to make that happen.

What you gain: a timeline that stays in sync automatically

Once real-time updates are in place, the Gantt Chart behaves more like a shared system than a static UI:

Immediate updates: Changes made by one user appear for everyone instantly.
No refresh cycles: The UI stays current without manual intervention.
Event-driven behavior: Updates are pushed only when something changes.
Less coordination overhead: Everyone stays aligned without follow-ups.

Where this approach actually matters

Integrating SignalR with the Angular Gantt Chart is most useful when multiple roles interact with the same timeline.

For example, in a sprint planning tool:

A product owner adjusts deadlines.
Developers update tasks and dependencies.
QA engineer modifies testing windows.

Without real-time sync, updates get missed or overwritten, and teams fall back to messaging each other for confirmation.

With SignalR in place, the Gantt Chart behaves like a shared workspace; updates are visible immediately, and everyone works off the same state.

You’ll see similar benefits in tools like:

Construction scheduling,
Resource planning dashboards, or
Internal workflow trackers,

….. and anywhere multiple users actively edit the timeline.

What you need to get started

The setup is fairly lightweight:

Visual Studio or VS Code
Angular application
.NET 8+ backend
SignalR
Node.js and Angular CLI (ng new gantt-signalr)
A valid Syncfusion license key

Setting up the backend: .NET Core with SignalR

Before jumping onto the Angular side, it’s worth getting the backend ready. This is where the real-time behavior actually lives. Instead of thinking of it as just another API, think of it more like an event relay that pushes updates whenever something changes.

If you’ve tried solving multi-user sync with polling before, you already know how quickly it becomes inefficient. SignalR avoids that entirely by maintaining a connection and pushing updates only when needed.

#1: Getting a basic API in place

Start with a standard ASP.NET Core Web API project. Nothing unusual here.

If you already have a backend serving your Gantt data, you’re in a good place; you don’t need to rebuild anything. Just add SignalR on top of what you already have.

#2: Adding the SignalR hub (your real-time bridge)

Once the project is ready, the next step is adding a hub.

Create a folder called Hubs, and inside that add a file named ChatHub.cs. This hub defines the SendMessage method that broadcasts messages to all connected clients.

//Hubs/ChatHub.cs

using Microsoft.AspNetCore.SignalR;

namespace GanttSignalRBackend.Hubs
{
    public class ChatHub : Hub
    {
        public async Task SendMessage(string message)
        {
            await Clients.All.SendAsync("ReceiveMessage", message);
        }
    }
}

At this point, you’re not doing anything complex; you’re just broadcasting a message to every connected client. That’s enough to build your sync loop.

#3: Wiring it up so Angular can talk to it

With the hub in place, the next step is to register SignalR services and enable CORS (Cross-Origin Resource Sharing) and make sure your frontend can actually connect to it.

Program.cs

using signalR.Hubs;

builder.Services.AddSignalR(); // Add SignalR services

builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.WithOrigins("https://localhost:7297") // Angular dev server
              .AllowAnyHeader()
              .AllowAnyMethod()
              .AllowCredentials();
    });
});

The CORS setup is important during development, since our Angular app typically runs on a different port. Without it, the connection won’t go through.

#4: Run the project

At this point, you can just start the backend using the following command:

dotnet run

It should start on:

https://localhost:7297(or a similar port).

Now, the backend is ready! It can accept connections and push updates to any client that’s listening.

Setting up the frontend: Angular with Syncfusion Gantt Chart

With the backend ready to push updates, the front-end is where things start to feel different.

Up until now, your Gantt chart has probably behaved like a snapshot; render data once, and that’s it. Now, you’re going to make it react to changes happening elsewhere.

You don’t need a complex setup to get there. A regular Angular app with a working Gantt chart is enough.

#1: Start with your usual Angular setup

Create your Angular project and set up the Gantt Chart however you normally would. Nothing has changed here yet.

#2: Add the SignalR client package

To handle real-time updates, we need the SignalR client:

npm install @microsoft/signalr –save

Once that’s installed, Angular is ready to connect to the backend and start listening for updates.

#3: Register the Syncfusion license key

Before moving further, make sure your license key is registered in your component:

app.component.ts

import { registerLicense } from '@syncfusion/ej2-base';
registerLicense('YOUR_SYNC FUSION_LICENSE_KEY');

After that, your Gantt Chart setup remains exactly as usual.

Read the full blog post on the Syncfusion Website

How to Scale React Pivot Tables with Docker and Server-Side Processing

Lucy Muturi — Mon, 22 Jun 2026 12:20:31 +0000

TL;DR: Large datasets can quickly slow down applications when the browser handles heavy data operations. In this guide, you’ll learn how to implement React Pivot Table server-side processing using Docker, move expensive filtering and aggregation to the backend, and build faster, scalable React applications with better performance.

When you start working with large datasets in a Pivot Table, things can slow down quickly. What works fine with a few thousand rows can become frustrating with hundreds of thousands.

The main problem?
Too much processing is happening in the browser.

That’s where a server-side pivot engine comes in; it shifts heavy operations like aggregation, filtering, and sorting to the backend.

In this guide, we’ll walk through how to:

Set up a Syncfusion^® React Pivot Table server-side pivot engine
Containerize it using Docker
Connect it to a React application

By the end, you’ll have a setup that’s portable, scalable, and much easier to maintain.

Why would you actually need this?

Before diving into setup, let’s make this real.

You’ll need a server-side Pivot Table when building things like:

A sales dashboard with hundreds of thousands of records
A finance reporting tool with complex aggregations
A business intelligence UI where users slice and dice large datasets

In scenarios like these:

Browser memory gets stressed
UI becomes sluggish
Data processing becomes unreliable

Moving that workload to the server solves all of that cleanly.

Why Docker makes this easier

Setting up a backend service manually can be messy, with different machines, missing dependencies, and version mismatches.

Docker simplifies this by packaging everything your app needs into a container.

Think of it like this:

Docker Image → blueprint
Container → running instance

Once your app is containerized:

It behaves the same everywhere
You avoid “works on my machine” issues
Deployment becomes predictable

To explore Docker further and start using it on your system, visit the official Docker documentation.

Prerequisites

Before getting started, make sure you have the following installed:

Visual Studio 2022 with ASP.NET workload
Docker Desktop (installed and running)
- Windows
- Linux
- Mac
Node.js LTS

Phase 1: Get the server-side engine ready

Let’s start with the backend.

Instead of building everything from scratch, you can use a ready-made ASP.NET Core GitHub sample that already includes the pivot engine.

Once you download it:

Open the project in Visual Studio
Build it

That’s it, the required dependencies will be restored automatically.

At this point, you already have a backend capable of:

Processing pivot data
Handling API requests
Working with large datasets efficiently

For more details about the server-side Pivot Engine and how it works, you can refer to our React Pivot Table official documentation.

Phase 2: Containerize the backend using Docker

Now let’s package this backend so it can run anywhere.

Option 1 (simplest): Use Visual Studio

If you’re using Visual Studio, this is almost effortless:

Right-click the project
Select Add → Docker Support

Adding Docker Support in Visual Studio

Choose Linux

Choosing Target OS for Docker

Visual Studio automatically generates:

A Dockerfile
A .dockerignore file

You don’t need to manually configure anything.

Option 2: Use a Dockerfile manually

If you prefer more control, you can add a Dockerfile yourself.

Sample configuration

Dockerfile

# This stage is used when running from VS in fast mode (Default for Debug configuration)

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
USER $APP_UID
WORKDIR /app
EXPOSE 8080
EXPOSE 8081

# This stage is used to build the service project

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY ["PivotController.csproj", "."]
RUN dotnet restore "./PivotController.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "./PivotController.csproj" -c $BUILD_CONFIGURATION -o /app/build

# This stage is used to publish the service project to be copied to the final stage

FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "./PivotController.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

# This stage is used in production or when running from VS in regular mode (Default when not using the Debug configuration)
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "PivotController.dll"]

Note: If your application uses a different version of .NET (for example, .NET 8.0 or .NET 7.0), make sure to update the version numbers in the FROM lines accordingly.

At a high level, the Dockerfile:

FROM: Sets the base image (usually a .NET SDK image).
WORKDIR: Defines the working directory inside the container.
COPY: Copies your project files into the container.
RUN: Runs commands like dotnet build or dotnet publish.
EXPOSE: Tells Docker which port the container will use.
ENTRYPOINT: Specifies the command to run when the container starts.

Even if you’ve never worked with Dockerfiles before, you don’t need to memorize every instruction; the structure is consistent across most .NET apps.

Build the Docker image

Once the Dockerfile is ready, build the image.

Option 1: Using Visual Studio

Just right-click the Dockerfile and build; it handles everything.

Building a Docker Image in Visual Studio

Option 2: Using terminal

Run:

Docker CLI

docker build -t pivotcontroller .

That single command creates your container image.

Note: Make sure to include the dot (.) at the end; it tells Docker to use the current directory.

Read the full blog post on the Syncfusion Website