Skip to content
WrightKit

Tooling for Overwatch Workshop development.

Native Workshop, OverPy / OSTW, and AI agents.

WrightKit is an open-source tooling ecosystem for Overwatch Workshop development. Whether you work in native Workshop text, OverPy, OSTW, or use AI coding agents — Wright provides linting, static analysis, semantic inspection, validated source editing, and language services.

Install Wright View on GitHub
$
curl -fsSL https://wrightkit.dev/install.sh | bash

Install Wright

Standalone wright and wright-lsp binaries for macOS (Apple Silicon & Intel), Linux (x86_64), and Windows (x86_64). Zero runtime dependencies — no Node.js, .NET, or external interpreters required.

Homebrew (Recommended) 
brew tap wrightkit/tap
brew install wrightkit/tap/wright

Installs wright and wright-lsp to your path with checksums verified by Homebrew.

Alternative: Unix installer script 
curl -fsSL https://wrightkit.dev/install.sh | bash
Manual precompiled release archives (.tar.gz / .zip) with SHA-256 checksums are available on the GitHub Releases page.

Who is WrightKit for?

WrightKit supports three established Workshop development workflows. Pick the one closest to how you work.

Parse, inspect, lint, and transform raw Workshop scripts.

Workshop text is the canonical interoperability boundary. WrightKit treats it as a first-class source form — not only as compiler output. Parse, validate, check, analyze, and emit Workshop projects with full catalog awareness.

  • Parse and validate Workshop text against the live action/value catalog
  • Static analysis and lint rules with stable diagnostic codes
  • Semantic inspection: rules, variables, subroutines, control flow
  • Deterministic re-emission for diffs, CI, and round-trip verification
  • Source-span diagnostics in terminal and machine-readable JSON
$
wright lint src/main.workshop

Lint native Workshop text with stable diagnostic codes.

Shared Capabilities

The same tooling foundation — linting, diagnostics, semantic inspection, language services, and agent APIs — applies across all supported source forms.

Static analysis & linting

Stability and performance rules with stable diagnostic codes: min-wait-loop, duplicate-condition, expensive-loop-check, repeated-value, and while-without-wait.

wright lint input.opy

Deterministic diagnostics

Structured errors, warnings, and exact source spans in terminal format and machine-readable wright-result/v1 JSON.

wright check input.opy

Semantic inspection

Structural models, rules, symbols, variable assignments, subroutine dependencies, and control-flow graphs.

wright analyze input.opy

Agent & embedding APIs

Session-based driver (wright-driver) with stdio/JSON-RPC adapters (wright-serve) for programmatic inspection and verified source editing from CI and agents.

cat input.opy | wright lint -

Language server

Lightweight wright-lsp providing hover documentation, definition navigation, reference searches, project-wide identifier rename, and semantic syntax highlighting.

wright-lsp

Compiler

Compile .opy and Workshop text to deterministic, catalog-validated Workshop output (en-US baseline).

wright compile input.opy

Compatibility

Workshop text is the interoperability hub: it is the canonical boundary between supported source forms and the target for compilation.

Workshop text

Supported

Canonical boundary & interoperability layer

Parsing, validation, the localized action/value catalog, and deterministic emission are owned by workshop-rs, the canonical Workshop semantic core. Rules, actions, values, events, enums, variables, subroutines, and settings are covered.

Owned by: workshop-rs · canonical core

OPY / OverPy

Supported

Corpus-evidenced semantic frontend

Native frontend shipped in Wright v0.1.0: preprocessor (#!include, #!define), macros, declarations, expressions, enums, and settings blocks, verified against a pinned OverPy oracle. A standalone opy-rs provider is in development.

Owned by: wright v0.1.0 · opy-rs provider (in development)

DEL / OSTW

In development

Independent compatible frontend

A native DEL/OSTW-compatible frontend is declared on Wright main for the protect-ban slice; the standalone del-rs provider owns the durable implementation. Not yet in a release.

Owned by: del-rs (in development) · declared surface on Wright main

Conversion directions

  • OPY → Workshop
    Supported
  • Workshop → Workshop
    Supported
  • OSTW → Workshop
    In development
  • Workshop → OPY
    In development

Four-Level S/D/N/E Verification Model

Compiler compatibility is rigorously evidenced under a prioritized verification framework:

Priority: E (semantics) > D (diagnostics) > S (syntax) > N (text output)
S (Syntax)

Agrees on accepting valid inputs and rejecting unsupported syntax across the corpus.

D (Diagnostics)

Reports structured diagnostic categories, codes, and accurate source spans for diagnosed inputs.

N (Normalized Output)

Produces equivalent Workshop output under versioned normalization.

E (Observable Semantics)

High-risk runtime semantics are verified against repeatable behavioral scenarios.

Ecosystem

WrightKit is a multi-repository ecosystem: each repository owns a distinct product, contract, or language implementation, and Wright orchestrates them through shared contracts.

  • wrightkit/wright Tooling & orchestration
    Released v0.1.0

    Wright is the primary user-facing product: CLI, diagnostics, static analysis and linting, language services (wright-lsp), validated source editing, and agent/embedding APIs. AGPL-3.0-or-later.

  • wrightkit/workshop-rs Canonical Workshop core
    In development

    Canonical Workshop semantics: actions, values, events, operators, the localized catalog, parser, Workshop IR, and emitter. The interoperability hub for supported source forms. MIT.

  • wrightkit/opy-rs OPY language provider
    In development

    Standalone, Workshop-independent OPY/OverPy-compatible frontend: lexer, preprocessor, parser, semantic resolution, and Opy HIR.

  • wrightkit/del-rs DEL/OSTW language provider
    In development

    Independent DEL/OSTW-compatible frontend: lexer, recoverable parser, project and import loading, semantic analysis, and a backend-neutral HIR.

  • wrightkit/language-provider-protocol Provider protocol
    LPP v1.0

    The versioned process and data contract between Wright tooling and language providers: source text, positions, diagnostics, and source-level edits, without leaking provider internals. MIT.

  • wrightkit/workshop-agent Agent skills & tools
    Released v0.1.4

    Workshop-native engineering knowledge and deterministic CLI tools for coding agents — Codex, Claude Code, Gemini CLI, OpenCode, and other Agent Skills-compatible harnesses.

Open Source

WrightKit is open source: repositories are licensed independently and hosted on GitHub. Wright is AGPL-3.0-or-later; the canonical Workshop core and the provider protocol are MIT.

View Wright on GitHub Releases