At Build 2025, we introduced the Microsoft 365 Copilot APIs. Developers now have an extensibility layer that empowers them to create intelligent, AI-driven experiences deeply integrated with the Microsoft 365 ecosystem. These APIs unlock powerful capabilities like content retrieval, meeting summarization, and user interaction export and accelerate innovation while ensuring enterprise-grade security and compliance. 

Today, we’re excited to announce that the Retrieval API, one of the most requested APIs in the set, is now available in Public Preview.  

The Retrieval API gives developers a secure, compliant and scalable way to integrate enterprise content into their AI workflows. Whether you’re building RAG pipelines, domain-specific agents or mining insights, it provides a powerful foundation for grounding large language models in trusted organization’s knowledge with minimal setup and maximum flexibility.  

Early adopters such as Accenture, Thomson Reuters, Peppermint, Templafy, and Petrobras are already putting the Retrieval API to work and powering value across a range of enterprise AI use cases. 

“At Accenture, we view the Retrieval API as a transformative advancement in our multi-platform agentic strategy. It extends the capabilities of our substantial Microsoft 365 Copilot footprint by enabling intelligent, context-aware agents to operate seamlessly across various environments. This API allows our custom applications and agents to securely access Microsoft 365 data while maintaining existing permissions, simplifying development and ensuring built-in compliance.” – Accenture  

Why it matters: Built for enterprise-grade AI

Building AI experiences in the enterprise isn’t just about model quality; it’s about trust, scale, and seamless integration with how your organization works. The Retrieval API is designed to meet that bar, enabling developers to innovate confidently with secure, scalable access to enterprise knowledge.  

The Retrieval API enables natural language queries over Microsoft 365 content, returning relevant, permission-trimmed snippets ready to ground AI experiences. With a simple REST call, developers can retrieve knowledge from SharePoint Online and Copilot connector–indexed content, making it easy to build intelligent, context-aware solutions. 

“As a customer who is heavily invested in Microsoft’s storage, SharePoint Online and OneDrive, the main benefit of the Retrieval API is relieving us of the weight of managing content indexing. With the Retrieval API, we can maintain our own post processing flows and create agents while still being able to access raw content and leverage it through the gen AI platform of our choice.” – Petrobras  

Here’s what makes the Retrieval API stand out:  

• Secure and trustworthy by design: All results are permission-trimmed at query time, reflect Microsoft Entra ID access controls, and carry sensitivity label metadata, ensuring your agents and orchestrators never surface unauthorized or misclassified content.  

• Less infrastructure overhead: You no longer need to build and maintain your own retrieval infrastructure or vector indexes. The Retrieval API uses the same semantic index that powers Microsoft 365 Copilot, so you can ground LLM responses without additional pipelines or duplication.  

• Developer control with enterprise flexibility: With support for custom filters using metadata fields and connector labels, the API gives developers fine-grained control over what content is retrieved and how it’s used in downstream logic.   

• Faster performance with fewer API calls: The Retrieval API supports JSON batching, allowing multiple queries to be sent through a single request. This makes it easier to power concurrent grounding workflows while keeping API calls efficient and scalable in large applications.  

The Retrieval API brings the semantic richness of Microsoft 365 to your AI stack, without compromising security, governance, or developer agility.  

What can you build with the Retrieval API

The Retrieval API unlocks powerful, real-world scenarios by providing a secure, scalable semantic access layer to enterprise content. It expands what’s possible for pro-code developers, enabling use cases that previously were only possible with low-code tools like Copilot Studio through Tenant Graph grounding, while still supporting a range of approaches to building agents in Microsoft 365. 

“Thomson Reuters is pioneering the integration of its AI assistant, CoCounsel, with Microsoft 365 via the Retrieval API to enhance legal workflows. In document review scenarios, CoCounsel enables legal professionals to query batches of contracts stored in SharePoint or OneDrive—extracting key clauses like indemnity or confidentiality—grounded in actual document content for accuracy and compliance. Simultaneously, CoCounsel can search and pull value from internal legal databases and Microsoft 365 content to answer complex legal queries, such as identifying standard clauses or retrieving documents tied to specific clients or legal issues. Thomson Reuters early adoption underscores its commitment to transforming legal operations through AI, without compromising on security, context sensitivity, or compliance.” – Thomson Reuters  

