Skip to content
WrightKit

Tooling for the Overwatch Workshop.

WrightKit is an open-source ecosystem of tools for Overwatch Workshop development. Wright, its primary product, is a standalone Rust toolchain for linting, static analysis, semantic inspection, and compilation — for developers, CI, and AI agents.

Install Wright View on GitHub
$ curl -fsSL https://wrightkit.dev/install.sh | bash
wright lint & compile v0.1.0
$ wright lint src/hero.opywarning[expensive-loop-check]: geometry predicate in loop body  --> src/hero.opy:24:9   |24 |     while @hero.is_in_view(target):   |           ^^^^^^^^^^^^^^^^^^^^^^^^   =   = note: evaluated on each iteration; may spike server load   = rule: expensive-loop-check (stability)$ wright compile src/hero.opy -o dist/hero.txt✓ compiled 12 rules, 4 subroutines (0.018s)

wright lint: static analysis with stable diagnostic codes and exact source spans.

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.

Features

Developer tooling — linting, diagnostics, semantic queries, editor assistance, and safe source transformations — as first-class product surfaces.

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.

The same interface for people and agents

If a developer can ask the tooling a question, a coding agent can ask it through the same JSON contract. No scraped logs or brittle regexes.

Structured interfaces

Transport-neutral request/response (wright-result/v1) for program summaries, rules, symbols, references, usage, control flow, and findings.

Deterministic output

Equal inputs, configuration, and toolchain produce the exact same IR, diagnostics, and snapshots.

Machine-readable diagnostics

Errors and findings carry stable codes, severity levels, and source spans so an agent or IDE can act without parsing prose.

Clean-room & reproducible checks

Isolated reference oracles, fixture corpora, and regenerable snapshots keep compatibility claims verifiable.

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