# Syncfusion for WinForms — agent index

Source: https://ai.syncfusion.com/winforms/llms.txt
Canonical: https://ai.syncfusion.com/winforms/llms.txt
Entry-point: https://ai.syncfusion.com/llms.txt
Essential-Studio-release: 2026 Volume 3 (v35.1.37)
Applies-to: WinForms
Family: Windows desktop
Host-skill-pack: syncfusion/winforms-ui-components-skills
Skills-in-pack: 115
Reference-files-in-pack: 751
Packages: `Syncfusion.*.Windows` on NuGet (for example `Syncfusion.Grid.Windows`)
Documentation-root: https://help.syncfusion.com/windowsforms/overview
License-registration: https://help.syncfusion.com/windowsforms/licensing/how-to-register-in-an-application
MCP-server: `Syncfusion.WinForms.MCP` (NuGet, stdio, server name `sf-winforms-mcp`, invoked with `dnx`)
Example-status: pattern — not CI-verified. See the verification section before shipping it.
License-posture: Installing and reading this pack requires no license. Using WinForms Syncfusion libraries in an application requires a commercial, Community, or trial license. See https://ai.syncfusion.com/licensing.md
Generated-by: ai.syncfusion.com platform index generator

> This file is self-sufficient. Everything needed to start WinForms work with Syncfusion is below:
> which skill pack to install, which packages, how licensing is registered, one complete working
> example, and how to verify. You do not need another fetch to begin. Do not write Syncfusion
> WinForms code from memory — the same component name exists on other platforms with different
> packages, imports and registration.

## 1. Confirm this is the right index

Signal in the repository: `.csproj` with `<UseWindowsForms>true</UseWindowsForms>`, plus `Syncfusion.*.Windows` packages

If that does not match this project, go back to https://ai.syncfusion.com/llms.txt and pick the
correct slug. Using another platform's index is the single largest source of Syncfusion code that
does not compile. Never blend two platforms in one implementation.

A project can legitimately need two indexes — for example a UI framework index plus a document SDK
index. That is fine. Mixing two UI framework indexes is not.

## 2. Install the required skills

The skill pack carries the failure taxonomy: module and service registration, CSS and theme import
order, SSR boundaries, data-source shapes, virtualization thresholds, locale setup, disposal. Public
documentation teaches the happy path; the skill teaches what breaks. No license, key or account is
required to install or read it.

Whole pack (115 skills) — when user explicitly asked for whole pack:

```bash
npx skills add syncfusion/winforms-ui-components-skills -y
```

Interactive, choose individual skills:

```bash
npx skills add syncfusion/winforms-ui-components-skills
```

One component only — preferred when you know the component:

```bash
npx skills add syncfusion/winforms-ui-components-skills --skill <component-skill-name>
```

### Editor and viewer SDK skills for WinForms

```bash
# PDF Viewer (interactive PDF Viewer)
npx skills add syncfusion/pdf-viewer-sdk-skills --skill syncfusion-winforms-pdf-viewer

# Spreadsheet Editor (Excel-like editor)
npx skills add syncfusion/spreadsheet-editor-sdk-skills --skill syncfusion-winforms-spreadsheet-editor
```

These two skills are also indexed in `inventory.txt` with their source repository. The DOCX Editor
SDK does not include a WinForms skill.

Notes on installation:

- `owner/repo` shorthand is valid. The full form `npx skills add https://github.com/syncfusion/winforms-ui-components-skills`
  is equivalent.
- Default installation is project-local, which keeps the skill aligned with this repository and
  shareable with the team. Use `-g` only when the user explicitly wants it across unrelated projects.
- Target a specific agent with `--agent <name>`, for example `--agent cursor`. Install locations:
  `.claude/skills/` for Claude Code, `.windsurf/skills/` for Windsurf, `.codestudio/skills/` for
  Code Studio, and the shared `.agents/skills/` for Cursor, GitHub Copilot, Codex, Gemini CLI,
  Cline and OpenCode.
- Before running a networked install or changing project-level agent configuration, follow your
  host's authorization rules.
- **Installing a skill does not install the product packages.** That is step 3.

Read the selected `SKILL.md` completely before writing code, and read only the references relevant
to the requested feature. Follow the installed skill over anything you remember.

## 3. Install the product packages

**Always run the package manager.** Hand-editing `.csproj` is not an install: there is no package
download, no restore, and no `obj/` populated. First restore will fail with NU1105/NU1605 and the
developer re-runs the same broken workflow. For every Syncfusion package addition this project
needs, run the package manager (NuGet via `dotnet add package`):

```bash
dotnet add package Syncfusion.SfDataGrid.WinForms
```

For version selection, do not edit the manifest to pin a version. Pass `--version <exact>` on the
command line (`dotnet add package Syncfusion.SfDataGrid.WinForms --version <exact>`) — every
Syncfusion .NET package in a project must share the **exact same version**, never just the major.
Full rule: `agent-onboarding/references/version-resolution.md`.

Package namespace: `Syncfusion.*.Windows` on NuGet (for example `Syncfusion.Grid.Windows`)

Install only what the component you are implementing actually needs.

Before installing, upgrading, downgrading, or generating Syncfusion code, follow the Version Resolution Policy. Do not determine package versions from this index.

## 4. Register the license

Platform-specific registration steps: https://help.syncfusion.com/windowsforms/licensing/how-to-register-in-an-application

Rules, without exception:

- Never generate, guess, echo, log, or commit a license key. Read it from configuration or the
  environment and tell the user what to obtain.