Here are a few examples of what’s possible with the Retrieval API:  

• Policy and process agents: Build agents that can answer questions like “What’s our latest expense policy?” by retrieving relevant snippets from SharePoint and connector-indexed documents, ensuring responses are grounded in real, up-to-date internal content.  

• Meeting-aware workflows: Use the Retrieval API alongside the Meeting Insights API to surface documents or decisions related to a meeting topic, helping teams follow up more effectively without having to search manually.  

• Domain-specific knowledge assistants: Create agents tailored for legal, HR, or finance teams that pull content from curated sites and filtered fields using metadata, content source, or connector tags.  

• RAG-based applications: Use the Retrieval API as the retrieval layer in retrieval-augmented generation (RAG) pipelines, grounding model responses in tenant-specific content while preserving full compliance with organizational security and access policies.  

By combining natural language queries with live, governed enterprise data, the Retrieval API brings intelligence closer to where work gets done, without adding infrastructure burden or governance risk.  

Get started

The Retrieval API is now available for public preview via Microsoft Graph. Getting started is simple.  

Prerequisites:  

• You’ll need a Microsoft 365 tenant with Copilot licenses assigned to any users making API calls.  

• Make sure your tenant has access to SharePoint Online or indexed entities via Copilot connectors. 

•  The Copilot Retrieval API will adhere to Restricted SharePoint Search and Copilot connector staged rollout settings. 

Try it out:  

• Use Graph Explorer or any REST client to test requests against the `/beta/copilot/retrieval` endpoint.  

• Start with a simple POST request containing a natural language query and the data source you are targeting.  

• Access the API via client libraries included in the Microsoft 365 Agents SDK under the Microsoft.Agents.M365Copilot namespace. Libraries are available for .NET, TypeScript, and Python.  

• Explore filters, batching, and response fields to customize for your scenario.  

Provide feedback:  

• Microsoft Q&A is the site for technical questions and answers for Microsoft products. Use the Microsoft 365 Copilot Development tag to ask questions, connect with other developers, and submit answers. 

Learn more:  

Check out the Retrieval API documentation to learn about the capabilities available today for public preview.  

We’re excited to see what you build with the Microsoft 365 Copilot APIs, and we look forward to learning from your feedback.  

The post Microsoft 365 Copilot APIs: Unlocking enterprise knowledge for AI with the Retrieval API — Now in Public Preview appeared first on Microsoft 365 Developer Blog.

AzureAD PowerShell was announced as deprecated in 2023. In this update, we’ll share more information about the timeline, what to expect, and required actions. We understand that retirements can be disruptive, but this activity is an important part of our commitment to security and programmability for our customers’ tenants.  

Key points 

1. The AzureAD and AzureAD-Preview PowerShell modules will be retired (and stop working) starting in mid-October 2025. 
2. You can expect one or more temporary outage tests of 8-24hrs in duration in the month of September 2025.  

It's important to take action now by migrating your scripts using these retiring modules to Microsoft Graph PowerShell SDK or Microsoft Entra PowerShell. Over the coming months, we’ll provide more specific timelines regarding impact of these retirements through M365 Message Center messages.  

Identifying use of AzureAD PowerShell in your tenant 

There are two tools available to you to understand usage of these legacy modules and impact of this retirement: Entra Recommendations and Sign-in logs.  

Entra Recommendations 
The recommendation titled: Migrate from the retiring MSOnline and AzureAD PowerShell usage to Microsoft Graph PowerShell provides a report on usage of legacy PowerShell in the last 30days. This recommendation is updated daily and shows the operations, number of API requests, last request date, and max daily user count for these modules.  

Sign-in logs 
Sign-in logs are useful to identify who’s using AzureAD PowerShell. You can search Sign-in logs (interactive and non-interactive both) for the application “Azure Active Directory PowerShell” to show sign-in requests made with the retiring modules. 

Migrating AzureAD PowerShell to Microsoft Graph  

To migrate from your scripts to Microsoft Graph, identify the scripts using the AzureAD cmdlets and replace them with Microsoft Graph PowerShell or Microsoft Entra PowerShell equivalents. Additional documentation, including cmdlet mapping guidance, can be found in the More resources links below. 

