Genome and Protein Structure Annotation Tools Compared

Most variant review, genome annotation curation, and structure viewing runs on free, open-source software such as IGV, igv-reports, JBrowse, Apollo, Mol*, and open-source PyMOL, and the paid licenses in the field are Incentive PyMOL, from $99 a year for one academic user, and the commercial license for UCSF ChimeraX. Potato is a free, self-hosted alternative to Incentive PyMOL and ChimeraX for several experts marking residues on the same structures, and Potato runs manual variant review in igv.js with every call sent to two or more reviewers and agreement reported on the calls. Potato calls no variants, aligns no reads, predicts no structures, and edits no gene models.

A variant caller compares a sample's sequencing reads with a reference genome and lists the differences in a VCF file, one call per line (SNV calling). The aligned reads sit in a BAM or CRAM file, and an index beside each file lets a viewer read one region at a time. Manual review means a person looks at the reads under each call and decides whether the call is real. A standard operating procedure for somatic variant refinement gives reviewers four calls, Somatic, Germline, Ambiguous, and Fail, plus 19 tags for the read patterns behind a call (Barnell et al., 2019). Genome annotation marks genes and other features on a genome sequence, and biocuration is the work of experts checking and correcting such records by hand.

Protein structures come as PDB or mmCIF files from the Protein Data Bank. The mmCIF format is the large-molecule form of the Crystallographic Information File. AlphaFold predicts a structure from a sequence and scores each residue with a confidence called pLDDT, and the predicted aligned error (PAE) gives the expected error, in ångströms, in the position of one residue when the model is aligned on another residue. Life sciences in Potato lists Potato's life science tasks in one place, and Genome Loci and Protein Structures document every option of the two viewers.

Genomics tools worth comparing

Licenses come from each project's own pages, checked on 2026-10-29.

The IGV team's own description calls igv-reports a tool for "variant review and other genomic applications", and igv-reports reads the variant sites from a VCF, BED, MAF, or BEDPE file. The SV-plaudit README now recommends the separate PlotCritic and Samplot packages instead of the SV-plaudit module.

Protein structure tools worth comparing

ChimeraX's alphafold fetch command loads a model from AlphaFold DB by UniProt accession, and ChimeraX colors the model by pLDDT by default. PyMOL's own site states that most of PyMOL's source code is freely available under a permissive license and that license purchases fund the project.

Which tool for which task

The viewers appear where one person explores data or makes a figure. Potato appears where the same call or structure goes to several people and the study keeps each person's answer.

Where Potato fits after the analysis

Every tool on this page works on output that another program made. An aligner writes the BAM or CRAM file, a caller writes the VCF, a gene predictor writes the first gene models, and AlphaFold or an experiment produces the structure. IGV and igv-reports show reads and calls, Apollo edits genome annotations, and PyMOL, ChimeraX, and Mol* show structures.

igv.js 3.8.9 ships with Potato, and Potato's genome_locus display opens each item's locus in igv.js. The display reads an indexed FASTA reference and tracks in BAM, CRAM, VCF, BED, GFF3, GTF, bigBed, bigWig, bedGraph, or WIG format from the project's media folder, a slice at a time. Each track names one file for every item, such as a cohort VCF, or an item field. With an item field, each call brings the call's own tumor and normal BAM files. The protein_structure display shows an mmCIF, BinaryCIF, or PDB file in 3Dmol.js 2.5.5 by default, or in Mol* 5.12.0 with engine: molstar, and colors the cartoon by pLDDT when plddt: true is set. A viewer_selection scheme stores the residues an expert clicks, as chain, residue number, and residue name. Potato has no importer for VCF or structure files. A short script writes one line of the data file per call or per structure.

Free PyMOL and ChimeraX alternatives

Incentive PyMOL and the commercial license for ChimeraX are the two paid products in the tables above. Incentive PyMOL renders and animates structures for figures and movies, and the subscription adds Schrödinger's installers, support, and documentation. ChimeraX colors AlphaFold models by pLDDT, plots PAE, and shares one scene between several computers with the meeting command, and ChimeraX costs nothing for academic, government, nonprofit, or personal use.

