Official agent skill

Use Igniteui Blazor

by dotnet in dotnet/skills

Add, configure, or review Ignite UI for Blazor Lite component support in Blazor applications.

OfficialMITAuto-check passedFrontend & Design

Install Use Igniteui Blazor

skills CLI
$ npx skills add dotnet/skills --skill use-igniteui-blazor -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install dotnet/skills use-igniteui-blazor --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/dotnet/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/dotnet-blazor/skills/use-igniteui-blazor .claude/skills/use-igniteui-blazor && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
use-igniteui-blazor
GitHub stars
5.6k
Used in
1 other repo
Token cost
~1.4k tokens
SKILL.md length
455 words
Files
1
Skills in repo
91
Repo updated
First seen
Licence
MIT

At a glance

Add, configure, or review Ignite UI for Blazor Lite component support in Blazor applications.

  • Works in 5 steps: NuGet package → IgniteUI.Blazor.Lite Service Registration → _Imports.razor → …
  • : installing IgniteUI.Blazor.Lite
  • SKILL.md covers 1. NuGet package, 2. IgniteUI.Blazor.Lite…, 3. _Imports.razor and 4. Host page — theme stylesheet, plus 1 more section
  • Calls dotnet

What it does

Use Igniteui Blazor is an agent skill from dotnet/skills, published by the product's own GitHub organization. Add, configure, or review Ignite UI for Blazor Lite component support in Blazor applications. USE FOR: installing IgniteUI.Blazor.Lite or IgniteUI.Blazor.GridLite, registering AddIgniteUIBlazor() in Blazor Server, WASM, Hybrid, or split Blazor Web App projects, adding @using IgniteUI.Blazor.Controls, wiring the theme stylesheet, picking the right host page, locating the GridLite stylesheet path, explaining single-project vs split Server/Client Web App setup differences, and checking where an interactive render…

Its SKILL.md is about 1.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Frontend & Design, covering CSS and styling. It works with Blazor, WebAssembly, .NET and JavaScript. The repository describes itself as: Repository for skills to assist AI coding agents with .NET and C. The licence is MIT.

When your agent uses it

  • : installing IgniteUI.Blazor.Lite
  • IgniteUI.Blazor.GridLite
  • Registering AddIgniteUIBlazor() in Blazor Server
  • Split Blazor Web App projects

Example prompts

  • “/use-igniteui-blazor”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. NuGet package
  2. IgniteUI.Blazor.Lite Service Registration
  3. _Imports.razor
  4. Host page — theme stylesheet
  5. Render mode (Blazor Web App only)

What it can do on your machine

Read from SKILL.md and the folder at commit a660de8. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • dotnet

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Use Igniteui Blazor loads about 1.4k tokens when it runs. Until then it costs about 231 tokens; SKILL.md has 455 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~231
When it runs · the whole SKILL.md, loaded when a task matches
~1.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from dotnet/skills at commit a660de8, republished under its MIT licence (© dotnet). 455 words, ~1,412 tokens.