If you’re using Microsoft Entra PowerShell, you can also use the compatibility mode option to make migration easier. With this feature, Microsoft Entra PowerShell can run most AzureAD PowerShell scripts with only minimal changes: 

Import-Module -Name Microsoft.Entra.Users 

Connect-Entra #Replaces Connect-AzureAD for auth 

Enable-EntraAzureADAlias #Activate aliasing 

Also using Azure AD Graph APIs in your apps? 

Those APIs are going away in early September 2025, and temporary outages will begin as soon as late July. For guidance on identifying affected apps and migrating to Microsoft Graph, read this blog post on Azure AD Graph API retirement. 

Kristopher Bash 

More resources 

• Migrate from Azure AD PowerShell to Microsoft Graph PowerShell.  
• Find Azure AD and MSOnline cmdlets in Microsoft Graph PowerShell 
• Microsoft Graph PowerShell SDK 
• Microsoft Entra PowerShell 

Learn more about Microsoft Entra  

Prevent identity attacks, ensure least privilege access, unify access controls, and improve the experience for users with comprehensive identity and network access solutions across on-premises and clouds. 

• ⁠Microsoft Entra News and Insights | Microsoft Security Blog  
• ⁠⁠Microsoft Entra blog | Tech Community  
• ⁠Microsoft Entra documentation | Microsoft Learn 
• Microsoft Entra discussions | Microsoft Community  

Goose is an innovative CLI assistant designed to automate development tasks using AI models. Docker Model Runner simplifies deploying AI models locally with Docker. Combining these technologies creates a powerful local environment with advanced AI assistance, ideal for coding and automation.

Looking for a seamless way to run AI-powered development tasks locally without compromising on privacy or flexibility? Look no further. By combining the power of Goose, a CLI-based AI assistant, with Docker Model Runner, you get a streamlined, developer-friendly setup for running large language models right on your machine.

Docker Model Runner makes it easy to run open-source AI models with Docker, no cloud APIs or external dependencies required. And the best part? It works out of the box with tools like Goose that expect an OpenAI-compatible interface. That means you can spin up advanced local assistants that not only chat intelligently but also automate tasks, run code, and interact with your system, without sending your data anywhere else.

In this guide, you’ll learn how to build your own AI assistant with these innovative tools. We’ll walk you through how to install Goose, configure it to work with Docker Model Runner, and unleash a private, scriptable AI assistant capable of powering real developer workflows. Whether you want to run one-off commands or schedule recurring automations, this local-first approach keeps you in control and gets things done faster.

Install Goose CLI on macOS

Goose is available on Windows, macOS, and Linux as a command-line tool, and also has a desktop application for macOS if that’s what you prefer. In this article, we’ll configure and show the CLI version on macOS. 

To install Goose on you can use this handy curl2sudo oneliner technique:

curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash

Enable Docker Model Runner

First, ensure you have Docker Desktop installed. Then, configure Docker Model Runner with your model of choice. Go to Settings > Beta features and check the checkboxes for Docker Model Runner.

By default, it’s not wired to be available from your host machine, as a security precaution, but we want to simplify the setup and enable the TCP support as well. The default port for that would be 12434, so the base URL for the connection would be: http://localhost:12434

Figure 1: Docker Desktop beta features settings showing how to enable port 12434

Now we can pull the models from Docker Hub: hub.docker.com/u/ai and run the models. For this article, we’ll use ai/qwen3:30B-A3B-Q4_K_M because it gives a good balance of world knowledge and intelligence at just 3B active parameters: 

docker model pull ai/qwen3:30B-A3B-Q4_K_M
docker model run ai/qwen3:30B-A3B-Q4_K_M

This command starts the interactive chat with the model.

Configure Goose for Docker Model Runner

Edit your Goose config at ~/.config/goose/config.yaml:

GOOSE_MODEL: ai/qwen3:30B-A3B-Q4_K_M
GOOSE_PROVIDER: openai
extensions:
  developer:
    display_name: null
    enabled: true
    name: developer
    timeout: null
    type: builtin
GOOSE_MODE: auto
GOOSE_CLI_MIN_PRIORITY: 0.8
OPENAI_API_KEY: irrelevant
OPENAI_BASE_PATH: /engines/llama.cpp/v1/chat/completions
OPENAI_HOST: http://localhost:12434

