# ChimeraX vs. PyMOL for AlphaFold Visualization

ChimeraX understands AlphaFold output natively, including pLDDT coloring, the predicted aligned error matrix, and direct fetching from the AlphaFold Database, while PyMOL gives you finer control over ray-traced publication figures but treats AlphaFold models as ordinary coordinate files. The rule of thumb is simple. If your question is "how much do I trust this prediction, and which parts of it belong together," open it in ChimeraX. If your question is "how do I present this prediction in a figure or movie that looks exactly the way I want," open it in PyMOL. Most working structural biologists eventually install both, because the difference between ChimeraX and PyMOL for AlphaFold work is less about which one can load the model and more about which one answers the question you are actually asking.

This guide walks through what AlphaFold output actually contains, how to get predictions from the AlphaFold Database and AlphaFold Server, what each program does well on its own terms, a side-by-side comparison across the criteria that decide real choices, three worked scenarios, and the mistakes that trip up nearly everyone working with predicted structures for the first time.

## What You Are Actually Visualizing: AlphaFold Output Explained

Before choosing software, you need to know what an AlphaFold model is, because the choice between ChimeraX and PyMOL hinges almost entirely on how each program handles confidence data.

An AlphaFold prediction is not an experimentally determined structure. It is a computational model built by a neural network, shipped with two kinds of uncertainty information that you ignore at your peril.

### pLDDT, the per-residue confidence score

pLDDT stands for predicted local distance difference test. It is a per-residue score from 0 to 100 that estimates how accurately each residue's local geometry is predicted. The convention used across AlphaFold tools and databases divides scores into four bands:

| pLDDT band | Interpretation | Standard color |
|--|--|--|
| Above 90 | Very high confidence, backbone usually accurate to sub-angstrom level | Dark blue |
| 70 to 90 | Confident backbone, side chains more variable | Cyan (light blue) |
| 60 to 70 | Low confidence, backbone approximate | Yellow |
| Below 60 | Very low confidence, often intrinsically disordered | Orange |

The practical takeaway, established in the AlphaFold literature and repeated in the database documentation, is that high pLDDT means the local backbone placement is reliable. Low pLDDT frequently means the region is genuinely disordered in solution, not that the network failed. Flexible termini and long loops often show orange coloring because they genuinely have no single stable conformation.

Here is the detail that trips up newcomers. AlphaFold models store pLDDT in the B-factor column of the coordinate file. In a crystal structure, that same column stores atomic displacement parameters, which describe thermal motion. The number means something completely different depending on where the file came from, and both ChimeraX and PyMOL color by that column, so a naive "color by B-factor" gives you pLDDT coloring for one file type and thermal motion coloring for another.

### PAE, the inter-residue confidence metric

PAE stands for predicted aligned error. It is a matrix, one value for every ordered pair of residues, expressing the expected position error of one residue relative to another, measured in angstroms, after optimal superposition. Where pLDDT tells you whether a residue is well-structured locally, PAE tells you whether two residues or two domains are reliably positioned relative to each other.

Two domains can each have excellent pLDDT while the PAE between them is high, meaning the network is confident about each fold but not about how the two folds are arranged relative to one another. This is the single most common misreading of AlphaFold output. Conversely, two residues connected by a flexible linker can both have moderate pLDDT while their mutual PAE is low, meaning the domain moves as a rigid unit even though its position in space is uncertain. Only the PAE matrix reveals that relationship.

For multi-chain predictions from AlphaFold Server or ColabFold, the PAE matrix extends across chains, and the cross-chain blocks of that matrix are the primary evidence for or against a predicted interface. Interface confidence metrics in newer AlphaFold versions quantify this further, but reading the cross-chain PAE blocks visually remains the standard first check.

### File formats you will encounter

AlphaFold tools output coordinates in mmCIF format (also called PDBx/mmCIF), a modern text format that has largely replaced the older PDB format. The AlphaFold Database distributes single-chain models as compressed mmCIF files with names built from the UniProt accession, for example AF-P69905-F1-model_v4.cif. ColabFold and AlphaFold Server also return a JSON file containing the PAE matrix, and ColabFold returns per-residue and pairwise confidence scores in additional outputs. The older PDB format cannot always represent large models cleanly, so working with mmCIF is the default expectation in both programs, and both handle it.

## Getting Structures: The AlphaFold Database and AlphaFold Server

