Skip to content
Wright Kit

Tooling-first semantic platform for Overwatch Workshop.

An independent, standalone Rust toolchain for the Overwatch Workshop and OverPy ecosystem. Fast compiler, static linter, language server, and embedding APIs for developers, CI, and AI agents with zero runtime dependencies.

Install Wright View on GitHub
$ curl -fsSL https://raw.githubusercontent.com/wrightkit/wright/main/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, Linux, and Windows. 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 verified checksums.

Alternative: Unix installer script 
curl -fsSL https://raw.githubusercontent.com/wrightkit/wright/main/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.

High-Performance Compiler

Compile .opy source scripts and Workshop text to optimized, localized Workshop code with deterministic output.

wright compile input.opy

First-Class Static Linting

Static stability and performance analysis with configurable rules: 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 surfaced in human-readable terminal format and machine-readable wright-result/v1 JSON.

wright check input.opy --format json

Language Server (wright-lsp)

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

wright-lsp

Semantic Analysis & CFG

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

wright analyze input.opy

Embedding & Agent Tooling

Session-based driver (wright-driver) with stdio/JSON-RPC adapters (wright-serve) enabling programmatic inspection and verified refactoring.

cat input.opy | wright lint -

Ecosystem Compatibility

Vanilla Workshop text is the canonical interoperability boundary and conversion hub.

Vanilla Workshop

Supported

Canonical target & interoperability layer

Native parser, localized catalog (catalog.json), validation, and deterministic emitter (wright-workshop). Supports rules, actions, values, events, enums, variables, subroutines, and custom-game-settings.

OPY / OverPy

Supported

Native compatible semantic frontend

Native Rust parser (wright-opy), preprocessor (#!include, #!define), macro expansion, declarations, expressions, enums, custom-game-settings JSONC blocks, and lowering to Wright HIR and Workshop IR.

OSTW

Planned

Future compatible semantic frontend

Planned OSTW frontend mapping into Wright HIR/WIR for standalone compilation, linting, analysis, and language services under clean-room isolation (ADR-0008).

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.

System Architecture

Wright processes source code through a modular, owned pipeline with zero third-party AST leaks.

01

Owned Frontends

Parse .opy or Workshop text into typed representations with full source provenance.

crates/wright-opy · crates/wright-workshop

02

Wright HIR & WIR

Frontend-independent High-Level Intermediate Representation and target-oriented Workshop IR.

crates/wright-core · crates/wright-ir

03

Semantic Layer

Symbol resolution, control-flow graph (CFG) construction, reference indexing, and lint evaluation.

crates/wright-analyzer

04

Downstream Tooling

Deterministic Workshop text compiler, language server (LSP), and session driver with JSON-RPC.

crates/wright-lsp · crates/wright-driver · crates/wright-cli

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

Wright is open source under the AGPL-3.0-or-later license. All code, releases, and distribution packages are publicly hosted on GitHub.

View wright on GitHub Releases