The OPENAI_API_KEY is irrelevant as Docker Model Runner does not require authentication because the model is run locally and privately on your machine.

We provide the base path for the OpenAI compatible API, and choose the model GOOSE_MODEL: ai/qwen3:30B-A3B-Q4_K_M that we have pulled before.

Testing It Out

Try Goose CLI by running goose in the terminal. You can see that it automatically connects to the correct model, and when you ask for something, you’ll see the GPU spike as well.

Figure 2: Goose CLI running in terminal, showing example of response to local prompts

Now, we also configure Goose to have the Developer extension enabled. It allows it to run various commands on your behalf, and makes it a much more powerful assistant with access to your machine than just a chat application.

You can additionally configure the custom hints to Goose to tweak its behaviour using the .goosehints file.

And what’s even better, you can script Goose to run tasks on your behalf with a simple one-liner:

goose run -t "your instructions here" or goose run -i instructions.md
where instructions.md is the file with what to do.

On macOS you have access to crontab for scheduling recurrent scripts, so you can automate Goose with Docker Model Runner to activate repeatedly and act on your behalf. For example, crontab -e, will open the editor for the commands you want to run, and a line like the one below should do the trick:

5 8 * * 1-5 goose run -i fetch_and_summarize_news.md

Will make Goose run at 8:05 am every workday and follow the instructions in the fetch_and_summarize_news.md file. For example, to skim the internet and prioritize news based on what you like.

Conclusion

All in all, integrating Goose with Docker Model Runner creates a simple but powerful setup for using local AI for your workflows.
You can make it run custom instructions for you or easily script it to perform repetitive actions intelligently.
It is all powered by a local model running in Docker Model Runner, so you don’t compromise on privacy either.

Learn more

• Read our quickstart guide to Docker Model Runner.
• Find documentation for Model Runner.
• Subscribe to the Docker Navigator Newsletter.
• New to Docker? Create an account. 
• Have questions? The Docker community is here to help.

The Syncfusion^® Blazor 2025 Volume 2 release brings powerful updates for developers, including a new spreadsheet component, up to 99% performance improvements, and enhanced DataGrid and Charts. Explore how these features can elevate your Blazor applications.

Let us dive into the exciting new features and enhancements for Blazor developers.

.NET 10 preview compatibility

Syncfusion^® Blazor components are now fully compatible with .NET 10 Previews 1 through 5.

Note: .NET 10 is in preview, and features may change in the final release.

Blazor Spreadsheet component (Preview)

The most anticipated addition to the Blazor suite is the comprehensive Spreadsheet component, delivering an Excel-like experience in your web applications. This powerful component transforms how users interact with tabular data, offering familiar spreadsheet functionality with modern web performance.

Key features of the Blazor Spreadsheet

The Spreadsheet component provides an extensive feature set designed for complex data scenarios:

Core functionality:

• Formula calculations: Over 400 built-in formulas for mathematical, statistical, financial, and logical operations.
• File operations: Complete support for opening, editing, and saving Excel format files.
• Dynamic resizing: Interactive row and column resizing for optimal data presentation.
• Cell styling: Comprehensive formatting options including fonts, backgrounds, and alignment.

Advanced data management:

• Sorting and filtering: Organize data with multiple criteria and advanced filtering options.
• Clipboard operations: Full copy, cut, and paste functionality with formatting preservation.
• Autofill capabilities: Intelligent data entry with pattern recognition.
• Undo/redo support: Complete action history for flexible editing workflows.
• Sheet management: Add, insert, delete, duplicate, and move worksheets.
• Hyperlinks: Create and edit hyperlinks within cells.
• Image insertion: Insert and edit images within spreadsheet cells.

Note: For more details, refer to the Blazor Spreadsheet demo.

Massive performance improvements across Blazor components

One of the most significant improvements in this release focuses on the Dropdown component performance. The optimization efforts have resulted in dramatic speed increases across all dropdown controls through optimized code logic and removal of unnecessary DOM attributes.

Blazor Dropdown performance enhancements

The performance improvements span multiple scenarios and environments:

These improvements are particularly beneficial for applications handling large datasets and require no code changes to existing implementations.

Enhanced DataGrid with advanced features