The AlphaFold Database, maintained by DeepMind in partnership with EMBL-EBI, hosts predicted structures for over 200 million protein sequences, essentially the catalogued proteomes of well-studied organisms. Every UniProt accession with a prediction can be downloaded or streamed directly into visualization software. These database entries are single-chain predictions of individual proteins.

AlphaFold Server is Google DeepMind's free web service for predicting complexes. Where the database gives you one protein chain at a time, AlphaFold Server accepts multiple protein chains together with [nucleic acids](/blog/guides/nucleic-acids), common ligands and ions, and chemical modifications, and returns a full complex prediction with cross-chain confidence data. Access is free for non-commercial use with a daily job quota, and the results arrive as a downloadable package containing the mmCIF model and the confidence outputs, ready to open in either visualization program.

The distinction matters for tool choice. If your entire workflow is "look up a UniProt ID, evaluate the monomer," both programs serve you, and ChimeraX makes the lookup a single command. If your workflow is "submit a complex to AlphaFold Server, then interrogate the interfaces," ChimeraX's native handling of cross-chain PAE gives it a decisive edge, because interrogating interfaces is exactly what its AlphaFold toolset was built for.

One more point on scope. The AlphaFold Database contains predicted protein structures, not experimentally observed complexes, and database models generally do not include bound ligands, cofactors, post-translational modifications, or membrane-mimicking environments unless the specific prediction pipeline included them. Treat every prediction as a hypothesis about the protein alone.

## ChimeraX for AlphaFold, On Its Own Terms

UCSF ChimeraX is the successor to Chimera, developed by the Resource for Biocomputing, Visualization, and Informatics at UC San Francisco. It is free for academic and non-profit use, with paid licensing for commercial settings, and it runs on Windows, macOS, and Linux. Its design philosophy is analysis-first: the developers built AlphaFold support directly into the program's command set rather than leaving it to user scripts.

### Direct fetching and automatic confidence coloring

The signature convenience is that you never need to visit a website or download a file to get a database model. In the ChimeraX command line:

```
open alphafold:P69905
```

That single command streams the human hemoglobin subunit alpha prediction from the AlphaFold Database, opens it, and colors it by pLDDT using the standard four-band palette automatically. You can substitute any UniProt accession. ChimeraX also recognizes confidence data in locally opened ColabFold and AlphaFold Server outputs and applies the same coloring.

For a quick alphafold tutorial workflow in ChimeraX, a first session with a new protein looks like this:

1. Run `open alphafold:YOUR-UNIPROT-ID` to fetch and color the model.
2. Open the sequence viewer with `sequence chain #1` to see the residue numbering and any UniProt feature annotations pulled in alongside the model.
3. Run `alphafold pae #1` to open the PAE matrix as an interactive heatmap panel beside the structure.
4. Click a block in the PAE heatmap to select the corresponding residues in the 3D view, which turns the matrix from a static picture into an exploration tool.
5. Use `interface` analysis commands or the `contacts` and `hbonds` commands to interrogate specific residue relationships.

Step 4 is the part with no equivalent in PyMOL. The PAE heatmap in ChimeraX is bidirectionally linked to the model, so visual inspection of the structure and inspection of the confidence matrix happen in the same interaction loop.

### Superposition and model-to-model comparison

A frequent task is comparing an AlphaFold prediction against an experimental structure of the same protein. ChimeraX ships a dedicated command for this:

```
alphafold match #1 to #2
```

This superposes the predicted model onto an experimental structure, reports the RMSD, and can color the model by per-residue deviation so you see exactly where prediction and experiment agree or diverge. The `mmcss` and general `matchmaker` commands handle broader cases, and `measure distance`, `measure angle`, and `distance` cover geometric interrogation.

### Handling maps, large assemblies, and movies

ChimeraX grew out of a lab deeply embedded in cryo-electron microscopy, so comparing an AlphaFold model against an experimental density map is a core workflow rather than an add-on. You open the map, open the model, run `fitmap` to fit the model into the density, and use `molmap` to convert any model into a simulated density at a chosen resolution for direct visual comparison. If you want to know whether an AlphaFold model is consistent with your own reconstruction, ChimeraX answers that question in minutes.

It also handles very large assemblies gracefully. Volume rendering, GPU-accelerated rendering, and efficient memory management let it open models with hundreds of thousands of residues or generate simulated maps of entire organelle-scale complexes without choking. Virtual reality support is built in for headsets, which some groups use for teaching and for exploring large predicted assemblies.

