HLA Typing from Short Reads: Why the Most Polymorphic Region in the Genome Defeats Standard Alignment

Zetobit Bioinformatics Insight Series

Immunogenomics & Clinical Typing

HLA Typing from Short Reads: Why the Most Polymorphic Region in the Genome Defeats Standard Alignment

Typing HLA is not variant calling. It is choosing two alleles out of thousands whose sequences differ by less than the ambiguity of a single short read — against a reference database that is itself incomplete. That is why a pipeline that nails the rest of the genome can quietly return the wrong HLA type.

By Kanna Nandakumar, PhD · Zetobit

The human leukocyte antigen region on chromosome 6p21.3 is the part of the genome where standard sequencing intuition breaks down most completely. It is the most polymorphic region in the human genome, and the alleles it encodes govern transplant compatibility, autoimmune risk, and a set of drug hypersensitivity reactions consequential enough that HLA typing is a prerequisite for prescribing certain medications.¹ Getting the type right is not a research nicety; it is the difference between a matched and a rejected marrow graft, or between safely prescribing a drug and triggering a life-threatening reaction.

And yet the standard genomics workflow — align reads to GRCh38, call variants, read off genotypes — is close to useless here. The reason is structural, and it is worth understanding precisely, because it explains why HLA typing requires its own tools, its own reference, and its own quality metrics, and why even those have hard limits at short read lengths.

Typing is a selection problem, not a calling problem

For most of the genome, variant calling asks: at this position, does the sample differ from the reference, and how? The reference is a fixed backbone and variants are deviations from it. HLA inverts this. There is no single “reference allele” that meaningfully represents an HLA gene, because the gene exists in the population as hundreds to well over a thousand distinct allelic variants at a single locus, catalogued in a dedicated database — IMGT/HLA — rather than as positions on the linear genome.¹ Typing therefore is not “how does this sample deviate from the reference” but “which two of these thousands of known alleles did this person inherit.” It is a selection problem against a catalogue, and the catalogue entries differ from one another by a handful of bases.

This is why aligning HLA reads to GRCh38 produces a mess. The reference carries one arbitrary allele per HLA gene; reads from a sample carrying different alleles pile up mismatches, map ambiguously, or scatter, and the resulting “variants” do not translate cleanly into an allele name. The tools that work — OptiType, HLA-VBSeq, arcasHLA, xHLA and others — abandon the linear reference entirely and align instead to the IMGT/HLA allele database, then solve for the most likely pair of alleles.¹

The reads are too short to tell the alleles apart

Even with the right reference, the fundamental obstacle remains: HLA alleles are so similar to one another that a short read is frequently compatible with many of them. Typing from short reads is complicated by the high level of homology between HLA alleles and genes; the tools must resolve ambiguities from limited information, low read counts, and short read lengths.² A 150–250 bp read spanning a stretch that is identical across a dozen alleles cannot, by itself, distinguish them. The read is not wrong; it is simply consistent with too many answers.

The consequence shows up sharply as you push for higher resolution. HLA nomenclature is hierarchical: two-field (four-digit) resolution like A*02:01 names the specific protein, while lower resolution names only the allele group. An early demonstration of typing from RNA-seq found the method worked reasonably at low resolution but collapsed at the protein level: only roughly 32% of four-digit class I calls were correct, with the errors typically being highly similar alleles from the same group carrying slightly fewer supporting reads than the true allele.³ That failure mode — the winner and the runner-up separated by a few reads of noise — is the signature of a selection problem where the candidates are nearly indistinguishable.

Distinguishing alleles requires spanning their differences. When two alleles differ at only a few positions, a read landing on the shared stretch is compatible with both. Separating the two chromosomes into phased alleles requires a single read (or pair) that covers at least two differing sites at once — and in SNP-sparse loci, short reads rarely do.

The reference database itself is incomplete

A second, less obvious problem compounds the homology. The IMGT/HLA database, which defines the very alleles you are selecting among, does not contain full-length sequence for most of them. Class I entries typically have exon 2 and 3 sequences; class II entries typically have exon 2 — the “core exons” encoding the antigen-recognition domain — while sequence availability for other exons ranges from only about 5% to 36% of alleles.¹ Because many typing tools restrict themselves to these core exons, they inherit a real limitation: two alleles can share an identical peptide-binding sequence yet encode different protein types, and restricting to fewer exons increases the rate of ambiguous typing outright.² You are selecting from a catalogue that is itself partly blank, and the blank parts sometimes carry exactly the distinction you need.

Phasing: the reason short reads hit a wall

