GitHub C# Monthly Trending

iOfficeAI/OfficeCLI

OfficeCLI is the first and best Office suite purpose-built for AI agents to read, edit, and automate Word, Excel, and PowerPoint files. Free, open-source, single binary, no Office installation required.

OfficeCLI

OfficeCLI is the world's first and the best Office suite designed for AI agents.

Give any AI agent full control over Word, Excel, and PowerPoint — in one line of code.

Open-source. Single binary. No Office installation. No dependencies. Works everywhere.

OfficeCLI's built-in HTML rendering engine reproduces documents with high fidelity — and that's what gives AI eyes. It renders .docx / .xlsx / .pptx to HTML or PNG, closing the render → look → fix loop.

English | 中文 | 日本語 | 한국어

🌐 Website: officecli.ai | 💬 Community: Discord

PPT creation process using OfficeCLI on AionUi

PowerPoint Presentations

—

Word Documents

—

Excel Spreadsheets

All documents above were created entirely by AI agents using OfficeCLI — no templates, no manual editing.

For AI Agents — Get Started in One Line

Paste this into your AI agent's chat — it will read the skill file and install everything automatically:

curl -fsSL https://officecli.ai/SKILL.md

That's it. The skill file teaches the agent how to install the binary and use all commands.

For Humans

Option A — GUI: Install AionUi — a desktop app that lets you create and edit Office documents through natural language, powered by OfficeCLI under the hood. Just describe what you want, and AionUi handles the rest.

Option B — CLI: Download the binary for your platform from GitHub Releases, then run:

officecli install

This copies the binary to your PATH and installs the officecli skill into every AI coding agent it detects — Claude Code, Cursor, Windsurf, GitHub Copilot, and more. Your agent can immediately create, read, and edit Office documents on your behalf, no extra configuration needed.

For Developers — See It Live in 30 Seconds

# 1. Install (macOS / Linux) — or: brew install officecli / npm install -g @officecli/officecli
curl -fsSL https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.sh | bash
# Windows (PowerShell): irm https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.ps1 | iex

# 2. Create a blank PowerPoint
officecli create deck.pptx

# 3. Start live preview — opens http://localhost:26315 in your browser
officecli watch deck.pptx

# 4. Open another terminal, add a slide — watch the browser update instantly
officecli add deck.pptx / --type slide --prop title="Hello, World!"

That's it. Every add, set, or remove command you run will refresh the preview in real time. Keep experimenting — the browser is your live feedback loop.

Quick Start

# Create a presentation and add content
officecli create deck.pptx
officecli add deck.pptx / --type slide --prop title="Q4 Report" --prop background=1A1A2E
officecli add deck.pptx '/slide[1]' --type shape \
  --prop text="Revenue grew 25%" --prop x=2cm --prop y=5cm \
  --prop font=Arial --prop size=24 --prop color=FFFFFF

# View as outline
officecli view deck.pptx outline
# → Slide 1: Q4 Report
# →   Shape 1 [TextBox]: Revenue grew 25%

# View as HTML — opens a rendered preview in your browser, no server needed
officecli view deck.pptx html

# Get structured JSON for any element
officecli get deck.pptx '/slide[1]/shape[1]' --json

# Save and close — flushes the resident session to disk
officecli close deck.pptx

{
  "tag": "shape",
  "path": "/slide[1]/shape[1]",
  "attributes": {
    "name": "TextBox 1",
    "text": "Revenue grew 25%",
    "x": "720000",
    "y": "1800000"
  }
}

Why OfficeCLI?

What used to take 50 lines of Python and 3 separate libraries:

from pptx import Presentation
from pptx.util import Inches, Pt
prs = Presentation()
slide = prs.slides.add_slide(prs.slide_layouts[0])
title = slide.shapes.title
title.text = "Q4 Report"
# ... 45 more lines ...
prs.save('deck.pptx')

Now takes one command:

officecli add deck.pptx / --type slide --prop title="Q4 Report"

What OfficeCLI can do:

Create documents from scratch -- blank or with content
Read text, structure, styles, formulas -- in plain text or structured JSON
Analyze formatting issues, style inconsistencies, and structural problems
Modify any element -- text, fonts, colors, layout, formulas, charts, images
Reorganize content -- add, remove, move, copy elements across documents

Format	Read	Modify	Create
Word (.docx)	✅	✅	✅
Excel (.xlsx)	✅	✅	✅
PowerPoint (.pptx)	✅	✅	✅

Word — full i18n & RTL support (per-script font slots, per-script BCP-47 lang tags lang.latin/ea/cs, complex-script bold/italic/size, direction=rtl cascading through paragraph/run/section/table/style/header/footer/docDefaults, rtlGutter + pgBorders shorthand, locale-aware page numbering for Hindi/Arabic/Thai/CJK; create --locale ar-SA auto-enables RTL), paragraphs (framePr, tabs shorthand, char-based indents), runs (underline.color, position half-pts), tables (virtual column ops add/remove/move/copyfrom, hMerge), styles, textbox / shape (textbox: rotation, textDirection eaVert/vert270, gradient, shadow, opacity), headers/footers, images (PNG/JPG/GIF/SVG), equations (LaTeX input), diagrams (mermaid → native editable shapes, or any mermaid type as a full-fidelity PNG), comments, footnotes, watermarks, bookmarks, TOC, charts, hyperlinks, sections, form fields, content controls (SDT), fields (22 zero-param types + MERGEFIELD / REF / PAGEREF / SEQ / STYLEREF / DOCPROPERTY / IF), OLE objects, revisions / tracked changes (revision.type=ins\|del\|format\|moveFrom\|moveTo + revision.action=accept\|reject, per-target /revision[@author=Alice] selector, tracked Find&Replace), page background color, document properties

Excel — cells (phonetic guide / furigana on add, Excel-UI --shift left\|up on remove / shift=right\|down on add), formulas (350+ built-in functions with auto-evaluation, spilling dynamic arrays with _xlfn. auto-prefix, financial / bond and statistical families, OFFSET/INDIRECT, defined-name formula bodies inlined at parse, formula-ref rewrite on row/col insert), sheets (visible/hidden/veryHidden, print margins, printTitleRows/Cols, RTL sheetView, cascade-aware sheet rename, empty-cell bloat filter on open), boolean and/or selectors (row[Salary>5000 and Region=EMEA]), tables, sort (sheet / range, multi-key, sidecar-aware), conditional formatting, charts (including box-whisker, pareto with auto-sort + cumulative-%, log axis), pivot tables (multi-field, date grouping, showDataAs, sort, grandTotals, subtotals, compact/outline/tabular layout, repeat item labels, blank rows, calculated fields, persistent labelFilter / topN filters, cache CoW + cross-pivot sharing), slicers, named ranges, data validation, images (PNG/JPG/GIF/SVG with dual-representation fallback), sparklines, comments (RTL), autofilter, shapes, OLE objects, CSV/TSV import, $Sheet:A1 cell addressing

PowerPoint — slides (header/footer/date/slidenum toggles, hidden), shapes (pattern fill, blur effect, hyperlink tooltip + slide-jump links, highlight color on runs, slideMaster/slideLayout typed add/set/remove, arrow alias, effective.X + effective.X.src), images (PNG/JPG/GIF/SVG, fill modes: stretch/contain/cover/tile, brightness/contrast/glow/shadow, rotation, link + tooltip), tables (built-in PowerPoint style catalogue, virtual /col[C] get + swap/copyFrom, row/col Move/CopyFrom, fill/background alias), charts (pieOfPie, barOfPie, per-attr axisLine/gridline setters, series add/remove with theme palette, anchor=x,y,w,h shorthand), animations (15 emphasis + 16 exit template-backed presets, multi-effect chains, motion-path presets, repeat/restart/autoReverse, chart animations + chartBuild), transitions (morph + p14 + 12 p15 PowerPoint 2013+ presets), 3D models (.glb) (combined rotation=ax,ay,az), slide zoom, equations (LaTeX input), diagrams (mermaid flowchart / sequence → native editable shapes, or any mermaid type as a full-fidelity PNG), themes, connectors (from/to accept a full /slide[N]/shape[@name=Foo] path), video/audio (loop, autoStart), groups (link + tooltip; Get/Query/Add/Remove all descend into groups), notes (RTL, lang), comments (RTL, legacy + modern p188 threaded round-trip), SmartArt (round-trip via add-part + raw-set), OLE objects, placeholders (add/set by phType)

Use Cases

For Developers:

Automate report generation from databases or APIs
Batch-process documents (bulk find/replace, style updates)
Build document pipelines in CI/CD environments (generate docs from test results)
Headless Office automation in Docker/containerized environments

For AI Agents:

Generate presentations from user prompts (see examples above)
Extract structured data from documents to JSON
Validate and check document quality before delivery

For Teams:

Clone document templates and populate with data
Automated document validation in CI/CD pipelines

Installation

Ships as a single self-contained binary. The .NET runtime is embedded -- nothing to install, no runtime to manage.

One-line install:

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.sh | bash

# Windows (PowerShell)
irm https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.ps1 | iex

Or via a package manager:

# Homebrew (macOS / Linux)
brew install officecli

# Scoop (Windows)
scoop install officecli

# npm (all platforms — fetches the native binary for your platform)
npm install -g @officecli/officecli

Or download manually from GitHub Releases:

Platform	Binary
macOS Apple Silicon	`officecli-mac-arm64`
macOS Intel	`officecli-mac-x64`
Linux x64	`officecli-linux-x64`
Linux ARM64	`officecli-linux-arm64`
Windows x64	`officecli-win-x64.exe`
Windows ARM64	`officecli-win-arm64.exe`

Verify installation: officecli --version

Or self-install from a downloaded binary (or run bare officecli to auto-install):

officecli install    # explicit
officecli            # bare invocation also triggers install

Updates are checked automatically in the background. Disable with officecli config autoUpdate false or skip per-invocation with OFFICECLI_SKIP_UPDATE=1. Configuration lives under ~/.officecli/config.json.

Key Features

Built-in Engines & Generation Primitives

OfficeCLI is self-contained. The capabilities below ship inside the binary — no Office required.

Rendering engine — high-fidelity, built-in

OfficeCLI's keystone: a from-scratch, high-fidelity HTML rendering engine that lets an AI agent see the rendered document instead of guessing from the DOM. It covers shapes, charts (trendlines, error bars, waterfall, candlestick, sparklines), equations (OMML → LaTeX, rendered with KaTeX), 3D .glb models via Three.js, morph transitions, slide zoom, and shape effects. Per-page PNG screenshots are produced by piping the rendered HTML through a headless browser. Three modes:

view html — standalone HTML file, assets inlined. Open in any browser.
view screenshot — per-page PNG, ready for multimodal agents to read.
watch — local HTTP server with auto-refreshing preview; every add / set / remove updates the browser instantly. Excel watch supports inline cell editing and drag-to-reposition charts.

officecli view deck.pptx html -o /tmp/deck.html
officecli view deck.pptx screenshot -o /tmp/deck.png # add --page 1-N for more slides
officecli watch deck.pptx                            # http://localhost:26315

Without visualization, an agent generating slides is flying blind — it can read the DOM but can't tell if the title overflows or two shapes overlap. Because rendering is built into the binary, the render → look → fix loop works in CI, in Docker, on a server with no display — anywhere the binary runs.

Formula & pivot engine

350+ built-in Excel functions evaluated automatically on write — write =SUM(A1:A2), get the cell, the value is already there. No round-trip through Office to recalc. Covers spilling dynamic arrays (FILTER / SORT / UNIQUE / SEQUENCE / LET / LAMBDA / MAP), VLOOKUP / XLOOKUP / INDEX / MATCH, financial & bond math (XIRR / PRICE / YIELD / DURATION / COUPNUM), statistical distributions, tests & regression (NORM.DIST / T.TEST / LINEST), and date & text functions.

Plus native OOXML pivot tables from a source range with one command — multi-field rows/cols/filters, 10 aggregations, showDataAs modes, date grouping, calculated fields, top-N, layouts. Pivot cache + definition are written to OOXML, so Excel opens the file with the aggregation already populated:

officecli add sales.xlsx '/Sheet1' --type pivottable \
  --prop source='Data!A1:E10000' --prop rows='Region,Category' \
  --prop cols=Quarter --prop values='Revenue:sum,Units:avg' \
  --prop showDataAs=percentOfTotal

Template merge — generate once, fill many

merge replaces {{key}} placeholders in any .docx / .xlsx / .pptx with JSON data — across paragraphs, table cells, shapes, headers, footers, and chart titles. Agent designs the layout once (expensive); production code fills it N times (cheap, deterministic, zero token cost). Avoids the failure mode where an agent regenerates each report from scratch and produces N inconsistent layouts.

officecli merge invoice-template.docx out-001.docx '{"client":"Acme","total":"$5,200"}'
officecli merge q4-template.pptx q4-acme.pptx data.json

Round-trip dump — learn from existing docs

dump serializes any .docx, .pptx, or .xlsx — whole document or any subtree (a single paragraph, table, slide, worksheet, the styles part, numbering, theme, or settings) — into a replayable batch JSON; batch replays it. Given a sample the user wants to imitate, an agent reads the structured spec instead of raw OOXML XML, mutates, and replays. Bridges "I have an existing template" and "generate me 100 variations."

officecli dump existing.docx -o blueprint.json                  # whole document
officecli dump existing.docx /body/tbl[1] -o table.json         # any subtree
officecli dump existing.xlsx /Sheet1 -o sheet.json              # a single worksheet
officecli batch new.docx --input blueprint.json

Resident Mode & Batch

For multi-step workflows, resident mode keeps the document in memory. Batch mode applies multiple operations in a single pass.

# Resident mode — near-zero latency via named pipes
officecli open report.docx
officecli set report.docx /body/p[1]/r[1] --prop bold=true
officecli set report.docx /body/p[2]/r[1] --prop color=FF0000
officecli close report.docx

# Batch mode — multi-command execution (continues on error by default; --stop-on-error to abort)
echo '[{"command":"set","path":"/slide[1]/shape[1]","props":{"text":"Hello"}},
      {"command":"set","path":"/slide[1]/shape[2]","props":{"fill":"FF0000"}}]' \
  | officecli batch deck.pptx --json

# Inline batch with --commands (no stdin needed)
officecli batch deck.pptx --commands '[{"op":"set","path":"/slide[1]/shape[1]","props":{"text":"Hi"}}]'

# Abort on the first failing command (default is continue-on-error)
officecli batch deck.pptx --input updates.json --stop-on-error --json