The Blazor DataGrid provides powerful new features that enhance data manipulation and user experience.

Drag and drop anywhere in the Grid

The DataGrid now supports dropping rows into empty areas using the AllowEmptyAreaDrop property, which is enabled by default. This provides more flexible row rendering capabilities within-grid and cross-grid drag-and-drop scenarios.

Note: For more details, refer to the Blazor DataGrid drag and drop demo.

Filter editor customization

Customize built-in filter editors using the FilterEditorSettings property on GridColumn for enhanced user experience in both filter menu and Excel filter dialogs.

Note: For more details, refer to the Blazor DataGrid filter customization demo.

Accent-insensitive search

Enhanced search functionality using the IgnoreAccent property in GridSearchSettings that ignores diacritic marks for multilingual applications when using IEnumerable data sources.

Note: For more details, refer to the Blazor DataGrid accent-insensitive search demo.

Significant Diagram performance improvements

The Blazor Diagram component receives unprecedented performance enhancements, ranging from 24% to 99% in various scenarios through optimized rendering algorithms and memory management.

Diagram performance benchmarks

The performance improvements span multiple operations and environments:

Enhanced connector routing algorithm

The new AvoidLineOverlapping constraint in DiagramConstraints prevents connector overlapping and maintains diagram clarity by automatically adjusting connector geometry to avoid neighboring connectors.

Connector ports support

The new ConnectorPort feature allows users to define precise connection points on connectors, enabling accurate connections between connectors or shapes.

UML sequence diagram generation

Automatically generate UML sequence diagrams from model data, creating lifelines, messages, and activation boxes dynamically. Includes support for importing and exporting UML sequences in Mermaid syntax.

Key features:

• Automatic diagram generation from model data.
• Mermaid syntax import/export support.
• Dynamic lifeline and message creation.
• AI assistant integration for Mermaid syntax generation.

Note: For more details, refer to the Blazor Diagram UML sequence diagram demo.

Rich Text Editor with advanced features

The Blazor Rich Text Editor provides powerful features for enhanced content creation and productivity.

Insert a code block with language selection

The Code Block feature allows users to insert formatted code snippets using the toolbar button or Ctrl+Shift+B shortcut. It also supports a language selection dropdown.

• Configure languages using the Languages property and set the default language with RichTextEditorCodeBlockSettings.DefaultLanguage.
• Supports JavaScript, Python, HTML, and other programming languages.

Note: For more details, refer to the Blazor Rich Text Editor code block demo.

Slash menu for quick actions

The slash command menu (triggered by) provides rapid access to formatting options and content insertion using RichTextEditorSlashMenuSettings.

• Set the Enable property to true to use this feature.
• Configure items using the Items collection.
• Customize behavior with the SlashMenuItemSelecting event.

Note: For more details, refer to the Rich Text Editor slash menu demo.

Format Painter for consistent styling

The Format Painter tool enables copying formatting attributes from one text selection to another, with configurable allowed and denied formats.

• Add FormatPainter to ToolbarItems array.
• Configure with RichTextEditorFormatPainterSettings.
• Control formats using the AllowedFormats and DeniedFormats properties.

Note: For more details, refer to the Blazor Rich Text Editor Format Painter demo.

Additional features

Bottom Toolbar Support: The Bottom Toolbar feature introduces a fixed toolbar at the bottom of the Rich Text Editor, offering quick access to frequently used formatting tools.

• Configure position using Position property
• Supports Top and ToolbarPosition.Bottom enums

Popup toolbar: The Popup toolbar automatically relocates overflowing toolbar items into a popup container when there isn’t enough space to display them, making it especially useful for constrained layouts or smaller screens.

• Enable with Type set to ToolbarType.Popup
• Automatically handles overflowing toolbar items

Enhanced file upload: The MaxFileSize support feature in the Rich Text Editor allows developers to configure a maximum file size limit for uploaded media files, including images, audio, and video, helping to validate uploads and prevent oversized content.

• Configure maximum file size using MaxFileSize
• Default limit: 30MB, customizable per media type

Recent colors support: The Show Recent Color support feature in the Rich Text Editor enhances the font color and background color pickers by displaying recently used colors, allowing users to quickly access and reuse them for consistent formatting.

• Control the recent colors display with the ShowRecentColors property
• Available in font color and background color pickers

