Performance Studio

A cross-platform SQL Server execution plan analyzer with built-in MCP server for AI-assisted analysis. Parses .sqlplan XML, identifies performance problems, suggests missing indexes, and provides actionable warnings — from the command line or a desktop GUI.

Built for developers and DBAs who want fast, automated plan analysis without clicking through SSMS.

Screenshots

Query Editor

Write queries with syntax highlighting and SQL keyword completion, connect to any SQL Server, and capture plans with one click.

Actual Execution Plan with Plan Insights

Graphical plan tree with SSMS-style operator icons, cost percentages, row counts, and warning badges. The Plan Insights panel shows runtime summary, missing indexes, parameters, and wait stats at a glance.

Multi-Statement Navigation

Navigate stored procedures and batches with multiple statements. Click any statement in the grid to jump to its plan. Plan Insights shows parameters with compiled vs runtime values.

Operator Tooltip and Properties

Hover over any operator for a detailed tooltip with costs, rows, I/O, timing, parallelism, and warnings. Click to open the full properties panel with per-thread timing, predicates, and more.

Advice for Humans

One-click text report with server context, warnings, wait stats, and expensive operators — ready to read or share.

Plan Comparison

Side-by-side comparison of two plans showing cost, runtime, I/O, memory, and wait stat differences.

Query Store Integration

Fetch top queries by CPU, duration, logical reads, physical reads, writes, memory, or executions from Query Store and load their plans directly into the analyzer.

Minimap and colored links by accuracy ratio divergence

The minimap provides a high-level overview of the entire plan, allowing you to quickly navigate to areas of interest. Colored links between operators indicate accuracy ratio divergence, helping you identify where estimates are most off from actuals.

MCP Integration

Ask Claude Code to analyze loaded plans, identify warnings, suggest indexes, and compare plans — all through the built-in MCP server.

What It Does

Feed it a query plan and it tells you what's wrong:

• Large memory grants — flags queries hoarding memory they don't use
• Row estimate mismatches — finds operators where estimates are 10x+ off from actuals
• Missing indexes — extracts SQL Server's index suggestions with ready-to-run CREATE statements
• Hash, sort, and exchange spills — identifies operators spilling to TempDB with severity based on volume
• Parallel skew — detects threads doing all the work while others sit idle
• Scan predicates — warns when scans filter rows with residual predicates
• Key and RID lookups — flags lookups back to the base table, distinguishes heaps from clustered indexes
• Late filters — finds Filter operators discarding rows deep in the plan
• Nested loop concerns — flags high-execution nested loops that might be better as hash joins
• Parameter sniffing — compares compiled vs runtime parameter values
• Scalar UDFs — warns about T-SQL and CLR scalar functions in execution paths
• Implicit conversions — detects type mismatches, upgrades severity when a seek plan is prevented
• Anti-patterns — OPTIMIZE FOR UNKNOWN, NOT IN with nullable columns, leading wildcards, function-wrapped predicates, and more

Each warning includes severity (Info, Warning, or Critical), the operator node ID, and enough context to act on immediately.

Prerequisites

• .NET 10 SDK (only needed to build from source — the pre-built binaries below are self-contained and require no SDK)
• SQL Server instance (optional — only needed for live plan capture; file analysis works without one)
• Docker (optional — macOS/Linux users can run SQL Server locally via Docker)

Download

Pre-built binaries are available on the Releases page:

These are self-contained — no .NET SDK required. Extract the zip and run.

macOS note: macOS may block the app because it isn't signed with an Apple Developer certificate. If you see a warning that the app "can't be opened," run this after extracting:

xattr -cr PerformanceStudio.app

Then open the app normally.

Build from Source

Clone and build:

git clone https://github.com/erikdarlingdata/PerformanceStudio.git
cd PerformanceStudio
dotnet build

To verify the build:

dotnet test tests/PlanViewer.Core.Tests    # 37 tests should pass
dotnet run --project src/PlanViewer.Cli -- analyze --help

Quick Start

Analyze an existing .sqlplan file

If you already have a .sqlplan file (saved from SSMS, Azure Data Studio, or another tool):

# JSON output (default) — full operator tree, suitable for automation
planview analyze my_query.sqlplan

# Human-readable text output
planview analyze my_query.sqlplan --output text

# Text output, warnings and missing indexes only (skip operator tree)
planview analyze my_query.sqlplan --output text --warnings-only

Capture and analyze plans from a live server

Connect to a SQL Server instance, run queries, and capture their execution plans automatically.

Quickest way — pass credentials directly:

# Capture an actual execution plan (the query WILL run)
planview analyze --server sql2022 --database AdventureWorks \
    --login sa --password YourPassword \
    --query "SELECT * FROM Sales.SalesOrderHeader WHERE OrderDate > '2024-01-01'" \
    --trust-cert --output-dir ./results/

# Capture an estimated plan (safe for production — query is NOT executed)
planview analyze --server sql2022 --database AdventureWorks \
    --login sa --password YourPassword \
    --query "SELECT * FROM Sales.SalesOrderHeader" \
    --estimated --trust-cert --output-dir ./results/

Using a .env file — drop a .env in your working directory to avoid repeating connection details:

# .env
PLANVIEW_SERVER=sql2022
PLANVIEW_DATABASE=AdventureWorks
PLANVIEW_LOGIN=sa
PLANVIEW_PASSWORD=YourPassword
PLA