Reading the file with another tool? Flush to disk first. officecli's own reads (get/query/view) always see your latest edits, so within officecli you never need to save. But a live resident defers the disk write, so before a non‑officecli program reads the file — python‑docx/openpyxl, Microsoft Word, a renderer, delivery/upload — flush it:
officecli set report.docx /body/p[1] --prop bold=true
officecli save report.docx           # flush, keep the resident warm (or `close` to flush + release)
python my_reader.py report.docx      # now sees the edit
A live resident also auto‑flushes shortly after going idle (adaptive 2–10s, scaled to the document's measured save cost). For a pipeline where another program reads after every command, set OFFICECLI_RESIDENT_FLUSH=each — every mutation is on disk before the command returns, while the resident stays warm. Full flush model (each/auto/fixed/off, save / close, env tuning): wiki → open / close.

Three-Layer Architecture

Start simple, go deep only when needed.

Layer	Purpose	Commands
L1: Read	Semantic views of content	`view` (text, annotated, outline, stats, issues, html, svg, screenshot)
L2: DOM	Structured element operations	`get`, `query`, `set`, `add`, `remove`, `move`, `swap`
L3: Raw XML	Direct XPath access — universal fallback	`raw`, `raw-set`, `add-part`, `validate`

# L1 — high-level views
officecli view report.docx annotated
officecli view budget.xlsx text --cols A,B,C --max-lines 50

# L2 — element-level operations
officecli query report.docx "run:contains(TODO)"
officecli add budget.xlsx / --type sheet --prop name="Q2 Report"
officecli move report.docx /body/p[5] --to /body --index 1

# L3 — raw XML when L2 isn't enough
officecli raw deck.pptx '/slide[1]'
officecli raw-set report.docx document \
  --xpath "//w:p[1]" --action append \
  --xml '<w:r><w:t>Injected text</w:t></w:r>'

AI Integration

MCP Server

Built-in MCP server — register with one command:

officecli mcp claude       # Claude Code
officecli mcp cursor       # Cursor
officecli mcp vscode       # VS Code / Copilot
officecli mcp lmstudio     # LM Studio
officecli mcp list         # Check registration status

Exposes all document operations as tools over JSON-RPC — no shell access needed.

Direct CLI Integration

Get OfficeCLI working with your AI agent in two steps:

Install the binary -- one command (see Installation)
Done. OfficeCLI automatically detects your AI tools (Claude Code, GitHub Copilot, Codex) by checking known config directories and installs its skill file. Your agent can immediately create, read, and modify any Office document.

Manual setup (optional)

If auto-install doesn't cover your setup, you can install the skill file manually:

Feed SKILL.md to your agent directly:

curl -fsSL https://officecli.ai/SKILL.md

Install as a local skill for Claude Code:

curl -fsSL https://officecli.ai/SKILL.md -o ~/.claude/skills/officecli.md

Other agents: Include the contents of SKILL.md in your agent's system prompt or tool description.

Why your agent will thrive on OfficeCLI

Deterministic JSON output — every command supports --json with consistent schemas. No regex parsing, no scraping stdout.
Path-based addressing — every element has a stable path (/slide[1]/shape[2]). Agents navigate documents without understanding XML namespaces. (OfficeCLI syntax: 1-based indexing, element local names — not XPath.)
Progressive complexity (L1 → L2 → L3) — agents start with read-only views, escalate to DOM ops, fall back to raw XML only when needed. Minimizes token usage.
Self-healing workflow — validate, view issues, and the structured error codes (not_found, invalid_value, unsupported_property) return suggestions and valid ranges. Agents self-correct without human intervention.
Built-in agent-friendly rendering engine — view html / view screenshot / watch emit HTML and PNG natively. No Office required. Agents can see their output and fix layout issues, even inside CI / Docker / headless environments.
Built-in formula & pivot engine — 350+ Excel functions auto-evaluated on write (incl. spilling dynamic arrays, financial / bond and statistical families); native OOXML pivot tables from a source range with one command. Agents read computed values and shipped aggregations immediately, without round-tripping through Office.
Template merge — agent designs the layout once, downstream code fills {{key}} placeholders N times. Avoids burning tokens regenerating every report from scratch.
Round-trip dump — dump turns any .docx, .pptx, or .xlsx into replayable batch JSON. Agents learn from human-authored samples by reading a structured spec, not raw OOXML XML.
Built-in help — when unsure about property names or value formats, the agent runs officecli <format> set <element> instead of guessing.
Auto-install — OfficeCLI detects your AI tooling (Claude Code, Cursor, VS Code, …) and configures itself. No manual skill-file setup.

Built-in Help

Don't guess property names — drill into the help:

officecli pptx set              # All settable elements and properties
officecli pptx set shape        # Detail for one element type
officecli pptx set shape.fill   # One property: format and examples
officecli docx query            # Selector reference: attributes, :contains, :has(), etc.

Run officecli --help for the full overview.

JSON Output Schemas

All commands support --json. The general response shapes:

Single element (get --json):

{"tag": "shape", "path": "/slide[1]/shape[1]", "attributes": {"name": "TextBox 1", "text": "Hello"}}

List of elements (query --json):

[
  {"tag": "paragraph", "path": "/body/p[1]", "attributes": {"style": "Heading1", "text": "Title"}},
  {"tag": "paragraph", "path": "/body/p[5]", "attributes": {"style": "Heading1", "text": "Summary"}}
]

Errors return a non-zero exit code with a structured error object including error code, suggestion, and valid values when available:

{
  "success": false,
  "error": {
    "error": "Slide 50 not found (total: 8)",
    "code": "not_found",
    "suggestion": "Valid Slide index range: 1-8"
  }
}

Error codes: not_found, invalid_value, unsupported_property, invalid_path, unsupported_type, missing_property, file_not_found, file_locked, invalid_selector. Property names are auto-corrected -- misspelling a property returns a suggestion with the closest match.

Error Recovery -- Agents self-correct by inspecting available elements:

# Agent tries an invalid path
officecli get report.docx /body/p[99] --json
# Returns: {"success": false, "error": {"error": "...", "code": "not_found", "suggestion": "..."}}

# Agent self-corrects by checking available elements
officecli get report.docx /body --depth 1 --json
# Returns the list of available children, agent picks the right path

Mutation confirmations (set, add, remove, move, create with --json):

{"success": true, "path": "/slide[1]/shape[1]"}

See officecli --help for full details on exit codes and error formats.

Comparison

	OfficeCLI	Microsoft Office	LibreOffice	python-docx / openpyxl
Open source & free	✓ (Apache 2.0)	✗ (paid license)	✓	✓
AI-native CLI + JSON	✓	✗	✗	✗
Zero install (single binary)	✓	✗	✗	✗ (Python + pip)
Call from any language	✓ (CLI)	✗ (COM/Add-in)	✗ (UNO API)	Python only
Path-based element access	✓	✗	✗	✗
Raw XML fallback	✓	✗	✗	Partial
Built-in agent-friendly rendering engine	✓	✗	✗	✗
Headless HTML/PNG output	✓	✗	Partial	✗
Template merge (`{{key}}`) across formats	✓	✗	✗	✗
Round-trip dump → batch JSON	✓	✗	✗	✗
Live preview (auto-refresh on edit)	✓	✗	✗	✗
Headless / CI	✓	✗	Partial	✓
Cross-platform	✓	Windows/Mac	✓	✓
Word + Excel + PowerPoint	✓	✓	✓	Separate libs

Command Reference

Command	Description
`create`	Create a blank .docx, .xlsx, or .pptx (type from extension)
`view`	View content (modes: `outline`, `text`, `annotated`, `stats` (`--page-count`), `issues`, `html`, `svg`, `screenshot`, `pdf` (via exporter plugin), `forms` (via format-handler plugin)). docx supports `--render auto\|native\|html`.
`load_skill`	Print embedded SKILL.md content for a specialized skill (no install)
`get`	Get element and children (`--depth N`, `--json`)
`query`	CSS-like query with boolean `and`/`or`, row-by-column-name (`row[Salary>5000]`), `--find` flag
`set`	Modify element properties; accepts selectors and Excel-native paths (parity with `get`/`query`), `--find`/`--replace` flags
`add`	Add element (or clone with `--from <path>`)
`remove`	Remove an element
`move`	Move element (`--to <parent>`, `--index N`, `--after <path>`, `--before <path>`)
`swap`	Swap two elements
`validate`	Validate against OpenXML schema
`view <file> issues`	Enumerate document issues (text overflow, missing alt text, formula errors, ...)
`batch`	Multiple operations applied in a single pass (stdin, `--input`, or `--commands`; continues on error by default, `--stop-on-error` to abort)
`dump`	Serialize a `.docx`, `.pptx`, or `.xlsx` into a replayable batch JSON (round-trip via `batch`); accepts a subtree path
`refresh`	Recalculate TOC page numbers / `PAGE` / cross-references (`.docx`; Word backend on Windows, headless-HTML fallback)
`plugins`	List / inspect / lint installed plugins (extend to `.doc`, `.hwpx`, `.pdf` export via dump-reader / exporter / format-handler kinds)
`merge`	Template merge — replace `{{key}}` placeholders with JSON data
`watch`	Live HTML preview in browser with auto-refresh
`mcp`	Start MCP server for AI tool integration
`raw`	View raw XML of a document part
`raw-set`	Modify raw XML via XPath
`add-part`	Add a new document part (header, chart, etc.)
`open`	Start resident mode (keep document in memory)
`close`	Save and close resident mode
`install`	Install binary + skills + MCP (`all`, `claude`, `cursor`, etc.)
`config`	Get or set configuration
`<format> <command>`	Built-in help (e.g. `officecli pptx set shape`)

End-to-End Workflow Example

A typical self-healing agent workflow: create a presentation, populate it, verify, and fix issues -- all without human intervention.

# 1. Create
officecli create report.pptx

# 2. Add content
officecli add report.pptx / --type slide --prop title="Q4 Results"
officecli add report.pptx '/slide[1]' --type shape \
  --prop text="Revenue: $4.2M" --prop x=2cm --prop y=5cm --prop size=28
officecli add report.pptx / --type slide --prop title="Details"
officecli add report.pptx '/slide[2]' --type shape \
  --prop text="Growth driven by new markets" --prop x=2cm --prop y=5cm

# 3. Verify
officecli view report.pptx outline
officecli validate report.pptx

# 4. Fix any issues found
officecli view report.pptx issues --json
# Address issues based on output, e.g.:
officecli set report.pptx '/slide[1]/shape[1]' --prop font=Arial

Units & Colors

All dimension and color properties accept flexible input formats:

Type	Accepted formats	Examples
Dimensions	cm, in, pt, px, or raw EMU	`2cm`, `1in`, `72pt`, `96px`, `914400`
Colors	Hex, named, RGB, theme	`#FF0000`, `FF0000`, `red`, `rgb(255,0,0)`, `accent1`
Font sizes	Bare number or pt-suffixed	`14`, `14pt`, `10.5pt`
Spacing	pt, cm, in, or multiplier	`12pt`, `0.5cm`, `1.5x`, `150%`

Common Patterns

# Replace all Heading1 text in a Word doc
officecli query report.docx "paragraph[style=Heading1]" --json | ...
officecli set report.docx /body/p[1]/r[1] --prop text="New Title"

# Export all slide content as JSON
officecli get deck.pptx / --depth 2 --json

# Bulk-update Excel cells
officecli batch budget.xlsx --input updates.json --json

# Import CSV data into an Excel sheet
officecli add budget.xlsx / --type sheet --prop name="Q1 Data" --prop csv=sales.csv

# Template merge for batch reports
officecli merge invoice-template.docx invoice-001.docx '{"client":"Acme","total":"$5,200"}'

# Check document quality before delivery
officecli validate report.docx && officecli view report.docx issues --json

From Python or Node.js — install one of the thin resident-pipe SDKs (no per-call process spawn):

# Python — `pip install officecli-sdk`
from officecli import Doc
with Doc("deck.pptx") as d:
    d.add("/", type="slide", title="Q4 Report")
    print(d.get("/slide[1]"))

// Node.js — `npm install @officecli/sdk`
import { Doc } from "@officecli/sdk";
await using d = await Doc.open("deck.pptx");
await d.add("/", { type: "slide", title: "Q4 Report" });
console.log(await d.get("/slide[1]"));

Both SDKs auto-provision the native CLI when missing (mirror-first, Windows-capable) and announce the install rather than doing it silently.

Or wrap subprocess directly, one-shot:

import json, subprocess
def cli(*args):
    return json.loads(subprocess.check_output(["officecli", *args, "--json"], text=True))
cli("create", "deck.pptx")

Documentation

The Wiki has detailed guides for every command, element type, and property:

By format: Word | Excel | PowerPoint
Workflows: End-to-end examples -- Word reports, Excel dashboards, PowerPoint decks, batch modifications, resident mode
Runnable examples: examples/ -- copy-paste scripts (.sh/.py) for Word, Excel, and PowerPoint, with output files included
Troubleshooting: Common errors and solutions
AI agent guide: Decision tree for navigating the wiki

Build from Source

Requires .NET 10 SDK for compilation only. The output is a self-contained, native binary -- .NET is embedded in the binary and is not needed at runtime.

./build.sh

License

Apache License 2.0

Bug reports and contributions are welcome on GitHub Issues.

If you find OfficeCLI useful, please give it a star on GitHub — it helps others discover the project.

OfficeCLI.AI | GitHub

CoplayDev/unity-mcp

Unity MCP acts as a bridge between AI assistants and your Unity Editor. Give your LLM tools to manage assets, control scenes, edit scripts, and automate tasks within Unity.

English 简体中文 | Discord Wiki

Proudly sponsored and maintained by Aura — the AI assistant for Unreal & Unity.

And don't miss Godot AI, the new open source project from the makers of MCP for Unity.

Create your Unity apps with LLMs. MCP for Unity bridges AI assistants — Claude, Codex, VS Code, local LLMs, and more — with your Unity Editor via Model Context Protocol. Give your LLM the tools to manage assets, control scenes, edit scripts, run tests, and automate your game dev workflows.

Recent Updates

v10.0.0 (2026-06-30)
v9.7.3 (2026-06-15)
v9.7.1 (2026-05-24)
v9.7.0 (2026-05-22)
v9.6.8 (2026-04-27)

Full history: Release Notes.

What it does

Control the Unity Editor in natural language from any MCP client — create scenes & GameObjects, edit C# scripts, manage assets, run tests, profile, and build. 47 focused MCP tool entrypoints, any client, free & MIT.

Browse the full tool catalog →

Quickstart

Requirements: Unity 2021.3 LTS → 6.x · Python 3.10+ (via uv). Works with any MCP client — Claude Desktop & Code, Cursor, VS Code, Windsurf, Cline, Gemini CLI, and more.

Install — Unity → Package Manager → Add from git URL: https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#main (pin #v10.0.0 for this release, or openupm add com.coplaydev.unity-mcp)
Configure — Window → MCP for Unity → Configure All Detected Clients.
Prompt — "Create a cube at the origin and add a Rigidbody." The cube appears in seconds.

Community

Discord — chat with maintainers and other contributors
Issues — bugs and feature requests
Discussions — design ideas and broader questions
Security: see SECURITY.md for private reporting

Contributing

See CONTRIBUTING.md. Branch off beta, not main. The full dev setup, testing, and release process live in the Contributing docs.

Advanced

Multiple Unity instances — Multi-Instance Routing
Tool groups (vfx / animation / ui / testing / etc.) — Tool Groups
v10 asset generation and upgrade notes — v10 Migration
Roslyn script validation — Roslyn Validation
Remote-hosted server with auth — Remote Server Auth

Star History

Citation

If MCP for Unity helped your research, please cite it.

@inproceedings{wu2025mcpunity,
  author    = {Wu, Shutong and Barnett, Justin P.},
  title     = {{MCP-Unity}: {Protocol-Driven} Framework for Interactive {3D} Authoring},
  year      = {2025},
  isbn      = {9798400721366},
  publisher = {Association for Computing Machinery},
  address   = {New York, NY, USA},
  url       = {https://doi.org/10.1145/3757376.3771417},
  doi       = {10.1145/3757376.3771417},
  series    = {SA Technical Communications '25}
}

Unity AI Tools by Aura

Aura offers 2 AI tools for Unity:

MCP for Unity is available freely under the MIT license.
Aura for Unity is a premium Unity/Unreal AI assistant built for game devs.

Disclaimer

This project is a free and open-source tool for the Unity Editor, and is not affiliated with Unity Technologies.

License: MIT — see LICENSE.

k1tbyte/Wand-Enhancer

Advanced UX and interoperability extension for Wand (WeMod) app

WandEnhancer

An open-source interoperability tool designed to extend local client-side configurations and improve the UX of the Wand application.

🚨 IMPORTANT NOTICE: THIS PROJECT HAS NO OFFICIAL YOUTUBE TUTORIALS, GUIDES, OR PREBUILT EXECUTABLE DOWNLOADS. 🚨 There are no official videos showing how to install or use this tool. Scammers are creating fake tutorials using this project's name and placing malware/password stealers in the video descriptions. Official GitHub releases contain release notes only, not .exe files. If you downloaded an .exe or archive from a YouTube link, a random website, or a third-party mirror, you did not get it from this project. We are not responsible for third-party downloads.

👾 Is it safe to use?

Yes. This project is entirely open-source, allowing anyone to audit the code. It operates strictly locally, does not require internet access, and makes zero network requests. It simply adjusts local client settings to enhance your user experience.

💫 What features are improved?

✅ Local environment configuration management
✅ Automated compatibility adjustments for new client versions
✅ Advanced layout and theme customization (Client-side only)
✅ AI Features
✅ Remote web panel (Remote Connect on mobile)

🌐 Remote Web Panel

WandEnhancer includes a built-in Remote Web Panel allowing you to control app features directly from your phone.

Quick Start:

Ensure both your PC and phone are on the same Wi-Fi network.
Hover over the Connect button in the top bar of WandEnhancer.
Scan the displayed QR code with your phone's camera.

Troubleshooting & Remote Access:

Page isn't loading? First, ensure both your PC and phone are connected to the same local network. Some routers and guest Wi-Fi networks enable client isolation/AP isolation, which blocks devices on the same SSID from reaching each other. If it still does not load, check Windows Firewall and allow inbound traffic on TCP port 3223 for your local network. If Windows marked your connection as Public, switching it to Private can also help.
Using mobile data or a different network? If you want to use the panel over mobile data (LTE/5G) or from an entirely different network, you can use Tailscale or similar VPN tools.

👀 How to use?

This repository does not publish official compiled binaries. Build your own executable from your own fork using GitHub Actions.

Sign in to GitHub and fork this repository.
Open your fork, go to the Actions tab, and enable workflows if GitHub asks you to.
Select the Build executable workflow.
Click Run workflow, keep the default branch, and start the run.
Wait for the workflow to finish, open the completed run, and download the artifact.
Extract the artifact zip and run WandEnhancer.exe to apply local client modifications.

Here how you do it:

https://github.com/user-attachments/assets/7966cabe-0aa6-424d-8c2f-981ad91e0f91

🧩 Custom scripts

You can inject your own JavaScript into Wand at patch time to tweak or fix things in the client UI. This reuses the same renderer injection the Remote Web Panel uses, so it requires the Remote Web Panel patch to be enabled.

How to add a script

In the patch dialog, add one or more .js files (only existing .js files are accepted), or
Drop .js files into a renderer-scripts/ folder placed next to the patcher executable.

Then patch as usual — your scripts are bundled into the client and run inside Wand's window.

How it runs

Each script runs inside Wand's renderer (full DOM access, plus Node require).
It is wrapped so a thrown error is logged and never crashes Wand.
It may run more than once per launch (on load and again shortly after), so guard one‑time work behind a global flag.
A small WandEnhancer helper is available: WandEnhancer.log(...), WandEnhancer.remoteUrl, WandEnhancer.apiVersion.

Minimal example (hello.js)

// Injected scripts can run multiple times — guard one-time setup.
if (!globalThis.__helloScriptInstalled) {
  globalThis.__helloScriptInstalled = true;

  WandEnhancer.log("Hello from my custom script!", WandEnhancer.remoteUrl);

  new MutationObserver(() => {
    const dialog = document.querySelector("ux-dialog:not([data-seen])");
    if (dialog) {
      dialog.setAttribute("data-seen", "1");
      WandEnhancer.log("A dialog opened.");
    }
  }).observe(document.documentElement, { childList: true, subtree: true });
}

Scripts run with the same privileges as the Wand client. Only add scripts you trust and understand.

🛠️ How to build from source

Building from source on Windows requires a local development environment.

Requirements

CMake
Node.js and pnpm
Visual Studio 2022 or Build Tools for Visual Studio 2022 with MSBuild
Visual Studio Desktop development with C++ workload
.NET Framework 4.8 desktop build tools / targeting pack

Build steps

Clone this repository.
Install the requirements above and make sure cmake, pnpm, and MSBuild are available.
Run build.cmd from Command Prompt or PowerShell.

The build script installs the web panel dependencies, builds the frontend, compiles the native helper with CMake, restores NuGet packages, and builds the WPF solution.

❓ Q&A

Why is there no .exe in GitHub Releases?
- Official releases are notes-only on purpose. The project no longer distributes prebuilt executables because unsigned or self-built patching tools are repeatedly reuploaded, mislabeled, and flagged by third-party scanners. Build the executable from your own fork using GitHub Actions instead.
Where do I download the executable?
- From your own fork's Actions artifact after running the Build executable workflow. Do not download .exe files from YouTube descriptions, random mirrors, Discord attachments, or issue comments.
Why does Windows Defender or SmartScreen warn about my build?
- The GitHub Actions artifact is unsigned and uncommon, so Windows may warn even when the code was built directly from your fork. Review the source, verify the workflow logs, and only run binaries you built yourself.
Can I use a binary built by someone else?
- You can, but you should treat it as untrusted. This repository cannot verify or support third-party builds.
Does this send data anywhere?
- The desktop patching work is local to your machine. The Remote Web Panel is served from your PC on your local network.

🖼️ Screenshots

📜 License

This project is licensed under the Apache-2.0 - see the LICENSE file for details.

❤️ Support

If you find this project useful, you can support its development using any of the options below 🙌

Legal Disclaimer: This project is a third-party enhancement tool intended solely for educational, research, and local interoperability purposes. It does not distribute any proprietary code or bypass server-side validations. All modifications are performed locally to customize the user's interface.

Sonarr/Sonarr

Smart PVR for newsgroup and bittorrent users.

Sonarr

Sonarr is a PVR for Usenet and BitTorrent users. It can monitor multiple RSS feeds for new episodes of your favorite shows and will grab, sort and rename them. It can also be configured to automatically upgrade the quality of files already downloaded when a better quality format becomes available.

Getting Started

Support

Note: GitHub Issues are for Bugs and Feature Requests Only

Features

Current Features

Support for major platforms: Windows, Linux, macOS, Raspberry Pi, etc.
Automatically detects new episodes
Can scan your existing library and download any missing episodes
Can watch for better quality of the episodes you already have and do an automatic upgrade. eg. from DVD to Blu-Ray
Automatic failed download handling will try another release if one fails
Manual search so you can pick any release or to see why a release was not downloaded automatically
Fully configurable episode renaming
Full integration with SABnzbd and NZBGet
Full integration with Kodi, Plex (notification, library update, metadata)
Full support for specials and multi-episode releases
And a beautiful UI

Contributing

Development

This project exists thanks to all the people who contribute. Contribute.

Supporters

This project would not be possible without the support of our users and software providers. Become a sponsor or backer to help us out!

Mega Sponsors

Backers

JetBrains

Thank you to for providing us with free licenses to their great tools

Licenses

GNU GPL v3
Copyright 2010-2025

dotnet/aspnetcore

ASP.NET Core is a cross-platform .NET framework for building modern cloud-based web applications on Windows, Mac, or Linux.

ASP.NET Core

ASP.NET Core is an open-source and cross-platform framework for building modern cloud-based internet-connected applications, such as web apps, IoT apps, and mobile backends. ASP.NET Core apps run on .NET, a free, cross-platform, and open-source application runtime. It was architected to provide an optimized development framework for apps that are deployed to the cloud or run on-premises. It consists of modular components with minimal overhead, so you retain flexibility while constructing your solutions. You can develop and run your ASP.NET Core apps cross-platform on Windows, Mac, and Linux. Learn more about ASP.NET Core.

Get started

Follow the Getting Started instructions.

Also check out the .NET Homepage for released versions of .NET, getting started guides, and learning resources.

See the Triage Process document for more information on how we handle incoming issues.

How to engage, contribute, and give feedback

Some of the best ways to contribute are to try things out, file issues, join in design conversations, and make pull-requests.

Download our latest daily builds
Follow along with the development of ASP.NET Core:
- Community Standup: The community standup is held every week and streamed live on YouTube. You can view past standups in the linked playlist.
- Roadmap: The schedule and milestone themes for ASP.NET Core.
Build ASP.NET Core source code
Check out the contributing page to see the best places to log issues and start discussions.

Reporting security issues and bugs

Security issues and bugs should be reported privately to the Microsoft Security Response Center (MSRC) via the MSRC Researcher Portal. You should receive a response within 24 hours. Further information can be found in the MSRC Report an Issue FAQ. You can also find these instructions in this repo's Security doc.

Also see info about related Microsoft .NET Bounty Program.

Related projects

These are some other repos for related projects:

Documentation - documentation sources for https://learn.microsoft.com/aspnet/core/
Entity Framework Core - data access technology
Runtime - cross-platform runtime for cloud, mobile, desktop, and IoT apps
Razor - the Razor compiler and tooling for working with Razor syntax (.cshtml, .razor)

Code of conduct

See CODE-OF-CONDUCT

Nightly builds

This table includes links to download the latest builds of the ASP.NET Core Shared Framework. Also included are links to download the Windows Hosting Bundle, which includes the ASP.NET Core Shared Framework, the .NET Runtime Shared Framework, and the IIS plugin (ASP.NET Core Module). You can download the latest .NET Runtime builds here, and the latest .NET SDK builds here. If you're unsure what you need, then install the SDK; it has everything except the IIS plugin.

Platform	Shared Framework (Installer)	Shared Framework (Binaries)	Hosting Bundle (Installer)
Windows x64	Installer	Binaries	Installer
Windows x86	Installer	Binaries	Installer
Windows arm64	Installer	Binaries	Installer
macOS x64	N/A	Binaries	N/A
macOS arm64	N/A	Binaries	N/A
Linux x64	Deb Installer - RPM Installer	Binaries	N/A
Linux arm	N/A	Binaries	N/A
Linux arm64	RPM Installer	Binaries	N/A
Linux-musl-x64	N/A	Binaries	N/A
Linux-musl-arm	N/A	Binaries	N/A
Linux-musl-arm64	N/A	Binaries	N/A

SirDiabo/GithubLauncher

A Launcher that Downloads and Updates Applications from Github Releases

Github Launcher

Important

Migration from N64RecompLauncher to GithubLauncher

This software was previously knows as the "N64Recomp Launcher", but this had to be changed due to continued requests by the N64Recomp Tool Developers. If you are interested in a version of the launcher that is primarily for N64 Recompiled Games, then check out this version. You can then go into the update_check.json and change the year in LastCheckTime to something like 9999 to disable self-updates.

If you have an old version, and wish to update to the newer ones, you will have to update manually by dragging the new files into your launcher folder. You can then delete all files with "N64Recomp" in their names. Your settings will remain compatible.

A modern, user-friendly launcher application for managing and running GitHub-hosted applications. This tool streamlines the process of downloading, installing, and launching your favorite projects.

Features

Automated Updates: Seamlessly download and install the latest releases from GitHub
Version Management: Stay up-to-date with automatic version checking and updates
App Management: Easy-to-use interface for launching GitHub-hosted apps
Smart Integration: Direct integration with GitHub releases for smooth updates

Getting Started

Prerequisites

.NET 9 Runtime (get it here)
Internet connection for updates and downloads

Installation

Download the latest release from the Releases page
Extract the downloaded archive to your preferred location
Run the executable.

Usage

Launch the application
The launcher will automatically check for updates on startup
Browse your app library through the interface
Select an app and click "Download/Launch" to use it

Configuration

GitHub API Token

To avoid hitting GitHub's API rate limits, you can provide a personal access token. Create a token with no special permissions needed and set it in the launcher settings. You can create a token at GitHub Settings -> Developer settings > Personal access tokens > Tokens (classic) > Generate new token You don't need to give it any special permissions. Then paste that Token into your Settings field. Do not share your Token!

apps.json Structure

The launcher uses an apps.json file to manage the available apps. Every entry is user-managed and editable; there are no built-in stable, experimental, or custom categories.

App Entry Properties

Each app entry requires the following properties:

name - The display name of the app as it appears in the launcher
repository - The GitHub repository in the format username/repository
folderName - The folder name where the app will be downloaded and installed
appIconUrl - URL of the app's icon image. If null, a default icon will be used.

Example Configuration

{
    "apps": [
        {
            "name": "Example App",
            "repository": "username/example-app-repo",
            "folderName": "ExampleApp",
            "appIconUrl": null
        },
        {
            "name": "Another App",
            "repository": "anotheruser/another-app-repo",
            "folderName": "AnotherApp",
            "appIconUrl": "link/to/an/image.png"
        }
    ]
}

Support

If you encounter any issues or have questions:

Open an issue
Check existing issues for solutions

space-wizards/space-station-14

A multiplayer game about paranoia and chaos on a space station. Remake of the cult-classic Space Station 13.

Space Station 14 is a remake of SS13 that runs on Robust Toolbox, our homegrown engine written in C#.

This is the primary repo for Space Station 14. To prevent people forking RobustToolbox, a "content" pack is loaded by the client and server. This content pack contains everything needed to play the game on one specific server.

If you want to host or create content for SS14, this is the repo you need. It contains both RobustToolbox and the content pack for development of new content packs.

Documentation/Wiki

Our docs site has documentation on SS14's content, engine, game design, and more.
Additionally, see these resources for license and attribution information:

We also have lots of resources for new contributors to the project.

Contributing

We are happy to accept contributions from anybody. Get in Discord if you want to help. We've got a list of issues that need to be done and anybody can pick them up. Don't be afraid to ask for help either!
Just make sure your changes and pull requests are in accordance with the contribution guidelines.

We are not currently accepting translations of the game on our main repository. If you would like to translate the game into another language, consider creating a fork or contributing to a fork.

AI-generated contributions disclaimer

This project does not accept low-effort or wholesale AI-generated contributions. Examples include, but are not limited to:

Any code (including yaml) generated by tools like GitHub Copilot, ChatGPT, or similar.
AI-created artwork, sound files, or other assets.
Auto-generated documentation, issue reports or pull request descriptions.

Exceptions to this are simple tools like Rider's single-line completion feature.

Building

Clone this repo:

git clone https://github.com/space-wizards/space-station-14.git

Go to the project folder and run RUN_THIS.py to initialize the submodules and load the engine:

cd space-station-14
python RUN_THIS.py

Compile the solution:

Build the server using dotnet build.

More detailed instructions on building the project.

License

All code for the content repository is licensed under the MIT license.

Most assets are licensed under CC-BY-SA 3.0 unless stated otherwise. Assets have their license and copyright specified in the metadata file. For example, see the metadata for a crowbar.

Note

Some assets are licensed under the non-commercial CC-BY-NC-SA 3.0 or similar non-commercial licenses and will need to be removed if you wish to use this project commercially.

dotnet/skills

Repository for skills to assist AI coding agents with .NET and C#

.NET Agent Skills

This repository contains the .NET team's curated set of core skills and custom agents for coding agents. For information about the Agent Skills standard, see agentskills.io.

📊 Dashboard - Accuracy and efficiency scoring trends for contained plugins (https://dotnet.github.io/skills/)

What's Included

Plugin	Description
dotnet	C# language server (LSP) integration for coding agents and high-level .NET development skills.
dotnet-advanced	Collection of .NET skills for handling specific .NET tasks for special scenarios.
dotnet-data	Skills for .NET data access and Entity Framework related tasks.
dotnet-diag	Skills for .NET performance investigations, debugging, and incident analysis.
dotnet-msbuild	Comprehensive MSBuild and .NET build skills: failure diagnosis, performance optimization, code quality, and modernization.
dotnet-nuget	NuGet and .NET package management: dependency management and modernization.
dotnet-upgrade	Skills for migrating and upgrading .NET projects across framework versions, language features, and compatibility targets.
dotnet-maui	Skills for .NET MAUI development: environment setup, diagnostics, and troubleshooting.
dotnet-ai	AI and ML skills for .NET: technology selection, LLM integration, agentic workflows, RAG pipelines, MCP, and classic ML with ML.NET.
dotnet-template-engine	.NET Template Engine skills: template discovery, project scaffolding, and template authoring.
dotnet-test	Skills for running, generating, analyzing, and improving .NET tests: test execution, filtering, platform detection, coverage, testability, and MSTest workflows.
dotnet-test-migration	Skills and an orchestrator agent for migrating .NET test frameworks and platforms: MSTest and xUnit version upgrades, xUnit-to-MSTest conversion, and VSTest to Microsoft.Testing.Platform.
dotnet-aspnetcore	ASP.NET Core web development skills including middleware, endpoints, real-time communication, and API patterns.
dotnet-blazor	Skills for Blazor development: component authoring, interactivity, and web application patterns.
dotnet11	Skills for new .NET 11 APIs and language features.

Installation

🚀 Plugins - Copilot CLI / Claude Code

Launch Copilot CLI or Claude Code
Add the marketplace:
```
/plugin marketplace add dotnet/skills
```

Install a plugin:

/plugin install <plugin>@dotnet-agent-skills

Restart to load the new plugins
View available skills:
```
/skills
```
View available agents:
```
/agents
```

Update plugin (on demand):

/plugin update <plugin>@dotnet-agent-skills

VS Code / VS Code Insiders (Preview)

Important

VS Code plugin support is a preview feature and subject to change. You may need to enable it first.

// settings.json
{
  "chat.plugins.enabled": true,
  "chat.plugins.marketplaces": ["dotnet/skills"]
}

Once configured, type /plugins in Copilot Chat or use the @agentPlugins filter in Extensions to browse and install plugins from the marketplace.

Cursor

This repository is a Cursor plugin marketplace. You can discover and install published plugins directly in Cursor:

Open the marketplace panel in Cursor
Search for .NET or browse cursor.com/marketplace
Install the desired plugins

For local development or unpublished changes, import plugins from a local checkout:

Copy or symlink your local checkout to ~/.cursor/plugins/local/dotnet-agent-skills
Restart Cursor or run Developer: Reload Window

Codex CLI

Skills in this repository follow the agentskills.io open standard and are compatible with OpenAI Codex.

Plugin marketplace (recommended)

Codex CLI v0.121.0 and later supports a plugin marketplace. This repository ships a Codex-native marketplace manifest at .agents/plugins/marketplace.json, so you can register dotnet/skills as a marketplace and install plugins from it directly.

Add the marketplace:

codex plugin marketplace add dotnet/skills

Launch Codex and open the plugin browser:
```
/plugins
```
Browse the dotnet-agent-skills tab and install the desired plugins.

Update plugins on demand:

codex plugin marketplace upgrade dotnet-agent-skills

Individual skills

You can also install individual skills using the skill-installer CLI with the GitHub URL:

$ skill-installer install https://github.com/dotnet/skills/tree/main/plugins/<plugin>/skills/<skill-name>

Contributing

See CONTRIBUTING.md for contribution guidelines and how to add a new plugin.

License

See LICENSE for details.

fullstackhero/dotnet-starter-kit

Production Grade Cloud-Ready .NET 10 Starter Kit (Web API + React Client) with Multitenancy Support, and Clean/Modular Architecture that saves roughly 200+ Development Hours! All Batteries Included.

⚡ FullStackHero .NET 10 Starter Kit

A production-ready, modular .NET 10 monolith + two React 19 apps — the fastest way to ship a multi-tenant SaaS.

Identity, multitenancy, billing, auditing, webhooks, files, chat, real-time, caching, jobs, storage, OpenAPI and OpenTelemetry — already wired, fully tested, and 100% yours as source (no black-box packages).

📖 Documentation · 🚀 Get Started · 🧩 Modules · 🏗️ Architecture · 📦 Changelog

Why FullStackHero?

Most starter kits give you a login page and a TODO list. This one gives you the boring, hard parts already done right — multitenancy, auth, billing, auditing, background jobs, real-time, file storage, observability — across a clean Vertical Slice backend and two polished React 19 front-ends, orchestrated locally with one command via .NET Aspire, and deployable to Docker or AWS.

You scaffold with the fsh CLI and get the complete, detached source — every BuildingBlock, Module, and Host project with real project references. No hidden NuGet runtime, nothing to "eject" later. Own it, read it, change it.

dotnet tool install -g FullStackHero.CLI
fsh new MyApp
cd MyApp
dotnet run --project src/Host/MyApp.AppHost   # 🎉 whole stack up: API + 2 React apps + Postgres + Valkey + MinIO

Then open the Aspire dashboard at https://localhost:15888, the API + Scalar docs at https://localhost:7030/scalar, the admin app at http://localhost:5173, and the dashboard app at http://localhost:5174. Sign in with a seeded demo account (e.g. admin@acme.com / Password123!).

✨ What's inside

Backend — modular monolith, vertical slices

.NET 10 · C# latest · Minimal APIs · Mediator (source-generated CQRS) · FluentValidation
EF Core 10 on PostgreSQL (Npgsql), with domain events, the specification pattern, soft-delete + audit interceptors, and tenant-isolated DbContexts.
JWT auth + ASP.NET Identity — issuance/refresh, roles & fine-grained permissions, rate-limited auth, password policies, sessions, impersonation.
Multitenancy via Finbuckle — tenant resolution, provisioning, per-tenant migrations & seeding, isolation enforced by default.
Cross-cutting: HybridCache on Valkey (Redis-compatible), Hangfire jobs, presigned S3/MinIO storage, mailing, idempotency, quotas, rate limiting, API versioning, RFC 9457 ProblemDetails.
Observability: Serilog structured logging + OpenTelemetry traces/metrics/logs, health probes, security/exception auditing.
Docs: OpenAPI + the Scalar API reference UI.

Front-ends — two React 19 apps

clients/admin (operator console) and clients/dashboard (tenant app): React 19 + Vite 7 + TypeScript, TanStack Query v5, React Router 7, Radix + Tailwind v4 (shadcn-style), real-time via SignalR/SSE.
Runtime config (/config.json, no rebuild per environment), hand-written typed API client, and Playwright E2E suites.

Modules (bounded contexts)

Identity · Multitenancy · Billing · Catalog · Tickets · Chat · Files · Webhooks · Auditing · Notifications — each a runtime project plus a .Contracts project (its only public surface), boundaries enforced by architecture tests.

Cloud-native & DevOps

.NET Aspire orchestrates the entire stack locally with one command (Postgres + pgAdmin, Valkey + RedisInsight, MinIO, migrator, demo-seeder, API, and both React apps).
Docker Compose production stack (deploy/docker) and Terraform for AWS (deploy/terraform); API image published to GHCR.
A one-shot DbMigrator (migrations are never run at API startup), and the fsh CLI + dotnet new template for distribution.

Quality

1,600+ backend tests (xUnit, Shouldly, NSubstitute, AutoFixture, NetArchTest boundaries, Testcontainers integration) and 200+ front-end E2E tests (Playwright). Path-scoped CI for backend and frontend; warnings-as-errors.

🚀 Getting started

Option 1 — the `fsh` CLI (recommended)

dotnet tool install -g FullStackHero.CLI
fsh doctor          # verify your environment (SDK, Docker, Aspire, ports)
fsh new MyApp       # interactive wizard

The wizard asks what to include (Aspire AppHost, the React apps). Non-interactive:

fsh new MyApp --non-interactive          # full stack, Postgres
fsh new MyApp --no-frontend              # backend-only
fsh new MyApp --no-aspire --no-frontend  # minimal API + migrator

Option 2 — the `dotnet new` template

dotnet new install FullStackHero.NET.StarterKit
dotnet new fsh -n MyApp

Option 3 — clone the repo

git clone https://github.com/fullstackhero/dotnet-starter-kit.git MyApp && cd MyApp
dotnet run --project src/Host/FSH.Starter.AppHost

Prerequisites: .NET 10 SDK · Docker (Postgres/Valkey/MinIO via Aspire) · Node 20+ (for the React apps).

fsh commands: new · doctor · info · update · --version. Full reference → fullstackhero.net/docs/cli.

🧱 Tech stack

Backend		Frontend
Runtime	.NET 10 / C# latest	Framework	React 19 + Vite 7 + TS 5
API	Minimal APIs + Mediator (CQRS)	Data	TanStack Query v5
Validation	FluentValidation	Routing	React Router 7
ORM / DB	EF Core 10 / PostgreSQL	UI	Radix + Tailwind v4 (shadcn)
Auth	JWT + ASP.NET Identity	Realtime	SignalR · SSE
Multitenancy	Finbuckle 10	Tests	Playwright
Cache / Jobs	Valkey · Hangfire
Storage	S3 / MinIO (presigned)	Infra
Docs	OpenAPI + Scalar	Orchestration	.NET Aspire
Observability	Serilog + OpenTelemetry	Deploy	Docker Compose · Terraform
Testing	xUnit · Testcontainers · NetArchTest

🗺️ Repository layout

Path	What
`src/BuildingBlocks/`	Shared framework libraries (Core, Persistence, Web, Caching, Eventing, Storage, Quota…)
`src/Modules/{Name}/`	Bounded contexts — each with a runtime project + a `.Contracts` project (its public API)
`src/Host/FSH.Starter.Api`	Composition-root Web API host
`src/Host/FSH.Starter.AppHost`	.NET Aspire orchestrator (Postgres, Valkey, MinIO, migrator, API, both React apps)
`src/Host/FSH.Starter.DbMigrator`	One-shot migrate/seed runner (DB is not migrated at API startup)
`src/Tools/CLI`	The `fsh` CLI (Spectre.Console)
`clients/admin`, `clients/dashboard`	The two React apps
`deploy/`	Docker Compose, Terraform (AWS), Dokploy
`src/Tests/`	Unit, Architecture (NetArchTest), Integration (Testcontainers)

Architecture deep-dive → fullstackhero.net/docs/architecture.

☁️ Deploy

Single-host via Docker Compose:

cd deploy/docker
cp .env.example .env   # fsh new pre-generates this with strong secrets
docker compose up -d --build

AWS via Terraform (ECS Fargate + RDS + ElastiCache + S3/CloudFront) lives in deploy/terraform.

Guides → Local orchestration · Docker · AWS / Terraform · Database migrations.

🧪 Testing

dotnet test src/FSH.Starter.slnx        # backend: unit + architecture + Testcontainers integration
cd clients/admin     && npm run test:e2e # Playwright (operator app)
cd clients/dashboard && npm run test:e2e # Playwright (tenant app)

Integration tests require Docker (Testcontainers spins real Postgres). Architecture tests enforce module boundaries.

📖 Documentation

Full guides, module references, and architecture decisions live at fullstackhero.net:

Getting started — scaffold, run, and the default credentials
Architecture — modular monolith + vertical slices, multitenancy deep-dive
Modules — Identity, Catalog, Tickets, Chat, and more
Local orchestration with Aspire
CLI reference · Changelog

🤝 Contributing

Issues and PRs are welcome — see CONTRIBUTING.md. Branch from and target main; CI runs path-scoped backend + frontend pipelines, and stable releases are cut from v* tags.

📄 License

MIT — see LICENSE. Built and maintained by Mukesh Murugan and the FullStackHero community, for teams that want to ship fast without sacrificing architectural discipline.

⭐ Star us on GitHub if this saves you time — it genuinely helps.

JosefNemec/Playnite

Video game library manager with support for wide range of 3rd party libraries and game emulation support, providing one unified interface for your games.

Playnite

An open source video game library manager and launcher with support for 3rd party libraries like Steam, Epic, GOG, EA App, Battle.net and others. Includes game emulation support, providing one unified interface for your games.

Screenshots are available at the Homepage

If you find Playnite useful please consider supporting the lead developer Josef Nemec on Patreon.

Features

See the Homepage for the list of features.

Download

Grab the latest installer or portable package from the download page. Playnite will automatically notify you about a new version upon release.

Requirements: Windows 10 or 11

FAQ, Known Issues, user manual

Can be found here

Questions, issues etc.

If you find a bug please file an issue and if relevant (crashes, broken features) please attach a diagnostics package, which can be created from inside the "About Playnite..." submenu.

Biggest community around Playnite currently gathers on our Discord server and Reddit.

Privacy Statement

Playnite itself doesn't store any user information and you generally don't need to provide any information to import installed games. All game library data is stored locally on your PC.

Account connection process depends on how a library plugin is implemented, but is usually done via official login web forms and only the web session cookies or tokens are stored, the same way when you login to those services via the web browser.

Add-ons

Playnite can be extended with plugins (written in .NET languages), PowerShell scripts and user interface themes.

See the extensions portal for more information about how to make these addons.

Translations

We use Crowdin to manage localization, please join our project if you want to submit translations:

https://crowdin.com/project/playnite

Proofreading changes to original English strings can be submitted by creating pull request for LocSource.xaml file.

Code Contributions

Pull requests are generally on pause because majority of code base is being rewritten for Playnite 11. Smaller "safe" changes for P10 might get accepted based on what they and if they come with test coverage. If you plan to work on bigger changes, please discuss it first in related issue or on Discord, thank you.

Please ask in the related issue first before starting implementing something to make sure that nobody else is already working on it. If an issue doesn't exist for your feature/bug fix, create one first.

Regarding code styling, there are only a few major rules:

private fields and properties should use camelCase (without underscore)
all methods (private and public) should use PascalCase
use spaces instead of tabs with 4 spaces width
add empty line between code block end } and additional expression
always encapsulate the code body after if, for, foreach, while etc. with curly braces:

if (true)
{
    DoSomething();
}

DoSomethingElse();

instead of

if (true)
    DoSomething();
DoSomethingElse();

Branches

master - default branch representing state of currently released build.
devel - development branch containing latest changes. All pull requests should be made against devel branch.
devel* - development branches for specific features/versions.

Roadmap

Playnite is currently being rewritten from scratch for next major version release 11. The work is being done in private repository until beta release, after which the code will be release in this repository under the same license as current version 10 release. There is no list of planned changes and new features for version 11.

Development

See the wiki for info about building and setting up the development environment.

Others

.NET development tools courtesy of JetBrains

This program uses free code signing provided by SignPath.io, and a free code signing certificate by the SignPath Foundation

seerge/g-helper

Lightweight Armoury Crate alternative for Asus laptops with nearly the same functionality. Works with ROG Zephyrus, Flow, TUF, Strix, Scar, ProArt, Vivobook, Zenbook, Expertbook, ROG Ally, and many more.

G-Helper - Lightweight control tool for Asus laptops

Small and lightweight Armoury Crate alternative for Asus laptops offering almost same functionality with a much smaller footprint. Works with all popular models, such as ROG Zephyrus G14, G15, G16, M16, Flow X13, Flow X16, Flow Z13, DUO, TUF Series, Strix or Scar Series, ProArt, Vivobook, Zenbook, Expertbook, ROG Ally or Ally X and many more!

⭐ Like the app? Help spread the word.

📢 YouTube Reviews and Guides


Josh Cravey	Crimson Tech	cbutters Tech

📰 Articles

🎁 Advantages

Seamless and automatic GPU switching
All performance modes can be fully customized with power limits and fan curves
Lightweight. Just a single exe to run. Doesn't install anything in your system.
Simple and clean native UI with easy access to all settings
FN-Lock and custom hotkeys

⚡ Features

Performance modes: Silent - Balanced - Turbo (built-in, with default fan curves)
GPU modes: Eco - Standard - Ultimate - Optimized
Screen refresh rate control with display overdrive
Custom fan curve editor, power limits and turbo boost selection for every performance mode
Anime Matrix or Slash Lighting control including animated GIFs, clock and Audio visualizer
RGB Backlight animation modes and colors
Hotkey handling
Monitor CPU and GPU temperature, fan speeds and battery status
Battery charge limit to preserve battery health
NVidia GPU overclocking and undervolting
XG Mobile Control
AMD CPU Undervolting and temp limits
BIOS and Driver Updates
Asus Mice controls
Mini-led multi-zone switch
Flicker-free dimming and Visual Modes

⚙️ Automation

Performance Mode switching when on battery or plugged in
Optimized GPU mode - disables dGPU on battery and enables when plugged in
Auto Screen refresh rate (60Hz on battery and max Hz when plugged)
Keyboard backlight timeout on battery or when plugged in

🚀 Performance Modes

Note

All Modes are baked into BIOS along with default fan curves and power limits. And and they are the same thing as in the Armoury Crate.

Each default BIOS mode is paired with matching Windows Power Mode. You can adjust this setting under Fans + Power

Silent in BIOS + Best power efficiency power mode
Balanced (Performance in AC) in BIOS + Balanced power mode
Turbo in BIOS + Best performance power mode

🎮 GPU Tweaking

In each mode dedicated GPU can be tweaked to specific needs, including Core and Memory Clock offsets, GPU power, Dynamic Boost, Temperature Limit etc

💻 GPU Modes

Eco : only low power integrated GPU enabled, iGPU drives built in display
Standard (MS Hybrid) : iGPU and dGPU enabled, iGPU drives built in display
Ultimate: iGPU and dGPU enabled, but dGPU drives built in display (supported on 2022+ models)
Optimized: disables dGPU on battery (Eco) and enables when plugged in (Standard)

💿Driver Updates

The app includes an automatic BIOS and driver update checker that pulls directly from the official Asus website for your specific model, highlighting new downloads as they become available. All links in the Updates section point to official Asus downloads.

🎮 Metrics Overlay

A built-in in-game overlay (OSD) that shows live FPS, CPU / GPU temperatures, usage and power right on top of your game - no extra tools needed. Works in DX10+ games. May not be visible over old titles that use exclusive full-screen mode, so set the game to windowed / borderless full-screen mode.

Ctrl + Shift + Alt + O - Toggle in-game overlay ON / OFF
Ctrl + Shift + Alt + Mouse Drag - Move overlay
Ctrl + Shift + Alt + Mouse Click - Switch mode (Light / Default / Full / Complete)
Ctrl + Shift + Alt + Wheel - Resize overlay
Ctrl + Shift + Alt + Wheel Click - Reset overlay size

🐭 Asus Mouse and other peripherals support

Currently supported models (click to expand)

ROG Chakram X
ROG Chakram Core
ROG Gladius II and Gladius II Origin
ROG Gladius II Wireless
ROG Gladius III
ROG Gladius III Wireless
ROG Harpe Ace Extreme
ROG Harpe Ace Aim Lab Edition
ROG Harpe Ace Mini
ROG Harpe II Ace
ROG Keris Wireless
ROG Keris II Ace
ROG Keris Wireless Aimpoint
ROG Strix Carry
ROG Strix III Gladius III Aimpoint Wireless
ROG Strix Impact III
ROG Strix Impact III Wireless
ROG Spatha X
ROG Strix Impact II Wireless
ROG Pugio
ROG Pugio II
TUF Gaming M4 Wireless
TUF Gaming M3
TUF Gaming M3 Gen II
TUF Gaming M4 AIR
TUF Gaming M5
TX Gaming Mini

Huge thanks to @IceStormNG 👑 for contribution and research (!).

⌨️ Keybindings

Fn + F5 / Fn + Shift + F5 - Toggle Performance Modes forwards / backwards
Ctrl + Shift + F5 / Ctrl + Shift + Alt + F5 - Toggle Performance Modes forwards / backwards
Ctrl + Shift + F12 - Open G-Helper window
Ctrl + M1 / M2 - Screen brightness Down / Up
Shift + M1 / M2 - Backlight brightness Down / Up
Fn + V - Visual Modes
Fn + C / Fn + Esc - Fn-Lock
Fn + Ctrl + F7 / F8 / Ctrl + Shift + Alt + F7 / F8 - Flicker-free dimming Down / Up
Fn + Shift + F7 / F8 - Matrix / Slash Lighting brightness Down / Up
Fn + Shift + F7 / F8 / Ctrl + Shift + Alt + F7 / F8 - Screenpad brightness Down / Up
Ctrl + Shift + F20 - Mute Microphone
Ctrl + Shift + Alt + F13 - Toggle Display Refresh Rate
Ctrl + Shift + Alt + F14 - Eco GPU Mode
Ctrl + Shift + Alt + F15 - Standard GPU Mode
Ctrl + Shift + Alt + F16 - Silent
Ctrl + Shift + Alt + F17 - Balanced
Ctrl + Shift + Alt + F18 - Turbo
Ctrl + Shift + Alt + F19 - Custom 1 (if exists)
Ctrl + Shift + Alt + F20 - Custom 2 (if exists)
Custom keybindings / hotkeys

🎮ROG Ally Bindings

M + DPad Left / Right - Display Brightness
M + DPad Up - Touch keyboard
M + DPad Down - Show desktop
M + Y - Toggle AMD overay
M + X - Screenshot
M + Right Stick Click - Controller Mode

Note

🔖 Important Notice

G-Helper is NOT an operating system, firmware, or driver. It DOES NOT "run" your hardware in real-time anyhow.

It's an app that lets you select one of the predefined operating modes created by manufacturer (and stored in BIOS) and optionally(!) set some settings that already exist on your device same as Armoury Crate can. It does it by using the Asus System Control Interface "driver" that Armoury uses for it.

If you use equivalent mode/settings as in Armoury Crate - the performance or the behavior of your device won't be different.

The role of G-Helper for your laptop is similar to the role of a remote control for your TV.

Libraries and projects used

Linux Kernel for some basic endpoints in ASUS ACPI/WMI interface
NvAPIWrapper for accessing Nvidia API
Starlight for anime matrix communication protocol
UXTU for undervolting endpoints using Ryzen SMU
PawnIO for access to RyzenSMU
AsusCtl for inspiration and some reverse engineering

Code Signing Policy

Free code signing provided by SignPath.io, certificate by SignPath Foundation

Privacy Policy

This program will not transfer any information to other networked systems

Disclaimers

"Asus", "ROG", "TUF", and "Armoury Crate" are trademarked by and belong to AsusTek Computer, Inc. I make no claims to these or any assets belonging to AsusTek Computer and use them purely for informational purposes only.

THE SOFTWARE IS PROVIDED “AS IS” AND WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. MISUSE OF THIS SOFTWARE COULD CAUSE SYSTEM INSTABILITY OR MALFUNCTION.

itsfatduck/optimizerDuck

Free, open-source Windows optimization tool for performance, privacy, and simplicity.

optimizerDuck

optimizerDuck is a free, open-source Windows optimization tool focused on performance, privacy, and simplicity.

Getting Started | How It Works | FAQ

⭐ Star History

If optimizerDuck helped improve your PC, consider giving the repo a ⭐ and sharing it with others. Every star helps motivate future improvements.

Quick Start

Download from GitHub Releases
Run the .exe directly, no installation required
Choose the optimizations you want, apply them, and restart your PC when you're ready

Tip

Always create a system restore point before making changes.

Note

	Language	Native Name	Translator
🇺🇸	English (United States)	English	Primary & recommended
🇻🇳	Vietnamese	Tiếng Việt	itsfatduck
🇹🇼	Traditional Chinese	正體中文	abc0922001
🇨🇳	Simplified Chinese	简体中文	wcxu21
🇷🇺	Russian	Русский	Foodhead
🇫🇷	French	Français	Robocnop
🇩🇪	German	Deutsch	pixeldepartment
🇮🇱	Hebrew	עברית	yosef-chai
🇰🇷	Korean	한국어	klfnn
🇪🇸	Spanish	Español	thexxtt
🇯🇵	Japanese	日本語	zerofrip
🇵🇱	Polish	Polski	dudus2000
🇧🇷	Portuguese (Brazil)	Português (Brasil)	mhanelia
🇹🇷	Turkish	Türkçe	amhunter1

Want to add your language? See CONTRIBUTING.md (Japanese, Turkish).

What optimizerDuck Does & Why It Matters

Windows works great out of the box. However, a fresh installation also includes background services, telemetry, pre-installed apps, and scheduled tasks that continue running even if you never use them. These consume system resources such as CPU, RAM, disk, and network in the background.

At the same time, many settings that can improve performance, reduce latency, or provide a smoother experience are not enabled by default.

optimizerDuck brings everything together in one place. It helps you optimize Windows, remove unnecessary components, customize system settings, and manage common Windows features without digging through the Registry, Group Policy, or PowerShell.

It also includes built-in management tools, allowing you to see what is running, remove what you don't need, and restore changes whenever necessary.

Why optimize Windows?

System Optimizations

Over 30 tweaks across 6 categories, each with a clear description and risk rating so you know exactly what each change does before applying it.

Category	What it covers
Performance	Service host tuning based on your RAM, process priority adjustments, keyboard latency reduction, and multimedia scheduler tweaks for smoother gaming
Privacy	Disable Windows telemetry, error reporting, advertising ID, location tracking, Cortana, Copilot, and content delivery suggestions
GPU	Vendor-specific registry tweaks for AMD, NVIDIA, and Intel GPUs, covering power states, clock gating, and display latency
Power	Disable hibernation and fast startup, turn off USB selective suspend, install a custom high-performance power plan, and disable power throttling
Bloatware & Services	Block OEM app reinstall behavior and fine-tune startup types for 200+ Windows services
User Experience	Remove menu show delays, disable visual effects like taskbar animations and transparency for a snappier feel

Note

The optimizations here are researched from well-known tools with large user bases, nothing is AI-generated or blindly added. Every tweak is chosen for real-world impact.

Customize

No need to dig through the registry, just toggles, dropdowns, and number inputs presented in one place. Organized into four categories:

Desktop: Show or hide icons (This PC, Recycle Bin, Network, User Files, Control Panel), remove shortcut arrow overlays
Preferences: Taskbar alignment, widgets, Task View and End Task buttons, clock seconds, dark mode, file extensions, hidden files, clipboard history, compact view, snap assist, item checkboxes, classic context menu, and Bing search
Gaming: Game Mode, Game Bar, background recording, mouse acceleration, fullscreen optimizations, hardware-accelerated GPU scheduling
System: Enable Num Lock on boot

Built-in Tools

Tool	What it does
System Dashboard	View your CPU, RAM, GPU, storage drives, and OS details in one panel
Startup Manager	See every app and task that launches at boot, toggle them on or off, and open their file location
Scheduled Tasks	Browse, run, stop, enable, disable, or delete Windows scheduled tasks
Disk Cleanup	Scan and clear temp files, system cache, Windows Update leftovers, prefetch, thumbnails, recycle bin, crash dumps, and old Windows installations
Bloatware Remover	Lists all removable AppX packages with risk badges (Safe, Caution, Unknown), so you can pick what to remove

Why optimize Windows instead of just upgrading your hardware?

The fastest way to improve performance is always upgrading your hardware. A better CPU, GPU, more RAM, or a faster SSD will usually provide much larger improvements than software tweaks alone.

But hardware is only one part of the picture.

Windows is designed for hundreds of millions of PCs with different hardware, workloads, and users. Because of that, Microsoft ships Windows with settings that prioritize compatibility, stability, battery life, and ease of use instead of maximum performance.

As a result, a default Windows installation includes many background services, scheduled tasks, telemetry, power-saving features, and pre-installed apps that many users may never need.

This is especially true after reinstalling Windows. Even after installing all drivers and updates, many useful performance-related settings remain untouched, while unnecessary background components continue running.

Optimizing Windows is simply about reducing unnecessary overhead so your PC can spend more of its resources on what actually matters, whether that's gaming, programming, content creation, or everyday work.

It won't magically double your FPS, but it can reduce background activity, lower system latency, improve responsiveness, and help your hardware perform more consistently.

This is also one reason why many people recommend Linux for better performance and lower system overhead. If you prefer staying on Windows for its software compatibility and familiar experience, optimizerDuck helps you get the best possible experience without switching operating systems.

When should I optimize Windows?

The best time is after setting up a fresh Windows installation.

We recommend this order:

Install Windows.
Install all hardware drivers (chipset, GPU, network, audio, etc.).
Run Windows Update until no more updates are available.
Install all Optional Updates.
Open the Microsoft Store and update all built-in applications.
Install the software and games you normally use.
Apply your preferred optimizerDuck optimizations.
Use optimizerDuck's built-in tools to remove unnecessary apps, clean up Windows, and manage startup programs.

Following this order helps avoid Windows or driver updates overwriting your optimizations later.

Tip

Many advanced users choose to temporarily disable automatic Windows Updates after finishing their setup. Large Windows updates may restore default settings, reinstall certain components, or undo some optimizations. If you do this, remember to periodically enable Windows Update again to install important security updates before disabling it again.

Note

Every optimization provided by optimizerDuck can also be performed manually. The goal of optimizerDuck is simply to make Windows optimization easier, safer, and more convenient.

Safety

Changing system settings carries risk. optimizerDuck is built around reversibility and user control.

See the Privacy Policy for details on our data practices.

Automatic backups: Every change writes a revert file to a local folder. You can restore individual tweaks or roll back everything
One-click revert: Undo any applied optimization from the UI with a single click
Risk ratings: Each tweak is labeled Safe, Moderate, or Risky based on its potential impact
No defaults applied: Nothing runs until you select it. The tool does not enable anything on its own
Restore point prompt: Before your first optimization, the app suggests creating a Windows restore point

FAQ

Tip

Visit our Website FAQ for more questions and answers.

Is optimizerDuck safe to use?

Yes. optimizerDuck is fully open-source (GPL v3), meaning anyone can inspect, audit, or build the source code themselves. Every release is built automatically by GitHub Actions from the public source; no hidden modifications, no unsigned binaries injected after build. If you prefer, you can clone the repo and build the .exe yourself with a single dotnet build.

The app does not collect any telemetry, usage data, or personal information. See the Privacy Policy.

Does optimizerDuck actually improve performance, reduce latency, or speed up my network?

It can help. Every optimization in optimizerDuck is researched from well-known tools, community guides, and hardware vendor recommendations, nothing is AI-generated, blindly added, or made up. Each tweak addresses a real setting that Windows configures conservatively by default (e.g., service host grouping, GPU power states, network throttling, process scheduling).

There are no fake registry hacks here, every change has a documented purpose and real-world impact backed by community testing and vendor documentation.

Why does Windows SmartScreen / Defender flag the download?

optimizerDuck is not code-signed because code signing certificates are expensive for open-source projects. When Windows encounters an unsigned executable downloaded from the internet, SmartScreen displays a warning by default. This is normal and does not mean the file is unsafe.

To bypass, click "More info" > "Run anyway". If you are still concerned:

Build the .exe yourself from source
Submit the binary to online sandboxes like ANY.RUN for independent verification

Can I revert changes if something goes wrong?

Yes. Every optimization creates a revert file before applying. You can undo individual tweaks or roll back everything from the UI with one click. The app also suggests creating a Windows System Restore point before your first optimization.

Does this work on Windows 10 and Windows 11?

Yes. optimizerDuck supports Windows 10 (x64) and Windows 11 (x64).

Do I need administrator rights?

Yes. optimizerDuck modifies system settings and the Windows registry, so it requires administrator privileges to run.

Does optimizerDuck collect my data?

No. The app contains zero telemetry, analytics, or phone-home functionality. It runs entirely offline and does not send any data anywhere.

Why does Task Manager show 100% CPU after applying the power plan? (#29)

A known Task Manager display bug triggered by non-default power plans, it incorrectly reports 100% CPU on some systems while actual load is normal. Visual only, does not affect real performance or cause overheating. If unwanted, simply toggle off this optimization.

Troubleshooting

Tip

Visit our Troubleshooting page for more detailed guidance and known issue workarounds.

The app fails to start or crashes on launch

Make sure you are running as Administrator. optimizerDuck requires elevated privileges. If it still crashes, download the latest version from Releases; an outdated build may be incompatible with your Windows version.

Changes don't seem to take effect after applying

Some optimizations require a system restart to apply fully. If a tweak doesn't appear to work after restarting, try applying it again or check the revert section to verify the change was saved.

Revert file is missing or corrupted

Revert files are stored in %LocalAppData%\optimizerDuck\Revert\. If a file is accidentally deleted or corrupted, you can restore it from a backup or create a System Restore Point beforehand as a fallback.

Windows Update resets my settings

Windows feature updates occasionally reset certain registry values and service configurations to defaults. Simply re-apply your previous optimizations from the app after a major update.

I found a bug / want to request a feature

Open an issue on GitHub with as much detail as possible: your Windows version, what you applied, and what went wrong. Feature requests are also welcome.

Technical Details

Framework: WPF on .NET 10, using the WPF UI library for Fluent design
Revert system: Four revert step types (Registry, Service, Scheduled Task, Shell) with JSON-persisted state and thread-safe file I/O
Theming: Dark (default), Light, and High Contrast modes with Mica backdrop support
No installer: Runs as a single .exe, no installation required
Backup system: Local folder-based backup for every change, with one-click restore
Discovery: Optimization and Feature categories are discovered automatically via reflection + custom attributes, no manual registration needed
No telemetry: The app does not collect any user data

Documentation

Official Documentation

Guides, optimization details, and usage tips.

Contribute

Bug reports, new optimizations, docs improvements, and translations are all welcome. See CONTRIBUTING.md (Japanese, Turkish).

Community

Tip

Join our Discord server for support, tips, and discussions with other users and contributors.

If optimizerDuck helped your PC:

⭐ Star the repo
💬 Join Discord for support
🐞 Report bugs on GitHub
🎁 Support the project here

Disclaimer

optimizerDuck is provided "as is", without warranty of any kind.

By using this tool, you agree that the authors are not liable for system instability, data loss, or issues caused by third-party software or user modifications.

Always create a restore point before applying changes.

Note

optimizerDuck modifies system settings and the Windows registry. Use at your own risk. We recommend backing up important data and creating a restore point before making changes.

See Terms of Service, Privacy Policy, and Disclaimer for more information.

License

GPL v3 License
See LICENSE.

Thanks to all Contributors

SubtitleEdit/subtitleedit

the subtitle editor :)

Subtitle Edit

The subtitle editor 😃

🌐 Documentation & FAQ

http://subtitleedit.github.io/subtitleedit/

🚀 Automated Builds

You can find the latest cross-platform builds here:
👉 Releases

💻 System Requirements

Windows

Minimum: Windows 10 version 22H2 (build 19045) or newer, fully updated. Older Windows 10 builds (2004/20H2/21H1/21H2) are end-of-life and may fail to start with a .NET runtime error (0x80131506).

macOS

Minimum macOS version: 12 (Monterey) or newer
The .dmg is self-contained: libmpv and ffmpeg are bundled inside Subtitle Edit.app, so no MacPorts or Homebrew install is required.

Installing Subtitle Edit on macOS (Unsigned App)

Because Subtitle Edit is not signed with an Apple developer certificate, macOS will block it by default. You can still install and run it by following these steps:

Download and double-click the .dmg file to mount it.
In the window that appears, drag Subtitle Edit.app into your Applications folder.
Open the Terminal app (you can find it via Spotlight or in /Applications/Utilities/).

In Terminal, run the following commands to remove macOS’s security quarantine flag and add adhoc code signature:

sudo xattr -rd com.apple.quarantine "/Applications/Subtitle Edit.app"

sudo codesign --force --deep --sign - "/Applications/Subtitle Edit.app"

Linux

Flatpak (any distribution)

A Flatpak package is available from the Releases page. It bundles all required dependencies (mpv, ffmpeg) — no separate installation needed.

flatpak install SubtitleEdit-linux-x64.flatpak
flatpak run dk.nikse.subtitleedit

Native packages

Requires mpv and ffmpeg (ffmpeg is normally already installed) to enable video functionality.

Debian/Ubuntu

sudo apt update && sudo apt install -y mpv libmpv-dev ffmpeg

Arch

sudo pacman -S mpv ffmpeg

Fedora

sudo dnf install mpv-libs ffmpeg

openSUSE

sudo zypper install libmpv1 ffmpeg

⚙️ Note: The provided builds are self-contained and do not require a separate .NET installation.

🔒 Privacy

Subtitle Edit is an offline, open-source application.
It does not collect, store, transmit, or analyze the content of your subtitle files, media files, or any associated metadata — not for analytics, not for model training, and not for any other secondary purpose, now or in the future.

All core features, including editing, converting, video playback, and local auto-backup, run entirely on your device.

If you choose to use optional third-party online services within Subtitle Edit (such as translation, speech-to-text, text-to-speech, OCR, or dictionary/lookups), only the minimal data required to perform that specific request is sent directly to the selected provider. Any such data transfer is governed by the provider’s own privacy policy, and Subtitle Edit does not retain or forward this data in any way.

Subtitle Edit aims to give you full control over your files — your data stays yours.

❤️ Support the Project

If you’d like to support the continued development of Subtitle Edit, please consider donating:

dotnet/runtime

.NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.

.NET Runtime

This repo contains the code to build the .NET runtime, libraries and shared host (dotnet) installers for all supported platforms, as well as the sources to .NET runtime and libraries.

What is .NET?

Official Starting Page: https://dotnet.microsoft.com

How to use .NET (with VS, VS Code, command-line CLI)
- Install official releases
- Documentation (Get Started, Tutorials, Porting from .NET Framework, API reference, ...)
  - Deploying apps
Support (Releases, OS Versions, ...)
Roadmap

How can I contribute?

We welcome contributions! Many people all over the world have helped make this project better.

Contributing explains what kinds of contributions we welcome
Workflow Instructions explains how to build and test
Dogfooding .NET explains how to get nightly builds of the runtime and its libraries to test them in your own projects.

Reporting security issues and security bugs

Security issues and bugs should be reported privately to the Microsoft Security Response Center (MSRC) via the MSRC Researcher Portal. You should receive a response within 24 hours. Further information can be found in the Security TechCenter. You can also find these instructions in this repo's Security doc.

Also see info about related Microsoft .NET Bounty Program.

Filing issues

This repo should contain issues that are tied to the runtime, the class libraries and frameworks, the installation of the dotnet binary (sometimes known as the muxer) and the installation of the .NET runtime and libraries.

For other issues, please file them to their appropriate sibling repos. We have links to many of them on our new issue page.

Useful Links

.NET source index / .NET Framework source index
API Reference docs
.NET API Catalog (incl. APIs from daily builds and API usage info)
API docs writing guidelines - useful when writing /// comments
.NET Discord Server - a place to discuss the development of .NET and its ecosystem

.NET Foundation

.NET Runtime is a .NET Foundation project.

There are many .NET related projects on GitHub.

.NET home repo - links to 100s of .NET projects, from Microsoft and the community.
ASP.NET Core home - the best place to start learning about ASP.NET Core.

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information, see the .NET Foundation Code of Conduct.

General .NET OSS discussions: .NET Foundation Discussions

License

.NET (including the runtime repo) is licensed under the MIT license.

stride3d/stride

Stride (formerly Xenko), a free and open-source cross-platform C# game engine.

Welcome to the Stride Game Engine

Stride is an open-source C# game engine designed for realistic rendering and VR. Highly modular, it aims to give game makers more flexibility in their development. Stride comes with an editor, Game Studio, which allows you to create and manage the content of your games or applications visually and intuitively. To learn more about Stride, visit stride3d.net.

This README is intended for users who want to build the Stride engine from source or contribute to its development. If your goal is to create games using Stride, we recommend visiting the Get started with Stride guide. There, you'll find detailed instructions on downloading, installing, and getting started with game development in Stride.

🚀 Try Stride from the command line

Create and manage Stride projects from the command line — no editor required.

The Stride CLI tool installs and manages Stride engine versions, creates projects from templates, and opens Game Studio:

dotnet tool install -g Stride.Cli

stride sdk install                   # install the latest Stride engine
stride new fps -n MyShooter          # template: game, fps, platformer2d, topdownrpg, vrsandbox, ...
cd MyShooter && dotnet run --project MyShooter.Windows

stride studio                        # open Game Studio, the visual editor

stride new with no template lists what's available, stride sdk manages installed engine versions (list, install, uninstall, update), and stride upgrade moves a project to a newer engine. See sources/launcher/README.md.

Prefer standard .NET templating? The same templates are available through dotnet new:

dotnet new install Stride.Templates.Games
dotnet new stride-game -n MyGame
cd MyGame && dotnet run --project MyGame.Windows

See sources/templates/README.md for the full template catalog (genre starters, 18 feature demos, tutorials) and the local-development workflow.

🤝 Contributing

Want to get involved? See our Contributing section for how to ask questions, report bugs, submit pull requests (including good first issues), and how you can earn money by contributing via funded tasks/bug bounties.

🗺️ Roadmap

Our Roadmap communicates upcoming changes to the Stride engine.

🛠️ Building from Source

Prerequisites

Latest Git — the Windows installer includes Git LFS by default; make sure it stays enabled. For convenience, you can also use a UI client like GitExtensions.
Visual Studio 2026 (Community edition is free), with these two workloads:
- .NET desktop development (bundles the .NET 10 SDK)
- Desktop development with C++

See docs/build/README.md for detailed prerequisites (specific MSVC toolset versions, optional iOS/Android/ARM64/VSIX components, command-line builds without VS, and troubleshooting).

Build Stride

git clone https://github.com/stride3d/stride.git
Open build\Stride.slnx in Visual Studio 2026.
Build the Stride.GameStudio project (default startup, in the 60-Editor folder) or run it directly from the toolbar.

Contribution Guidelines

Please check our Contributing Guidelines.

🔬 Build Status

Build	Status
Windows
Linux Vulkan/OpenGL
iOS
Tests (Simple)
Tests (Game/WARP)

📖 Stride Documentation Landscape

The Stride documentation is organized across different locations. Here's how it's structured:

Stride Game Engine - The main repository for Stride.
- Contributing to Stride - A guide for developers interested in contributing to or developing the Stride engine.
Stride Website - The official site showcasing Stride, featuring:
- Features
- Blog
- Community
- Download
- Sponsor
- Contributing to the Website - Guide for contributing to the Stride website.
Stride Docs - The official documentation, including:
- Manual
- Tutorials
- Release Notes
- Ways to contribute
- API Reference
- Community Resources - Demos, articles, shaders, physics examples, and more.
- Contributing to the Docs - Guide for contributing to the Stride documentation.
Stride Community Toolkit - A set of C# helpers and extensions to enhance your experience with the Stride game engine.
- Contributing to Toolkit - Contribute to or explore the toolkit's source code.

🌐 .NET Foundation

This project is supported by the .NET Foundation.

🛡️ License

Stride is covered by the MIT License unless stated otherwise (i.e. for some files that are copied from other projects). You can find the list of third-party projects here. Contributors need to sign the following Contribution License Agreement.

✨ Contributors

Thanks to all these wonderful people who have contributed to Stride!

_xen2 💻	_Eideren 💻	_{Jorn Theunissen} 📖	_{Tebjan Halm} 💻	_{Elias Holzer} 💻	_{Johan Gustafsson} 💻	_{Youness KAFIA} 💻
_{Marian Dziubiak} 💻	_AmbulantRex 💻	_Basewq 💻	_Jarmo 💻	_{Antonio Junaković} 💻	_{Nicolas Musset} 💻	_Novaleaf 💻
_salahchafai 🎨	_Mehar 💻	_{Vaclav Elias} 💻	_{EternalTamago} 💻	_WhyPenguins 💻	_{Aunnop Kattiyanet} 💻	_Anon 🎨
_D3ZAX 💻	_Phr00t 💻	_sebl 💻	_Artromskiy 💻	_{Jean-François Pustay} 💻	_{Daniel Miller} 💻	_joreg 💻
_{James Rinker} 💻	_{Tristan McPherson} 💻	_Eric 💻	_{Sebastian Gregor} 💻	_insomnyawolf 💻	_Doprez 💻	_{Jakub Ławreszuk} 💻
_{Mario Guerra} 💻	_tamamutu 💻	_IXLLEGACYIXL 💻	_arturo 💻	_{Chia-Hsiang Cheng} 💻	_{Nicolae Tugui} 💻	_{Mattias Cibien} 💻
_{Oleg Ageev} 💻	_SeleDreams 💻	_{Alexandre Castro} 💻	_SVNMLR 🎨	_{Jeromy Walsh} 💻	_{Parham Gholami} 🎨	_adrsch 💻
_{Alexander Schill} 💻	_froce 💻	_Fydar 💻	_{MaximilianEmel} 💻	_Schossi 💻	_{Dagan Hartmann} 💻	_nicogo.eth 💻
_{hatim ourahou} 💻	_kopffarben 💻	_{Tomasz Czech} 💻	_{Tranquil Abyss} 💻	_{Levi Ferreira} 🎨	_{Tyler Kvochick} 📖	_Arc 💻
_minktusk 💻 🖋	_{Tim Cassell} 💻	_{Dylan Loe} 💻	_{Will S} 💻	_{Ryan Soo} 💻	_{MechWarrior99} 💻	_Proxid 💻
_{Yerko Andrei} 💻	_{Addison Schmidt} 💻	_{Tim Conner} 💻	_{Caleb L.} 💻	_net2cn 💻	_{Peter Laske} 💻	_{Mikhail Arsentev} 💻
_{Matthias Hölzl} 💻	_{Rahul Pai} 💻	_{ModxVoldHunter} 💻	_Steve 💻	_{Niklas Arndt} 💻	_Fera 💻	_Kreblc3428 💻
_Will 💻

This project follows the all-contributors specification. Contributions of any kind welcome!

MessagePack-CSharp/MessagePack-CSharp

Extremely Fast MessagePack Serializer for C#(.NET, .NET Core, Unity, Xamarin). / msgpack.org[C#]

MessagePack for C# (.NET Framework, .NET 8, Unity, Xamarin)

The extremely fast MessagePack serializer for C#. It is 10x faster than MsgPack-Cli and outperforms other C# serializers. MessagePack for C# also ships with built-in support for LZ4 compression - an extremely fast compression algorithm. Performance is important, particularly in applications like games, distributed computing, microservices, or data caches.

MessagePack has a compact binary size and a full set of general purpose expressive data types. Please have a look at the comparison with JSON, protobuf, ZeroFormatter section and learn why MessagePack C# is the fastest.

Installation

This library is distributed via NuGet. Special Unity support is available, too.

We target .NET Standard 2.0 with special optimizations for .NET 8+ and .NET Framework. The library code is pure C# (with Just-In-Time IL code generation on some platforms or AOT safe source generators).

NuGet packages

To install with NuGet, just install the MessagePack package:

Install-Package MessagePack

There are also a range of official and third party Extension Packages available (learn more in our extensions section):

Install-Package MessagePack.ReactiveProperty
Install-Package MessagePack.UnityShims
Install-Package MessagePack.AspNetCoreMvcFormatter

Unity

For Unity projects, please read the Unity Support section to install.

Migration notes from prior versions

Migrating from a prior major version of MessagePack to the latest? Check out these instructions.

Quick Start

Define the struct or class to be serialized and annotate it with a [MessagePackObject] attribute. Annotate members whose values should be serialized (fields as well as properties) with [Key] attributes.

[MessagePackObject]
public class MyClass
{
    // Key attributes take a serialization index (or string name)
    // The values must be unique and versioning has to be considered as well.
    // Keys are described in later sections in more detail.
    [Key(0)]
    public int Age { get; set; }

    [Key(1)]
    public string FirstName { get; set; }

    [Key(2)]
    public string LastName { get; set; }

    // All fields or properties that should not be serialized must be annotated with [IgnoreMember].
    [IgnoreMember]
    public string FullName { get { return FirstName + LastName; } }
}

Call MessagePackSerializer.Serialize<T>/Deserialize<T> to serialize/deserialize your object instance. You can use the ConvertToJson method to get a human readable representation of any MessagePack binary blob.

class Program
{
    static void Main(string[] args)
    {
        var mc = new MyClass
        {
            Age = 99,
            FirstName = "hoge",
            LastName = "huga",
        };

        // Call Serialize/Deserialize, that's all.
        byte[] bytes = MessagePackSerializer.Serialize(mc);
        MyClass mc2 = MessagePackSerializer.Deserialize<MyClass>(bytes);

        // You can dump MessagePack binary blobs to human readable json.
        // Using indexed keys (as opposed to string keys) will serialize to MessagePack arrays,
        // hence property names are not available.
        // [99,"hoge","huga"]
        var json = MessagePackSerializer.ConvertToJson(bytes);
        Console.WriteLine(json);
    }
}

By default, a MessagePackObject annotation is required. This can be made optional; see the Object Serialization section and the Formatter Resolver section for details.

Analyzer

The MessagePackAnalyzer package(includes in default) aids with:

Produces compiler warnings upon incorrect attribute use, member accessibility, and more.
Automating attributing of your serializable classes and members.
Optionally improving startup time through AOT formatter generation.

The first two of these features is demonstrated below:

Two assembly-level attributes exist to help with mixing in your own custom formatters with the automatically generated ones:

MessagePackKnownFormatterAttribute - Identifies classes that implement IMessagePackFormatter<T>. The T type argument will not produce an analyzer warning when T is used elsewhere in a serializable object. When using a source generated resolver, the resolver will refer to this formatter for the appropriate type(s).
MessagePackAssumedFormattableAttribute - Identifies types that are assumed to have an IMessagePackFormatter<T> somewhere, and that will be combined within an IFormatterResolver at runtime to ensure the specified type can be serialized. This attribute will suppress the analyzer warning from using that type although the type does not have a [MessagePackObject] attribute on it.

Built-in supported types

These types can serialize by default:

Primitives (int, string, etc...), Enums, Nullable<>, Lazy<>
TimeSpan, DateTime, DateTimeOffset, DateOnly (.NET 6+), TimeOnly (.NET 6+)
Guid, Uri, Version, StringBuilder, decimal, Type
BigInteger, Complex, Half (.NET 5+), Rune (.NET 5+), Int128 (.NET 7+), UInt128 (.NET 7+)
Memory<byte>, ReadOnlyMemory<byte>, ReadOnlySequence<byte>
System.Numerics.Vector2, Vector3, Vector4, Quaternion, Matrix3x2, Matrix4x4
Array[], Array[,], Array[,,], Array[,,,], ArraySegment<>, BitArray
KeyValuePair<,>, Tuple<,...>, ValueTuple<,...>
ArrayList, Hashtable
List<>, LinkedList<>, Queue<>, Stack<>, HashSet<>, ReadOnlyCollection<>, SortedList<,>
IList<>, ICollection<>, IEnumerable<>, IReadOnlyCollection<>, IReadOnlyList<>
Dictionary<,>, IDictionary<,>, SortedDictionary<,>, ILookup<,>, IGrouping<,>, ReadOnlyDictionary<,>, IReadOnlyDictionary<,>
ObservableCollection<>, ReadOnlyObservableCollection<>
ISet<>,
ConcurrentBag<>, ConcurrentQueue<>, ConcurrentStack<>, ConcurrentDictionary<,>
Immutable collections (ImmutableList<>, etc)
Custom implementations of ICollection<> or IDictionary<,> with a parameterless constructor
Custom implementations of IList or IDictionary with a parameterless constructor

You can add support for custom types, and there are some official/third-party extension packages for:

ReactiveProperty
for Unity (Vector3, Quaternion, etc...)
F# (Record, FsList, Discriminated Unions, etc...)

Please see the extensions section.

MessagePack.Nil is the built-in type representing null/void in MessagePack for C#.

Object Serialization

MessagePack for C# can serialize your own public class or struct types. By default, serializable types must be annotated with the [MessagePackObject] attribute and members with the [Key] attribute. Keys can be either indexes (int) or arbitrary strings. If all keys are indexes, arrays are used for serialization, which offers advantages in performance and binary size. Otherwise, MessagePack maps (dictionaries) will be used.

If you use [MessagePackObject(keyAsPropertyName: true)], then members do not require explicit Key attributes, but string keys will be used.

[MessagePackObject]
public class Sample1
{
    [Key(0)]
    public int Foo { get; set; }
    [Key(1)]
    public int Bar { get; set; }
}

[MessagePackObject]
public class Sample2
{
    [Key("foo")]
    public int Foo { get; set; }
    [Key("bar")]
    public int Bar { get; set; }
}

[MessagePackObject(keyAsPropertyName: true)]
public class Sample3
{
    // No need for a Key attribute
    public int Foo { get; set; }

    // If want to ignore a public member, you can use the  IgnoreMember attribute
    [IgnoreMember]
    public int Bar { get; set; }
}

// [10,20]
Console.WriteLine(MessagePackSerializer.SerializeToJson(new Sample1 { Foo = 10, Bar = 20 }));

// {"foo":10,"bar":20}
Console.WriteLine(MessagePackSerializer.SerializeToJson(new Sample2 { Foo = 10, Bar = 20 }));

// {"Foo":10}
Console.WriteLine(MessagePackSerializer.SerializeToJson(new Sample3 { Foo = 10, Bar = 20 }));

All public instance members (fields as well as properties) will be serialized. If you want to ignore certain public members, annotate the member with a [IgnoreMember] attribute.

Please note that any serializable struct or class must have public accessibility; private and internal structs and classes cannot be serialized! The default of requiring MessagePackObject annotations is meant to enforce explicitness and therefore may help write more robust code.

Should you use an indexed (int) key or a string key? We recommend using indexed keys for faster serialization and a more compact binary representation than string keys. However, the additional information in the strings of string keys can be quite useful when debugging.

When classes change or are extended, be careful about versioning. MessagePackSerializer will initialize members to their default value if a key does not exist in the serialized binary blob, meaning members using reference types can be initialized to null. If you use indexed (int) keys, the keys should start at 0 and should be sequential. If a later version stops using certain members, you should keep the obsolete members (C# provides an Obsolete attribute to annotate such members) until all other clients had a chance to update and remove their uses of these members as well. Also, when the values of indexed keys "jump" a lot, leaving gaps in the sequence, it will negatively affect the binary size, as null placeholders will be inserted into the resulting arrays. However, you shouldn't reuse indexes of removed members to avoid compatibility issues between clients or when trying to deserialize legacy blobs.

Example of index gaps and resulting placeholders:

[MessagePackObject]
public class IntKeySample
{
    [Key(3)]
    public int A { get; set; }
    [Key(10)]
    public int B { get; set; }
}

// [null,null,null,0,null,null,null,null,null,null,0]
Console.WriteLine(MessagePackSerializer.SerializeToJson(new IntKeySample()));

If you do not want to explicitly annotate with the MessagePackObject/Key attributes and instead want to use MessagePack for C# more like e.g. Json.NET, you can make use of the contractless resolver.

public class ContractlessSample
{
    public int MyProperty1 { get; set; }
    public int MyProperty2 { get; set; }
}

var data = new ContractlessSample { MyProperty1 = 99, MyProperty2 = 9999 };
var bin = MessagePackSerializer.Serialize(
  data,
  MessagePack.Resolvers.ContractlessStandardResolver.Options);

// {"MyProperty1":99,"MyProperty2":9999}
Console.WriteLine(MessagePackSerializer.ConvertToJson(bin));

// You can also set ContractlessStandardResolver as the default.
// (Global state; Not recommended when writing library code)
MessagePackSerializer.DefaultOptions = MessagePack.Resolvers.ContractlessStandardResolver.Options;

// Now serializable...
var bin2 = MessagePackSerializer.Serialize(data);

If you want to serialize private members as well, you can use one of the *AllowPrivate resolvers.

[MessagePackObject]
public class PrivateSample
{
    [Key(0)]
    int x;

    public void SetX(int v)
    {
        x = v;
    }

    public int GetX()
    {
        return x;
    }
}

var data = new PrivateSample();
data.SetX(9999);

// You can choose either StandardResolverAllowPrivate
// or ContractlessStandardResolverAllowPrivate
var bin = MessagePackSerializer.Serialize(
  data,
  MessagePack.Resolvers.DynamicObjectResolverAllowPrivate.Options);

If you want to use MessagePack for C# more like a BinaryFormatter with a typeless serialization API, use the typeless resolver and helpers. Please consult the Typeless section.

Resolvers are the way to add specialized support for custom types to MessagePack for C#. Please refer to the Extension point section.

DataContract compatibility

You can use [DataContract] annotations instead of [MessagePackObject] ones. If type is annotated with DataContract, you can use [DataMember] annotations instead of [Key] ones and [IgnoreDataMember] instead of [IgnoreMember].

Then [DataMember(Order = int)] will behave the same as [Key(int)], [DataMember(Name = string)] the same as [Key(string)], and [DataMember] the same as [Key(nameof(member name)].

Using DataContract, e.g. in shared libraries, makes your classes/structs independent from MessagePack for C# serialization. However, it is not supported by the analyzers nor source generator. Also, features like UnionAttribute, MessagePackFormatter, SerializationConstructor, etc can not be used. Due to this, we recommend that you use the specific MessagePack for C# annotations when possible.

Serializing readonly/immutable object members (SerializationConstructor)

MessagePack for C# supports serialization of readonly/immutable objects/members. For example, this struct can be serialized and deserialized.

[MessagePackObject]
public struct Point
{
    [Key(0)]
    public readonly int X;
    [Key(1)]
    public readonly int Y;

    public Point(int x, int y)
    {
        this.X = x;
        this.Y = y;
    }
}

var data = new Point(99, 9999);
var bin = MessagePackSerializer.Serialize(data);

// Okay to deserialize immutable object
var point = MessagePackSerializer.Deserialize<Point>(bin);

MessagePackSerializer will choose the constructor with the best matched argument list, using argument indexes index for index keys, or parameter names for string keys. If it cannot determine an appropriate constructor, a MessagePackDynamicObjectResolverException: can't find matched constructor parameter exception will be thrown. You can specify which constructor to use manually with a [SerializationConstructor] annotation.

[MessagePackObject]
public struct Point
{
    [Key(0)]
    public readonly int X;
    [Key(1)]
    public readonly int Y;

    [SerializationConstructor]
    public Point(int x)
    {
        this.X = x;
        this.Y = -1;
    }

    // If not marked attribute, used this(most matched argument)
    public Point(int x, int y)
    {
        this.X = x;
        this.Y = y;
    }
}

C# 9 `record` types

C# 9.0 record with primary constructor is similar immutable object, also supports serialize/deserialize.

// use key as property name
[MessagePackObject(true)]public record Point(int X, int Y);

// use property: to set KeyAttribute
[MessagePackObject] public record Point([property:Key(0)] int X, [property: Key(1)] int Y);

// Or use explicit properties
[MessagePackObject]
public record Person
{
    [Key(0)]
    public string FirstName { get; init; }

    [Key(1)]
    public string LastName { get; init; }
}

C# 9 `init` property setter limitations

When using init property setters in generic classes, a CLR bug prevents our most efficient code generation from invoking the property setter. As a result, you should avoid using init on property setters in generic classes when using the public-only DynamicObjectResolver/StandardResolver.

When using the DynamicObjectResolverAllowPrivate/StandardResolverAllowPrivate resolver the bug does not apply and you may use init without restriction.

Serialization Callback

Objects implementing the IMessagePackSerializationCallbackReceiver interface will received OnBeforeSerialize and OnAfterDeserialize calls during serialization/deserialization.

[MessagePackObject]
public class SampleCallback : IMessagePackSerializationCallbackReceiver
{
    [Key(0)]
    public int Key { get; set; }

    public void OnBeforeSerialize()
    {
        Console.WriteLine("OnBefore");
    }

    public void OnAfterDeserialize()
    {
        Console.WriteLine("OnAfter");
    }
}

Union

MessagePack for C# supports serializing interface-typed and abstract class-typed objects. It behaves like XmlInclude or ProtoInclude. In MessagePack for C# these are called Union. Only interfaces and abstracts classes are allowed to be annotated with Union attributes. Unique union keys are required.

// Annotate inheritance types
[MessagePack.Union(0, typeof(FooClass))]
[MessagePack.Union(1, typeof(BarClass))]
public interface IUnionSample
{
}

[MessagePackObject]
public class FooClass : IUnionSample
{
    [Key(0)]
    public int XYZ { get; set; }
}

[MessagePackObject]
public class BarClass : IUnionSample
{
    [Key(0)]
    public string OPQ { get; set; }
}

// ---

IUnionSample data = new FooClass() { XYZ = 999 };

// Serialize interface-typed object.
var bin = MessagePackSerializer.Serialize(data);

// Deserialize again.
var reData = MessagePackSerializer.Deserialize<IUnionSample>(bin);

// Use with e.g. type-switching in C# 7.0
switch (reData)
{
    case FooClass x:
        Console.WriteLine(x.XYZ);
        break;
    case BarClass x:
        Console.WriteLine(x.OPQ);
        break;
    default:
        break;
}

Unions are internally serialized to two-element arrays.

IUnionSample data = new BarClass { OPQ = "FooBar" };

var bin = MessagePackSerializer.Serialize(data);

// Union is serialized to two-length array, [key, object]
// [1,["FooBar"]]
Console.WriteLine(MessagePackSerializer.ConvertToJson(bin));

Using Union with abstract classes works the same way.

[Union(0, typeof(SubUnionType1))]
[Union(1, typeof(SubUnionType2))]
[MessagePackObject]
public abstract class ParentUnionType
{
    [Key(0)]
    public int MyProperty { get; set; }
}

[MessagePackObject]
public class SubUnionType1 : ParentUnionType
{
    [Key(1)]
    public int MyProperty1 { get; set; }
}

[MessagePackObject]
public class SubUnionType2 : ParentUnionType
{
    [Key(1)]
    public int MyProperty2 { get; set; }
}

Please be mindful that you cannot reuse the same keys in derived types that are already present in the parent type, as internally a single flat array or map will be used and thus cannot have duplicate indexes/keys.

Dynamic (Untyped) Deserialization

When calling MessagePackSerializer.Deserialize<object> or MessagePackSerializer.Deserialize<dynamic>, any values present in the blob will be converted to primitive values, i.e. bool, char, sbyte, byte, short, int, long, ushort, uint, ulong, float, double, DateTime, string, byte[], object[], IDictionary<object, object>.

// Sample blob.
var model = new DynamicModel { Name = "foobar", Items = new[] { 1, 10, 100, 1000 } };
var blob = MessagePackSerializer.Serialize(model, ContractlessStandardResolver.Options);

// Dynamic ("untyped")
var dynamicModel = MessagePackSerializer.Deserialize<dynamic>(blob, ContractlessStandardResolver.Options);

// You can access the data using array/dictionary indexers, as shown above
Console.WriteLine(dynamicModel["Name"]); // foobar
Console.WriteLine(dynamicModel["Items"][2]); // 100

Exploring object trees using the dictionary indexer syntax is the fastest option for untyped deserialization, but it is tedious to read and write. Where performance is not as important as code readability, consider deserializing with ExpandoObject.

Object Type Serialization

StandardResolver and ContractlessStandardResolver can serialize object/anonymous typed objects.

var objects = new object[] { 1, "aaa", new ObjectFieldType { Anything = 9999 } };
var bin = MessagePackSerializer.Serialize(objects);

// [1,"aaa",[9999]]
Console.WriteLine(MessagePackSerializer.ConvertToJson(bin));

// Support anonymous Type Serialize
var anonType = new { Foo = 100, Bar = "foobar" };
var bin2 = MessagePackSerializer.Serialize(anonType, MessagePack.Resolvers.ContractlessStandardResolver.Options);

// {"Foo":100,"Bar":"foobar"}
Console.WriteLine(MessagePackSerializer.ConvertToJson(bin2));

Unity supports is limited.

When deserializing, the behavior will be the same as Dynamic (Untyped) Deserialization.

Typeless

The typeless API is similar to BinaryFormatter, as it will embed type information into the blobs, so no types need to be specified explicitly when calling the API.

object mc = new Sandbox.MyClass()
{
    Age = 10,
    FirstName = "hoge",
    LastName = "huga"
};

// Serialize with the typeless API
var blob = MessagePackSerializer.Typeless.Serialize(mc);

// Blob has embedded type-assembly information.
// ["Sandbox.MyClass, Sandbox",10,"hoge","huga"]
Console.WriteLine(MessagePackSerializer.ConvertToJson(bin));

// You can deserialize to MyClass again with the typeless API
// Note that no type has to be specified explicitly in the Deserialize call
// as type information is embedded in the binary blob
var objModel = MessagePackSerializer.Typeless.Deserialize(bin) as MyClass;

Type information is represented by the MessagePack ext format, type code 100.

MessagePackSerializer.Typeless is a shortcut of Serialize/Deserialize<object>(TypelessContractlessStandardResolver.Instance). If you want to configure it as the default resolver, you can use MessagePackSerializer.Typeless.RegisterDefaultResolver.

TypelessFormatter can used standalone or combined with other resolvers.

// Replaced `object` uses the typeless resolver
var resolver = MessagePack.Resolvers.CompositeResolver.Create(
    new[] { MessagePack.Formatters.TypelessFormatter.Instance },
    new[] { MessagePack.Resolvers.StandardResolver.Instance });

public class Foo
{
    // use Typeless(this field only)
    [MessagePackFormatter(typeof(TypelessFormatter))]
    public object Bar;
}

If a type's name is changed later, you can no longer deserialize old blobs. But you can specify a fallback name in such cases, providing a TypelessFormatter.BindToType function of your own.

MessagePack.Formatters.TypelessFormatter.BindToType = typeName =>
{
    if (typeName.StartsWith("SomeNamespace"))
    {
        typeName = typeName.Replace("SomeNamespace", "AnotherNamespace");
    }

    return Type.GetType(typeName, false);
};

Security

Deserializing data from an untrusted source can introduce security vulnerabilities in your application. Depending on the settings used during deserialization, untrusted data may be able to execute arbitrary code or cause a denial of service attack. Untrusted data might come from over the network from an untrusted source (e.g. any and every networked client) or can be tampered with by an intermediary when transmitted over an unauthenticated connection, or from a local storage that might have been tampered with, or many other sources. MessagePack for C# does not provide any means to authenticate data or make it tamper-resistant. Please use an appropriate method of authenticating data before deserialization - such as a MAC .

Please be very mindful of these attack scenarios; many projects and companies, and serialization library users in general, have been bitten by untrusted user data deserialization in the past.

When deserializing untrusted data, put MessagePack into a more secure mode by configuring your MessagePackSerializerOptions.Security property:

var options = MessagePackSerializerOptions.Standard
    .WithSecurity(MessagePackSecurity.UntrustedData);

// Pass the options explicitly for the greatest control.
T object = MessagePackSerializer.Deserialize<T>(data, options);

// Or set the security level as the default.
MessagePackSerializer.DefaultOptions = options;

You should also avoid the Typeless serializer/formatters/resolvers for untrusted data as that opens the door for the untrusted data to potentially deserialize unanticipated types that can compromise security.

The UntrustedData mode merely hardens against some common attacks, but is no fully secure solution in itself.

Performance

Benchmarks comparing MessagePack For C# to other serializers were run on Windows 10 Pro x64 Intel Core i7-6700K 4.00GHz, 32GB RAM. Benchmark code is available here - and their version info. ZeroFormatter and FlatBuffers have infinitely fast deserializers, so ignore their deserialization performance.

MessagePack for C# uses many techniques to improve performance.

The serializer uses IBufferWriter<byte> rather than System.IO.Stream to reduce memory overhead.
Buffers are rented from pools to reduce allocations, keeping throughput high through reduced GC pressure.
Don't create intermediate utility instances (*Writer/*Reader, *Context, etc...)
Utilize dynamic code generation and JIT to avoid boxing value types. Use AOT generation on platforms that prohibit JITs.
Cached generated formatters on static generic fields (don't use dictionary-cache because dictionary lookup is overhead). See Resolvers
Heavily tuned dynamic IL code generation and JIT to avoid boxing value types. See DynamicObjectTypeBuilder. Use AOT generation on platforms that prohibit JIT.
Call the Primitive API directly when IL code generation determines target types to be primitive.
Reduce branching of variable length formats when IL code generation knows the target type (integer/string) ranges
Don't use the IEnumerable<T> abstraction to iterate over collections when possible, see: CollectionFormatterBase and derived collection formatters
Use pre-generated lookup tables to reduce checks of mgpack type constraints, see: MessagePackBinary
Uses optimized type key dictionary for non-generic methods, see: ThreadsafeTypeKeyHashTable
Avoid string key decoding for lookup maps (string key and use automata based name lookup with inlined IL code generation, see: AutomataDictionary
To encode string keys, use pre-generated member name bytes and fixed sized byte array copies in IL, see: UnsafeMemory.cs

Before creating this library, I implemented a fast serializer with ZeroFormatter#Performance. This is a further evolved implementation. MessagePack for C# is always fast and optimized for all types (primitive, small struct, large object, any collections).

Deserialization Performance for different options

Performance varies depending on the options used. This is a micro benchmark with BenchmarkDotNet. The target object has 9 members (MyProperty1 ~ MyProperty9), values are zero.

Method	Mean	Error	Scaled	Gen 0	Allocated
M IntKey	72.67 ns	NA	1.00	0.0132	56 B
M StringKey	217.95 ns	NA	3.00	0.0131	56 B
M Typeless_IntKey	176.71 ns	NA	2.43	0.0131	56 B
M Typeless_StringKey	378.64 ns	NA	5.21	0.0129	56 B
MsgPackCliMap	1,355.26 ns	NA	18.65	0.1431	608 B
MsgPackCliArray	455.28 ns	NA	6.26	0.0415	176 B
ProtobufNet	265.85 ns	NA	3.66	0.0319	136 B
Hyperion	366.47 ns	NA	5.04	0.0949	400 B
JsonNetString	2,783.39 ns	NA	38.30	0.6790	2864 B
JsonNetStreamReader	3,297.90 ns	NA	45.38	1.4267	6000 B
JilString	553.65 ns	NA	7.62	0.0362	152 B
JilStreamReader	1,408.46 ns	NA	19.38	0.8450	3552 B

IntKey, StringKey, Typeless_IntKey, Typeless_StringKey are MessagePack for C# options. All MessagePack for C# options achieve zero memory allocations in the deserialization process. JsonNetString/JilString is deserialized from strings. JsonNetStreamReader/JilStreamReader is deserialized from UTF-8 byte arrays using StreamReader. Deserialization is normally read from Stream. Thus, it will be restored from byte arrays (or Stream) instead of strings.

MessagePack for C# IntKey is the fastest. StringKey is slower than IntKey because matching the character string of property names is required. IntKey works by reading the array length, then for (array length) { binary decode }. StringKey works by reading map length, for (map length) { decode key, lookup key, binary decode }, so it requires an additional two steps (decoding of keys and lookups of keys).

String key is often a useful, contractless, simple replacement of JSON, interoperability with other languages, and more robust versioning. MessagePack for C# is also optimized for string keys as much a possible. First of all, it does not decode UTF-8 byte arrays to full string for matching with the member name; instead it will look up the byte arrays as it is (to avoid decoding costs and extra memory allocations).

And It will try to match each long type (per 8 character, if it is not enough, pad with 0) using automata and inline it when generating IL code.

This also avoids calculating the hash code of byte arrays, and the comparison can be made several times faster using the long type.

This is the sample of decompiled generated deserializer code, decompiled using ILSpy.

If the number of nodes is large, searches will use an embedded binary search.

Extra note, this is serialization benchmark result.

Method	Mean	Error	Scaled	Gen 0	Allocated
IntKey	84.11 ns	NA	1.00	0.0094	40 B
StringKey	126.75 ns	NA	1.51	0.0341	144 B
Typeless_IntKey	183.31 ns	NA	2.18	0.0265	112 B
Typeless_StringKey	193.95 ns	NA	2.31	0.0513	216 B
MsgPackCliMap	967.68 ns	NA	11.51	0.1297	552 B
MsgPackCliArray	284.20 ns	NA	3.38	0.1006	424 B
ProtobufNet	176.43 ns	NA	2.10	0.0665	280 B
Hyperion	280.14 ns	NA	3.33	0.1674	704 B
ZeroFormatter	149.95 ns	NA	1.78	0.1009	424 B
JsonNetString	1,432.55 ns	NA	17.03	0.4616	1944 B
JsonNetStreamWriter	1,775.72 ns	NA	21.11	1.5526	6522 B
JilString	547.51 ns	NA	6.51	0.3481	1464 B
JilStreamWriter	778.78 ns	NA	9.26	1.4448	6066 B

Of course, IntKey is fastest but StringKey also performs reasonably well.

String interning

The msgpack format does not provide for reusing strings in the data stream. This naturally leads the deserializer to create a new string object for every string encountered, even if it is equal to another string previously encountered.

When deserializing data that may contain the same strings repeatedly it can be worthwhile to have the deserializer take a little extra time to check whether it has seen a given string before and reuse it if it has.

To enable string interning on all string values, use a resolver that specifies StringInterningFormatter before any of the standard ones, like this:

var options = MessagePackSerializerOptions.Standard.WithResolver(
    CompositeResolver.Create(
        new IMessagePackFormatter[] { new StringInterningFormatter() },
        new IFormatterResolver[] { StandardResolver.Instance }));

MessagePackSerializer.Deserialize<ClassOfStrings>(data, options);

If you know which fields of a particular type are likely to contain duplicate strings, you can apply the string interning formatter to just those fields so the deserializer only pays for the interned string check where it matters most. Note that this technique requires a [MessagePackObject] or [DataContract] class.

[MessagePackObject]
public class ClassOfStrings
{
    [Key(0)]
    [MessagePackFormatter(typeof(StringInterningFormatter))]
    public string InternedString { get; set; }

    [Key(1)]
    public string OrdinaryString { get; set; }
}

If you are writing your own formatter for some type that contains strings, you can call on the StringInterningFormatter directly from your formatter as well for the strings.

LZ4 Compression

MessagePack is a fast and compact format but it is not compression. LZ4 is an extremely fast compression algorithm, and using it MessagePack for C# can achieve extremely fast performance as well as extremely compact binary sizes!

MessagePack for C# has built-in LZ4 support. You can activate it using a modified options object and passing it into an API like this:

var lz4Options = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4BlockArray);
MessagePackSerializer.Serialize(obj, lz4Options);

MessagePackCompression has two modes, Lz4Block and Lz4BlockArray. Neither is a simple binary LZ4 compression, but a special compression integrated into the serialization pipeline, using MessagePack ext code (Lz4BlockArray (98) or Lz4Block (99)). Therefore, it is not readily compatible with compression offered in other languages.

Lz4Block compresses an entire MessagePack sequence as a single LZ4 block. This is the simple compression that achieves best compression ratio, at the cost of copying the entire sequence when necessary to get contiguous memory.

Lz4BlockArray compresses an entire MessagePack sequence as a array of LZ4 blocks. Compressed/decompressed blocks are chunked and thus do not enter the GC's Large-Object-Heap, but the compression ratio is slightly worse.

We recommend to use Lz4BlockArray as the default when using compression. For compatibility with MessagePack v1.x, use Lz4Block.

Regardless of which LZ4 option is set at the deserialization, both methods can be deserialized. For example, when the Lz4BlockArray option was used, binary data using either Lz4Block and Lz4BlockArray can be deserialized. Neither can be decompressed and hence deserialized when the compression option is set to None.

Attributions

LZ4 compression support is using Milosz Krajewski's lz4net code with some modifications.

Comparison with protobuf, JSON, ZeroFormatter

protobuf-net is major, widely used binary-format library on .NET. I love protobuf-net and respect their great work. But when you use protobuf-net as a general purpose serialization format, you may encounter an annoying issue.

[ProtoContract]
public class Parent
{
    [ProtoMember(1)]
    public int Primitive { get; set; }
    [ProtoMember(2)]
    public Child Prop { get; set; }
    [ProtoMember(3)]
    public int[] Array { get; set; }
}

[ProtoContract]
public class Child
{
    [ProtoMember(1)]
    public int Number { get; set; }
}

using (var ms = new MemoryStream())
{
    // serialize null.
    ProtoBuf.Serializer.Serialize<Parent>(ms, null);

    ms.Position = 0;
    var result = ProtoBuf.Serializer.Deserialize<Parent>(ms);

    Console.WriteLine(result != null); // True, not null. but all property are zero formatted.
    Console.WriteLine(result.Primitive); // 0
    Console.WriteLine(result.Prop); // null
    Console.WriteLine(result.Array); // null
}

using (var ms = new MemoryStream())
{
    // serialize empty array.
    ProtoBuf.Serializer.Serialize<Parent>(ms, new Parent { Array = System.Array.Empty<int>() });

    ms.Position = 0;
    var result = ProtoBuf.Serializer.Deserialize<Parent>(ms);

    Console.WriteLine(result.Array == null); // True, null!
}

protobuf(-net) cannot handle null and empty collection correctly, because protobuf has no null representation (see this SO answer from a protobuf-net author).

MessagePack's type system can correctly serialize the entire C# type system. This is a strong reason to recommend MessagePack over protobuf.

Protocol Buffers have good IDL and gRPC support. If you want to use IDL, I recommend Google.Protobuf over MessagePack.

JSON is good general-purpose format. It is simple, human-readable and thoroughly-enough specified. Utf8Json - which I created as well - adopts same architecture as MessagePack for C# and avoids encoding/decoding costs as much as possible just like this library does. If you want to know more about binary vs text formats, see Utf8Json/which serializer should be used.

ZeroFormatter is similar as FlatBuffers but specialized to C#, and special in that regard. Deserialization is infinitely fast but the produced binary size is larger. And ZeroFormatter's caching algorithm requires additional memory.

For many common uses, MessagePack for C# would be a better fit.

Hints to achieve maximum performance when using MessagePack for C#

MessagePack for C# prioritizes maximum performance by default. However, there are also some options that sacrifice performance for convenience.

Use indexed keys instead of string keys (Contractless)

The Deserialization Performance for different options section shows the results of indexed keys (IntKey) vs string keys (StringKey) performance. Indexed keys serialize the object graph as a MessagePack array. String keys serializes the object graph as a MessagePack map.

For example this type is serialized to

[MessagePackObject]
public class Person
{
    [Key(0)] or [Key("name")]
    public string Name { get; set;}
    [Key(1)] or [Key("age")]
    public int Age { get; set;}
}

new Person { Name = "foobar", Age = 999 }

IntKey: ["foobar", 999]
StringKey: {"name:"foobar","age":999}.

IntKey is always fast in both serialization and deserialization because it does not have to handle and lookup key names, and always has the smaller binary size.

StringKey is often a useful, contractless, simple replacement for JSON, interoperability with other languages with MessagePack support, and less error prone versioning. But to achieve maximum performance, use IntKey.

Create own custom composite resolver

CompositeResolver.Create is an easy way to create composite resolvers. But formatter lookups have some overhead. If you create a custom resolver (or use StaticCompositeResolver.Instance), you can avoid this overhead.

public class MyApplicationResolver : IFormatterResolver
{
    public static readonly IFormatterResolver Instance = new MyApplicationResolver();

    // configure your custom resolvers.
    private static readonly IFormatterResolver[] Resolvers = new IFormatterResolver[]
    {
    };

    private MyApplicationResolver() { }

    public IMessagePackFormatter<T> GetFormatter<T>()
    {
        return Cache<T>.Formatter;
    }

    private static class Cache<T>
    {
        public static IMessagePackFormatter<T> Formatter;

        static Cache()
        {
            // configure your custom formatters.
            if (typeof(T) == typeof(XXX))
            {
                Formatter = new ICustomFormatter();
                return;
            }

            foreach (var resolver in Resolvers)
            {
                var f = resolver.GetFormatter<T>();
                if (f != null)
                {
                    Formatter = f;
                    return;
                }
            }
        }
    }
}

NOTE: If you are creating a library, recommend using the above custom resolver instead of CompositeResolver.Create. Also, libraries must not use StaticCompositeResolver - as it is global state - to avoid compatibility issues.

Use native resolvers

By default, MessagePack for C# serializes GUID as string. This is much slower than the native .NET format GUID. The same applies to Decimal. If your application makes heavy use of GUID or Decimal and you don't have to worry about interoperability with other languages, you can replace them with the native serializers NativeGuidResolver and NativeDecimalResolver respectively.

Also, DateTime is serialized using the MessagePack timestamp format. By using the NativeDateTimeResolver, it is possible to maintain Kind and perform faster serialization.

Be careful when copying buffers

MessagePackSerializer.Serialize returns byte[] in default. The final byte[] is copied from an internal buffer pool. That is an extra cost. You can use IBufferWriter<T> or the Stream API to write to buffers directly. If you want to use a buffer pool outside of the serializer, you should implement custom IBufferWriter<byte> or use an existing one such as Sequence<T> from the Nerdbank.Streams package.

During deserialization, MessagePackSerializer.Deserialize(ReadOnlyMemory<byte> buffer) is better than the Deserialize(Stream stream) overload. This is because the Stream API version starts by reading the data, generating a ReadOnlySequence<byte>, and only then starts the deserialization.

Choosing compression

Compression is generally effective when there is duplicate data. In MessagePack, arrays containing objects using string keys (Contractless) can be compressed efficiently because compression can be applied to many duplicate property names. Indexed keys compression is not as effectively compressed as string keys, but indexed keys are smaller in the first place.

This is some example benchmark performance data;

Serializer	Mean	DataSize
IntKey	2.941 us	469.00 B
IntKey(Lz4)	3.449 us	451.00 B
StringKey	4.340 us	1023.00 B
StringKey(Lz4)	5.469 us	868.00 B

IntKey(Lz4) is not as effectively compressed, but performance is still somewhat degraded. On the other hand, StringKey can be expected to have a sufficient effect on the binary size. However, this is just an example. Compression can be quite effective depending on the data, too, or have little effect other than slowing down your program. There are also cases in which well-compressible data exists in the values (such as long strings, e.g. containing HTML data with many repeated HTML tags). It is important to verify the actual effects of compression on a case by case basis.

Extensions

MessagePack for C# has extension points that enable you to provide optimal serialization support for custom types. There are official extension support packages.

Install-Package MessagePack.ReactiveProperty
Install-Package MessagePack.UnityShims
Install-Package MessagePack.AspNetCoreMvcFormatter

The MessagePack.ReactiveProperty package adds support for types of the ReactiveProperty library. It adds ReactiveProperty<>, IReactiveProperty<>, IReadOnlyReactiveProperty<>, ReactiveCollection<>, Unit serialization support. It is useful for save viewmodel state.

The MessagePack.UnityShims package provides shims for Unity's standard structs (Vector2, Vector3, Vector4, Quaternion, Color, Bounds, Rect, AnimationCurve, Keyframe, Matrix4x4, Gradient, Color32, RectOffset, LayerMask, Vector2Int, Vector3Int, RangeInt, RectInt, BoundsInt) and corresponding formatters. It can enable proper communication between servers and Unity clients.

After installation, extension packages must be enabled, by creating composite resolvers. Here is an example showing how to enable all extensions.

// Set extensions to default resolver.
var resolver = MessagePack.Resolvers.CompositeResolver.Create(
    // enable extension packages first
    ReactivePropertyResolver.Instance,
    MessagePack.Unity.Extension.UnityBlitResolver.Instance,
    MessagePack.Unity.UnityResolver.Instance,

    // finally use standard (default) resolver
    StandardResolver.Instance
);
var options = MessagePackSerializerOptions.Standard.WithResolver(resolver);

// Pass options every time or set as default
MessagePackSerializer.DefaultOptions = options;

For configuration details, see: Extension Point section.

The MessagePack.AspNetCoreMvcFormatter is add-on for ASP.NET Core MVC's serialization to boost up performance. This is configuration sample.

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().AddMvcOptions(option =>
    {
        option.OutputFormatters.Clear();
        option.OutputFormatters.Add(new MessagePackOutputFormatter(ContractlessStandardResolver.Options));
        option.InputFormatters.Clear();
        option.InputFormatters.Add(new MessagePackInputFormatter(ContractlessStandardResolver.Options));
    });
}

Other authors are creating extension packages, too.

MagicOnion - gRPC based HTTP/2 RPC Streaming Framework
MasterMemory - Embedded Readonly In-Memory Document Database

You can make your own extension serializers or integrate with frameworks. Let's create and share!

MessagePack.FSharpExtensions - supports F# list, set, map, unit, option, discriminated union
MessagePack.NodaTime - Support for NodaTime types to MessagePack C#
WebApiContrib.Core.Formatter.MessagePack - supports ASP.NET Core MVC (details in blog post)
MessagePack.MediaTypeFormatter - MessagePack MediaTypeFormatter

Experimental Features

MessagePack for C# has experimental features which provides you with very performant formatters. There is an official package.

Install-Package MessagePack.Experimental

For detailed information, see: Experimental.md

API

High-Level API (`MessagePackSerializer`)

The MessagePackSerializer class is the entry point of MessagePack for C#. Static methods make up the main API of MessagePack for C#.

API	Description
`Serialize<T>`	Serializes an object graph to a MessagePack binary blob. Async variant for Stream available. Non-generic overloads available.
`Deserialize<T>`	Deserializes a MessagePack binary to an object graph. Async variant for Stream available. Non-generic overloads available.
`SerializeToJson`	Serialize a MessagePack-compatible object graph to JSON instead of MessagePack. Useful for debugging.
`ConvertToJson`	Convert MessagePack binary to JSON. Useful for debugging.
`ConvertFromJson`	Convert JSON to a MessagePack binary.

The MessagePackSerializer.Typeless class offers most of the same APIs as above, but removes all type arguments from the API, forcing serialization to include the full type name of the root object. It uses the TypelessContractlessStandardResolver. Consider the result to be a .NET-specific MessagePack binary that isn't readily compatible with MessagePack deserializers in other runtimes.

MessagePack for C# fundamentally serializes using IBufferWriter<byte> and deserializes using ReadOnlySequence<byte> or Memory<byte>. Method overloads are provided to conveniently use it with common buffer types and the .NET Stream class, but some of these convenience overloads require copying buffers once and therefore have a certain overhead.

The high-level API uses a memory pool internally to avoid unnecessary memory allocation. If result size is under 64K, it allocates GC memory only for the return bytes.

Each serialize/deserialize method takes an optional MessagePackSerializerOptions parameter which can be used to specify a custom IFormatterResolver to use or to activate LZ4 compression support.

Multiple MessagePack structures on a single `Stream`

To deserialize a Stream that contains multiple consecutive MessagePack data structures, you can use the MessagePackStreamReader class to efficiently identify the ReadOnlySequence<byte> for each data structure and deserialize it. For example:

static async Task<List<T>> DeserializeListFromStreamAsync<T>(Stream stream, CancellationToken cancellationToken)
{
    var dataStructures = new List<T>();
    using (var streamReader = new MessagePackStreamReader(stream))
    {
        while (await streamReader.ReadAsync(cancellationToken) is ReadOnlySequence<byte> msgpack)
        {
            dataStructures.Add(MessagePackSerializer.Deserialize<T>(msgpack, cancellationToken: cancellationToken));
        }
    }

    return dataStructures;
}

Low-Level API (`IMessagePackFormatter<T>`)

The IMessagePackFormatter<T> interface is responsible for serializing a unique type. For example Int32Formatter : IMessagePackFormatter<Int32> represents Int32 MessagePack serializer.

public interface IMessagePackFormatter<T>
{
    void Serialize(ref MessagePackWriter writer, T value, MessagePackSerializerOptions options);
    T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options);
}

Many built-in formatters exists under MessagePack.Formatters. Your custom types are usually automatically supported with the built-in type resolvers that generate new IMessagePackFormatter<T> types on-the-fly using dynamic code generation. See our AOT code generation support for platforms that do not support this.

However, some types - especially those provided by third party libraries or the runtime itself - cannot be appropriately annotated, and contractless serialization would produce inefficient or even wrong results. To take more control over the serialization of such custom types, write your own IMessagePackFormatter<T> implementation. Here is an example of such a custom formatter implementation. Note its use of the primitive API that is described in the next section.

/// <summary>Serializes a <see cref="FileInfo" /> by its full path as a string.</summary>
public class FileInfoFormatter : IMessagePackFormatter<FileInfo>
{
    public void Serialize(
      ref MessagePackWriter writer, FileInfo value, MessagePackSerializerOptions options)
    {
        if (value == null)
        {
            writer.WriteNil();
            return;
        }

        writer.WriteString(value.FullName);
    }

    public FileInfo Deserialize(
      ref MessagePackReader reader, MessagePackSerializerOptions options)
    {
        if (reader.TryReadNil())
        {
            return null;
        }

        options.Security.DepthStep(ref reader);

        var path = reader.ReadString();

        reader.Depth--;
        return new FileInfo(path);
    }
}

The DepthStep and Depth-- statements provide a level of security while deserializing untrusted data that might otherwise be able to execute a denial of service attack by sending MessagePack data that would deserialize into a very deep object graph leading to a StackOverflowException that would crash the process. This pair of statements should surround the bulk of any IMessagePackFormatter<T>.Deserialize method.

Important: A message pack formatter must read or write exactly one data structure. In the above example we just read/write a string. If you have more than one element to write out, you must precede it with a map or array header. You must read the entire map/array when deserializing. For example:

public class MySpecialObjectFormatter : IMessagePackFormatter<MySpecialObject>
{
    public void Serialize(
      ref MessagePackWriter writer, MySpecialObject value, MessagePackSerializerOptions options)
    {
        if (value == null)
        {
            writer.WriteNil();
            return;
        }

        writer.WriteArrayHeader(2);
        writer.WriteString(value.FullName);
        writer.WriteString(value.Age);
    }

    public MySpecialObject Deserialize(
      ref MessagePackReader reader, MessagePackSerializerOptions options)
    {
        if (reader.TryReadNil())
        {
            return null;
        }

        options.Security.DepthStep(ref reader);

        string fullName = null;
        int age = 0;

        // Loop over *all* array elements independently of how many we expect,
        // since if we're serializing an older/newer version of this object it might
        // vary in number of elements that were serialized, but the contract of the formatter
        // is that exactly one data structure must be read, regardless.
        // Alternatively, we could check that the size of the array/map is what we expect
        // and throw if it is not.
        int count = reader.ReadArrayHeader();
        for (int i = 0; i < count; i++)
        {
            switch (i)
            {
                case 0:
                    fullName = reader.ReadString();
                    break;
                case 1:
                    age = reader.ReadInt32();
                    break;
                default:
                    reader.Skip();
                    break;
            }
        }

        reader.Depth--;
        return new MySpecialObject(fullName, age);
    }
}

Your custom formatters must be discoverable via some IFormatterResolver. Learn more in our resolvers section.

You can see many other samples from builtin formatters.

Primitive API (`MessagePackWriter`, `MessagePackReader`)

The MessagePackWriter and MessagePackReader structs make up the lowest-level API. They read and write the primitives types defined in the MessagePack specification.

`MessagePackReader`

A MessagePackReader can efficiently read from ReadOnlyMemory<byte> or ReadOnlySequence<byte> without any allocations, except to allocate a new string as required by the ReadString() method. All other methods return either value structs or ReadOnlySequence<byte> slices for extensions/arrays. Reading directly from ReadOnlySequence<byte> means the reader can directly consume some modern high performance APIs such as PipeReader.

Method	Description
`Skip`	Advances the reader's position past the current value. If the value is complex (e.g. map, array) the entire structure is skipped.
`Read*`	Read and return a value whose type is named by the method name from the current reader position. Throws if the expected type does not match the actual type. When reading numbers, the type need not match the binary-specified type exactly. The numeric value will be coerced into the desired type or throw if the integer type is too small for a large value.
`TryReadNil`	Advances beyond the current value if the current value is `nil` and returns `true`; otherwise leaves the reader's position unchanged and returns `false`.
`ReadBytes`	Returns a slice of the input sequence representing the contents of a `byte[]`, and advances the reader.
`ReadStringSequence`	Returns a slice of the input sequence representing the contents of a `string` without decoding it, and advances the reader.
`Clone`	Creates a new `MessagePackReader` with the specified input sequence and the same settings as the original reader.
`CreatePeekReader`	Creates a new reader with the same position as this one, allowing the caller to "read ahead" without impacting the original reader's position.
`NextCode`	Reads the low-level MessagePack `byte` that describes the type of the next value. Does not advance the reader. See MessagePack format of first byte. Its static class has `ToMessagePackType` and `ToFormatName` utility methods. `MessagePackRange` means Min-Max fix range of MessagePack format.
`NextMessagePackType`	Describes the `NextCode` value as a higher level category. Does not advance the reader. See MessagePack spec of source types.
(others)	Other methods and properties as described by the .xml doc comment file and Intellisense.

The MessagePackReader is capable of automatically interpreting both the old and new MessagePack spec.

`MessagePackWriter`

A MessagePackWriter writes to a given instance of IBufferWriter<byte>. Several common implementations of this exist, allowing zero allocations and minimal buffer copies while writing directly to several I/O APIs including PipeWriter.

The MessagePackWriter writes the new MessagePack spec by default, but can write MessagePack compatible with the old spec by setting the OldSpec property to true.

Method	Description
`Clone`	Creates a new `MessagePackWriter` with the specified underlying `IBufferWriter<byte>` and the same settings as the original writer.
`Flush`	Writes any buffered bytes to the underlying `IBufferWriter<byte>`.
`WriteNil`	Writes the MessagePack equivalent of .NET's `null` value.
`Write`	Writes any MessagePack primitive value in the most compact form possible. Has overloads for every primitive type defined by the MessagePack spec.
`WriteIntType`	Writes an integer value in exactly the MessagePack type specified, even if a more compact format exists.
`WriteMapHeader`	Introduces a map by specifying the number of key=value pairs it contains.
`WriteArrayHeader`	Introduces an array by specifying the number of elements it contains.
`WriteExtensionFormat`	Writes the full content of an extension value including length, type code and content.
`WriteExtensionFormatHeader`	Writes just the header (length and type code) of an extension value.
`WriteRaw`	Copies the specified bytes directly to the underlying `IBufferWriter<byte>` without any validation.
(others)	Other methods and properties as described by the .xml doc comment file and Intellisense.

DateTime is serialized to MessagePack Timestamp format, it serialize/deserialize UTC and loses Kind info and requires that MessagePackWriter.OldSpec == false. If you use the NativeDateTimeResolver, DateTime values will be serialized using .NET's native Int64 representation, which preserves Kind info but may not be interoperable with non-.NET platforms.

Main Extension Point (`IFormatterResolver`)

An IFormatterResolver is storage of typed serializers. The MessagePackSerializer API accepts a MessagePackSerializerOptions object which specifies the IFormatterResolver to use, allowing customization of the serialization of complex types.

Resolver Name	Description
BuiltinResolver	Builtin primitive and standard classes resolver. It includes primitive(int, bool, string...) and there nullable, array and list. and some extra builtin types(`Guid`, `Uri`, `BigInteger`, etc...).
StandardResolver	Composited resolver. It resolves in the following order `builtin -> attribute -> dynamic enum -> dynamic generic -> dynamic union -> dynamic object -> dynamic object fallback`. This is the default of MessagePackSerializer.
ContractlessStandardResolver	Composited `StandardResolver`(except dynamic object fallback) -> `DynamicContractlessObjectResolver` -> `DynamicObjectTypeFallbackResolver`. It enables contractless serialization.
StandardResolverAllowPrivate	Same as StandardResolver but allow serialize/deserialize private members.
ContractlessStandardResolverAllowPrivate	Same as ContractlessStandardResolver but allow serialize/deserialize private members.
PrimitiveObjectResolver	MessagePack primitive object resolver. It is used fallback in `object` type and supports `bool`, `char`, `sbyte`, `byte`, `short`, `int`, `long`, `ushort`, `uint`, `ulong`, `float`, `double`, `DateTime`, `string`, `byte[]`, `ICollection`, `IDictionary`.
DynamicObjectTypeFallbackResolver	Serialize is used type in from `object` type, deserialize is used PrimitiveObjectResolver.
AttributeFormatterResolver	Get formatter from `[MessagePackFormatter]` attribute.
CompositeResolver	Composes several resolvers and/or formatters together in an ordered list, allowing reuse and overriding of behaviors of existing resolvers and formatters.
NativeDateTimeResolver	Serialize by .NET native DateTime binary format. It keeps `DateTime.Kind` that loses by standard(MessagePack timestamp) format.
NativeGuidResolver	Serialize by .NET native Guid binary representation. It is faster than standard(string) representation.
NativeDecimalResolver	Serialize by .NET native decimal binary representation. It is faster than standard(string) representation.
DynamicEnumResolver	Resolver of enum and there nullable, serialize there underlying type. It uses dynamic code generation to avoid boxing and boostup performance serialize there name.
DynamicEnumAsStringResolver	Resolver of enum and there nullable. It uses reflection call for resolve nullable at first time.
DynamicGenericResolver	Resolver of generic type(`Tuple<>`, `List<>`, `Dictionary<,>`, `Array`, etc). It uses reflection call for resolve generic argument at first time.
DynamicUnionResolver	Resolver of interface marked by UnionAttribute. It uses dynamic code generation to create dynamic formatter.
DynamicObjectResolver	Resolver of class and struct made by MessagePackObjectAttribute. It uses dynamic code generation to create dynamic formatter.
DynamicContractlessObjectResolver	Resolver of all classes and structs. It does not needs `MessagePackObjectAttribute` and serialized key as string(same as marked `[MessagePackObject(true)]`).
DynamicObjectResolverAllowPrivate	Same as DynamicObjectResolver but allow serialize/deserialize private members.
DynamicContractlessObjectResolverAllowPrivate	Same as DynamicContractlessObjectResolver but allow serialize/deserialize private members.
TypelessObjectResolver	Used for `object`, embed .NET type in binary by `ext(100)` format so no need to pass type in deserialization.
TypelessContractlessStandardResolver	Composited resolver. It resolves in the following order `nativedatetime -> builtin -> attribute -> dynamic enum -> dynamic generic -> dynamic union -> dynamic object -> dynamiccontractless -> typeless`. This is the default of `MessagePackSerializer.Typeless`

Each instance of MessagePackSerializer accepts only a single resolver. Most object graphs will need more than one for serialization, so composing a single resolver made up of several is often required, and can be done with the CompositeResolver as shown below:

// Do this once and store it for reuse.
var resolver = MessagePack.Resolvers.CompositeResolver.Create(
    // resolver custom types first
    ReactivePropertyResolver.Instance,
    MessagePack.Unity.Extension.UnityBlitResolver.Instance,
    MessagePack.Unity.UnityResolver.Instance,

    // finally use standard resolver
    StandardResolver.Instance
);
var options = MessagePackSerializerOptions.Standard.WithResolver(resolver);

// Each time you serialize/deserialize, specify the options:
byte[] msgpackBytes = MessagePackSerializer.Serialize(myObject, options);
T myObject2 = MessagePackSerializer.Deserialize<MyObject>(msgpackBytes, options);

A resolver can be set as default with MessagePackSerializer.DefaultOptions = options, but WARNING: When developing an application where you control all MessagePack-related code it may be safe to rely on this mutable static to control behavior. For all other libraries or multi-purpose applications that use MessagePackSerializer you should explicitly specify the MessagePackSerializerOptions to use with each method invocation to guarantee your code behaves as you expect even when sharing an AppDomain or process with other MessagePack users that may change this static property.

Here is sample of use DynamicEnumAsStringResolver with DynamicContractlessObjectResolver (It is Json.NET-like lightweight setting.)

// composite same as StandardResolver
var resolver = MessagePack.Resolvers.CompositeResolver.Create(
    MessagePack.Resolvers.BuiltinResolver.Instance,
    MessagePack.Resolvers.AttributeFormatterResolver.Instance,

    // replace enum resolver
    MessagePack.Resolvers.DynamicEnumAsStringResolver.Instance,

    MessagePack.Resolvers.DynamicGenericResolver.Instance,
    MessagePack.Resolvers.DynamicUnionResolver.Instance,
    MessagePack.Resolvers.DynamicObjectResolver.Instance,

    MessagePack.Resolvers.PrimitiveObjectResolver.Instance,

    // final fallback(last priority)
    MessagePack.Resolvers.DynamicContractlessObjectResolver.Instance
);

If you want to make an extension package, you should write both a formatter and resolver for easier consumption. Here is sample of a resolver:

public class SampleCustomResolver : IFormatterResolver
{
    // Resolver should be singleton.
    public static readonly IFormatterResolver Instance = new SampleCustomResolver();

    private SampleCustomResolver()
    {
    }

    // GetFormatter<T>'s get cost should be minimized so use type cache.
    public IMessagePackFormatter<T> GetFormatter<T>()
    {
        return FormatterCache<T>.Formatter;
    }

    private static class FormatterCache<T>
    {
        public static readonly IMessagePackFormatter<T> Formatter;

        // generic's static constructor should be minimized for reduce type generation size!
        // use outer helper method.
        static FormatterCache()
        {
            Formatter = (IMessagePackFormatter<T>)SampleCustomResolverGetFormatterHelper.GetFormatter(typeof(T));
        }
    }
}

internal static class SampleCustomResolverGetFormatterHelper
{
    // If type is concrete type, use type-formatter map
    static readonly Dictionary<Type, object> formatterMap = new Dictionary<Type, object>()
    {
        {typeof(FileInfo), new FileInfoFormatter()}
        // add more your own custom serializers.
    };

    internal static object GetFormatter(Type t)
    {
        object formatter;
        if (formatterMap.TryGetValue(t, out formatter))
        {
            return formatter;
        }

        // If type can not get, must return null for fallback mechanism.
        return null;
    }
}

MessagePackFormatterAttribute

MessagePackFormatterAttribute is a lightweight extension point of class, struct, interface, enum and property/field. This is like Json.NET's JsonConverterAttribute. For example, serialize private field, serialize x10 formatter.

[MessagePackFormatter(typeof(CustomObjectFormatter))]
public class CustomObject
{
    string internalId;

    public CustomObject()
    {
        this.internalId = Guid.NewGuid().ToString();
    }

    // serialize/deserialize internal field.
    class CustomObjectFormatter : IMessagePackFormatter<CustomObject>
    {
        public void Serialize(ref MessagePackWriter writer, CustomObject value, MessagePackSerializerOptions options)
        {
            options.Resolver.GetFormatterWithVerify<string>().Serialize(ref writer, value.internalId, options);
        }

        public CustomObject Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
        {
            var id = options.Resolver.GetFormatterWithVerify<string>().Deserialize(ref reader, options);
            return new CustomObject { internalId = id };
        }
    }
}

// per field, member

public class Int_x10Formatter : IMessagePackFormatter<int>
{
    public int Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
    {
        return reader.ReadInt32() * 10;
    }

    public void Serialize(ref MessagePackWriter writer, int value, MessagePackSerializerOptions options)
    {
        writer.WriteInt32(value * 10);
    }
}

[MessagePackObject]
public class MyClass
{
    // You can attach custom formatter per member.
    [Key(0)]
    [MessagePackFormatter(typeof(Int_x10Formatter))]
    public int MyProperty1 { get; set; }
}

Formatter is retrieved by AttributeFormatterResolver, it is included in StandardResolver.

IgnoreFormatter

IgnoreFormatter<T> is lightweight extension point of class and struct. If there exists types that can't be serialized, you can register IgnoreFormatter<T> that serializes those to nil/null.

// CompositeResolver can set custom formatter.
var resolver = MessagePack.Resolvers.CompositeResolver.Create(
    new IMessagePackFormatter[]
    {
        // for example, register reflection infos (can not serialize)
        new IgnoreFormatter<MethodBase>(),
        new IgnoreFormatter<MethodInfo>(),
        new IgnoreFormatter<PropertyInfo>(),
        new IgnoreFormatter<FieldInfo>()
    },
    new IFormatterResolver[]
    {
        ContractlessStandardResolver.Instance
    });

Reserved Extension Types

MessagePack for C# already used some MessagePack extension type codes, be careful to avoid using the same ext code for other purposes.

Range	Reserved for
[-128, -1]	Reserved by the msgpack spec for predefined types
[30, 120)	Reserved for this library's use to support common types in .NET

This leaves the following ranges for your use:

[0, 30)
[120, 127]

Within the reserved ranges, this library defines or implements extensions that use these type codes:

Code	Type	Use by
-1	DateTime	MessagePack-spec reserved for timestamp
30	Vector2[]	for Unity, UnsafeBlitFormatter
31	Vector3[]	for Unity, UnsafeBlitFormatter
32	Vector4[]	for Unity, UnsafeBlitFormatter
33	Quaternion[]	for Unity, UnsafeBlitFormatter
34	Color[]	for Unity, UnsafeBlitFormatter
35	Bounds[]	for Unity, UnsafeBlitFormatter
36	Rect[]	for Unity, UnsafeBlitFormatter
37	Int[]	for Unity, UnsafeBlitFormatter
38	Float[]	for Unity, UnsafeBlitFormatter
39	Double[]	for Unity, UnsafeBlitFormatter
98	All	MessagePackCompression.Lz4BlockArray
99	All	MessagePackCompression.Lz4Block
100	object	TypelessFormatter

Unity support

The minimum supported Unity version will be 2022.3.12f1, as it is necessary to support IL2CPP via C# Source Generator.

There are two installation steps required to use it in Unity. Do both, not just one.

Install MessagePack from NuGet using NuGetForUnity Open Window from NuGet -> Manage NuGet Packages, Search "MessagePack" and Press Install.
Install MessagePack.Unity package by referencing the git URL. Open Package Manager window and press Add Package from git URL..., enter following path
```
https://github.com/MessagePack-CSharp/MessagePack-CSharp.git?path=src/MessagePack.UnityClient/Assets/Scripts/MessagePack
```
MessagePack uses the ..* release tag, so you can specify a version like #v3.0.0. For example: https://github.com/MessagePack-CSharp/MessagePack-CSharp.git?path=src/MessagePack.UnityClient/Assets/Scripts/MessagePack#v3.0.0

In Unity, MessagePackSerializer can serialize Vector2, Vector3, Vector4, Quaternion, Color, Bounds, Rect, AnimationCurve, Keyframe, Matrix4x4, Gradient, Color32, RectOffset, LayerMask, Vector2Int, Vector3Int, RangeInt, RectInt, BoundsInt and their nullable, array and list types with the built-in extension UnityResolver.

MessagePack.Unity automatically adds UnityResolver to the default options Resolver when the application starts with code like this in the unity package to enable this serialization:

[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
private static void Init()
{
    MessagePackSerializer.DefaultOptions = MessagePackSerializerOptions.Standard.WithResolver(UnityResolver.InstanceWithStandardResolver);
}

If you want to customize the Resolver or change the DefaultOptions, it would be good to keep this in mind.

Share types with .NET

The MessagePack.UnityShims NuGet package is for .NET server-side serialization support to communicate with Unity. It includes shims for Vector3 etc and the Safe/Unsafe serialization extension.

There are several ways to share types between .NET and Unity:

Share using symbolic links
Place the actual files on the Unity side and reference them as link files in the .NET csproj
Use UPM local references to reference the .NET project from the Unity side

While the setup is a bit challenging, the smoothest way to share is using UPM local references. For detailed steps, please refer to the MagicOnion Sample.

UnsafeBlitResolver

MessagePack for C# has an additional unsafe extension. UnsafeBlitResolver is special resolver for extremely fast but unsafe serialization/deserialization of struct arrays.

x20 faster Vector3[] serialization than native JsonUtility. If use UnsafeBlitResolver, serialization uses a special format (ext:typecode 30~39) for Vector2[], Vector3[], Quaternion[], Color[], Bounds[], Rect[]. If use UnityBlitWithPrimitiveArrayResolver, it supports int[], float[], double[] too. This special feature is useful for serializing Mesh (many Vector3[]) or many transform positions.

If you want to use unsafe resolver, register UnityBlitResolver or UnityBlitWithPrimitiveArrayResolver.

Here is sample of configuration.

StaticCompositeResolver.Instance.Register(
    MessagePack.Unity.UnityResolver.Instance,
    MessagePack.Unity.Extension.UnityBlitWithPrimitiveArrayResolver.Instance,
    MessagePack.Resolvers.StandardResolver.Instance
);

var options = MessagePackSerializerOptions.Standard.WithResolver(StaticCompositeResolver.Instance);
MessagePackSerializer.DefaultOptions = options;

AOT Code Generation

A source generator is provided in the MessagePackAnalyzer package, which is automatically installed when you install MessagePack via NuGet. This will source generate the formatters required for all your [MessagePackObject]-annotated data types during compilation for the fastest possible startup and runtime. An IFormatterResolver is also generated that bundles all source generated and user-written formatters together. The StandardResolver includes the SourceGeneratedFormatterResolver which discovers and uses your source generated resolver automatically.

Therefore, in the usual scenario, it will work with AOT Safe without any special handling. If you prefer to restrict your resolver to source-generated formatters, you should use the MessagePack.GeneratedMessagePackResolver, which is source generated into your project for that purpose. This type's name and namespace can be customized by applying [GeneratedMessagePackResolver] to a partial class that you define, at which point that class becomes the resolver for you to use.

At runtime, if a source generated or hand-written formatter cannot be found for a given [MessagePackObject] type, MessagePack will generate the formatters on the fly using Reflection.Emit to create highly-tuned formatters for each type. This code generation has a minor upfront performance cost.

Note: When using Unity, dynamic code generation only works when targeting .NET Framework 4.x + mono runtime. For all other Unity targets, AOT is required.

Customizations

You can customize the generated source through properties on the GeneratedMessagePackResolverAttribute.

[GeneratedMessagePackResolver]
partial class MyResolver
{
}

When exposing the generated resolver publicly, consumers outside the library should aggregate the resolver using its Instance property, which contains only the generated formatters.

Two assembly-level attributes exist to help with mixing in your own custom formatters with the automatically generated ones:

MessagePackKnownFormatterAttribute
MessagePackAssumedFormattableAttribute

Learn more about using a mix of your own custom formatters and automatically generated ones in the Analyzer section.

MagicOnion

MagicOnion is a code-first gRPC framework based on grpc-dotnet and MessagePack. gRPC usually communicates with Protocol Buffers using IDL. But MagicOnion uses MessagePack for C# and does not need IDL. When communicating C# to C#, schemaless (or rather C# classes as schema) is better than using IDL.

StreamJsonRpc

The StreamJsonRpc library is based on JSON-RPC and includes a pluggable formatter architecture and as of v2.3 includes MessagePack support.

How to build

See our contributor's guide.

Code of Conduct

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information see the .NET Foundation Code of Conduct.

.NET Foundation

This project is supported by the .NET Foundation.

builtbybel/FluentCleaner

A real WinUI desktop cleaner with terminal control and multi-database support

FluentCleaner

modern, transparent, no spyware, no scareware, no dark patterns, no upsell garbage, no fake registry magic

i built my own take on a cleaner, inspired by the old CCleaner from back in the 2006 days, just adapted to how things should work today. modern (built with WinUI 3), minimal and focused on actually cleaning what matters (without all the usual nonsense)

i built this because at some point you start noticing a pattern

things that were genuinely good… slowly become worse. small devs ship something great, a company buys it, optimizes it into oblivion, and suddenly you're left wondering how a simple tool turned into a "what happened here?" story. Ccleaner is basically a case study at this point, everyone knows, nobody needs another paragraph about it

funny enough, CrapCleaner only ever really survived because of the community around it, especially things like the winapp2.ini signatures. that ecosystem did more for the tool than most official decisions ever did.

i was too lazy to rebuild all cleaners natively, so i just wrote a parser for that format instead. turns out its fast. like… surprisingly fast. faster than what i remember from the old piriform implementation (no idea why that was so slow, proprietary formats, overengineering, or just history doing its thing. doesnt matter anymore anyway)

the UI is built in WinUI3 you know, Microsofts "beautiful but slow" framework, except somehow it still manages to outperform the original. go figure

companies today dont really compete on making things better. they compete on who can add more noise without breaking everything completely. and somewhere along the way, "good tools" just turned into "things people remember fondly"

CCleaner used to be great. now it’s mostly a warning.

anyway, im not trying to fix the indutry. just wanted something that doesnt suck. i'll probably get bored, or it'll evolve into something else, and we end up back at square one like always.

for now i just called it FluentCleaner.

it wasnt even meant to be public, but a lot of genuinely nice people asked me to release it, so i probably will here's a first preview so you can get a feel for the direction. i might end up funding it through donations, we'll see.

if you like it, cool. if not, also fair

🚀 Download Latest Stable

⬇ Download Latest FluentCleaner

Older versions are available below. https://github.com/builtbybel/FluentCleaner/releases

Requirements

The Windows App SDK runtime is the only thing it needs. It's a native WinUI app, so that runtime is the foundation it runs on (like .net framework back in the day). install it once and you're good, the rest ships inside FluentCleaner

Windows 10 2004 (Build 19041) or later
Windows App SDK 2.0.1 this needs to be installed separately

FAQ

will this make my PC faster?

honestly? it depends and that's not a cop-out

on a modern system with plenty of free space, you probably won't notice a dramatic speed boost. but Microsoft themselves say that running low on storage can slow things down and even block Windows updates (source) so if your drive is getting full, cleaning matters more than you'd think.

beyond speed, there are solid reasons to clean regularly:

reclaim disk space that's been quietly eaten up over months
troubleshoot app issues caused by corrupted cache
shrink backup size
privacy, browser data, recently opened file lists, leftover traces from apps you uninstalled
keep Windows updates running smoothly
or just because a tidy system feels better. also valid.

Microsoft recommends doing this monthly. Storage Sense does it automatically. FluentCleaner just gives you more control over what exactly gets cleaned

what even is winapp2.ini?

a community-maintained database of cleaning rules for Windows apps, thousands of entries built up over 15+ years. it tells FluentCleaner exactly what to clean for each app: which temp folders, which cache paths, which registry keys. no guessing, no sweeping wildcards across your whole drive. every entry is specific, inspectable, and auditable. that's the whole point.

what are flavors?

winapp2.ini comes in different variants depending on which tool you're using. FluentCleaner uses the original CCleaner flavor, the same one that powered the tool back when it was still worth using

is it safe?

it's as safe as what you enable. nothing runs without you selecting it first. winapp2.ini entries only target what they're explicitly told to target, no broad "delete everything in temp" nonsense. that said: it deletes files. take a backup if something feels important

why WinUI 3?

because it's 2026 and windows tools shouldn't look like they were built in 2009. also fluent design is literally in the name. felt right

CCleaner 7 dropped winapp2.ini support, what does that mean for FluentCleaner?

nothing. FluentCleaner has its own parser, completely independent of CCleaner CCleaner dropping support was honestly part of the motivation to build this

can i translate FluentCleaner into my language?

yes please 🙌 it's built for it. here's the whole process:

copy FluentCleaner/Strings/en-US/Resources.resw
create FluentCleaner/Strings/{your-locale}/Resources.resw (e.g. fr-FR, pt-BR, zh-CN)
translate every <value> — leave the key names (name="...") untouched
set LblTranslatorCredit to your name (add your site if you want the credit)
open a pull request 🎉

two things that trip people up:

don't touch the XML structure — no editing <data>, <resheader>, the version header or the <?xml ...> line. only the text inside <value> gets translated.
this is only for the app UI. the cleaning databases (winapp2.ini etc.) come from the upstream Winapp2 project and aren't translated here.

save the file as UTF-8 and you're good. don't see your language yet? that just means nobody's done it — could be you 😉

can i use a custom winapp2 database?

yes. FluentCleaner isn't locked to one source.

tools like BBleachBit (primarily a Linux cleaner, discovered it through this project actually, but the UI was bad enough that it came right back off), and others have their own flavors of winapp2.ini, slightly modified versions tuned for their specific needs. you can grab any of them (or build your own) and plug it straight into FluentCleaner.

just drop the file somewhere on your system, then head to: Settings > Database > Custom and point it at your file. that's it.

the official database from the winapp2 project lives here: https://github.com/MoscaDotTo/Winapp2, it's community-maintained, updated regularly, and covers thousands of apps. a solid starting point if you want more coverage than the default.

where can i follow development?

i post insider stuff, early builds and the occasional rant about winui on x/twitter. if you want to know what's coming before it lands in a release, that's the place.

issues and feature requests go here on github as usual.

Can I run FluentCleaner without a UI / from Task Scheduler?

yes.

FluentCleaner.exe /AUTO

Runs a silent cleanup using your currently saved selection and exits immediately.
No window, prompts or interaction.

FluentCleaner.exe /AUTO /SHUTDOWN

Same behavior, but shuts Windows down after cleanup finishes.
/SHUTDOWN alone does nothing.

Logging

Each automatic run appends a detailed log to:

%AppData%\FluentCleaner\auto.log

The log contains:

timestamp
every deleted path grouped by entry
total cleaned size

Scheduling

To automate cleanup:

Open Windows Task Scheduler
Create a new task
Add FluentCleaner.exe
Use /AUTO as argument

No built-in scheduler UI needed.

which Windows versions are supported?

FluentCleaner officially supports:

Windows 10 2004 (Build 19041) and later
Windows 11

No Windows 11 requirement. Despite using WinUI 3, the app is intentionally built to remain compatible with modern Windows 10 systems as well

can i support development?

yes,if you'd like to 😄

FluentCleaner is a one-person project, not a multi-million dollar company with investors and a marketing department.

If you want to support development financially, you can do so here: PayPal

Optimizer Myths

why doesn't FluentCleaner have X?

secure file deletion (dod 7-pass, gutmann 35-pass…)

short answer: it would look impressive and do nothing useful.

secure overwrite made sense in the 90s when hdds were standard and forensic recovery was a real concern. today:

ssds use wear leveling and trim. the controller decides where bits physically land,not your software. you can overwrite a file 35 times and the controller writes to different nand blocks anyway. gutmann himself noted this in an addendum to his own paper.
the files Fluentcleaner deletes are browser cache, temp files and log entries. if someone is forensically recovering your discord cache you have bigger problems than your cleaner's deletion method.

normal file deletion is correct here. anything else is security theater.

registry cleaner

deliberate omission, worth explaining.

the premise sounds reasonable ; orphaned keys accumulate, windows slows down, cleaning helps. in practice:

windows loads registry keys on demand. ten thousand orphaned uninstaller entries have zero measurable impact on boot time or performance. this has been benchmarked to death.
the risk/reward is completely inverted. a registry cleaner that removes the wrong key can break applications or in edge cases the os itself. the upside is placebo. the downside is a broken install.

ccleaner has one because it's a selling point that sounds technical. FluentCleaner doesn't have one because shipping a feature that exists to look good rather than do good would be dishonest.

if you actually need to clean up after a broken uninstaller;autoruns or a targeted manual edit is the right tool, not a bulk cleaner.

general philosophy

FluentCleaner targets things that are unambiguously junk;cache files, temp data, leftover logs. it deliberately avoids the feature creep that turned ccleaner from a focused utility into bloatware with a vpn upsell on every launch.

fewer features. honest features.

ppy/osu

rhythm is just a *click* away!

osu!

A free-to-win rhythm game. Rhythm is just a click away!

This is the future – and final – iteration of the osu! game client which marks the beginning of an open era! Currently known by and released under the release codename "lazer". As in sharper than cutting-edge.

Status

This project is under constant development, but we do our best to keep things in a stable state. Players are encouraged to install from a release alongside their stable osu! client. This project will continue to evolve until we eventually reach the point where most users prefer it over the previous "osu!stable" release.

A few resources are available as starting points to getting involved and understanding the project:

Detailed release changelogs are available on the official osu! site.
You can learn more about our approach to project management.
Track our current efforts towards improving the game.

Running osu!

If you are just looking to give the game a whirl, you can grab the latest release for your platform:

Latest release:

Windows 10+ (x64)	macOS 12+ (Intel, Apple Silicon)	Linux (x64)	iOS 13.4+	Android 5+

You can also generally download a version for your current device from the osu! site.

If your platform is unsupported or not listed above, there is still a chance you can run the release or manually build it by following the instructions below.

For iOS/iPadOS users: The iOS testflight link fills up very fast (Apple has a hard limit of 10,000 users). We reset it occasionally. Please do not ask about this. Check back regularly for link resets or follow peppy on twitter for announcements. Our goal is to get the game on mobile app stores very soon so we don't have to live with this limitation.

Developing a custom ruleset

osu! is designed to allow user-created gameplay variations, called "rulesets". Building one of these allows a developer to harness the power of the osu! beatmap library, game engine, and general UX for a new style of gameplay. To get started working on a ruleset, we have some templates available here.

You can see some examples of custom rulesets by visiting the custom ruleset directory.

Developing osu!

Prerequisites

Please make sure you have the following prerequisites:

A desktop platform with the .NET 8.0 SDK installed.

When working with the codebase, we recommend using an IDE with intelligent code completion and syntax highlighting, such as the latest version of Visual Studio, JetBrains Rider, or Visual Studio Code with the EditorConfig and C# Dev Kit plugin installed.

Downloading the source code

Clone the repository:

git clone https://github.com/ppy/osu
cd osu

To update the source code to the latest commit, run the following command inside the osu directory:

git pull

Building

From an IDE

You should load the solution via one of the platform-specific .slnf files, rather than the main .sln. This will reduce dependencies and hide platforms that you don't care about. Valid .slnf files are:

osu.Desktop.slnf (most common)
osu.Android.slnf
osu.iOS.slnf

Run configurations for the recommended IDEs (listed above) are included. You should use the provided Build/Run functionality of your IDE to get things going. When testing or building new components, it's highly encouraged you use the osu! (Tests) project/configuration. More information on this is provided below.

To build for mobile platforms, you will likely need to run sudo dotnet workload restore if you haven't done so previously. This will install Android/iOS tooling required to complete the build.

From CLI

You can also build and run osu! from the command-line with a single command:

dotnet run --project osu.Desktop

When running locally to do any kind of performance testing, make sure to add -c Release to the build command, as the overhead of running with the default Debug configuration can be large (especially when testing with local framework modifications as below).

If the build fails, try to restore NuGet packages with dotnet restore.

Testing with resource/framework modifications

Sometimes it may be necessary to cross-test changes in osu-resources or osu-framework. This can be quickly achieved using included commands:

Windows:

UseLocalFramework.ps1
UseLocalResources.ps1

macOS / Linux:

UseLocalFramework.sh
UseLocalResources.sh

Note that these commands assume you have the relevant project(s) checked out in adjacent directories:

|- osu            // this repository
|- osu-framework
|- osu-resources

Code analysis

Before committing your code, please run a code formatter. This can be achieved by running dotnet format in the command line, or using the Format code command in your IDE.

We have adopted some cross-platform, compiler integrated analyzers. They can provide warnings when you are editing, building inside IDE or from command line, as-if they are provided by the compiler itself.

JetBrains ReSharper InspectCode is also used for wider rule sets. You can run it from PowerShell with .\InspectCode.ps1. Alternatively, you can install ReSharper or use Rider to get inline support in your IDE of choice.

Contributing

When it comes to contributing to the project, the two main things you can do to help out are reporting issues and submitting pull requests. Please refer to the contributing guidelines to understand how to help in the most effective way possible.

If you wish to help with localisation efforts, head over to crowdin.

Our team believes in human contributions. Any contribution – be it an issue report or a pull request – which is created by, documented by, or aided by AI/LLM usage will typically be closed and locked without further discussion.

Licence

osu!'s code and framework are licensed under the MIT licence. Please see the licence file for more information. tl;dr you can do whatever you want as long as you include the original copyright and license notice in any copy of the software/source.

Please note that this does not cover the usage of the "osu!" or "ppy" branding in any software, resources, advertising or promotion, as this is protected by trademark law.

Please also note that game resources are covered by a separate licence. Please see the ppy/osu-resources repository for clarifications.

RayWangQvQ/BiliBiliToolPro

B 站（bilibili）自动任务工具，支持docker、青龙、k8s等多种部署方式。全面拥抱AI。敏感肌也能用。

BiliTool

BiliTool 是一个自动执行任务的工具，当我们忘记做某项任务时，它会像一个贴心小助手，按照我们预先吩咐它的命令，在指定频率、时间范围内帮助我们完成计划的任务。

BiliTool is an automated task execution tool that acts as a helpful assistant, following pre-configured commands to complete planned tasks within specified frequencies and timeframes when we forget to do them.

主要功能如下：

扫码登录，自动更新cookie
每日获取满额升级经验（登录、投币、点赞、分享视频）（支持指定up主）
直播间挂机
每天漫画签到
每天直播签到
直播中心银瓜子兑换为硬币
每月领取大会员赠送的 5 张 B 币券和福利（忘记或者不领就浪费了哦）
每月领取大会员漫画福利
月底在 B 币券过期前进行充电（支持指定想要支持的up主，如果没有喜欢的up，也可以为自己充个电啊，做个用爱为自己发电的人~）
直播中心天选时刻自动参与抽奖
批量取关
大会员大积分任务
支持多账号
理论上支持所有远端的日志推送（默认支持推送到Telegram、企业微信、钉钉、PushPlus、Server酱、酷推，另外也支持自定义推送到任意api）

[目录]

Github 仓库地址：RayWangQvQ/BiliBiliToolPro

注意：

本应用仅用于学习和测试，作者本人并不对其负责，请于运行测试完成后自行删除，请勿滥用！
所有代码都是开源且透明的，任何人均可查看，程序不会保存或滥用任何用户的个人信息
应用内几乎所有功能都开放了配置（如任务开关、日期、id等），详细信息可阅读配置文档

运行图示：

1. 如何使用

BiliTool 实现自动完成任务的原理，是通过调用一系列开放的api实现的。

要使用 BiliTool，很简单，按照下面教程部署完成，运行后扫码登录即可。

1.1. 部署 BiliTool

支持多种部署方式，以下选择任一适合自己的方式即可。

1.1.1. 方案一：免费在线容器

有很多平台会提供一定免费额度的在线容器，基于官方镜像，部署 BiliTool 很容易。

以下以 ClawCloud 为例，其他平台操作类似：

>>ClawCloud 部署教程

1.2. 消息推送（可选）

如果配置了推送，执行成功后，指定的接收端会收到推送消息，推送效果如下所示：

目前默认支持Telegram推送、PushPlus推送、企业微信应用推送、企业微信推送、钉钉推送、Microsoft Teams推送、Server酱推送和酷推QQ推送（以上顺序即为个人推荐的排序），如果需要推送到其他端，也可以配置为任意的可以接受消息的Api地址，关于如何配置推送请详见下面的个性化自定义配置章节。

推送配置见：confifuration

2. 功能任务说明

这里的任务是指一组功能的集合，是工具每次运行的最小单位。

任务列表如下：

任务名	Code	功能	推荐运行频率
扫码登录	Login	使用app扫码登录，用于第一次运行时初始化cookie，或cookie过期时的更新。不同平台会将cookie存储到不同地方	手动
每日任务	Daily	完成每日任务获取满额65点经验（登录、观看视频、分享视频、投币），快速升级Lv6	每天一次
天选时刻抽奖	LiveLottery	直播中心天选时刻抽奖，大部分抽奖都需要关注主播，介意的不要开启	每天0-4次
批量取关	UnfollowBatched	批量取关指定分组下的所有关注（主要用于清理天选抽奖而产生的关注）	手动运行
大会员大积分	VipBigPoint	大会员大积分任务（签到、浏览、观看）	每天一次，建议凌晨
直播间挂机	LiveFansMedal	直播间挂机	每天一次
漫画任务	Manga	漫画签到、阅读	每天一次
领取大会员漫画权益	MangaPrivilege	领取大会员的漫画权益	每天一次
银瓜子兑换硬币	Silver2Coin	使用银瓜子换取硬币	每天一次
免费B币券充电	Charge	大会员每31天可免费领取一张5B币券，可用于给除自己以外的UP充电	每天一次
领取大会员福利	VipPrivilege	领取大会员福利	每天一次
测试Cookie	Test	测试Cookie是否正常	手动运行

3. 个性化自定义配置

>>点击查看配置说明文档

4. 多账号支持

部署成功后，直接去运行扫码登录任务，扫码成功后，应用会自动更新或添加cookie。

青龙平台会添加环境变量里，Key 为 Ray_BiliBiliCookies__0、Ray_BiliBiliCookies__1、Ray_BiliBiliCookies__2...

其他平台默认会添加到名为cookies.json的账号配置文件中：

{
  "BiliBiliCookies": [
    "cookie1",
    "cookie2",
    "...",
  ],
}

5. 常见问题

>>点击查看常见问题文档

Issues（议题）板块可以用来提交Bug和建议；

Discussions（讨论）板块可以用来提问和讨论。

大部分问题其实都可以在文档、议题和讨论中找到答案。

所以如果你有疑问，

请先确认是否可以通过升级到最新版本解决
然后搜索文档（特别是配置说明文档和常见问题文档）、议题和讨论，查看是否已有其他人遇到相同问题、是否已有解决方案

如果确认还未解决，可以自己提交 Issue，或发布 Discussions 与大家一起探讨，我会尽快确认并解决。

（关于如何正确的提交Issue，请详见常见问题文档）。

6. 版本发布及更新

当前正处于稳定的迭代开发中，详细待更新和计划内容可参见 Projects 和 Issues 。

想要有重要更新时收到通知的话，可以把仓库右上角的Star按钮点亮。

7. 成为开源贡献成员

7.1. 贡献代码

如果你有好的想法，欢迎向仓库贡献你的代码，贡献步骤：

搜索查看 Issue，确定是否已有人提过同类问题
对于不确定的主题，为避免code结束后PR不被接受，可以先新建 Issue，描述问题或建议，讨论清楚后再动手编码
如果确认自己可以解决，请 Fork 仓库后，在develop 分支进行编码开发，完成后提交 PR 到 develop 分支

我会尽快进行代码审核，测试成功后会合并入 main 主分支，提前感谢您的贡献。

7.2. 贡献文档

文档部分由于我个人精力有限（写文档比写代码累多了），所以有些地方写的很简略，甚至有遗漏和错别字，不能贡献代码的朋友也欢迎来一起维护文档，欢迎 PR 来纠正我，一样都算是对开源做贡献了。

8. 捐赠支持

个人维护开源不易

如果觉得我写的程序对你小有帮助

或者，就是单纯的想集资给我买瓶霸王增发液

那么下面的赞赏码可以扫一扫啦

（赞赏时记得留下【昵称】和【留言】~ 另外我发现很多留言想要进群或者加好友的，一定一定要记得留下微信号哈，微信赞赏页面是看不到微信号的）

☟☟☟ 扫码自动赞赏 1 元：☟☟☟

项目中的优先支持的UP主的配置项，默认是作者的 UpId （只是作为了 JSON 配置文件的默认值，代码是干净的），需要更改的话，直接修改相应配置即可（secrets或环境变量等各种方式都行）。当然，不改的话，也算是另一种捐赠支持作者的方式啦。

感谢支持~

9. 其他

API参考：

❤️Thanks to JetBrains for the free certificate support:

❤️Thanks to YxVM & NodeSeekDev for sponsoring the server for testing support:

❤️Thanks to DartNode for sponsoring the server for testing support:

❤️Thank you for your star to this project:

tModLoader/tModLoader

A mod to make and play Terraria mods. Supports Terraria 1.4 (and earlier) installations

tModLoader, a Terraria modding API

tModLoader (TML) is an open-source, community-driven, modification and expansion of the Terraria game that makes it possible to make and play mods. TML expands your Terraria adventures with new content to explore created by the Terraria community! TML allows players to create and play Terraria mods and is designed in such a way so that you can play alone or together with friends, with one mod or with multiple mods: choose to play however you like! It is however required that all your friends also install TML if you want to play together; vanilla users can't play with TML users. Find the instructions below to learn how to install TML.

Note: the code on this GitHub repository will be ahead of the current released version.

Instructions

Want to play or create mods? Or do you want to contribute to tModLoader perhaps? Click the text that applies to you.

Get tModLoader on Steam

I am a player (Play mods)

I am a developer (Create mods)

I am a contributor (Help create tModLoader)

Support us

First and foremost, TML is largely a community endeavor: built by the community; used by the community. Without all the contributions people in the community have made over the years, TML would not be in the state it is in. TML is a free-to-use modification of the game and will stay that way. However, if you would like to buy us a coffee, or maybe even multiple, you can choose to pledge some money to support us financially. We'd like to kindly express once again that TML was not created to create a profit. All of the core team members continue their best efforts to improve and maintain TML despite their real-life obligations, free of charge or any request from the community.

The preferred method of supporting the core team is by choosing a pledge through Patreon. All of the money donated this way is equally shared amongst the core members to those who wish to receive part of it. This truly is the right way to support us financially if you want to do so. By becoming a patron you can receive a special role on our Discord server if desired. You should be able to couple your Discord account to your Patreon account and automatically receive your role.

If you do not want to use a Patreon subscription, you should contact one of the core team members through the Discord server to find an appropriate method of supporting us. Thanks again!

Get in touch

If you would like to contact us or TML users, it's best to join our Discord server. To use Discord you will need to register a new account on their website.

Contributors

Core team

TML is largely created and maintained by a core team of contributors: Blushiemagic, Chicken-Bones, Jopojelly, Jofairden, Mirsario and Solxanich

This project exists in its current state thanks to all the people who have contributed:

License

TML is licensed under the MIT license

dotnet/efcore

EF Core is a modern object-database mapper for .NET. It supports LINQ queries, change tracking, updates, and schema migrations.

Repository

This repository is home to the following .NET Foundation projects. These projects are maintained by Microsoft and licensed under the MIT License.

Entity Framework Core

EF Core is a modern object-database mapper for .NET. It supports LINQ queries, change tracking, updates, and schema migrations. EF Core works with SQL Server, Azure SQL Database, SQLite, Azure Cosmos DB, MariaDB, MySQL, PostgreSQL, and other databases through a provider plugin API.

Installation

EF Core is available on NuGet. Install the provider package corresponding to your target database. See the list of providers in the docs for additional databases.

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Cosmos

Use the --version option to specify a preview version to install.

Daily builds

We recommend using the daily builds to get the latest code and provide feedback on EF Core. These builds contain latest features and bug fixes; previews and official releases lag significantly behind.

Basic usage

The following code demonstrates basic usage of EF Core. For a full tutorial configuring the DbContext, defining the model, and creating the database, see getting started in the docs.

using var db = new BloggingContext();

// Inserting data into the database
db.Add(new Blog { Url = "http://blogs.msdn.com/adonet" });
db.SaveChanges();

// Querying
var blog = db.Blogs
    .OrderBy(b => b.BlogId)
    .First();

// Updating
blog.Url = "https://devblogs.microsoft.com/dotnet";
blog.Posts.Add(
    new Post
    {
        Title = "Hello World",
        Content = "I wrote an app using EF Core!"
    });
db.SaveChanges();

// Deleting
db.Remove(blog);
db.SaveChanges();

Build from source

Most people use EF Core by installing pre-built NuGet packages, as shown above. Alternatively, the code can be built and packages can be created directly on your development machine.

Contributing

We welcome community pull requests for bug fixes, enhancements, and documentation. See How to contribute for more information.

Getting support

If you have a specific question about using these projects, we encourage you to ask it on Stack Overflow. If you encounter a bug or would like to request a feature, submit an issue. For more details, see getting support.

Microsoft.Data.Sqlite

Microsoft.Data.Sqlite is a lightweight ADO.NET provider for SQLite. The EF Core provider for SQLite is built on top of this library. However, it can also be used independently or with other data access libraries.

Installation

The latest stable version is available on NuGet.

dotnet add package Microsoft.Data.Sqlite

Use the --version option to specify a preview version to install.

Daily builds

We recommend using the daily builds to get the latest code and provide feedback on Microsoft.Data.Sqlite. These builds contain the latest features and bug fixes; previews and official releases lag significantly behind.

Basic usage

This library implements the common ADO.NET abstractions for connections, commands, data readers, and so on. For more information, see Microsoft.Data.Sqlite on Microsoft Docs.

using var connection = new SqliteConnection("Data Source=Blogs.db");
connection.Open();

using var command = connection.CreateCommand();
command.CommandText = "SELECT Url FROM Blogs";

using var reader = command.ExecuteReader();
while (reader.Read())
{
    var url = reader.GetString(0);
}

Build from source

Most people use Microsoft.Data.Sqlite by installing pre-built NuGet packages, as shown above. Alternatively, the code can be built and packages can be created directly on your development machine.

Contributing

We welcome community pull requests for bug fixes, enhancements, and documentation. See How to contribute for more information.