Agent skill

Sharpconsoleui

by managedcode in managedcode/dotnet-skills

Use SharpConsoleUI to build full terminal (TUI) applications in .NET — equally suited to full-screen single-window apps and multi-window desktops with overlapping draggable windows — using a…

MITAuto-check passed

Install Sharpconsoleui

skills CLI
$ npx skills add managedcode/dotnet-skills --skill sharpconsoleui -a claude-code

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

GitHub CLI
$ gh skill install managedcode/dotnet-skills sharpconsoleui --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/managedcode/dotnet-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/catalog/Frameworks/SharpConsoleUI/skills/sharpconsoleui .claude/skills/sharpconsoleui && 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
sharpconsoleui
GitHub stars
486
Token cost
~2.4k tokens
SKILL.md length
845 words
Files
9 (incl. references)
Skills in repo
81
Repo updated
First seen
Licence
MIT

At a glance

Use SharpConsoleUI to build full terminal (TUI) applications in .NET — equally suited to full-screen single-window apps and multi-window desktops with overlapping draggable windows — using a…

  • Works in 6 steps: Create a NetConsoleDriver and a… → Build one or more windows with… → Add controls to each window with… → …
  • : interactive console apps
  • SKILL.md covers Trigger On, Install, Workflow and Best practices, plus 4 more sections
  • Calls dotnet

What it does

Sharpconsoleui is an agent skill from managedcode/dotnet-skills. Use SharpConsoleUI to build full terminal (TUI) applications in .NET — equally suited to full-screen single-window apps and multi-window desktops with overlapping draggable windows — using a compositor, a DOM layout engine, and 40+ reactive controls (data tables, tree views, forms, an embedded PTY terminal, markdown, charts, video). USE FOR: interactive console apps, full-screen TUIs, multi-window terminal desktops, dashboards, wizards, and admin/monitoring UIs that need focus, mouse, and flicker-free rendering…

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 9 other files, including reference files (for example `manifest.json`, `references/app-patterns.md` and `references/architecture.md`). Compatibility notes: Requires a .NET 8.0+ console project (net8.0/net9.0/net10.0) that can reference the SharpConsoleUI package and run against a modern terminal. Uses a…

It works with .NET. The repository describes itself as: Installable .NET skill catalog and CLI for Codex, Claude Code, GitHub Copilot, and Gemini. The licence is MIT.

When your agent uses it

  • : interactive console apps
  • Full-screen TUIs
  • Multi-window terminal desktops
  • Admin/monitoring UIs that need focus

Example prompts

  • “/sharpconsoleui”

Requirements

  • Compatibility (from SKILL.md): Requires a .NET 8.0+ console project (net8.0/net9.0/net10.0) that can reference the `SharpConsoleUI` package and run against a modern terminal. Uses a retained-mode UI on a single cooperative UI thread, not immediate-mode Console.Write.

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Create a NetConsoleDriver and a ConsoleWindowSystem that owns all windows.
  2. Build one or more windows with WindowBuilder (title, size, position, borders, padding).
  3. Add controls to each window with window.AddControl(...), usually via the Controls static factory.
  4. Wire interactivity through control events (e.g. Button.OnClick); call windowSystem.Shutdown() to exit.
  5. windowSystem.AddWindow(window) then windowSystem.Run() starts the render/input loop (blocks until shutdown).
  6. For layout, dialogs, portals/overlays, forms, and the full control set, load the reference files below.

What it can do on your machine

Read from SKILL.md and the folder at commit 535dd55. 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

    Links to these hosts (documentation or services it may open):

    • nuget.org
    • github.com
    • nickprotop.github.io

    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.

  • Compatibility

    Requires a .NET 8.0+ console project (net8.0/net9.0/net10.0) that can reference the `SharpConsoleUI` package and run against a modern terminal. Uses a retained-mode UI on a single cooperative UI thread, not immediate-mode Console.Write.

    From compatibility in the SKILL.md frontmatter.

Context cost

