Ur is very new and very raw software. Expect bugs. Please tell us about them.

Ur is an integrated toolchain for every programming language and ecosystem. Parsers, formatters, linters, test runners, and static analysis are usually built again, from scratch, for each language, and each works a little differently. Ur builds them once, on a common foundation, and makes them fast and easy to use for coding agents.

# Install Ur
curl -fsSL https://ur.dev/setup.sh | sh
# Set Ur up in this project
ur init
# Parse, format, lint, and test in one pass, fixing what it can
ur check --fix

Run ur check --fix after every change for one report on the whole project. It runs as a Claude Code stop hook, so an agent keeps working until the check is clean.

Incremental everything

Ur keeps what it learns about your code in one shared store, keyed by each file’s bytes. A later run, in any command or any checkout, reuses it and does only the work that changed, so a check after a small edit takes little longer than the tests it has to run.

Formatting in the style of each ecosystem’s reference formatter, checked byte for byte against it. ur format reads each tool’s own configuration, formats only the files that changed, and leaves alone any file it cannot format safely.

$ ur format
reformatted shop/hello.py
1 reformatted, 2 unchanged, 0 skipped, 0 failed

Incremental testing with each language’s own framework. ur test skips every test whose code, and everything that code reaches, is unchanged since it last passed.

$ ur test
ur test: skipping 1396 of 1400 tests, unchanged since they passed

Next-generation linting, starting with true semantic clone detection: finding code that does the same thing however differently it is written. ur lint reports as text or SARIF, ends each finding with a one-line fix for the person or agent reading it, and keeps a baseline so a project fails only on new findings.

# shop/billing.py
def total(orders):
    amount = 0
    for order in orders:
        if order.paid:
            amount += len(order.lines) * 2
    return amount

# shop/reports.py
def paid_sum(items):
    return sum(len(i.lines) * 2 for i in items if i.paid)

$ ur lint shop
warning[semantic-clone]: 2 functions have the same behavior
  --> shop/billing.py:1:1-6 function `total`
  --> shop/reports.py:1:1-2 function `paid_sum`
  = assumes: builtins-unshadowed, pure-operators
  = hint: keep one copy and call it from the other places
1 clone class in 2 files

Supported languages

Rust, every edition from 2015 to 2024, tested with cargo test.
Python, from 2.7 to 3.14, formatted as Black does and tested with pytest.
JavaScript, ECMAScript 2025 and JSX, formatted as Prettier does and tested with Vitest, Jest, or node --test.
TypeScript 5.9, with TSX and experimental decorators, formatted as Prettier does and tested as JavaScript is.
Java, from 8 to 27, tested with JUnit through Maven.
Ruby, from 3.3 to 4.0, formatted as RuboCop’s layout cops do and tested with RSpec and Minitest.
TLA+, with each model checked by TLC as a test.

Open source

Free, under the GNU AGPL. Ur is a command-line tool and a set of Rust libraries, released on GitHub: use it, change it, and share it. If you run a changed Ur for others over a network, share your changes with them under the same license.

The Ur Language SDK

To build high-quality integrated formatters, linters, and test runners, we had to build an integrated static analysis toolkit. The Ur Language SDK opens that toolkit to you, for static application security testing (SAST), vulnerability and secret scanners, taint analysis, code search, and code review tools. We continually maintain these parsers and analyzers so you don’t have to, and we love to add new features that our customers need.

Every grammar Ur ships, as Rust libraries you can import. Parse any language Ur speaks, at any of its versions and dialects, into the same lossless syntax trees Ur’s own tools read. Each grammar is written in Urscal, our meta-grammar system, inspired by Rascal and Spoofax and written in Rust, and validated against the language’s reference parser over large real-world corpora.

Commercial license and enterprise support, for building your own products on the SDK without the AGPL’s terms, with a direct line to the people who build Ur. Contact us at info@powderworks.dev.