// basilisk — 100% PEP conformant

The open-source
Python language server.

The only Python type checker scoring 100% on the official python/typing conformance suite — and the fastest we’ve measured. A complete, open-source Python dev environment in Rust: type checker, language server, debugger, profiler — autocomplete, go-to-definition, hover, refactoring, diagnostics and integrated debugging in VS Code, Cursor, Zed, and Neovim, without the proprietary lock-in. Strict by default. Weighing up the best Python type checker for your codebase? Start with the scoreboard.

Get Started Install for VS Code Join Discord
Full LSP Built in Rust Incremental re-checks Every IDE — VS Code, Cursor, Windsurf, Zed, Neovim MIT License
100% PEP conformance — only checker at a perfect score 141 of 141 tests in the official python/typing suite · the only tool on the board at 100% · 0 false positives, graded against python/typing@39164cd (2026-07-22)
10 ms Cold full-file check Median across benchmarked constructs, fastest measured · vs Pyright 573 · mypy 574 · ty 40 · Pyrefly 110 · zuban 28 ms

Self-measured against the official python/typing suite & the committed benchmark CSV. How we measure conformance → Full benchmarks & methodology →

How it compares

Everything you expect.
Fully open source.

A feature-complete, open-source language server with no proprietary lock-in. And in our own cold-start benchmark it posts the lowest median of every checker we tested: a 10 ms median cold check, against Pyright’s 573 ms and the Rust-based ty, Pyrefly, and zuban. Every competitor claim below links to that tool’s own docs — and the benchmark methodology shows exactly how these were measured.

Feature Basilisk Pyright mypy ty Pyrefly zuban pycroscope
PEP conformance ¹ 100% (141/141) 96.8% 77.3% 82.3% 97.9% 99.6% 92.2%
Cold full-file check (median) 10 ms 573 ms 574 ms 40 ms 110 ms 28 ms —
Implementation Rust TypeScript Python/C Rust Rust Rust Python
Runtime required None Node.js Python None None None Python
Full LSP (completions, hover, goto) ✓ ✓ — ✓ ✓ ✓ —
Integrated debugger ² ✓ — — — — — —
Official editor extensions VS Code, Cursor, Zed, Neovim (JetBrains soon) Pylance · LSP linter plugins VS Code, PyCharm, Neovim VS Code, Neovim, Zed VS Code (ZubanLS) —
License MIT MIT MIT MIT MIT AGPL-3.0 / commercial Apache-2.0

PEP-conformance row: full-pass scores from the official python/typing conformance suite — one identical run that grades every tool, Basilisk included. Snapshot of python/typing@f051625 (Jul 6 2026); each score links to that tool’s live results folder, since these figures move as the tools improve. Basilisk is the only checker at 100%.

01 — Conformance first

100% to the typing spec.
Re-run against main, every release.

Scored by the official python/typing conformance suite — the same published harness that grades Pyright, mypy, and Pyrefly — run on the real binary with every conformance rule enabled and nothing disabled: 21 of 21 categories at 100%, 0 false positives, 0 missed required errors. Every release re-pulls the suite from python/typing@main and requires a perfect score to ship, so the number is reproducible — never hand-typed — and always graded against the exact commit shown below. Basilisk is now listed in the official python/typing results — graded on the same run as every other checker, it is the only one at a perfect 100%, ahead of the tools from Microsoft, Meta and Astral.

100% PEP conformance score graded against python/typing@39164cd (2026-07-22) — re-cloned from main every release
10 ms median cold full-file check

02 — Measured, not promised

The lowest median
we’ve benchmarked.

The numbers come from make bench — hyperfine wall-clock against Pyright, mypy, ty, Pyrefly, and zuban on identical fixtures — and the raw CSV is committed to the repo, so the site renders exactly what was last measured. Basilisk posts the lowest median cold full-file check of every tool we measured — 10 ms, against Pyright’s 573 ms. And because re-checks are incremental — only the edited file and its importers are re-analyzed — warm edits do even less work. See the benchmark methodology →

03 — Quick fixes & refactoring

Lightbulb-ready.
Every diagnostic.

Many diagnostics ship with a one-keystroke fix — add the missing annotation, modernise Optional[X] to X | None, convert to an f-string. Plus a full refactoring suite: extract, inline, change signature, and move symbol.

quick-fix.py 
# 💡 Quick Fix available
def process(data) # BSK-0001

# → Add type annotation
def process(data: str) -> str:
  return data.upper()
8 opt-in rules that make typing mandatory part of 20 opt-in rules — off by default, never scored for conformance

04 — Beyond the spec

The spec makes types optional.
These make them mandatory.