Enhanced Charts with advanced visualization

The Blazor charts component introduces new features for better data visualization and user interaction.

Border radius for Accumulation Charts

Add rounded corners to pie and donut charts using the BorderRadius property in AccumulationChartSeries for enhanced visualization.

• Property: BorderRadius
• Applies to pie and donut chart types
• Customizable radius values for different visual effects

Note: For more details, refer to the Blazor Charts border radius demo.

Center label support for Pie and Donut charts

Display desired labels at the center of pie and donut charts using the AccumulationChartCenterLabel with dynamic content based on hover interactions.

• Component: AccumulationChartCenterLabel
• Dynamic updates with HoverTextFormat property
• Context-sensitive label display on data point hover

Note: For more details, refer to the Blazor Charts center label demo.

Stack labels for Stacked Charts

Display total values for each section in stacked column or bar charts using ChartStackLabelSettings for improved data readability.

• Component: ChartStackLabelSettings
• Automatic calculation and display of section totals
• Enhances data interpretation in complex datasets

Note: For more details, refer to the Blazor Charts stack labels demo.

Customizable scrollbar position

Control scrollbar placement using the Position property in ChartAxisScrollbarSettings for enhanced user interaction.

• Property: Position
• Vertical scrollbar: left or right placement
• Horizontal scrollbar: top or bottom placement

Zoom toolbar positioning

Customize the zoom toolbar location using ChartZoomToolbarPosition in ChartZoomSettings with precise offset positioning support.

• Property: ChartZoomToolbarPosition
• Positions: left, right, top, bottom
• Offset positioning for precise placement

Note: Explore the Blazor Charts with Zooming and Panning demo.

Column width in pixels

Specify exact column widths using the ColumnWidthInPixel property in ChartSeries for precise layout control.

• Property: ColumnWidthInPixel
• Exact pixel value specification
• Applies to column series types

Enhanced PDF Viewer with redaction support

The PDF Viewer now includes comprehensive redaction annotation capabilities for document security and customizable zoom controls.

Redaction annotation implementation

Key features:

• Secure content redaction with permanent removal capability
• Customizable redaction marks with color and overlay text options
• Real-time preview functionality for accuracy verification
• User-friendly interface for area selection and redaction application

Note: Explore the Blazor PDF Viewer demo.

Zoom customization

Control zoom limits using the MinZoomValue and MaxZoomValue properties in the PDF Viewer for an enhanced viewing experience.

• Properties: MinZoomValue and MaxZoomValue
• Customizable zoom range for different document types
• Improved user control over document viewing

Enhanced TreeGrid performance for remote data

The TreeGrid component achieves remarkable performance improvements, particularly in WebAssembly environments, with optimized remote data handling and virtualization support.

TreeGrid performance benchmarks

• Optimized LoadChildOnDemand feature for remote data sources
• Enhanced virtualization with hierarchical data binding
• Improved rendering performance for deeply nested structures

Enhanced Scheduler performance

The Blazor Scheduler component delivers significant performance improvements across multiple scenarios through optimized event handling and rendering algorithms.

Scheduler performance improvements

These improvements ensure an efficient and streamlined user experience when managing large numbers of scheduled events.

Enhanced Image Editor with advanced features

The Image Editor receives powerful new capabilities for professional image manipulation and broader file format support.

Custom dimensions support

Open images with specified dimensions using additional parameters in the OpenAsync method for precise control over image rendering.

• Method: OpenAsync with width, height, and isAspectRatio parameters
• Precise dimension control while preserving aspect ratio
• Optimized for high-resolution images and fixed canvas requirements

Text annotation enhancements

Added Underline and Strikethrough formatting options for text annotations.

BMP format support

You can load BMP (Bitmap) image files through the file uploader UI or programmatically using the OpenAsync method, expanding file format compatibility for design professionals.

Note: Explore the Image Editor demo.

Enhanced Pivot Table with advanced analytics

The Pivot Table component introduces powerful new features for comprehensive data analysis and Excel integration.

Value sorting on both axes

Perform value sorting simultaneously on row and column axes, independent of the value axis, using enhanced sorting algorithms for flexible data analysis.

Note: Explore the Pivot Table value sorting demo.

Export as Excel Pivot Table

