Introduction
You’ve just called variants on your RNA-seq or whole genome dataset. Your variant caller output is a 50 MB VCF file sitting on your disk. You need to look at actual reads covering a variant, check the breakpoints on a rearrangement, or visually inspect the coverage across a region. This is when you reach for a genome browser.
IGV (Integrative Genomics Viewer), built and maintained by the Broad Institute, is probably what everyone you work with is using. But is it still the right choice in 2025? This post is a hands-on review based on years of production use: what IGV does exceptionally well, where it stumbles, and when you should seriously consider alternatives.
The bottom line upfront: yes, for most bioinformaticians, IGV remains the best general-purpose genome browser. But it has real gaps that matter if you’re doing certain kinds of analysis, and some of those gaps have alternatives worth knowing about.
What IGV Actually Is
IGV is a desktop and web-based genome browser built for visualizing genomic data. It handles BAM files (alignments), VCF files (variants), BED/GFF files (genomic features), bigWig tracks (coverage), and many other standard bioinformatics formats. You can load local files or stream from URLs, zoom from chromosome-scale down to single-base resolution, and inspect the actual sequencing reads backing any region of interest.
The key distinction: IGV is primarily a lookup tool. You already know what region or gene you want to look at, and you want to see what’s really there in your data. It’s not designed for discovery-scale exploration across whole genomes in a single view.
Installation and Getting Started
IGV has two flavors: a Java-based desktop application and a pure-web version. Both are free.
Desktop App
Download the Java application from the official IGV website. It’s available for Linux, macOS, and Windows. You’ll need Java 11 or later (most bioinformatics environments have this).
Installation is straightforward. Open the app, and you’re ready to load files.
Web Version (IGV-Web)
The web version requires no installation. Just navigate to igv.org/app, drag a file into the browser (or paste a URL), and start exploring. The web version is slower for very large files but works fine for spot-checking variants or inspecting a single region.
Loading Remote Data
One of IGV’s strengths is streaming data from URLs. Here’s how to load a BAM file and its index from a remote server:
igv.createBrowser({
genome: "hg38",
tracks: [
{
url: "https://example.com/path/to/your_file.bam",
indexURL: "https://example.com/path/to/your_file.bam.bai",
name: "My Alignment"
}
]
});
This is useful for collaborative analysis: you host the files on S3 or a web server, share a link, and colleagues can inspect the same data without downloading 100+ GB BAM files. This is genuine convenience that IGV handles better than most alternatives.
What IGV Does Exceptionally Well
1. Visual Variant Inspection
This is IGV’s core strength. Load a VCF file and a BAM file, click a variant, and you instantly see the reads supporting or refuting the call. You can see exactly which reads carry the alternate allele, what their mapping quality is, what their base quality is for that position, and whether reads split across a breakpoint.
For validating critical variants, this is indispensable. I’ve caught variant caller errors by eye more times than I can count: homopolymer artifacts, misaligned reads claiming a variant that isn’t really there, or a genuine variant buried in a region of low-quality mappings.
Real-world example: A sample calls a frameshift insertion in a cancer-relevant gene. You zoom to that region, load the BAM, and immediately see that all the “supporting” reads are from a single library preparation kit batch (visible by their read group tags and clip patterns). This flags the variant as technical artifact, not biological signal. This kind of forensic inspection is what IGV excels at.
2. Coverage and Depth Visualization
IGV plots read depth (coverage) automatically. You can see at a glance where coverage drops off, where there are unexpected peaks, and where targeted panels have achieved their design goals.
The bar chart at the top of the coverage track scales automatically with zoom level, and you can overlay multiple BAM files to compare coverage across samples. This is useful for QC: has the low-coverage region been sequenced enough? Does this region look like a copy number deletion?
3. Splice Junction Visualization
For RNA-seq data, IGV draws arcs connecting exon junctions directly on the reads. You can see which junctions are supported by many reads (solid arcs) and which are rare (faint arcs). This makes it obvious when a novel junction appears or when a known junction is completely absent.
This is particularly valuable for validating fusion calls or checking whether alternative splicing is real or an artifact of the calling method.
4. Indexing and Large File Handling
IGV can work with BAM and VCF files that are many gigabytes in size because it uses compressed indexing (.bai, .tbi files). You only load the region you’re looking at, not the whole file. This is elegant and fast, even over a network connection.
This matters for production analysis: you don’t need to extract and copy subsets of your alignment files to make them manageable for visual inspection.
5. Session Files for Reproducibility
IGV can save and load session files (.xml) that capture your current view: which tracks you have open, which region you’re zoomed to, color schemes, display settings. This is genuinely useful for collaborative work and for returning to a variant you were investigating weeks ago.
Where IGV Falls Short
1. Scripting and Automation Are Clunky
IGV has a batch script interface, but it’s painful. You write a text file listing commands in IGV’s own syntax, and IGV processes them headless. The interface is undocumented, non-intuitive, and slow for anything beyond a few dozen snapshots.
If you need to generate visualizations programmatically (e.g., create a PNG of 500 variants for a report), IGV’s batch system will make you want to write a Python script instead. And you often will.
This is a real limitation if your workflow is automation-heavy. Many teams end up using alternatives like pyGenomeTracks or the R package Gviz precisely because their APIs are programmable and IGV’s is not.
2. The UI Feels Dated
The IGV interface hasn’t had a major overhaul in years. Buttons are small, some features are buried in menus, and the overall aesthetic is 2010s MATLAB. This is purely cosmetic, but it matters for user experience. Newer tools feel snappier and more intuitive.
The web version is better, but the desktop app in particular feels like it’s from another era.
3. Limited Programmatic Access
If you want to extract data from IGV (coordinates, read information, coverage values at a specific position) programmatically, you’re out of luck. IGV is a viewer, not a library. The batch scripting can save images, but you can’t easily query the data programmatically.
For research workflows where you need to extract quantitative metrics (e.g., “how many reads support this variant?”), you’re better off writing Python code with pysam or using R packages. IGV is not a data extraction tool.
4. Large Cohort Visualization Is Not a Strength
If you have 100 samples and you want to see the same region across all of them, IGV can handle it, but it’s not elegant. You load 100 BAM files as separate tracks, and the UI becomes crowded and slow. Most production analysis platforms support cohort-level visualization better.
Similarly, if you want to visualize genome-scale patterns (copy number variation across a cohort, allele frequency heatmaps, recurrence of variants), IGV isn’t designed for this. You’ll turn to other tools.
5. No Native Support for Advanced Annotations
IGV can load GTF/GFF files, but it doesn’t do much with them beyond display. If you want to overlay variant effect predictions, conservation scores, or clinical significance annotations, you need to prepare those as separate tracks. This is more manual work than some alternatives require.
Comparison to Alternatives
Here’s a practical breakdown of IGV vs. the most common alternatives:
| Tool | Best For | Local/Web | Programmable | Learning Curve | Verdict |
|---|---|---|---|---|---|
| IGV | Spot-checking variants, visual inspection, read-level validation | Both | No (batch only) | Low | General-purpose lookup; first choice for most |
| UCSC Genome Browser | Quick web-based lookups, pre-loaded public datasets, basic annotation | Web-only | Moderate (batch API) | Low | Best for exploratory browsing of known genes; less useful for your own data |
| Ensembl Genome Browser | Gene annotation lookup, variation browser, population data | Web-only | Limited | Low | Good for annotation context; slow for large custom datasets |
| pyGenomeTracks | Programmatic visualization, publication-ready figures, complex multi-track layouts | Python API | Yes | High | Best if you need to automate variant report generation |
| Gviz (R/Bioconductor) | Bioinformatic pipelines, reproducible R-based workflows, integration with analysis | R package | Yes | High | Best choice if you’re already in R; pairs naturally with DESeq2, edgeR, etc. |
The nuance: These aren’t either/or choices. Most research groups use IGV for interactive exploration and another tool for automation or publication-grade figures.
When to Use UCSC Genome Browser Instead
UCSC is faster for quick web-based lookups of public genes if you don’t need to inspect your own data. It’s also built with pre-loaded annotation tracks (conservation, disease databases, regulatory elements), so if you’re validating a finding against public knowledge, UCSC is often a better starting point.
The downside: UCSC is optimized for humans looking at pre-indexed human data. If your organism isn’t human or your data isn’t in their databases, it’s less useful.
When to Use pyGenomeTracks or Gviz
If you’re generating variant reports and you have 100+ variants to visualize, writing a Python or R script is faster than clicking through IGV 100 times. Both tools produce publication-ready PNG/PDF figures directly.
pyGenomeTracks is particularly strong for multi-track layouts and coverage heatmaps. Gviz integrates seamlessly with other Bioconductor packages (like DESeq2), so if you’re already using those for differential expression or copy number analysis, Gviz feels natural.
Verdict
Yes, use IGV. It remains the best general-purpose genome browser for the question most bioinformaticians ask: “What does this look like in the actual reads?” For visual validation of variants, checking coverage, inspecting splice junctions, and spot-checking regions of interest, IGV has no real competition.
Use it for: Interactive visual inspection, variant validation, read-level forensics, collaboration (via remote URLs and session files), and any workflow where you’re looking up specific regions.
Skip IGV and use something else if:
- You need to automate visualization for 100+ variants (use pyGenomeTracks or Gviz)
- You’re doing genome-scale cohort analysis (use specialized cohort tools)
- You want a purely web-based experience with no installation (UCSC Genome Browser works for public data)
- You need to extract quantitative metrics programmatically (use pysam in Python or specialized R packages)
Next Steps
Start with the official IGV quick start guide. Download the desktop app and load a BAM file from one of your own analyses. Spend 10 minutes zooming around and inspecting some reads. You’ll immediately understand why it’s the standard.
If you’re building a production variant analysis pipeline and IGV’s lack of automation is a blocker, read the pyGenomeTracks documentation and evaluate whether it fits your workflow. If you’re working in R, consider whether Gviz integrates better with your downstream analysis.
And if you’re setting up a fresh bioinformatics environment, the tutorials on how to set up a bioinformatics environment with Conda and Mamba and how to run your first Nextflow pipeline both reference IGV as a QC step for the data coming out of your pipelines.