Go-Python Toolchain

Check. Lock. Ship.
Fast, focused tools that accelerate the Python workflow without replacing Python.

The Python ecosystem has three chronic pain points: slow type checking, fragile dependency resolution, and cumbersome deployment. Each already has an answer, and each answer is slower than it should be on modern multi-core hardware.

Go-Python Toolchain (GPT) is a suite of three independent, standalone binaries, written in Go, that take over the heavy parts of that workflow and hand the rest back to the tools you already use. It does not replace Python. It sits beside it. Adoption is frictionless: you never change your code, your directory structure, or your primary commands.

The three tools follow the life of a change, and each takes over one heavy job:

1. Check with pypls. Fast type feedback in your editor and in continuous integration.
2. Lock with gopip. A deterministic gpt.lock that is byte-identical across machines.
3. Ship with gopack. One executable that runs on a machine with no Python installed.

Adopt one, or all three. They share a philosophy but not a dependency: each is its own repository, with its own releases.

All three tools are installable today, and each carries its own guides, a runnable example, and a benchmark you can reproduce.

Type check your code with pypls:

pip install pypls-client
pypls check .

Resolve and lock your dependencies with gopip:

pip install gopip-client
gopip lock -r requirements.txt

Bundle your app into one executable with gopack:

pip install gopack-client
gopack build ./myapp -r ./myapp/requirements.txt -o myapp

Each repository has a getting started guide, a tutorial, an architecture writeup, and more:

• pypls: getting started, tutorial, editors, benchmarks
• gopip: getting started, tutorial, resolver, benchmarks
• gopack: getting started, tutorial, protocol, benchmarks

Every tool ships a reproducible benchmark harness, and every benchmark carries a threats to validity note. The numbers are candid about where each tool wins and where it does not:

• pypls checks a large Django file in single-digit milliseconds, far faster and lighter than pyright and mypy on the same file.
• gopack trades a larger bundle for zero per-framework configuration and fast warm startup, measured next to PyInstaller across real Django, FastAPI, and machine learning apps.
• gopip has a fast, correct solver that resolves the same sets as uv and pip-tools, and it is honest that it is slower end to end today because it fetches metadata serially with no cache. Concurrent fetch and a persistent cache are the top of its roadmap.

Run the harness in each repository's examples/benchmark and see for yourself.

• Drop-in. GPT tools sit alongside pip, mypy, and PyInstaller and offload the heavy work to compiled Go. You change nothing.
• Independent. Each tool is its own repository with its own releases. No monorepo, no cross-repo coupling.
• Local and private. Everything runs on your machine. Your code never leaves it.
• Open source. Apache 2.0, for everyone.

The toolchain has a home page at go-python-toolchain.github.io/website, with documentation pages for each tool.

We build one tool to full production quality before starting the next, and each tool publishes its own roadmap and limitations.

1. pypls, the type checker and language server. Released.
2. gopip, the dependency resolver. Released. Next: concurrent metadata fetch and a persistent cache to make warm resolves fast. See its roadmap.
3. gopack, the deployment bundler. Released. Next: much smaller bundles and cross-platform builds. See its roadmap.
4. A unified documentation and marketing site. Live.

Follow the work in each repository. Issues and contributions are welcome.