Open-source PyMOL is free under a BSD-like license and is built from source without Schrödinger's installers or support. Mol* and 3Dmol.js are free, open-source viewers that run in a browser, and Mol* is the viewer on RCSB PDB, PDBe, and AlphaFold DB.

Potato covers the review step. Potato sends each structure to as many experts as the config sets, shows the structure in 3Dmol.js or Mol* with pLDDT colors and a PAE image beside the view, and stores each expert's residue selection separately. Potato does not render figures, make movies, measure distances, superpose structures, or compare the experts' residue selections, and what Potato does not do lists the other gaps.

For genomics, the main review tools are already free. IGV, igv.js, igv-reports, JBrowse 2, and Apollo are open source under the MIT or Apache license. Potato fits a variant review when each call needs two or more independent reviewers and a measure of how often the reviewers agree.

Several reviewers and agreement by tool

The tools share review among several people in different ways. Each row gives a tool's setup for several people on the same calls or structures and the agreement measure that the tool's documentation describes.

A dash means we found nothing for the cell in the tool's own documentation, checked on 2026-10-29. If a cell is wrong, tell us.

When four novice reviewers followed the Barnell et al. procedure, accuracy against expert calls rose from 77.4% to 94.1%, and the mean agreement score between reviewers rose from 80.7 to 93.4 points, with no significant change in review time (Barnell et al., 2019). To measure the same agreement for your own project, send every call, or a sample of calls, to a second reviewer. Potato's admin dashboard at /admin/iaa reports agreement for each question, and the reliability export writes Krippendorff's alpha with a 95% bootstrap interval to a CSV file and a Markdown table. With an adjudication block, a named adjudicator makes the final call at /adjudicate on each item the reviewers disagree on, and the adjudication export writes one final call per item to adjudicated.csv.

Potato computes no agreement on residue selections. To compare experts on a binding site, read each expert's residue list from the export and compute Jaccard overlap over chain and residue-number pairs for each structure.

Offline use and controlled-access data

IGV desktop, PyMOL, and ChimeraX run on the computer that stores the files. igv-reports embeds the data for each site in the HTML file. Sending the report therefore sends the embedded reads and calls. SV-plaudit stores the images in Amazon S3 and the scores in DynamoDB. The ClinGen VCI is a public web interface that curators register for.

Potato installs with pip on a laptop or a server, and reviewers on the same network work in a browser. With a local reference and local tracks, the genome page loads nothing from outside the Potato server, and a remote track or a built-in genome such as hg38 is accepted only with allow_remote: true. A structure URL, such as an AlphaFold DB file, loads only with allow_remote: true, and the reviewer's browser fetches the file. igv.js and 3Dmol.js ship with Potato. Mol* is about 5 MB and is installed with potato vendor fetch molstar. In Potato 2.13.1, potato vendor fetch installs Mol* and RDKit.js, and a config with engine: molstar fails validation until Mol* is installed. For a server with no route out, run the fetch on a connected machine with the same POTATO_VENDOR_DIR, copy the folder across, and check the copy with potato vendor verify. Air-Gapped Deployment lists everything else Potato serves locally.

File formats and exports

The table lists the files a review moves between and what Potato 2.13.1 does with each file.

Potato writes no VCF. To put the reviewers' calls back into a VCF, join the CSV export to the VCF by the item ID, such as pt01_chr1_1201. SV-plaudit writes curation scores straight into a VCF's INFO field.

Somatic variant refinement with two reviewers in Potato

Prepare the files first. The reference needs a .fai index (samtools faidx), each BAM needs a .bai index (samtools index), and the VCF needs bgzip compression and a .tbi index (tabix -p vcf). Each call is one line of the data file, with the locus and the patient's tumor and normal BAM files:

{"id": "pt01_chr1_1201", "locus": "chr1:1201", "note": "pt01, C>G at chr1:1,201", "tumor_bam": "reads/pt01_tumor.bam", "normal_bam": "reads/pt01_normal.bam"}

