Ur isn’t released yet. Its code isn’t public, and the builds here are previews for friends, for Linux only: very new, very raw software. Expect bugs, and please tell us about them.

Ur is one linter for every programming language. Linters are usually built again, from scratch, for each language, and each works a little differently. Ur builds one, on a common foundation, and makes it fast and easy to use for coding agents.

# Install the preview build of Ur
curl -fsSL https://ur.dev/install.sh | sh -s -- --preview
# Set Ur up in this project
ur init
# Lint 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 is designed to be run as a stop hook for agents, so your code is always well linted after every turn.

Incremental linting

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 lints only what the edit touched.

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 lets a project keep a finding on purpose with an ur-allow comment above it, so it 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.
Python, from 2.7 to 3.14.
JavaScript, ECMAScript 2025 and JSX.
TypeScript 5.9, with TSX and experimental decorators.
Java, from 8 to 27.
Ruby, from 3.3 to 4.0.
TLA+ specifications.
Shell, Bash, POSIX sh, Zsh, and KornShell scripts.
Lean 4, where Ur also reports proofs Lean takes on trust and theorems that rest on them.
SQL, parsed in the ANSI, SQLite, MySQL, PostgreSQL, and SparkSQL dialects.

Open source

Free, under the GNU AGPL, once it is released. Ur is a command-line tool and a set of Rust libraries. Its code isn’t public yet; until it is, the preview builds are free to try. When it is released, 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 a high-quality linter for every language, 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 linter reads. 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.