🐍 Is There an SDKMAN! for Python?

Introduction: Why Python Needs Its Own SDKMAN!

If you’ve ever used SDKMAN! to manage multiple Java or Groovy versions, you know how seamless it feels — one command to install, switch, or publish SDKs. But what about Python? Can we manage Python versions and distribute packages in a similar way?

The short answer: not a single tool, but a powerful ecosystem that together covers everything SDKMAN! does — and more.

Not a Medium member? Use this open-access link to read the full article. (If the app blocks it, open in browser.)

🧩 1. Managing Python Versions (like sdk install java 17)

The direct counterpart to SDKMAN! for version management is pyenv.

🐍 pyenv

pyenv lets you install and switch between multiple Python versions with ease:

pyenv install 3.12.6
pyenv global 3.12.6
python --version
# → Python 3.12.6

Key features:

• System-wide or per-project Python versions (.python-version)
• Integration with virtualenv
• Custom builds (Anaconda, PyPy, Stackless, etc.)

If SDKMAN! manages SDKs, pyenv manages interpreters. It’s minimal, reliable, and the go-to choice for Python developers working across projects with different runtime requirements.

⚙️ asdf — The Universal Version Manager

If you work with multiple languages (e.g., Java, Node.js, Python, Kotlin), asdf offers a unified approach to version management.

asdf plugin add python
asdf install python 3.12.6
asdf global python 3.12.6

asdf manages all your SDKs and runtimes via plugins - similar to SDKMAN!'s multi-SDK approach, but language-agnostic.

Why choose asdf:

✅ Best for polyglot environments ✅ Works on macOS, Linux, WSL ✅ Single tool for managing Node, Ruby, Python, Java, and 300+ other runtimes ✅ Uses python-build (similar to pyenv’s backend) for Python installations

🚀 2. Publishing and Distributing Python Packages

While SDKMAN! has a Vendor API to publish SDKs, Python uses the PyPI ecosystem (Python Package Index).

📦 PyPI (The Python Package Index)

Think of PyPI as the central registry for all Python libraries, frameworks, and SDKs. Vendors publish via twine, flit, or poetry - and users install via pip.

pip install my-sdk

Publishing to PyPI:

python -m build
twine upload dist/*

This is the Python equivalent of curl -X POST [https://vendors.sdkman.io/release.](https://vendors.sdkman.io/release.)

Benefits:

✅ Global distribution to millions of developers ✅ Full version control via semantic versioning ✅ Integration with GitHub Actions, GitLab CI, or Jenkins

🧠 3. Environment and Dependency Management

While SDKMAN! focuses on installing and switching between multiple JVM-based SDKs and tools (Java distributions like Adoptium, Amazon Corretto, Azul Zulu, GraalVM, plus Groovy, Kotlin, Scala, Gradle, Maven, and more), Python’s tooling extends the concept to include project-level environments and dependency isolation.

🧰 Poetry

Poetry unifies dependency management, environment creation, packaging, and publishing in one workflow:

poetry new my-sdk
poetry add requests
poetry build
poetry publish

It’s roughly the equivalent of combining Maven (for dependencies), SDKMAN! (for version handling), and Twine (for publishing) into a single command-line tool.

Poetry can:

• Manage dependencies and virtual environments per project
• Build and publish packages to PyPI
• Integrate seamlessly with CI/CD pipelines

🧱 Hatch & PDM — Modern Alternatives

If you prefer modular or more lightweight workflows:

• Hatch — modern project management with built-in versioning, environment handling, and build automation
• PDM — PEP 582-compliant, removes venv clutter, and offers fast dependency resolution

These tools modernize Python’s packaging and release process while maintaining full automation — much like SDKMAN! simplifies managing multiple JDK vendors and versions across environments.

🧮 4. Automating Releases (like SDKMAN! Vendor API)

Here’s how you can automate SDK releases to PyPI with GitHub Actions — the Python equivalent of SDKMAN!’s Vendor API.

name: Publish SDK to PyPI
on:
  release:
    types: [published]

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install poetry
      - run: poetry publish --build --username ${{ secrets.PYPI_USER }} --password ${{ secrets.PYPI_PASS }}

Now every GitHub release automatically publishes your SDK to PyPI. That’s your Python-flavored Vendor API — automated, secure, and reproducible.

⚖️ Comparison: SDKMAN! vs Python Ecosystem

| Feature                | SDKMAN!                    | Python Equivalent               |
|------------------------|----------------------------|---------------------------------|
| Version management     | ✅ Built-in (`sdk install`) | `pyenv`, `asdf`                 |
| Environment isolation  | ⚠️ Limited                 | `virtualenv`, `poetry`, `hatch` |
| Package publishing     | ✅ Vendor API               | PyPI + Twine/Poetry             |
| Release automation     | ✅ Gradle/Maven plugins     | GitHub Actions, Poetry, Hatch   |
| Multi-language support | ⚠️ JVM only                | ✅ asdf (300+ plugins)           |

📊 Visual Mapping: SDKMAN! → Python Ecosystem

┌─────────────────────┐    ┌─────────────────────┐
│   SDKMAN!          │ ──→ │   pyenv / asdf     │
│   (Version Mgmt)   │    │   (Version Mgmt)   │
└─────────────────────┘    └─────────────────────┘

┌─────────────────────┐    ┌─────────────────────┐
│   Vendor API       │ ──→ │   PyPI / Twine     │
│   (Publishing)     │    │   (Publishing)     │
└─────────────────────┘    └─────────────────────┘

┌─────────────────────┐    ┌─────────────────────┐
│   Gradle / Maven   │ ──→ │   Poetry / Hatch   │
│   (Build Tools)    │    │   (Build Tools)    │
└─────────────────────┘    └─────────────────────┘

┌─────────────────────┐    ┌─────────────────────┐
│   CI Integration   │ ──→ │   GitHub Actions   │
│   (Automation)     │    │   (Automation)     │
└─────────────────────┘    └─────────────────────┘

🧭 Conclusion: Not One Tool — A Complete Ecosystem

Python may not have a single “SDKMAN! for Python” — instead, it offers a composable ecosystem where specialized tools work together seamlessly:

• pyenv or asdf for version management
• Poetry or Hatch for dependency management, builds, and releases
• PyPI for global distribution
• GitHub Actions or GitLab CI for automation

The key difference: SDKMAN! is a great single-purpose tool for the JVM world. Python embraces composability — multiple lightweight tools that integrate perfectly, giving you more flexibility and control.

When to use what:

• New to Python? Start with pyenv + poetry
• Multi-language projects? Use asdf
• Publishing packages? Use poetry publish or twine
• Need automation? Add GitHub Actions

🚀 Continue Exploring

Thank you for taking the time to read this article. If you found value in these insights, I appreciate your support through a follow or applause on Medium. Feel free to connect with me on LinkedIn to follow more articles and join the conversation around philosophy, science, society, and history.

📚 SDKMAN! Series (5/6)

Prev ← Publishing SDKs with SDKMAN! (Vendors)

Next → Do We Need an SDKMAN! for Python?