### Where ChimeraX is weaker

ChimeraX's rendering is clean and professional, but its ray tracing is not in PyMOL's league for stylized, magazine-cover-quality output. Its cartoon aesthetics and fine typographic control over labels take more effort to match what PyMOL produces almost by default. The scripting language is its own Python-flavored command system, which is powerful for automation but has a smaller community of shared example scripts than PyMOL's decades-deep ecosystem. And while the program is stable, users moving from PyMOL report a real learning curve in the first week because the command grammar, object model, and mouse behavior all differ.

## PyMOL for AlphaFold, On Its Own Terms

PyMOL, originally written by Warren DeLano and now developed and distributed by Schrödinger, is the most widely used molecular graphics program in structural biology publication figures. It is commercial software with paid academic and industrial licenses, but Schrödinger offers a free educational subscription for students and educators, and an open-source build circulates through community package repositories with most core features intact.

### Loading AlphaFold models and coloring by confidence

PyMOL treats an AlphaFold mmCIF as a standard structure file. The most common route is to download the model from the AlphaFold Database website and open it, or fetch experimental structures directly by PDB code:

```
fetch 6xyz, type=cif
load AF-P69905-F1-model_v4.cif
```

Because pLDDT lives in the B-factor column, coloring by confidence is a spectrum command away:

```
spectrum b, minimum=0, maximum=100
```

The default rainbow palette does not match the standard AlphaFold blue-cyan-yellow-orange scheme, so most users define the four canonical colors once and save them in a startup script:

```
set_color afblue,  [0,83,214]
set_color afcyan,  [0,159,227]
set_color afyellow,[255,210,63]
set_color aforange,[255,120,50]
```

Then a selection-based recoloring reproduces the AlphaFold Database look exactly. Once configured and saved in a `.pml` script or PyMOL's startup configuration, this becomes a one-command operation for every future session, which is the PyMOL way of working: invest in scripts, and every figure afterward takes one line.

### Publication figures, ray tracing, and fine control

PyMOL's reputation rests on its renderer. The `ray` command produces high-quality ray-traced output with shadows, depth cueing, ambient occlusion options, and outlines:

```
set ray_trace_mode, 1
ray 3000, 2250
png figure1.png, dpi=300
```

Cartoon representations in PyMOL offer granular control: per-residue cartoon width, custom color ramps along the chain, side-chain helpers, transparency, and a range of stylized looks (putty ribbons scaled by B-factor, cylindrical helices, nucleotide representations) that journals have visually standardized around. Label placement, 2D text annotations, arrow objects, and multi-panel composites are all mature. For a figure that must survive a journal's production process at exact dimensions and resolution, PyMOL remains the reference standard.

### Scripting and automation

PyMOL's Python API is its second superpower. Everything you can click, you can script, and decades of shared examples exist for every conceivable repetitive task: batch-rendering 200 AlphaFold models with identical cameras, measuring the same distance across an ensemble, generating turntable movies, exporting standardized contact maps. A typical automation loop:

```python
from pymol import cmd
for acc in ["P69905", "P02769", "P00698"]:
    cmd.load(f"AF-{acc}-F1-model_v4.cif", acc)
    cmd.spectrum("b", "afblue afcyan afyellow aforange", minimum=0, maximum=100)
    cmd.png(f"{acc}_figure", width=2400, height=1800, dpi=300)
```

If your AlphaFold work involves large batches, PyMOL's scripting depth pays off continuously.

### Where PyMOL is weaker

PyMOL has no built-in PAE viewer. To explore the predicted aligned error matrix interactively, you script it yourself in Python, render it externally with a plotting library, or lean on community plugins, none of which approach the tight model-to-matrix linkage ChimeraX provides out of the box. There is no one-command fetch from the AlphaFold Database comparable to ChimeraX's `open alphafold:` syntax. Interface analysis commands are more basic, and comparing models against cryoEM maps, while possible, is markedly less streamlined. Licensing is the other friction point: the polished full version requires a paid license in most professional settings, and the free open-source build lacks some of the advanced rendering and support features.

## Side-by-Side Comparison

The following table covers the criteria that actually decide which tool a lab adopts for AlphaFold work.

