Skip to content
WrightKit

Tooling for Overwatch Workshop development.

Native Workshop, OverPy / OSTW, and AI agents.

WrightKit combines independently usable Workshop, OverPy, and DEL/OSTW implementations with Wright, a unified tooling product for linting, analysis, semantic inspection, validated source editing, agents, CI, and language services.

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

Install Wright

Wright is the unified tooling product. The language implementations also expose standalone libraries and CLIs from their own repositories.

Homebrew 
brew tap wrightkit/tap
brew install wrightkit/tap/wright

Installs the released Wright binaries.

Alternative: Installer script 
curl -fsSL https://wrightkit.dev/install.sh | bash
Current precompiled release archives and 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.

A standalone Workshop implementation plus integrated tooling.

workshop-rs owns raw Workshop parsing, canonical semantics, WIR, catalog data, validation, localization, and emission. Wright consumes those capabilities and adds linting, analysis, source editing, CI, agents, and language services.

  • Parse and validate raw Workshop through workshop-rs
  • Canonical Workshop identities, WIR, settings, and localization
  • Static analysis and linting through Wright
  • Deterministic Workshop emission and locale conversion
  • Machine-readable diagnostics and semantic queries
$
wright lint src/main.workshop

Use Wright tooling on canonical Workshop semantics.

Shared Capabilities

Wright adds cross-language tooling on top of the source form implementations. Availability is bounded by the semantic support of the owning implementation.

Static analysis & linting

Workshop stability and performance rules operate on semantic information rather than raw text where the backing implementation provides it.

wright lint input.opy

Deterministic diagnostics

Structured errors, warnings, and source spans in terminal and machine-readable formats.

wright check input.opy

Semantic inspection

Rules, symbols, references, dependencies, and other queries derived from the owning semantic implementation.

wright analyze input.opy

Agent & embedding APIs

Programmatic inspection and validated source-edit workflows for CI, agents, and other consumers.

wright lint input.opy --format json

Language services

Wright integrates semantic capabilities into editor-neutral services and LSP where the source implementation exposes the required information.

wright-lsp

Compilation & conversion

Compilation and reconstruction are exposed only for the evidence-backed subset implemented by the owning language repository and workshop-rs.

wright compile input.opy

Compatibility

Workshop is the interoperability hub. Source-language support is defined by the owning implementation and its corpus, not by the presence of a Wright command.

Workshop text

Supported baseline

Standalone implementation & canonical interoperability layer

workshop-rs owns raw Workshop parsing, canonical identities, WIR, validation, localization, emission, and reviewed Workshop gameplay/catalog queries.

Owned by: workshop-rs

OPY / OverPy

Partial end-to-end

Standalone OverPy implementation

Standalone source analysis is implemented. Builtin/member/catalog breadth and OPY→Workshop compilation are still being closed; Workshop→OPY reconstruction is not yet supported.

Owned by: opy-rs

DEL / OSTW

Partial end-to-end

Standalone DEL/OSTW implementation

Parsing, projects, semantic/type analysis, and typed HIR are substantial. Advanced runtime/project lowering and end-to-end compilation remain incomplete; reconstruction is not yet supported.

Owned by: del-rs

Conversion directions

  • OPY → Workshop
    Partial
  • Workshop → Workshop
    Supported
  • OSTW → Workshop
    Partial
  • Workshop → OPY
    Not yet

Evidence-driven compatibility

Compatibility targets observable semantics and declared source/tooling contracts rather than compiler-output identity.

Priority: Observable semantics and valid source/tooling behavior > normalized text similarity
S (Syntax)

Valid and unsupported syntax is classified against corpus evidence.

D (Diagnostics)

Diagnostics retain stable categories and accurate source provenance.

N (Normalized Output)

Normalized text comparison is supporting evidence, not the product target.

E (Observable Semantics)

Semantically significant behavior is validated with the strongest available evidence.

Ecosystem

WrightKit combines independent implementations with a unified tooling product. Each repository keeps its own responsibility, public contracts, tests, and release identity.

  • wrightkit/wright Unified tooling & integration product
    Released

    One product surface for diagnostics, lint, analysis, source editing, agents, CI/embedding, language services, and supported compile/convert workflows.

  • wrightkit/workshop-rs Standalone Workshop implementation
    Canonical baseline available

    Raw Workshop parser, canonical WIR/catalog/settings/localization, validation, emission, gameplay queries, and conformance evidence.

  • wrightkit/opy-rs Standalone OverPy implementation
    In development

    OverPy parsing, preprocessing/macros, semantics, diagnostics/provenance, standalone tooling, and the language-owned compiler/reconstruction path.

  • wrightkit/del-rs Standalone DEL/OSTW implementation
    In development

    DEL/OSTW parsing, project loading, semantic/type system, typed HIR, runtime/compiler lowering, standalone tooling, and reconstruction ownership.

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

    A versioned process/data contract. Provider is an integration role that standalone implementations may expose; it is not their repository identity.

  • wrightkit/workshop-agent Agent skills & tools
    Released

    Workshop engineering knowledge and deterministic tools for coding-agent harnesses.

Source & licenses

WrightKit repositories are versioned and licensed independently. See each repository for its current license and provenance terms.

View Wright on GitHub Releases