The config below shows the tumor and normal reads under the call, as the Barnell et al. procedure asks, and uses the procedure's four calls. num_annotators_per_item: 2 sends every call to two reviewers for agreement on every call. The tag list is eight of the procedure's 19 tags, and a study adds the rest the same way. The config is complete and passes Potato's validator:

annotation_task_name: Somatic variant refinement, two reviewers per call
task_dir: .
output_annotation_dir: annotation_output/
media_directory: media
data_files:
  - data/calls.jsonl
item_properties:
  id_key: id
  text_key: note
user_config:
  allow_all_users: true
  users: []
 
# Two reviewers per call, for agreement on every call
num_annotators_per_item: 2
 
instance_display:
  fields:
    - key: note
      type: text
      label: Call
    - key: locus
      type: genome_locus
      label: Locus
      display_options:
        reference:
          fasta: genome/ref.fa
          name: GRCh38
        flank: 60
        tracks:
          - name: Calls
            url: calls/somatic.vcf.gz
          - name: Tumor
            field: tumor_bam
            height: 260
          - name: Normal
            field: normal_bam
            height: 200
 
annotation_schemes:
  - annotation_type: radio
    name: call
    description: Call this variant with the four calls of the Barnell et al. SOP.
    labels: [Somatic, Germline, Ambiguous, Fail]
    sequential_key_binding: true
    label_requirement:
      required: true
 
  - annotation_type: multiselect
    name: tags
    description: Which tags from the SOP apply?
    humanize_labels: false
    labels:
      - Low Variant Frequency (LVF)
      - Directional (D)
      - End of reads (E)
      - Multiple Mismatches (MM)
      - Mononucleotide repeat (MN)
      - Low Mapping quality (LM)
      - Tumor in Normal (TN)
      - Ambiguous Other (AO)

igv.js treats chr1 and 1 as different sequences. Use the reference the reads were aligned to, with the same sequence names. Reviewers answer the call with the keys 1 to 4 while igv.js is on the page. Start the server with potato start config.yaml -p 8000. To settle disagreements, add this block to the config above and name the adjudicator:

adjudication:
  enabled: true
  adjudicator_users: [carol]

Once the review is done, export the agreement table and each reviewer's calls:

python -m potato.export -c config.yaml -f reliability -o export/
python -m potato.export -c config.yaml -f csv -o export/

The reliability export writes Krippendorff's alpha for the call question at the nominal level and for the tags question with MASI distance, each with a 95% bootstrap interval, the percent agreement, and the number of calls and reviewers. The CSV has one row per call and reviewer.

Reviewing predicted models with three experts in Potato

The config below sends every predicted model to three experts. Each expert clicks the residues where the model looks wrong and says whether the model is usable. plddt: true colors the cartoon by the pLDDT values that AlphaFold writes into the B-factor column, and pae_field names the item field with the path of a PAE image. The config is complete and passes Potato's validator:

annotation_task_name: Predicted model review, three experts per model
task_dir: .
output_annotation_dir: annotation_output/
media_directory: media
data_files:
  - data/models.jsonl
item_properties:
  id_key: id
  text_key: note
user_config:
  allow_all_users: true
  users: []
 
# Three experts review every model
num_annotators_per_item: 3
 
instance_display:
  fields:
    - key: note
      type: text
    - key: structure
      type: protein_structure
      label: Model
      display_options:
        engine: 3dmol
        plddt: true
        pae_field: pae
 
annotation_schemes:
  - annotation_type: viewer_selection
    name: problem_residues
    description: Click the residues where the model looks wrong.
    viewer_field: structure
    labels: [clash, wrong fold, should be disordered]
 
  - annotation_type: radio
    name: model_verdict
    description: Is this model usable for the study?
    labels: [Usable, Usable with the marked regions removed, Not usable]
    label_requirement:
      required: true

