# GATK 4: the Broad Institute's genome analysis toolkit with Java 17, Conda pinning and an optional Spark layer

> GATK 4 is the Broad Institute's open-source toolkit for next-generation sequencing analysis, merging the GATK and Picard codebases into one Java executable. It requires Java 17, Python 3.10.13 and R 4.3.1 to run; Docker is the path that removes most of that setup complexity.

**broadinstitute/gatk** — Official code repository for GATK versions 4 and up

- Repository: https://github.com/broadinstitute/gatk
- Website: https://software.broadinstitute.org/gatk
- Stars: 2,004 · Forks: 628
- Language: Java
- License: NOASSERTION
- Published: 2026-10-09 · Updated: 2026-10-09 · Language: en
- Canonical page: https://hysenlabs.com/projects/broadinstitute-gatk

## GATK 4 merges two Broad Institute codebases into one entry point, with Picard as the absorbed alternative

GATK 4 is the next generation of the Genome Analysis Toolkit, written in Java and maintained by the Broad Institute. It brings together tools from the GATK and Picard codebases under a common framework, accessible through a single executable named `gatk` at the repository root. GATK 4 also contains tools not present in earlier releases, though the count is not listed in the repository.

Picard previously existed as a separate project at broadinstitute.github.io/picard. Teams that built pipelines around the Picard jar directly represent the clearest alternative path. GATK 4 absorbs those tools under the same gatk wrapper, so migrating from a Picard-only setup means accepting the full GATK 4 dependency chain in exchange for a unified interface. Whether that trade is worth it depends on which Picard tools a pipeline actually calls and whether their behavior under the gatk wrapper matches what the Picard jar produced.

The project targets next-generation sequencing analysis: the repository topics include bioinformatics, dna, genomics, sequencing and science. The homepage at software.broadinstitute.org/gatk is where the Broad Institute points users for pre-compiled executables, documentation and technical support.

## Selected tools scale to clusters and Google Cloud Dataproc through Apache Spark

Not every tool in GATK 4 supports Apache Spark. Selected tools can run in a massively parallel way on local clusters or in the cloud using Apache Spark, while others run only on a single machine. That qualifier matters for pipeline design, because a workflow mixing Spark-enabled tools with standard tools cannot uniformly distribute work across a cluster. Identifying which tools support Spark before planning a distributed run is a prerequisite that takes time to verify.

Three Spark execution modes are documented. Local mode runs the Spark runtime on the same machine as the gatk script. Cluster mode connects to an existing Spark cluster. The third option is Google Cloud Dataproc, which provisions the Spark infrastructure on demand. Running GATK 4 with inputs stored on Google Cloud Storage is also covered, which avoids staging large sequencing files locally before processing begins.

Bash tab completion is a separate feature: the GATK Tab Completion for Bash section covers the setup step, which helps with tools whose argument lists benefit from autocomplete. A dedicated section on Generating GATK4 WDL Wrappers also appears in the documentation table of contents, indicating that WDL pipeline definitions are generated from tool metadata rather than maintained separately.

## Java 17 from Adoptium and Python 3.10.13 are both required before running the first command

Java 17 is required to run or build GATK. Adoptium's Temurin distribution, available from adoptium.net at the Temurin release archive for Java 17, is the recommended source rather than an arbitrary JDK 17 vendor. On macOS, the installation command is:

```bash
brew install temurin@17
```

Python 3.10.13 is a separate requirement, needed to run the gatk frontend script and some tools. That is a version-pinned dependency, not a minimum floor, so a newer patch or minor release is not documented as equivalent. R 4.3.1 enters the dependency chain only when a tool needs to produce plots, making it the only runtime dependency that some pipelines can omit entirely. All three version numbers are specified explicitly in the requirements section.

The pinning matches what the official Docker image ships, and a local installation that drifts from those versions may produce behavior outside what the test suite covers. This version specificity is the practical argument for adopting Docker rather than managing a local environment.

## Conda must match version 23.10.0-1, and ARM Macs are confined to x86 emulation

GATK 4 uses Conda to manage its Python environment and dependencies. Miniconda3-py310_23.10.0-1 is the required version, matching what ships inside the official Docker image. Using a different version of Conda may introduce compatibility issues with how the toolkit resolves packages and activates its environment, which is why the version constraint is documented as a requirement rather than a recommendation.

To install on Linux or Intel macOS:

```bash
bash Miniconda3-py310_23.10.0-1-[YOUR_OS].sh -p /opt/miniconda -b
```

After installation, Conda's automatic self-update feature must be disabled:

```bash
conda config --set auto_update_conda false
```

Allowing Conda to update itself would drift the environment away from the tested version. ARM-based Macs require the MacOSX-x86_64 installer rather than the MacOSX-arm64 installer, relying on macOS's built-in x86 emulation. There is no native ARM build of the Conda environment. Any team on Apple Silicon hardware needs to account for that emulation layer when diagnosing performance or compatibility issues, and the documentation does not cover whether all features behave correctly under it.

## Docker images ship with Conda pre-configured and bypass all dependency installation steps

Pre-built Docker images for GATK 4 are available at hub.docker.com/r/broadinstitute/gatk/. These images ship with all needed dependencies installed. The Dockerfile shows the base image is broadinstitute/gatk:gatkbase-3.3.1, with the Conda environment pre-configured and activated inside the container.

For teams that want to run GATK tools without managing Java, Conda and R separately, Docker avoids the ARM Mac constraint, the Conda version pinning requirement and the R installation step. It introduces container management overhead, but Docker is the primary distribution path the project directs users toward ahead of building from source.