| Criterion | ChimeraX | PyMOL |
|--|--|--|
| Licensing and cost | Free for academic and non-profit use, paid for commercial | Paid license for full version, free educational subscription for students and educators, open-source build available |
| Fetching from AlphaFold Database | One command, `open alphafold:UniProtID`, automatic | Manual download or scripted fetch, no native one-command equivalent |
| Automatic pLDDT coloring | On by default with the standard four-band palette | Manual, via B-factor spectrum commands, one-time setup of custom colors |
| PAE matrix display | Built-in interactive heatmap, click-linked to 3D selection | Not built in, requires external scripting or plugins |
| Multi-chain complex analysis | Dedicated `interfaces`, `contacts`, cross-chain PAE tools | Basic contact analysis, more manual |
| Superposition against experimental structures | Dedicated `alphafold match` command with per-residue deviation coloring | General `align` and `super` commands, fully capable, less AlphaFold-specific |
| CryoEM map comparison | Core strength, `fitmap`, `molmap`, volume rendering | Possible, less streamlined |
| Publication-quality ray tracing | Good, not its forte | Best in class, the field's reference standard |
| Fine figure control (labels, styling) | Functional, more effort | Granular and mature |
| Scripting | ChimeraX Python command language, growing ecosystem | Mature Python API, decades of shared examples |
| Batch automation | Capable, smaller community script base | Excellent, extensive shared examples |
| Very large assemblies and volumes | Excellent, GPU-accelerated | Solid, but less optimized for extreme scale |
| Movies and VR | Built-in VR support, animation tools | Strong turntable and trajectory movie tooling |
| Learning curve | Moderate, unfamiliar grammar for PyMOL migrants | Gentle for molecular graphics beginners, deep for power users |
| Session sharing | `.cxs` sessions preserve full state | `.pse` sessions preserve full state, widely exchanged |

Read the table this way: every row where the criterion is "analyze or judge the prediction" favors ChimeraX, and every row where the criterion is "present or communicate the prediction" favors PyMOL. That asymmetry is the real difference between ChimeraX and PyMOL for AlphaFold visualization, and it explains why the honest answer to "which should I use" is usually a division of labor.

## Choosing by Task: Three Worked Scenarios

### Scenario 1: You submitted a complex to AlphaFold Server and need to know if the interface is real

![Flowchart from loading the AlphaFold Server model to reading cross-chain PAE blocks and deciding on follow-up.](/article-images/illustrations/chimerax-vs-pymol-alphafold-interface-check.webp)

You predicted a three-chain complex, two proteins and one RNA, and the AlphaFold Server package has landed in your downloads folder. The question is whether the predicted protein-RNA interface deserves experimental follow-up or whether the network invented it.

This is ChimeraX territory. Open the mmCIF model, and ChimeraX recognizes the complex confidence data. Run `alphafold pae #1` to open the matrix. Find the cross-chain blocks: a dark block where the protein rows meet the RNA columns indicates the relative positions of protein and RNA residues are confidently predicted, which is the quantitative signature of a well-supported interface. A pale, high-valued cross-chain block means the network placed the chains together but has little basis for the arrangement. While watching the matrix, use `interfaces #1` to enumerate inter-chain contacts, `contacts` to list specific residue pairs, and color the RNA-binding pocket by pLDDT to confirm the contacting residues themselves are confidently folded. In twenty minutes you have a defensible read on the interface, and you can export a session file so a collaborator sees exactly what you saw.

Attempting the same judgment in PyMOL is possible but painful. You would render the PAE matrix separately in Python, manually map matrix coordinates to residue numbers, and constantly switch between a plot window and PyMOL. The analysis exists, but the feedback loop is broken, and interface adjudication lives or dies on the feedback loop.

### Scenario 2: You need a journal figure of an AlphaFold model with a specific look

The paper is due, the figure shows an AlphaFold-predicted domain next to a crystal structure, and the journal wants a 300 dpi, 8 cm wide, stylized rendering with labeled secondary structure and consistent coloring across three panels.

This is PyMOL territory, almost without qualification. Load both structures, apply the custom AlphaFold palette to the prediction, choose cartoon settings, place labels with exact coordinates, set up a camera angle, and ray trace at the target resolution with outlines and depth cueing. Multi-panel consistency comes free from PyMOL's session and script structure: define the camera and styling once, apply to all three objects, render each. The visual polish that reviewers and editors expect from structural biology figures is PyMOL's home ground, and production artists at journals are used to receiving PyMOL output.