Export pivot tables as native Excel Pivot Tables, preserving the pivot structure for continued interaction and customization within Excel.

Enhanced export options

Headers and footers support:

• Include headers and footers during Excel export with the server-side engine
• Comprehensive document formatting preservation

Memory stream export:

• Save exported Excel documents as memory streams
• Enable further processing and customization before final export
• Flexible document handling for advanced scenarios

Enhanced Chat UI with modern features

The Chat UI component receives comprehensive updates for modern messaging experiences with enhanced user interaction capabilities.

Chat status indicators

Display user presence and activity states using the StatusIconCss property for visual representation of online, offline, busy, and away statuses.

• Property: StatusIconCss for status icon configuration
• Visual presence indicators for enhanced user experience
• Customizable status representations

Compact mode

Enable compact layout using the EnableCompactMode property to align all messages to the left, creating streamlined interfaces ideal for group conversations.

• Property: EnableCompactMode for layout control
• Left-aligned message display regardless of sender
• Optimized for space-constrained interfaces

Message operations

Comprehensive message-level actions including IsPinned, RepliedTo, and IsForwarded properties in the message model, with customizable MessageToolbar and MessageToolbarItem components.

• Message properties: IsPinned, RepliedTo, IsForwarded
• Components: MessageToolbar and MessageToolbarItem
• Default actions: Copy, Reply, Pin, Delete, Forward

Enhanced text input

Div-based text input instead of traditional textarea for a more intuitive and flexible user experience in message composition.

Note: Explore the Chat UI Demo.

Additional component enhancements

Enhanced AI AssistView with file attachments

The AI AssistView component now supports file attachments through the AttachmentSettings configuration, enabling richer AI interactions with document and image context.

Note: Explore the Blazor AI AssistView attachments demo.

Enhanced Tooltip with dynamic element support

The Tooltip component now automatically handles dynamically created elements using the TargetContainer property, eliminating the need for manual refresh operations.

• Property: TargetContainer for CSS selector assignment
• Automatic tooltip registration for new DOM elements
• Enhanced support for real-time content updates

Gantt Chart

Dialog closing event:

• New GanttDialogClosing event for enhanced dialog control
• Triggers on Cancel, Close icon, Escape key, or Save operations

Document editor

Accessibility improvements:

• Screen reader support for better accessibility
• Enhanced content interpretation for assistive technologies

Syncfusion Blazor components can be transformed into stunning and efficient web apps.

Try It Free

Conclusion

The 2025 Volume 2 release continues Syncfusion^® commitment to providing developers with the most comprehensive, performant, and feature-rich Blazor component suite available. Whether you’re building enterprise applications, data dashboards, or modern web experiences, these enhancements will accelerate your development and delight your users.

Start exploring these powerful new features today and transform your Blazor applications with cutting-edge capabilities that set new standards for web development excellence. 

To explore these new features:

• Download the latest release: Syncfusion^® Blazor components
• View live demos: Blazor component demos
• Read documentation: Blazor documentation
• Join the community: Syncfusion^® community forums

The Syncfusion^® Blazor 2025 Volume 2 release represents a significant leap forward in web application development capabilities. With the introduction of the comprehensive Spreadsheet component, massive performance improvements across dropdown controls, and enhanced features in over 15 existing components, this release empowers developers to build more responsive, feature-rich applications.

The performance optimizations, ranging from 1.2X to an impressive 99% improvement, will dramatically enhance user experience, particularly in data-intensive applications. The new AI-powered features, advanced visualization capabilities, and enhanced security features position Blazor applications at the forefront of modern web development.

Existing customers can download the new version of Essential Studio^® on the license and downloads page. If you are not a Syncfusion^® customer, try our 30-day free trial to check out our incredible features.

If you have any questions, contact us through our support forums, support portal, or feedback portal. We are always happy to assist you!

FAQs

Q: What does the new Spreadsheet component offer?
A: It provides an Excel-like experience with over 400 formulas, file operations, and advanced data management for web apps.

Q: How do the performance improvements impact dropdowns?
A: Dropdowns see up to 16X faster filtering and 4X faster virtualization, ideal for large datasets.

Q: Is .NET 10 support stable?
A: It supports .NET 10 Previews 1–5, but features may change in the final release