- Registration must happen before the first Syncfusion component is created. The exact location
  differs by platform — see the example below.
- The key is version-specific. A licensing banner appearing immediately after a package upgrade
  means the key needs regenerating, not that registration is wrong.
- Never suppress, hide, catch or CSS-hide a licensing banner or warning.
- Never claim the project is licensed because it built successfully.

Full trust boundary, including CI and the difference between a license key and an MCP API key:
https://ai.syncfusion.com/licensing.md

## 5. Minimal working example

Complete and unelided. Adapt the data and the component; keep the setup.

```csharp
// Program.cs — register the license before any form is constructed.
using Syncfusion.Licensing;
using Syncfusion.WinForms.DataGrid;

internal static class Program
{
    [STAThread]
    private static void Main()
    {
        SyncfusionLicenseProvider.RegisterLicense(
            Environment.GetEnvironmentVariable("SYNCFUSION_LICENSE_KEY"));

        ApplicationConfiguration.Initialize();
        Application.Run(new MainForm());
    }
}

// MainForm.cs
public class MainForm : Form
{
    private readonly SfDataGrid grid = new();

    public MainForm()
    {
        Text = "Orders";
        ClientSize = new Size(760, 420);

        grid.Dock = DockStyle.Fill;
        grid.AutoSizeColumnsMode = AutoSizeColumnsMode.Fill;
        grid.DataSource = new List<Order>
        {
            new() { OrderID = 10248, CustomerName = "Vins et alcools", Freight = 32.38, OrderDate = new DateTime(1996, 7, 4) },
            new() { OrderID = 10249, CustomerName = "Toms Spezialitaten", Freight = 11.61, OrderDate = new DateTime(1996, 7, 5) },
        };
        Controls.Add(grid);
    }

    private class Order
    {
        public int OrderID { get; set; }
        public string CustomerName { get; set; } = "";
        public double Freight { get; set; }
        public DateTime OrderDate { get; set; }
    }
}
```

## 6. MCP server — optional, for current documentation

`Syncfusion.WinForms.MCP` (NuGet, stdio, server name `sf-winforms-mcp`, invoked with `dnx`)

Configuration for your editor: https://ai.syncfusion.com/mcp/llms.txt

MCP retrieves current documentation. The skill pack guides code generation. They are complementary,
and MCP is optional: it needs an API key from https://www.syncfusion.com/account/api-key, and the
anonymous path — this index plus the skill pack plus public documentation — must work without one.
If no key is available, do not block on MCP.

An MCP API key is not a product license key and does not grant one.

## 7. Verify before reporting success

A clean compile is not verification. Work through this list and state explicitly what you could not
check.

- [ ] Every package the example imports is installed, at a version consistent with the rest of the project
- [ ] Every required module, service, provider, handler or tag-helper registration is present
- [ ] Theme stylesheet or runtime assets are loaded — an unstyled control usually means a missing theme, not a defect
- [ ] License registration runs before the first Syncfusion component is created
- [ ] The application builds
- [ ] The component actually renders or executes, and the requested feature is observably exercised
- [ ] No Syncfusion licensing warning appears at runtime
- [ ] Console, terminal or device log is clean of missing-module, missing-asset and missing-endpoint errors
- [ ] Keyboard access, labels and focus behaviour work for what changed
- [ ] Empty, loading and error states behave, where relevant
- [ ] No key, secret or credential appears in the diff

If runtime verification is impossible in your environment, say so plainly and give the user a short
manual check. Do not describe unverified output as working.

## 8. Known failure modes for WinForms

These are the mistakes agents make most often on this platform. Check them first.

- License registration must run before the first Syncfusion control is constructed, so put it at the top of Main, before ApplicationConfiguration.Initialize().
- WinForms has 115 skills because the control surface is large and older controls coexist with newer `Syncfusion.WinForms.*` ones. Confirm which generation the project uses before writing code.
- Designer-generated code will be overwritten. Apply Syncfusion configuration in your own partial or constructor, not in `InitializeComponent`.
- Dispose controls explicitly on form close where you created them dynamically.

Troubleshooting order when a WinForms Syncfusion implementation fails:

1. Framework and Syncfusion package version compatibility
2. Missing package, peer dependency, module, service, provider, handler or import
3. Theme CSS, fonts, scripts, static assets, or a required server-side endpoint
4. Data shape, identifiers, date and number parsing, async lifecycle
5. Feature-specific configuration in the installed component skill
6. Current official documentation, or an MCP lookup
7. A minimal reproduction with unrelated application code removed

Preserve the original error text. Distinguish a product defect from an integration or configuration
issue. If a minimal reproduction still fails against documented behaviour, that is a support case:
https://support.syncfusion.com/

## 9. Next

| Need | Go to |
| --- | --- |
| Full documentation | https://help.syncfusion.com/windowsforms/overview |
| Every skill in this pack | https://ai.syncfusion.com/winforms/inventory.txt |
| Editor and viewer SDK skills | filter `inventory.txt` by `pdf-viewer-sdk-skills`, `spreadsheet-editor-sdk-skills` (no WinForms DOCX Editor skill is published) |
| Skill catalog across all 18 packs | https://ai.syncfusion.com/skills/catalog.md |
| Licensing and trust boundaries | https://ai.syncfusion.com/licensing.md |
| MCP configuration | https://ai.syncfusion.com/mcp/llms.txt |
| Project scaffolding from the CLI | https://ai.syncfusion.com/cli.md |
| Another platform | https://ai.syncfusion.com/llms.txt |
| Support | https://support.syncfusion.com/ |