ChimeraX can produce a perfectly respectable version of this figure. It simply takes longer to hit the same aesthetic bar, particularly for outlines, custom label typography, and stylized color ramps.

### Scenario 3: You want to know whether an AlphaFold model fits your cryoEM density

You have a 3.2 angstrom cryoEM reconstruction and an AlphaFold prediction of the same protein. The model's global fold looks plausible. The question is whether it actually fits your map.

ChimeraX handles this end to end. Open the map, open the model, run `fitmap` to optimize the fit and report a correlation, generate a simulated map from the model with `molmap` at matching resolution, and compare the two volumes visually with isosurface and transparency settings. Per-region disagreements between the prediction and the density, often corresponding to low-pLDDT regions the network guessed freely, show up immediately. ChimeraX's parentage in the cryoEM community shows in every step of this workflow.

PyMOL can open the map and the model and display them together, and the recent versions handle volumes competently. But fitting optimization, simulated-map generation, and density-model deviation analysis are all more manual, and most cryoEM labs do not run this workflow in PyMOL.

## When to Use ChimeraX, Summarized

![Decision path asking whether the task is judging confidence or making a figure, leading to ChimeraX or PyMOL.](/article-images/illustrations/chimerax-vs-pymol-alphafold-tool-choice.webp)

Consolidating the scenarios, choose ChimeraX when the task is analytical. Reach for it when you need to evaluate prediction confidence interactively, adjudicate interfaces from AlphaFold Server complexes, superpose predictions on experimental structures with dedicated tooling, fit models into cryoEM maps, explore very large predicted assemblies, or give students and new lab members a zero-cost, zero-configuration entry point where fetching and confidence coloring happen automatically. Its `open alphafold:` command plus built-in PAE viewer combination means a newcomer goes from UniProt accession to a confidence-aware structural analysis in under five minutes, which no PyMOL configuration achieves.

Choose PyMOL when the task is communicative or heavily scripted. Reach for it when you need publication-grade ray-traced figures, precise per-element styling, standardized looks across many figures, batch automation over dozens or hundreds of models, or the largest ecosystem of shared scripts and community expertise in molecular graphics.

## Common Mistakes and Limitations

These are the errors that produce wrong conclusions, not just ugly figures.

**Treating low pLDDT as a prediction failure.** Orange regions with pLDDT below 60 frequently correspond to intrinsically disordered or flexibly linked segments that genuinely lack a single structure in solution. The network is often reporting biology correctly. Deleting these regions is a legitimate practice for clarity in figures and for downstream rigid-body work, but the deleted regions should be reported, and their existence can itself be biologically informative.

**Reading the PAE matrix as if it were a contact map.** PAE values describe expected relative position error, not contact likelihood. A dark block means low expected error between those residues under optimal alignment. Confusing the two leads to precisely inverted conclusions about whether domains are locked together.

**Confusing pLDDT with PAE when judging interfaces.** A two-chain model where both chains have beautiful pLDDT everywhere can still have a meaningless interface if the cross-chain PAE block is high. Interface adjudication is a PAE question first and a pLDDT question second.

**Copying pLDDT-colored screenshots without stating what the colors mean.** A blue-orange AlphaFold screenshot is meaningless to a reader who does not know the palette. State in the legend that coloring shows predicted confidence and define the bands.

**Trusting side-chain conformations in low-confidence regions.** Even in confident regions, side-chain rotamers are predictions, and packing details near binding sites should be checked against experimental data where any exists. Using `contacts` in ChimeraX or equivalent clash-checking to find steric absurdities in the model is a fast sanity check.

**Forgetting what is absent from the model.** AlphaFold Database models generally omit ligands, cofactors, ions, post-translational modifications, and membrane context. Building a mechanistic story about catalytic geometry around an active site that contains no ligand in the prediction is an error of omission that reviewers catch reliably.

**Overwriting the meaning of the B-factor column.** Any workflow that recolors by B-factor must know whether the current file is an AlphaFold model (column holds pLDDT) or an experimental structure (column holds displacement parameters). Scripts that process both file types silently produce false confidence maps on experimental structures.

**Using the older PDB format for large models.** Where mmCIF is available, prefer it. Format limitations on chain and atom identifiers cause avoidable loading problems in both programs.

