Managing multiple languages in a monorepo can be a nightmare. Tools, build systems, dependencies, and environments often conflict when Java, Python, and Go coexist. Enter Pants — a fast, scalable, and user-friendly build system built for polyglot monorepos.
In this article, we’ll explore how Pants supports multi-language development across Java, Python, and Go, how it improves developer workflows, and how to get started with real-world examples.
Why Use Pants in a Polyglot Repository?
Traditional build systems like Maven (Java), pip/venv (Python), or go build (Go) aren’t designed for managing multiple languages under one roof. Pants solves this by:
- Supporting multi-language builds natively
- Providing a unified CLI for building, testing, linting, and formatting
- Offering fine-grained caching, parallelism, and remote execution
- Integrating with popular tools like
black,flake8,pytest,javac, andgo build
Supported Languages and Toolchains
As of Pants 2.20+, these are officially supported:
| Language | Tooling |
|---|---|
| Python | Pytest, Black, Pylint, MyPy |
| Java | javac, JUnit |
| Go | go build, go test |
| Others | Shell, Protocol Buffers, Docker, etc. |
You can mix and match these in a single monorepo with minimal config changes.
Initializing Pants in Your Repository
Step 1: Bootstrap Pants
curl -fsSL https://static.pantsbuild.org/setup/pants | bash
[GLOBAL] backend_packages = [ "pants.backend.python", "pants.backend.java", "pants.backend.go", ] pants_version = "2.20.0"
Step 3: Create BUILD files
Pants uses BUILD or BUILD.<lang> files to declare targets. Here’s how you do it for each language:
Python Example
File structure:
src/
└── python/
└── mylib/
├── __init__.py
└── utils.py
BUILD file (src/python/mylib/BUILD):
python_sources()
You can test with:
./pants test src/python/mylib::
Java Example
File structure:
src/
└── java/
└── com/
└── example/
└── HelloWorld.java
BUILD file (src/java/com/example/BUILD):
java_sources()
Compile or run tests:
./pants compile src/java/com/example::
Go Example
File structure:
src/
└── go/
└── example/
└── main.go
BUILD file (src/go/example/BUILD):
go_package() go_binary(name="main", source="main.go")
./pants run src/go/example:main
Cross-Language Interop
While Pants doesn’t handle language interop directly (e.g., calling Go from Java), it allows independent language pipelines to co-exist cleanly. Teams can:
- Share a monorepo
- Define per-language CI steps with a shared CLI
- Cache builds and tests independently
- Use Pants’s dependency inference to reduce boilerplate
Developer Benefits
✅ Unified Tooling
No need to install Maven, pipenv, or Go directly — Pants manages the environments behind the scenes.
✅ Incremental & Cached Builds
Only what changes gets rebuilt or retested, thanks to Pants’s smart fingerprinting.
✅ IDE Support
Use ./pants export to generate project files for IntelliJ, VSCode, etc.
✅ First-Class Python Support
Many multi-language tools fall short with Python — Pants offers full support for Python packaging, testing, linting, and even lockfile generation.
Example: Adding a Python Test for a Java Build Artifact
You can structure your repo so Python tests or tools validate a Java CLI binary:
# Export Java binary ./pants package src/java/com/example:hello-cli # Call it from Python using subprocess in integration tests
This is helpful for integration testing or end-to-end validation workflows.
Running Tests for All Languages
Run all tests across all languages with:
./pants test ::
Or filter per language:
./pants test 'src/python::' ./pants test 'src/java::' ./pants test 'src/go::'
Sample Project Layout
repo/ ├── pants.toml ├── src/ │ ├── python/ │ │ └── ... │ ├── java/ │ │ └── ... │ └── go/ │ └── ... └── BUILD files in each subdir
Conclusion
Pants makes it easy to manage Java, Python, and Go in a single repository without forcing developers into language silos. With smart build caching, unified tooling, and deep support for popular workflows, it’s a solid foundation for polyglot teams embracing monorepo architecture.
References