Sharpconsoleui loads about 2.4k tokens when it runs, and up to ~18k if it reads all its reference files. Until then it costs about 213 tokens; SKILL.md has 845 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~213
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~18k

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 managedcode/dotnet-skills at commit 535dd55, republished under its MIT licence (© managedcode). 845 words, ~2,439 tokens.

Download SKILL.mdSave it as .claude/skills/sharpconsoleui/SKILL.md (or your agent's skills folder). This skill also uses 8 other files; get the full folder from GitHub.
name
sharpconsoleui
description
Use SharpConsoleUI to build full terminal (TUI) applications in .NET — equally suited to full-screen single-window apps and multi-window desktops with overlapping draggable windows — using a compositor, a DOM layout engine, and 40+ reactive controls (data tables, tree views, forms, an embedded PTY terminal, markdown, charts, video). USE FOR: interactive console apps, full-screen TUIs, multi-window terminal desktops, dashboards, wizards, and admin/monitoring UIs that need focus, mouse, and flicker-free rendering over local terminals or SSH; NativeAOT console tools. DO NOT USE FOR: simple line-based CLI output or argument parsing; non-interactive scripts; GUI/desktop (WPF/WinForms) or web UIs. INVOKES: inspect the project, add the SharpConsoleUI package, scaffold a window/control tree, and build/run to verify the app renders.
compatibility
Requires a .NET 8.0+ console project (net8.0/net9.0/net10.0) that can reference the `SharpConsoleUI` package and run against a modern terminal. Uses a retained-mode UI on a single cooperative UI thread, not immediate-mode Console.Write.

SharpConsoleUI terminal application framework

Trigger On

  • building an interactive terminal UI: dashboards, wizards, settings screens, admin/monitoring consoles
  • building a full-screen single-window TUI: a .Frameless() (no title bar, no title buttons) + .Maximized() app that owns the whole terminal
  • building a multi-window terminal desktop: overlapping windows with drag/resize/minimize/maximize, z-order, focus routing, modal windows, and mouse support (full-screen and multi-window are equally first-class here)
  • wanting flicker-free rendering that stays clean over SSH (diff-based cell buffer, not full repaints)
  • needing rich terminal controls: data tables, tree/list views, forms, an embedded PTY terminal, markdown, charts, or video
  • shipping a NativeAOT-ready console application with a real UI

Do not trigger for plain line-based CLI tools, argument parsing, or non-interactive scripts.

Install

Workflow

mermaid
flowchart LR
  A["NetConsoleDriver (RenderMode.Buffer)"] --> B["ConsoleWindowSystem"]
  B --> C["WindowBuilder -> Window"]
  C --> D["window.AddControl(Controls.*)"]
  D --> E["DOM layout: Measure -> Arrange -> Paint"]
  E --> F["windowSystem.AddWindow(window)"]
  F --> G["windowSystem.Run()  (blocks until Shutdown)"]
  G --> H["compositor merges per-window buffers -> terminal"]
  1. Create a NetConsoleDriver and a ConsoleWindowSystem that owns all windows.
  2. Build one or more windows with WindowBuilder (title, size, position, borders, padding).
  3. Add controls to each window with window.AddControl(...), usually via the Controls static factory.
  4. Wire interactivity through control events (e.g. Button.OnClick); call windowSystem.Shutdown() to exit.
  5. windowSystem.AddWindow(window) then windowSystem.Run() starts the render/input loop (blocks until shutdown).
  6. For layout, dialogs, portals/overlays, forms, and the full control set, load the reference files below.
Minimal app (read + show + interact)
csharp
using SharpConsoleUI;
using SharpConsoleUI.Builders;
using SharpConsoleUI.Controls;
using SharpConsoleUI.Drivers;

var driver = new NetConsoleDriver(RenderMode.Buffer);
var windowSystem = new ConsoleWindowSystem(driver);

var window = new WindowBuilder(windowSystem)
    .WithTitle("Hello World")
    .WithSize(50, 12)
    .Centered()
    .Build();

window.AddControl(Controls.Markup()
    .AddLine("[bold cyan]Hello, SharpConsoleUI![/]")
    .Build());

window.AddControl(Controls.Button("Quit")
    .OnClick((sender, e, win) => windowSystem.Shutdown())
    .Build());

windowSystem.AddWindow(window);
windowSystem.Run();
Layout + data example

Use a GridControl when you need columns/rows with fixed, size-to-content, or proportional (Star) tracks, and put content controls (tables, lists, markdown) into the cells:

csharp
var grid = Controls.Grid()
    .Columns(GridLength.Cells(20), GridLength.Star(1))   // fixed sidebar + fill
    .Rows(GridLength.Auto(), GridLength.Star(1))         // toolbar + body
    .RowGap(1)
    .Place(Controls.Markup("[bold]Dashboard[/]").Build(), 0, 0, colSpan: 2)
    .Place(sidebarList, 1, 0)
    .Place(dataTable, 1, 1)
    .Build();

window.AddControl(grid);

See references/recipes.md for full grid/table/form/dialog examples and references/controls.md for the control chosen per region.

Best practices

  • Describe the UI declaratively (retained mode). Let the framework own redraws, focus, and input — do not mix raw Console.Write into a running app.
  • The app runs on one cooperative UI thread. Never block it: don't call .Result / .Wait() on async work inside a handler (it deadlocks the loop). Push blocking/CPU work off-thread and marshal UI mutations back with EnqueueOnUIThread / InvokeAsync. See references/architecture.md.
  • Use portals for dropdowns, overlays, and toasts, and the built-in Dialogs for confirm/prompt/progress, instead of hand-positioning windows. See references/recipes.md.
  • Apply semantic control Roles (Primary, Success, Danger, …) so colors come from the active theme instead of being hand-set.
  • Style all text with [tag]text[/] markup — it works everywhere text renders (labels, titles, status bars, table cells, tree nodes), including [markdown], [gradient=…], and inline [spinner]. Escape untrusted text with MarkupParser.Escape(...). See references/markup.md.
  • Prefer Controls.* factory + fluent builders over manual control construction for consistent wiring.
  • For a full app (not a single screen), follow the production patterns in references/app-patterns.md: one maximized window with content-swap navigation, an app-owned header/hint bar, custom awaitable modals closed via CloseModalWindow, dialogs clamped to DesktopDimensions, a semantic color/theme layer (no hardcoded hex), and a wrapper so no async action can crash the loop.
Show full SKILL.md (381 more words)Show less

Limitations to check before production

  • It is a full retained-mode application framework, not a drop-in for one-off Console.WriteLine output. Small non-interactive tools do not need it.
  • Cooperative single-threaded UI model: unsynchronized cross-thread control mutation, or blocking the UI thread on async work, is a bug — not a shortcut.
  • TerminalControl (the embedded PTY emulator) runs on Linux and Windows 10 1809+ (openpty on Linux, ConPTY on Windows); it throws PlatformNotSupportedException on other OSes. On Linux it requires PtyShim.RunIfShim(args) as the very first line of Main (a safe no-op on Windows) — see references/controls.md.
  • Advanced media (video, Kitty-graphics image rendering) auto-detects terminal capability and degrades to half-block/ASCII/braille fallbacks; verify on the target terminal.
  • NativeAOT is supported (the library is IsAotCompatible and CI-verified), but confirm your own reflection/serialization code is trim/AOT-safe; HtmlControl is the one documented AOT caveat. See references/architecture.md.

Deliver

  • an install + first-run guide ready to paste into a .NET console project
  • a minimal window app and a layout/data example that actually render
  • clear notes on the threading model, portals/dialogs, and terminal-capability tradeoffs

Validate

  • dotnet add package SharpConsoleUI restores and the project compiles.
  • The minimal app above builds and runs, showing a centered window with a working Quit button (Tab to focus, Enter/click to quit).
  • One layout/control sample from references/recipes.md renders correctly.
  • Any control used is confirmed against references/controls.md (correct factory/API).

Load References

  • Control reference — the 40+ control set grouped by purpose, with the factory/API entry point and a "use when" for each group.
  • Markup reference — the [tag]text[/] markup language (colors, decorations, links, [spinner], [markdown], [gradient], MarkupParser API). Markup works everywhere text renders — load this for any styled-text work.
  • Architecture reference — compositor, DOM layout pipeline, cooperative UI-thread model, marshalling, and NativeAOT notes.
  • Recipe reference — full-screen and multi-window apps, window builders, grids, dialogs, portals/toasts, and forms, with verified code.
  • Feature reference — gradients, transparency/alpha blending, compositor effects, animations, desktop background, and image/video/syntax-highlighting rendering.
  • System reference — constructor overloads, state services, panels, configuration, registry, MVVM data binding, flows, plugins, clipboard, shell-pipeline/schost distribution, and the "when to choose this framework" comparison + pattern catalog.
  • Application-pattern reference — how to structure and polish a real production app: single-window shell + content-swap navigation, own-your-header, custom awaitable modals, live process output, the semantic color/theme layer, escaping untrusted text, threading discipline, and a never-crash wrapper. Load this when building a full app, not just one screen.

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

Files

SKILL.md and 8 other files (references) in catalog/Frameworks/SharpConsoleUI/skills/sharpconsoleui of managedcode/dotnet-skills.

  • SKILL.md
  • manifest.json
  • references/app-patterns.md
  • references/architecture.md
  • references/controls.md
  • references/features.md
  • references/markup.md
  • references/recipes.md
  • references/system.md

Open the folder on GitHubat commit 535dd55

Compare with similar skills

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

Sharpconsoleui compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Sharpconsoleui this skillmanagedcode/dotnet-skills486—~2.4kAutomated safety check: PassMIT
Minimax DOCXpoco-ai/poco-claw1.4k7 repos~3.9kAutomated safety check: PassMIT
Microsoft Skill CreatorMicrosoftDocs/mcp1.9k3 repos~2.1kAutomated safety check: PassCC-BY-4.0
Speckit ConstitutionWeihanLi/WeihanLi.Common24211 repos~2.1kAutomated safety check: PassApache-2.0
Copilot Session Failure Analysisdotnet/maui23k—~3.4kAutomated safety check: PassMIT
Microsoft Code ReferenceMicrosoftDocs/mcp1.9k4 repos~1.1kAutomated safety check: PassCC-BY-4.0

Similar skills

  • Minimax DOCX

    poco-ai/poco-claw

    Professional DOCX document creation, editing, and formatting using OpenXML SDK (.NET).

    1.4k GitHub starsUsed in 7 repos~3.9k tokens
    Documents & OfficeAuto-check passed
  • Microsoft Skill Creator

    MicrosoftDocs/mcp

    Official

    Create agent skills for Microsoft technologies using official documentation.

    1.9k GitHub starsUsed in 3 repos~2.1k tokens
    Agent WorkflowsAuto-check passed
  • Speckit Constitution

    WeihanLi/WeihanLi.Common

    Create or update the project constitution from interactive or provided principle inputs, ensuring all dependent templates stay in sync.

    242 GitHub starsUsed in 11 repos~2.1k tokens
    DevelopmentAuto-check passed
  • Mines local Copilot CLI session logs for dotnet/maui to rank costly or failing runs, tag recurring failure modes, propose repo edits and emit guard evals.

    23k GitHub stars~3.4k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Microsoft Code Reference

    MicrosoftDocs/mcp

    Official

    Find working code samples, verify API signatures, and fix Microsoft SDK errors using official docs.

    1.9k GitHub starsUsed in 4 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Official

    Audits and updates os-packages.json files listing the Linux packages each .NET release needs per distro, then regenerates the Markdown from the JSON.

    22k GitHub stars~2.3k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

More from managedcode/dotnet-skills

All 81 skills in this repo
  • Analyzer Config

    managedcode/dotnet-skills

    Use a repo-root .editorconfig to configure free .NET analyzer and style rules.

    486 GitHub stars~1.3k tokensUpdated today
    Auto-check passed
  • Archunitnet

    managedcode/dotnet-skills

    Use the open-source free ArchUnitNET library for architecture rules in .NET tests.

    486 GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Aspire

    managedcode/dotnet-skills

    Build, upgrade, and operate Aspire 13.5.x C or TypeScript application hosts with the current CLI, AppHost, ServiceDefaults, integrations, dashboard, testing, MCP, and deployment patterns for…

    486 GitHub stars~3.6k tokensUpdated today
    Auto-check passed
  • Aspnet Core

    managedcode/dotnet-skills

    Build, debug, modernize, or review ASP.NET Core applications with correct hosting, middleware, security, configuration, logging, and deployment patterns on current .NET.

    486 GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Asynkron Profiler

    managedcode/dotnet-skills

    Use the open-source free Asynkron.Profiler dotnet tool for CLI-first CPU, allocation, exception, contention, and heap profiling of .NET commands or existing trace artifacts.

    486 GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Azure Functions

    managedcode/dotnet-skills

    Build, review, or migrate Azure Functions in .NET with correct execution model, isolated worker setup, bindings, DI, and Durable Functions patterns.

    486 GitHub stars~2.6k tokensUpdated today
    Auto-check passed

Works with

Questions about Sharpconsoleui

What does Sharpconsoleui do?

Use SharpConsoleUI to build full terminal (TUI) applications in .NET — equally suited to full-screen single-window apps and multi-window desktops with overlapping draggable windows — using a…. Sharpconsoleui is an agent skill from managedcode/dotnet-skills.NET — equally suited to full-screen single-window apps and multi-window desktops with overlapping draggable windows — using a compositor, a DOM layout engine, and 40+ reactive controls (data tables, tree views, forms, an embedded PTY terminal, markdown, charts, video).

When should I use Sharpconsoleui?

Sharpconsoleui fits situations like: : interactive console apps; full-screen TUIs; multi-window terminal desktops; admin/monitoring UIs that need focus.

How do I install Sharpconsoleui in Claude Code?

Run `npx skills add managedcode/dotnet-skills --skill sharpconsoleui -a claude-code`. Or copy the skill folder (catalog/Frameworks/SharpConsoleUI/skills/sharpconsoleui in managedcode/dotnet-skills) into .claude/skills/sharpconsoleui in your project. Claude Code loads it when a task matches its description.

How do I install Sharpconsoleui in Codex?

Run `npx skills add managedcode/dotnet-skills --skill sharpconsoleui -a codex`. Or copy the skill folder (catalog/Frameworks/SharpConsoleUI/skills/sharpconsoleui in managedcode/dotnet-skills) into .agents/skills/sharpconsoleui in your project. Codex loads it when a task matches its description.

Can I use Sharpconsoleui 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 managedcode/dotnet-skills --skill sharpconsoleui -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/sharpconsoleui, .gemini/skills/sharpconsoleui, .github/skills/sharpconsoleui and .opencode/skills/sharpconsoleui in your project.

What does Sharpconsoleui need to run?

Going by SKILL.md and its folder, Sharpconsoleui needs the command-line tools its instructions call (dotnet). Compatibility (from SKILL.md): Requires a .NET 8.0+ console project (net8.0/net9.0/net10.0) that can reference the `SharpConsoleUI` package and run against a modern terminal. Uses a retained-mode UI on a single cooperative UI thread, not immediate-mode Console.Write..

Does Sharpconsoleui access the network?

SKILL.md names 3 domains. As links in the text: nuget.org, github.com and nickprotop.github.io. This is read from the text; nothing was executed.

Is Sharpconsoleui 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 Sharpconsoleui use?

Sharpconsoleui is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Sharpconsoleui use?

About 2.4k tokens (SKILL.md is roughly 9.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 16k tokens, read only when the agent opens those files.

What are the alternatives to Sharpconsoleui?

Skills that share tags, products or a category with Sharpconsoleui: Minimax DOCX (poco-ai/poco-claw, 1.4k stars), Microsoft Skill Creator (MicrosoftDocs/mcp, 1.9k stars), Speckit Constitution (WeihanLi/WeihanLi.Common, 242 stars) and Copilot Session Failure Analysis (dotnet/maui, 23k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Sharpconsoleui?

managedcode (a GitHub organization) maintains it in managedcode/dotnet-skills, which has 486 GitHub stars. The repository holds 81 skills in this directory. The repository was last updated on October 7, 2026.

Source: managedcode/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.