A genetic algorithm is only as effective as the loop that drives it. While selection, crossover, mutation, and elitism form the backbone of a genetic algorithm (GA), it is the configuration of the evolution loop that determines how the algorithm behaves over time.

Today’s focus is on designing and implementing the loop that runs your genetic algorithm. We will examine how to parameterize the loop with values such as population size, mutation rate, elite count, and maximum generations, and how to structure your logic to support reusable, testable, and adaptable evolutionary flows in C#.

The GA Loop Structure

At a high level, every GA loop looks like this:

1. Initialize population
2. Evaluate fitness
3. Select parents
4. Apply crossover and mutation
5. Preserve elite individuals
6. Replace the old population with the new
7. Repeat for N generations or until a stopping condition is met

By exposing configuration options and encapsulating the loop logic, we can create a flexible engine that adapts to multiple problem domains.

Configuration Parameters

Before implementing the loop, define your key GA parameters:

public class GAConfig
{
    public int PopulationSize { get; set; } = 100;
    public int MaxGenerations { get; set; } = 500;
    public double MutationRate { get; set; } = 0.01;
    public int EliteCount { get; set; } = 2;
    public string Target { get; set; } = "HELLO WORLD";
}

This GAConfig class allows you to configure your algorithm externally or via a UI or script.

Setting Up the Evolution Engine

Let’s encapsulate the core evolutionary logic into a method:

public class GeneticAlgorithm
{
    private readonly GAConfig _config;

    public GeneticAlgorithm(GAConfig config)
    {
        _config = config;
    }

    public Chromosome Run()
    {
        var population = InitializePopulation();

        for (int generation = 0; generation < _config.MaxGenerations; generation++)
        {
            EvaluatePopulation(population);

            var best = population.OrderByDescending(c => c.FitnessScore).First();
            Console.WriteLine($"Gen {generation}: {best} (Fitness: {best.FitnessScore})");

            if (best.FitnessScore == _config.Target.Length)
                return best;

            population = Evolve(population);
        }

        return population.OrderByDescending(c => c.FitnessScore).First();
    }

    private List<Chromosome> InitializePopulation()
    {
        return Enumerable.Range(0, _config.PopulationSize)
                         .Select(_ => new Chromosome(_config.Target.Length))
                         .ToList();
    }

    private void EvaluatePopulation(List<Chromosome> population)
    {
        foreach (var c in population)
        {
            c.FitnessScore = c.GetFitness(_config.Target);
        }
    }

    private List<Chromosome> Evolve(List<Chromosome> current)
    {
        var nextGen = new List<Chromosome>();
        var elites = current.OrderByDescending(c => c.FitnessScore)
                            .Take(_config.EliteCount)
                            .Select(c => new Chromosome((char[])c.Genes.Clone()))
                            .ToList();

        nextGen.AddRange(elites);

        while (nextGen.Count < _config.PopulationSize)
        {
            var parent1 = TournamentSelection(current, 5);
            var parent2 = TournamentSelection(current, 5);

            var child = parent1.UniformCrossover(parent2);
            child.Mutate(_config.MutationRate);
            nextGen.Add(child);
        }

        return nextGen;
    }

    private Chromosome TournamentSelection(List<Chromosome> population, int size)
    {
        var group = population.OrderBy(_ => Guid.NewGuid()).Take(size);
        return group.OrderByDescending(c => c.FitnessScore).First();
    }
}

Tuning the Parameters

Experiment with these values depending on problem complexity, gene size, and diversity needs.

Logging and Monitoring

To debug or visualize performance over time, add tracking:

• Best fitness per generation
• Average population fitness
• Diversity metrics (e.g., unique gene sequences)

These help determine whether your configuration promotes healthy evolution or premature convergence.

Conclusion

Configuring the GA loop isn’t just about wiring steps together. It is about balancing forces—mutation versus selection, exploration versus exploitation, and speed versus stability. By making your loop modular and parameter-driven, you gain the flexibility to evolve a wide variety of solutions in C#.

Up Next

With all core mechanics in place, we next begin solving real-world problems using genetic algorithms, starting with the classic “evolving text” challenge.

You’ve built the engine. Now it’s time to drive it.

The post Day 13: Configuring the Genetic Algorithm Loop in C# appeared first on Chris Woody Woodruff.