One general limitation applies to everything above. AlphaFold output is prediction, and every judgment made in either program is a judgment about a model, not a measurement. Confidence metrics are calibrated but not infallible, membrane proteins and multi-state proteins remain harder cases, and any conclusion that matters should be checked against experimental evidence where it exists. Individual research cases need domain-expert judgment that no software choice substitutes for.

## Frequently Asked Questions

### Should I use ChimeraX or PyMOL for AlphaFold structures?

Use ChimeraX if you need to evaluate prediction confidence, read the PAE matrix, or adjudicate predicted interfaces, because both are built in. Use PyMOL if you need publication-quality figures or deep scripted automation, because its renderer and Python API are stronger. Many structural biologists use ChimeraX for analysis and PyMOL for presentation.

### Can PyMOL display the AlphaFold PAE matrix?

Not natively. PyMOL has no built-in PAE viewer, so you need to script the matrix externally in Python or use community plugins. ChimeraX displays the PAE matrix as an interactive heatmap linked to the 3D structure with a single command.

### Why does my AlphaFold model have orange regions, and should I delete them?

Orange marks residues with pLDDT below 60, meaning very low prediction confidence, which usually corresponds to genuinely disordered or flexible regions. You can hide or delete them for cleaner figures and rigid-body modeling, but report that you did, because disorder is often biologically real.

### How do I fetch an AlphaFold Database model directly into ChimeraX or PyMOL?

In ChimeraX, type `open alphafold:` followed by the UniProt accession, and the model loads colored by pLDDT automatically. In PyMOL, download the mmCIF file from the AlphaFold Database website and open it, or script the download, then color by the B-factor column to reproduce pLDDT coloring.

### Does the AlphaFold Database include ligands and chemical modifications?

Generally no. AlphaFold Database entries are single-chain protein predictions that typically omit ligands, cofactors, ions, and post-translational modifications. For complexes with nucleic acids or small molecules, use AlphaFold Server or a local prediction pipeline instead of the database.

### Is ChimeraX or PyMOL better for publication figures of AlphaFold models?

PyMOL is the stronger choice for publication figures. Its ray tracing, per-element styling, label control, and multi-panel consistency are the field's reference standard, and journals are accustomed to its output. ChimeraX produces respectable figures but requires more effort to reach the same polish.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Should I use ChimeraX or PyMOL for AlphaFold structures?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Use ChimeraX if you need to evaluate prediction confidence, read the PAE matrix, or adjudicate predicted interfaces, because both are built in. Use PyMOL if you need publication-quality figures or deep scripted automation, because its renderer and Python API are stronger. Many structural biologists use ChimeraX for analysis and PyMOL for presentation."
      }
    },
    {
      "@type": "Question",
      "name": "Can PyMOL display the AlphaFold PAE matrix?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Not natively. PyMOL has no built-in PAE viewer, so you need to script the matrix externally in Python or use community plugins. ChimeraX displays the PAE matrix as an interactive heatmap linked to the 3D structure with a single command."
      }
    },
    {
      "@type": "Question",
      "name": "Why does my AlphaFold model have orange regions, and should I delete them?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Orange marks residues with pLDDT below 60, meaning very low prediction confidence, which usually corresponds to genuinely disordered or flexible regions. You can hide or delete them for cleaner figures and rigid-body modeling, but report that you did, because disorder is often biologically real."
      }
    },
    {
      "@type": "Question",
      "name": "How do I fetch an AlphaFold Database model directly into ChimeraX or PyMOL?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "In ChimeraX, type open alphafold: followed by the UniProt accession, and the model loads colored by pLDDT automatically. In PyMOL, download the mmCIF file from the AlphaFold Database website and open it, or script the download, then color by the B-factor column to reproduce pLDDT coloring."
      }
    },
    {
      "@type": "Question",
      "name": "Does the AlphaFold Database include ligands and chemical modifications?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Generally no. AlphaFold Database entries are single-chain protein predictions that typically omit ligands, cofactors, ions, and post-translational modifications. For complexes with nucleic acids or small molecules, use AlphaFold Server or a local prediction pipeline instead of the database."
      }
    },
    {
      "@type": "Question",
      "name": "Is ChimeraX or PyMOL better for publication figures of AlphaFold models?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "PyMOL is the stronger choice for publication figures. Its ray tracing, per-element styling, label control, and multi-panel consistency are the field's reference standard, and journals are accustomed to its output. ChimeraX produces respectable figures but requires more effort to reach the same polish."
      }
    }
  ]
}
</script>