The repository contains build_docker.sh and build_docker_remote.sh scripts for building the image locally, alongside the main Dockerfile. The Dockerfile uses a multi-stage build: the first stage runs gradlew to compile and bundle GATK; the second stage copies the bundle into a clean image. For most users, pulling the published image from DockerHub is the straightforward approach. Building the Docker image locally is a step for contributors or teams that need to modify the toolkit itself.

## Building from source requires git-lfs 1.1.0 and downloads approximately 5 gigabytes

Building GATK 4 requires git-lfs version 1.1.0 or greater, Git 2.5 or greater, and a Java 17 JDK. After cloning the repository, the build process starts with initializing and pulling git-lfs:

```bash
git lfs install
git lfs pull
```

The full download of all large files is approximately 5 gigabytes. For users who only need to build and not run the test suite, a lighter path exists: the build uses git-lfs to fetch the minimal set of large lfs resource files required to complete the build, while the test resources remain undownloaded. The documentation does not give a specific size for that reduced download, only that skipping test resources significantly reduces the download footprint.

The build itself goes through the gradlew wrapper script:

```bash
./gradlew
```

Using gradlew rather than a system-installed Gradle is the documented approach, because the wrapper downloads Gradle 5.6 automatically without requiring a manual installation step. The Dockerfile shows the CI build passing GRADLE_OPTS with -Xmx4048m and -Dorg.gradle.daemon=false to give the JVM 4 GB and disable the Gradle daemon; those flags appear in the Dockerfile for CI purposes and are absent from the build instructions covering local development.

## GitHub classifies the licence as Other despite the badge and the repository text both claiming Apache 2.0

The repository states that its contents are 100% open source and released under the Apache 2.0 license (see LICENSE.TXT). The badge at the top links to opensource.org/licenses/Apache-2.0. Despite that, GitHub classifies the licence as Other, meaning its automated scanner did not match the text in LICENSE.TXT to a known SPDX identifier.

That discrepancy affects automated compliance tools. Any pipeline that reads the licence from GitHub's API will see Other, not Apache-2.0. The authoritative source is LICENSE.TXT at the repository root.

The repository also holds CODE_OF_CONDUCT.md and an AUTHORS file. A Citing GATK section addresses academic use: GATK has a publication record, and the section points to how researchers should credit the toolkit in papers. For institutional adoption, the citation requirements and the licence terms in LICENSE.TXT are both worth reading before any redistribution or publication.

## Version 4.7.0.0 arrived in August 2026, and a Dockstore file registers the tools for workflow portability

GATK 4 has a documented release record spanning multiple years. Version 4.7.0.0 was released on 2026-08-18, 4.6.2.0 on 2025-04-14 and 4.6.1.0 on 2024-10-30. The repository last pushed on 2026-10-06. That pace of releases and pushes reflects an actively maintained project.

The repository root includes a .dockstore.yml file, which registers GATK tools with Dockstore, a platform for sharing and running scientific workflow tools. That file is the only indication in the repository listing of integration with a scientific workflow registry.

For teams working with WDL-based pipelines, a section on Generating GATK4 WDL Wrappers appears in the documentation table of contents, suggesting that WDL definitions are generated from tool metadata. Research groups already running Cromwell or Terra workflows will find GATK 4 fits that context. Teams running outside those ecosystems will rely primarily on the command-line interface. The repository's topics include spark, which signals that distributed execution is a first-class feature of the project rather than an afterthought.

## Conclusion

GATK 4 is the right tool when your work is next-generation sequencing variant calling and the pipeline lives in an environment already configured for multi-dependency Java toolkits. The Docker image at hub.docker.com/r/broadinstitute/gatk/ is the path with the lowest setup cost. Skip building from source unless you are modifying the code. Before adopting it, verify that your compute environment supports Java 17 from Adoptium, that Conda can be pinned to Miniconda3-py310_23.10.0-1, and read LICENSE.TXT directly rather than relying on GitHub's licence field, which shows Other rather than Apache-2.0.

## FAQ

### What is GATK used for?

GATK is the Genome Analysis Toolkit maintained by the Broad Institute. GATK 4 targets next-generation sequencing data analysis, merging tools from the GATK and Picard codebases under one Java executable with optional Apache Spark support for parallel execution on clusters and Google Cloud.

### How do I install GATK 4?

The documented paths are downloading a pre-compiled executable from software.broadinstitute.org/gatk, pulling a Docker image from hub.docker.com/r/broadinstitute/gatk/, or building from source with Java 17, git-lfs 1.1.0 and gradlew. Building from source downloads approximately 5 gigabytes of large files through git-lfs.

### What Java version does GATK 4 require?

GATK 4 requires Java 17. The recommended distribution is Adoptium's Temurin from adoptium.net, or on macOS, installing via brew install temurin@17.

### Does GATK 4 run on Apple Silicon Macs?

GATK 4 can run on Apple Silicon, but it requires the MacOSX-x86_64 version of Miniconda3-py310_23.10.0-1, not the MacOSX-arm64 version. The Python environment relies on macOS's built-in x86 emulation, and there is no documented native ARM build.

### What is the licence for GATK 4?

The repository states the project is released under the Apache 2.0 licence, and the badge links to opensource.org/licenses/Apache-2.0. GitHub's automated scanner classifies it as Other, so reading LICENSE.TXT in the repository is the authoritative check before any redistribution.

## Sources

- [broadinstitute/gatk on GitHub](https://github.com/broadinstitute/gatk)
- [Issues](https://github.com/broadinstitute/gatk/issues)
- [Project website](https://software.broadinstitute.org/gatk)
- [README](https://github.com/broadinstitute/gatk/blob/master/README.md)
- [Releases](https://github.com/broadinstitute/gatk/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/broadinstitute-gatk