Download SKILL.mdSave it as .claude/skills/use-igniteui-blazor/SKILL.md (or your agent's skills folder).
name
use-igniteui-blazor
description
Add, configure, or review Ignite UI for Blazor Lite component support in Blazor applications. USE FOR: installing IgniteUI.Blazor.Lite or IgniteUI.Blazor.GridLite, registering AddIgniteUIBlazor() in Blazor Server, WASM, Hybrid, or split Blazor Web App projects, adding @using IgniteUI.Blazor.Controls, wiring the theme stylesheet, picking the right host page, locating the GridLite stylesheet path, explaining single-project vs split Server/Client Web App setup differences, and checking where an interactive render mode is needed for Ignite UI components to work. DO NOT USE FOR: general Blazor component authoring without Ignite UI, choosing app architecture or render mode from scratch (see create-blazor-project), JavaScript interop (see use-js-interop), authentication (see configure-auth), prerendering (see support-prerendering), or layout/component design questions that need no Ignite UI setup.
license
MIT

Application Setup & Component Registration

1. NuGet package

Before adding packages, inspect the target projects' target framework and existing package references. The lowest supported target framework version is .NET 8.0. If IgniteUI.Blazor or IgniteUI.Blazor.Trial is already referenced, keep that package strategy and do not add Lite or GridLite. Only switch package families when the user explicitly asks, replacing conflicting references rather than keeping both.

bash
dotnet add package IgniteUI.Blazor.Lite       # OSS core UI components (MIT)
dotnet add package IgniteUI.Blazor.GridLite   # OSS lightweight grid (MIT)

Use IgniteUI.Blazor.Lite for core controls such as IgbInput, IgbCombo and IgbDialog, and IgniteUI.Blazor.GridLite for the lightweight grid. Reference both packages only when the app needs both. Do not invent per-component packages such as IgniteUI.Blazor.Combo.

Charts, maps, gauges and other premium components are not included in Lite. Check the requested component's package before recommending a reference.

2. IgniteUI.Blazor.Lite Service Registration

Usually in Program.cs:

csharp
builder.Services.AddIgniteUIBlazor();   // no modules pre-loaded; each loads on first render

Pass typeof(Igb<Name>Module) values to eagerly pre-load a specific set instead:

csharp
builder.Services.AddIgniteUIBlazor(
    typeof(IgbInputModule), typeof(IgbComboModule), typeof(IgbDialogModule));

Module names always follow Igb{ComponentName}Module. Passing modules eagerly loads them during startup, increasing the initial transfer to reduce first-render latency. Components not listed still register their own modules on first render.

For a GridLite-only setup, do not call AddIgniteUIBlazor() or add manual Ignite UI script tags. Reference IgniteUI.Blazor.GridLite, add the control namespace, and link the GridLite stylesheet shown below.

Split Blazor Web App: add each required package to both the Server and Client .csproj files. For core controls, use the actual project paths in place of these examples.

bash
dotnet add Server/Server.csproj package IgniteUI.Blazor.Lite
dotnet add Client/Client.csproj package IgniteUI.Blazor.Lite

If GridLite is needed, add IgniteUI.Blazor.GridLite to both projects as well. For a GridLite-only app, add only that package and skip the service registrations below.

For Lite, call AddIgniteUIBlazor() in both the server and client Program.cs.

csharp
// Server
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents()
    .AddInteractiveWebAssemblyComponents();
builder.Services.AddIgniteUIBlazor();

// Client (WebAssemblyHostBuilder)
builder.Services.AddIgniteUIBlazor();

For a single-project Interactive Server Blazor Web App, call AddIgniteUIBlazor() once in the server Program.cs. Do not add a client project or WebAssembly services.

Show full SKILL.md (172 more words)Show less

3. _Imports.razor

razor
@using IgniteUI.Blazor.Controls

Add it to both _Imports.razor files in split Blazor Web App solutions.

4. Host page — theme stylesheet

Host page is wwwroot/index.html (WASM/MAUI), Pages/_Host.cshtml (Server), or Components/App.razor (Web App).

IgniteUI.Blazor.Lite 0.1.1 loads its JavaScript automatically through a Blazor initializer. Keep the existing Blazor framework script and add the theme stylesheet below. Do not add a manual Ignite UI script tag.

html
<link href="_content/IgniteUI.Blazor/themes/light/bootstrap.css" rel="stylesheet" />

The stylesheet is required: without it components render unstyled.

Theme files under _content/IgniteUI.Blazor/themes/ are {light|dark}/{bootstrap|material|fluent|indigo}.css — link exactly one.

.NET 9+ Web App projects can use the fingerprinted asset collection:

razor
<link rel="stylesheet" href="@Assets["_content/IgniteUI.Blazor/themes/light/bootstrap.css"]" />

IgniteUI.Blazor.GridLite ships its own stylesheet from its own asset root, but should be used only if you are using the GridLite component exclusively. If you are using other Ignite UI components, do not link (or suggest) the GridLite stylesheet — use the main theme stylesheet above instead.

html
<link href="_content/IgniteUI.Blazor.GridLite/css/themes/light/bootstrap.css" rel="stylesheet" />

5. Render mode (Blazor Web App only)

Ignite UI components need an interactive render mode; static SSR renders nothing usable.

razor
@rendermode InteractiveServer

Or globally in App.razor: <Routes @rendermode="InteractiveServer" />.

Use InteractiveWebAssembly or InteractiveAuto in place of InteractiveServer as needed.

© dotnet, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in plugins/dotnet-blazor/skills/use-igniteui-blazor of dotnet/skills.

Open the folder on GitHubat commit a660de8

Used in 1 other repository

We found 2 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in dotnet/skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Use Igniteui Blazor next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Use Igniteui Blazor compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Use Igniteui Blazor this skilldotnet/skills5.6k1 repos~1.4kAutomated safety check: PassMIT
Language Supportlive-codes/livecodes1.5k—~1.6kAutomated safety check: PassMIT
Dotnet UInovotnyllc/dotnet-artisan233—~1.3kAutomated safety check: PassMIT
Stylelintmanagedcode/dotnet-skills486—~1.7kAutomated safety check: PassMIT
Abp Blazorabpframework/abp14k—~1.4kAutomated safety check: PassLGPL-3.0
Blazormanagedcode/dotnet-skills486—~2.1kAutomated safety check: PassMIT

Similar skills

  • Language Support

    live-codes/livecodes

    Work with 90+ supported languages, compilers, CSS processors, and WASM-compiled languages for markup, style, and script editors.

    1.5k GitHub stars~1.6k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Dotnet UI

    novotnyllc/dotnet-artisan

    Builds .NET UI apps across Blazor (Server, WASM, Hybrid, Auto), MAUI (XAML, MVVM, Shell, Native AOT), Uno Platform (MVUX, Extensions, Toolkit), WPF (.NET 8+, Fluent theme), WinUI 3 (Windows App SDK…

    233 GitHub stars~1.3k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Stylelint

    managedcode/dotnet-skills

    Use Stylelint in .NET repositories that ship CSS, SCSS, or other stylesheet assets alongside web frontends.

    486 GitHub stars~1.7k tokensUpdated yesterday
    Frontend & DesignAuto-check passed
  • Abp Blazor

    abpframework/abp

    ABP Blazor UI patterns - AbpComponentBase, AbpCrudPageBase, DataGrid, IMenuContributor, Message/Notify, Validations, JavaScript interop.

    14k GitHub stars~1.4k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Blazor

    managedcode/dotnet-skills

    Build and review Blazor applications across server, WebAssembly, web app, and hybrid scenarios with correct component design, state flow, rendering, and hosting choices.

    486 GitHub stars~2.1k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Tailwindcss Development

    anonaddy/anonaddy

    Always invoke when the user's message includes 'tailwind' in any form.

    4.9k GitHub starsUsed in 10 repos~865 tokens
    Frontend & DesignAuto-check passed

More from dotnet/skills

All 91 skills in this repo
  • Official

    Resolves .NET runtime frames in Apple .ips crash logs to function names, source files and line numbers using dSYM symbols, atos and the Microsoft symbol server.

    5.6k GitHub starsUsed in 1 repo~2.4k tokens
    Auto-check passed
  • Official

    Resolves native crash frames from .NET Android tombstones to function names, source files and line numbers using BuildIds, Microsoft's symbol server and llvm-symbolizer.

    5.6k GitHub starsUsed in 1 repo~2.1k tokens
    Auto-check passed
  • Official

    Scans C# and .NET code for about 50 performance anti-patterns and reports prioritized findings with concrete fixes, at a scan depth you choose.

    5.6k GitHub starsUsed in 3 repos~3.1k tokens
    Auto-check passed
  • Official

    Statically pairs source files with test files to list code that no test references, using Roslyn for C# or tree-sitter for many languages, with no build.

    5.6k GitHub starsUsed in 1 repo~3.3k tokens
    Auto-check passed
  • Microbenchmarking

    dotnet/skills

    Official

    Activate this skill when BenchmarkDotNet (BDN) is involved in the task — creating, running, configuring, or reviewing BDN benchmarks.

    5.6k GitHub starsUsed in 3 repos~3.3k tokens
    Auto-check passed
  • Official

    Makes .NET projects compatible with Native AOT and trimming by resolving IL trim and AOT analyzer warnings through annotations rather than suppressions.

    5.6k GitHub starsUsed in 2 repos~4.2k tokens
    Auto-check passed

Questions about Use Igniteui Blazor

What does Use Igniteui Blazor do?

Add, configure, or review Ignite UI for Blazor Lite component support in Blazor applications. Use Igniteui Blazor is an agent skill from dotnet/skills, published by the product's own GitHub organization. Add, configure, or review Ignite UI for Blazor Lite component support in Blazor applications.

When should I use Use Igniteui Blazor?

Use Igniteui Blazor fits situations like: : installing IgniteUI.Blazor.Lite; igniteUI.Blazor.GridLite; registering AddIgniteUIBlazor() in Blazor Server; split Blazor Web App projects.

How do I install Use Igniteui Blazor in Claude Code?

Run `npx skills add dotnet/skills --skill use-igniteui-blazor -a claude-code`. Or copy the skill folder (plugins/dotnet-blazor/skills/use-igniteui-blazor in dotnet/skills) into .claude/skills/use-igniteui-blazor in your project. Claude Code loads it when a task matches its description.

How do I install Use Igniteui Blazor in Codex?

Run `npx skills add dotnet/skills --skill use-igniteui-blazor -a codex`. Or copy the skill folder (plugins/dotnet-blazor/skills/use-igniteui-blazor in dotnet/skills) into .agents/skills/use-igniteui-blazor in your project. Codex loads it when a task matches its description.

Can I use Use Igniteui Blazor in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add dotnet/skills --skill use-igniteui-blazor -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/use-igniteui-blazor, .gemini/skills/use-igniteui-blazor, .github/skills/use-igniteui-blazor and .opencode/skills/use-igniteui-blazor in your project.

What does Use Igniteui Blazor need to run?

Going by SKILL.md and its folder, Use Igniteui Blazor needs the command-line tools its instructions call (dotnet).

Does Use Igniteui Blazor access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Use Igniteui Blazor safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Use Igniteui Blazor use?

Use Igniteui Blazor is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Use Igniteui Blazor use?

About 1.4k tokens (SKILL.md is roughly 5.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Use Igniteui Blazor?

Skills that share tags, products or a category with Use Igniteui Blazor: Language Support (live-codes/livecodes, 1.5k stars), Dotnet UI (novotnyllc/dotnet-artisan, 233 stars), Stylelint (managedcode/dotnet-skills, 486 stars) and Abp Blazor (abpframework/abp, 14k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Use Igniteui Blazor?

dotnet (a GitHub organization, an official publisher) maintains it in dotnet/skills, which has 5,576 GitHub stars. The repository holds 91 skills in this directory. The repository was last updated on October 8, 2026.

Source: dotnet/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.