Each line of data/models.jsonl names a structure file and a PAE image inside the media folder, such as {"id": "model_1", "note": "...", "structure": "structures/model_1.cif", "pae": "structures/model_1_pae.png"}. Potato reads only the first model of a multi-model file. Give each model a file of the model's own. The usability question gets kappa and alpha on the admin dashboard, and the residue selections need the Jaccard comparison described above. To use Mol* instead, run potato vendor fetch molstar and set engine: molstar.

What Potato does not do for life sciences

• No variant calling or read alignment. Callers and aligners run first, and Potato shows the BAM, CRAM, and VCF files the callers and aligners write.
• No VCF import or export. A script writes one data line per call, and the reviewers' calls come back as CSV or JSONL keyed by item ID.
• No genome annotation editing. Apollo edits genome annotations, and Potato shows GFF3 and GTF files as read-only tracks.
• No ACMG/AMP classification. Curators apply the criteria in ClinGen VCI, and an expert panel approves the classification there.
• No structure prediction, figures, or measurements. Potato shows a structure and stores clicked residues, and PyMOL and ChimeraX render, measure, and superpose.
• No agreement on residue selections. Agreement covers the calls, the tags, and other questions with fixed choices.
• One model per structure file. Split NMR ensembles and prediction batches before loading.
• Needs a server. Someone installs Potato with pip and runs the server, on a laptop for one reviewer or on a shared machine for a team.

Checked against each project's own documentation and pricing pages in October 2026.

Frequently asked questions

How do I take IGV snapshots of many variants at once?

Write an IGV batch script that runs goto and then snapshot for each locus, and run the script from IGV's Tools menu to save one PNG or SVG image per locus in the folder that snapshotDirectory sets. igv-reports skips the images and writes one HTML file with a table of the variant sites and a live IGV view of each site. Potato opens each call live in igv.js and stores each reviewer's call. Potato suits a review in which two or more people judge every variant.

How can reviewers make the same calls in manual variant review?

Reviewers make more consistent calls when the reviewers follow a written procedure with fixed labels, such as the four calls and 19 tags of the Barnell et al. procedure for somatic variants. With that procedure, the mean agreement score of four novice reviewers rose from 80.7 to 93.4 points. Measure your own reviewers by sending a sample of calls to two reviewers and computing Cohen's kappa or Krippendorff's alpha on the calls. In Potato, num_annotators_per_item: 2 sends every call to two reviewers, the admin dashboard reports kappa and alpha, and an adjudicator makes the final call wherever the two reviewers disagree.

Is there a free alternative to PyMOL?

Yes, open-source PyMOL is free under a BSD-like license, and UCSF ChimeraX is free for academic, government, nonprofit, and personal use, with a paid license for commercial use. Mol* and 3Dmol.js are free, open-source viewers that run in a browser. Incentive PyMOL adds Schrödinger's installers and support for $99 a year for one academic user. Potato is free and self-hosted for the case where several experts mark residues on the same structures, and Potato does not render figures or movies.

Further reading

• Life sciences in Potato, for the life science tasks in one place
• Genome Loci and Protein Structures, for every option of the two viewers
• Inter-Annotator Agreement and Adjudication
• Export Formats and Air-Gapped Annotation
• Medical Image and Clinical Text Annotation Tools Compared and Image Annotation Tools Compared
• The agreement calculator, for kappa and alpha from a CSV of calls made in another tool

References

1. Barnell, E. K., Ronning, P., Campbell, K. M., Krysiak, K., Ainscough, B. J., Sheta, L. M., et al. (2019). Standard operating procedure for somatic variant refinement of sequencing data with paired tumor and normal samples. Genetics in Medicine, 21(4), 972-981. https://doi.org/10.1038/s41436-018-0278-z
2. Preston, C. G., Wright, M. W., Madhavrao, R., et al. (2022). ClinGen Variant Curation Interface, a variant classification platform for the application of evidence criteria from ACMG/AMP guidelines. Genome Medicine, 14, 6. https://doi.org/10.1186/s13073-021-01004-8