The deepest limit is phasing. An HLA gene has two copies — one per chromosome — and a correct type is a pair of complete, phased alleles, not an unordered bag of variants. Determining which variant sits on which chromosome requires connecting variants along a single molecule, and a short read can only connect variants it physically spans. Separating the two phases requires at least two SNVs within one read; in SNP-dense regions like the polymorphic exons this works, but in SNP-sparse regions phasing is impossible from short reads.⁴ Some HLA loci — notably HLA-DQA1, HLA-DPA1, and HLA-DPB1 — have such low SNP density that two variants rarely fall within one short read at all, making them especially difficult to phase.⁴ Paired-end reads extend the reach somewhat, but only as far as the fragment length allows, and only when at least two informative sites fall within that span.⁵

This is the structural reason long-read and long-range approaches keep winning at HLA: spanning a whole gene on a single molecule dissolves the phasing problem that no amount of short-read depth can solve. Depth helps you count; it does not help you connect distant variants that no single read covers.

Depth and phase are different currencies. Piling on more short reads raises confidence that a given variant is real, but it does nothing to establish which chromosome that variant sits on when no read spans two informative sites. Below a locus’s SNP density, coverage stops buying you resolution.

How the working tools actually solve it

Given all this, accurate HLA typers do not call variants at all. They treat typing as a probabilistic assignment against the allele database, borrowing the machinery of RNA-seq transcript quantification: reads that are compatible with multiple alleles are distributed among them, and the algorithm solves for the allele pair that best explains the observed reads. arcasHLA, for instance, uses a graph-based pseudo-alignment to assign reads to compatible HLA transcripts, quantifies allele abundance, and additionally uses population-specific allele frequencies as priors to break ties between otherwise-ambiguous alleles.² Others — xHLA refines its mapping at the amino-acid level to reach high accuracy;¹ HLA-VBSeq jointly optimizes read alignment and allele abundance by variational Bayesian inference to reach full eight-digit resolution — but the common thread is the same: model the ambiguity explicitly rather than pretend a read maps to one place.⁵

Using population frequency priors is worth pausing on, because it cuts both ways. It genuinely improves accuracy by breaking ties toward alleles that are common in the relevant population. But it also means the tool is likelier to return a common allele when the truth is rare — a benign bias in a research cohort, a potential hazard in a clinical case involving an under-represented population where the rare allele is the one that matters.

What to check before trusting an HLA call

If an HLA type arrives as part of a larger pipeline, a few questions separate a dependable result from a plausible-looking one:

• Was a dedicated HLA typer used, or did the type come from GRCh38 variant calls? Only the former aligns to the IMGT/HLA allele database; the latter is not reliable for allele assignment.¹
• At what resolution? Two-field (four-digit) calls are far harder than low-resolution ones, and short-read four-digit accuracy can be poor — treat a confident four-digit call as needing orthogonal confirmation, especially for clinical decisions.³
• Which locus? Low-SNP-density loci such as DQA1, DPA1, and DPB1 are the hardest to phase from short reads and warrant extra scrutiny.⁴
• Which IMGT/HLA version, and were non-core exons available? A type is only as current as the database release, and core-exon-only typing can miss distinctions that live in the exons the database doesn’t fully cover.¹​²
• Were frequency priors used? If so, a rare true allele may have been out-competed by a common one — a concern precisely when the patient is not from the population the prior reflects.²

HLA is a reminder that “we sequenced the genome” and “we know the HLA type” are not the same statement. The most immunologically important locus in the genome is also the one where a standard pipeline is least trustworthy — not because the sequencing failed, but because typing asks a different question than calling, against a catalogue that short reads are structurally unable to resolve to the last digit.

References

1. Xie C, Yeo ZX, Wong M, et al. Fast and accurate HLA typing from short-read next-generation sequence data with xHLA. Proc. Natl. Acad. Sci. USA. 2017;114(30):8059–8064. pnas.org/doi/10.1073/pnas.1707945114
2. Orenbuch R, Filip I, Comito D, et al. arcasHLA: high-resolution HLA typing from RNAseq. Bioinformatics. 2020;36(1):33–40. academic.oup.com/bioinformatics/article/36/1/33
3. Boegel S, Löwer M, Schäfer M, et al. HLA typing from RNA-Seq sequence reads. Genome Medicine. 2012;4:102. genomemedicine.biomedcentral.com/articles/10.1186/gm403
4. Ton KNT, Cree SL, Gronert-Sum SJ, et al. Reference-grade characterization of polymorphisms in full-length HLA class I and II genes with short-read and long-read sequencing. Frontiers in Immunology. 2018;9:2294. frontiersin.org/articles/10.3389/fimmu.2018.02294
5. Nariai N, Kojima K, Saito S, et al. HLA-VBSeq: accurate HLA typing at full resolution from whole-genome sequencing data. BMC Genomics. 2015;16(Suppl 2):S7. bmcgenomics.biomedcentral.com/articles/10.1186/1471-2164-16-S2-S7

© Zetobit LLC · Bioinformatics Insight Series zetobit.com