The typing spec treats unannotated code as inferred, not an error. Basilisk’s 8 opt-in strictness rules refuse that: they require a type on every parameter, return, variable, *args/**kwargs, and class attribute, demand @override on overrides, reject implicit and explicit Any, and flag unannotated lambdas. Every one is off by default — switch them on project-wide or per-folder from your editor or pyproject.toml, and one-click quick-fixes drop in a placeholder annotation (: Any, -> None) so you can fill in the real type. They never run during conformance, so they can’t pad that score. See the rules →

Basilisk step-through debugging in VS Code — paused at a breakpoint in debug_demo.py with the Variables, Watch, and Call Stack panels populated and the debug toolbar active

05 — Integrated debugging

F5 to debug.
Basilisk handles the rest.

Set breakpoints, step through code, inspect variables — all brokered through the Basilisk LSP. The Rust server spawns debugpy on a free TCP port and connects VS Code’s DAP client automatically. No manual configuration. No separate debug extension. Just press F5.

06 — Single binary

Drop it in PATH.
That’s the whole install.

Compiled to a standalone Rust binary. No Node.js. No Python interpreter. No pip install. No npm install. Works on macOS, Linux, and Windows from a single download.

terminal 
# macOS / Linux (Homebrew)
brew install Nimblesite/tap/basilisk

# Windows (Scoop)
scoop install basilisk

# then just run it
basilisk check src/

Open source.
Conformant by default.

The type checker, LSP server, and editor extensions are working today — autocomplete, go-to-definition, hover info, diagnostics, refactoring, F5 debugging, and profiling — in VS Code, Cursor, Windsurf, Zed, and Neovim. JetBrains is on the way. Open source. No proprietary lock-in. Early adopters shape the roadmap.

Read the Docs Join Discord

Sources

  1. PEP conformance. The table figures are full-pass scores from a single run of the official python/typing conformance suite, which grades every listed checker — Basilisk included — on the identical test set. We snapshot them from python/typing@f051625 (Jul 6 2026) and link each score to that tool’s live results folder (pyright, mypy, ty, pyrefly, zuban), because those scores change as the tools improve. Basilisk scores 100% (141/141) — the only checker at a perfect score on this run. As a reproducible cross-check we also re-run the unmodified scorer on our own binary every release (100%, 141/141, graded against python/typing@39164cd); both measurements agree.
  2. Benchmark (cold full-file check). Mean wall-clock over 10 hyperfine runs of each tool’s CLI against identical single-construct fixtures, measured on Apple M4 Max (Darwin 25.5.0, arm64, 14 cores) on 2026-07-17T14:23:34+1000. All tools measured cold from the same run — basilisk dev (962f2b34-dirty), pyright 1.1.408, mypy 1.19.1, ty 0.0.19, pyrefly 0.54.0, zuban 0.9.0. mypy runs with --strict and zuban as zuban mypy --strict so both perform the strict analysis the fixtures stress. Source benchmarks/status/darwin-arm64-apple-m4-max.csv; reproduce with make bench. Cold full-file only — not warm incremental (LSP) performance.
  3. Implementation & runtime. ty: “An extremely fast Python type checker and language server, written in Rust.” Pyrefly: Meta’s announcement is titled “Open-sourcing Pyrefly: A faster Python type checker written in Rust.” zuban: “a high-performance Python Language Server and type checker implemented in Rust, by the author of Jedi.” Pyright (TypeScript) states you must install “node (which Pyright requires).” mypy: “Mypy is itself compiled using mypyc” (Python compiled to C extensions) and installs via pip (needs Python). ty, Pyrefly, zuban and Basilisk are compiled binaries, so no language runtime is required to run them.
  4. Language server & editors. Pyright ships an open-source language server (pyright-langserver --stdio) usable in any LSP editor; Microsoft’s docs note “core type checking functionality is associated with Pyright while language service functionality is associated with Pylance” — the proprietary Pylance VS Code extension. mypy has editor plugins that run it as a linter (not a language server). ty: “Editor integrations for VS Code, PyCharm, Neovim and more.” Pyrefly: “an extension for popular IDEs and editors such as VSCode, Neovim, Zed, and more.” zuban: “Most important LSP features are supported… completions, goto, references, rename, hover…” via the official ZubanLS extension.
  5. License. Basilisk, Pyright, mypy, ty and Pyrefly are MIT. zuban is dual-licensed AGPL-3.0 or a paid commercial license (PyPI classifier: “Other/Proprietary License”).
  6. Integrated debugger. Basilisk brokers debugpy through the language server (press F5). None of Pyright, mypy, ty, Pyrefly, or zuban documents an integrated debugger — each self-describes as a type checker and/or language server.
  7. Pyrefly throughput. The “1.85 million lines of code per second” figure is from pyrefly.org, “Tested using Meta infrastructure (166 cores, 228 GB RAM)” — a whole-project throughput number, not comparable to our single-file cold-check benchmark.