Lists the residues in contact across two selections, with distances and types.

This is the numeric counterpart to ligand_view and interface_view: instead of drawing the interactions, it reports them — which residue pairs touch, how close they get, and whether the contact is a salt bridge, hydrogen bond, hydrophobic packing or pi-stacking. Use it to answer "what holds this ligand in the pocket" or "which residues form this interface".

Classification uses heavy-atom distance criteria, since crystal structures usually have no hydrogens: salt bridge <= 4.0 A between formally charged sidechain tips, hydrogen bond <= 3.5 A between N/O pairs, hydrophobic <= 4.5 A between C/S pairs, pi-stacking <= 5.5 A between aromatic ring centroids (classified parallel or T-shaped by interplanar angle). A reported hydrogen bond is therefore a donor-acceptor pair with plausible geometry, not one verified against a hydrogen position.

Measures how large a protein-protein interface is, and which residues form it.

Reports buried surface area — the standard measure of how much of a complex is actually complex — by comparing each chain's solvent-accessible area free and bound. Also ranks the residues by how much surface each buries, and breaks the interface down by residue chemistry.

Interpretation: a per-side area under ~400 A^2 is usually a crystal packing contact rather than a biological interface, while over ~1000 A^2 indicates a substantial, likely specific association. These are guides from PDB-wide surveys, not a verdict — small biological interfaces exist.

For the interactions themselves — which pairs hydrogen bond, which form salt bridges — use contact_report on the same two chains.

Superposes two structures and colors the mobile one by per-residue shift.

An RMSD alone tells you that something moved, not where. This superposes mobile onto target, measures how far each residue's CA ended up from its counterpart, and colors the mobile structure blue (unchanged) through white to red (most shifted). The target is left as a grey reference cartoon.

Best on two states of the same protein — apo vs holo, open vs closed, a mutant against wild type. Residues are paired by chain and residue number, falling back to residue number alone when the two use different chain IDs.

Both structures have to be loaded first, and fetch_structure clears the session by default — so fetch the second one with replace=False or it will replace the first. If either entry is a multimer, compare single chains (create one object per chain): superposing one dimer onto another fits the assembly rather than the fold, which inflates the RMSD dramatically. 4AKE against 1AKE gives 18.5 A as deposited dimers and 2.1 A chain-to-chain.

Colors the structure by evolutionary conservation using Shannon entropy.

Runs a full pipeline: extracts the protein sequence from the loaded structure, submits it to an MMseqs2 server (ColabFold public API by default) for multiple sequence alignment, computes per-residue Shannon entropy, and maps the conservation scores onto the structure via the B-factor column and spectrum coloring.

Entropy scores are cached in memory by sequence, so changing the scale or re-running on the same protein does not require a repeat API call.

Magenta/blue = highly conserved (low entropy), white = moderate, cyan/green = highly variable (high entropy).

NOTE: The first call makes an external API call and may take 30 seconds to several minutes depending on the server and sequence length. Subsequent calls for the same sequence are instant.

Shows a graphical representation for a given selection.

Hides a graphical representation for a given selection.

Sets the color for a selection.

Creates (or replaces) a named selection for later reuse.

Permanently removes the atoms matching the selection. This deletes atoms; it does not just hide them. To hide instead, use :func:hide.

Measures the distance between two selections and returns it in Angstrom.

Also draws the measurement in the viewport as a named distance object. With multi-atom selections PyMOL reports the average over the pairs it found within its default cutoff.

Measures solvent-accessible surface area, in square Angstrom.

Reports the SASA of selection in the context of the object it belongs to — so a chain measured inside a complex is already partly occluded by its partner. To get the free (unbound) area, copy the chain to its own object first with create, or use interface_report, which does the bound/free bookkeeping for you.

Accuracy depends on PyMOL's dot_solvent (0 = molecular surface, 1 = solvent-accessible) and dot_density settings.

Measures RMSD between two selections without moving anything.

Use this when the structures are already superposed, or when you want to know how far apart they are as currently positioned. Compare with align and super, which move the mobile structure to minimise RMSD before reporting it, and with superposition_view, which shows where the difference is rather than summarising it as one number.

Requires the two selections to have matching atom counts.

Counts the atoms matching a selection.

Handy for checking a selection expression does what you think before building a scene on top of it — an empty count means the expression is wrong, which is otherwise invisible until the picture comes out blank.

Executes a raw PyMOL command string (PyMOL CLI syntax). PREFER the dedicated tools when one exists — show, color, select, distance, ligand_view, interface_view, etc. They have better defaults, do compound setup in one call, and produce cleaner results. Reach for this tool only when no other tool covers what you need (e.g. set ray_shadow, 0, bg_color grey20, multi-statement scripts). It takes PyMOL's command language, as typed at the PyMOL prompt. That language includes Python: a line starting with / and a python ... python end block run as Python inside PyMOL, with full access to the machine, so treat a command from untrusted text (a file, a web page) accordingly.

Returns once the command has finished, with what PyMOL printed (get_view, iterate output, ...). If PyMOL rejects a line — a bad selection, a typo, a Python error — the result is an error naming that line, in PyMOL's words; warnings from lines that still ran are listed. Put each command on its own line: alter, iterate and label take the rest of the line literally, so ; does not start a new command after them.

Shows one representation while hiding all others for the specified selection

Sets a PyMOL setting to a specified value.

Settings live at a level — global, object, object-state, atom or bond — and PyMOL ignores a value stored below its setting's level. cartoon_tube_radius on a residue range is stored per atom and never drawn; ray_shadow on an object is never read. PyMOL only warns about that, so this reports it as an error, with what to do instead.

Sets the cartoon type for the specified selection

Colors selection in a spectrum

Adds labels to atoms in the selection

Measures the angle between three selections and returns it in degrees.

Also draws the measurement as a named angle object.

Measures the dihedral (torsion) angle between four selections, in degrees.

Also draws the measurement as a named dihedral object. Useful for backbone phi/psi angles and ligand torsions.

Centers the view on a selection

Orients the view to align with principal axes of the selection

Zooms the view on a selection

Resets the view, optionally resetting an object's matrix

Rotates the camera around an axis

Moves the camera along an axis

Adjusts the clipping planes

Saves data to a file

Saves a PNG image

Clears the current selection

Creates a new object from a selection

Extracts a selection to a new object

Deletes objects or selections

Aligns one selection to another

Superimposes one selection onto another

Fits all states within an object

Calculates RMSD between states within an object

Alters atomic properties in a selection

Alters atomic coordinates in a state

Adds hydrogens to a selection

Fills open valences on the currently picked atom with hydrogens.

Takes no selection: cmd.h_fill operates on PyMOL's editor pick, so it needs an atom picked in the GUI and cannot be aimed from here. Passing it a selection used to land the string in its quiet argument and fail with an integer conversion error. For adding hydrogens to a selection over the bridge, use h_add.

Creates a bond between two atoms

Removes a bond between two atoms

Regenerates all displayed geometry

Refreshes the display

Colors by chain (Color By Chain)

Colors by atom, white carbons (Color By Atom, White)

Colors by atom, green carbons (Color By Atom, Green)

Colors by atom, cyan carbons (Color By Atom, Cyan)

Colors by atom, magenta carbons (Color By Atom, Magenta)

Colors by atom, yellow carbons (Color By Atom, Yellow)

Colors by atom, salmon carbons (Color By Atom, Salmon)

Colors by atom, slate carbons (Color By Atom, slateBLue)

Colors by atom, orange carbons (Color By Atom, Orange)

Colors by atom, purple carbons (Color By Atom, Purple)

Colors by atom, pink carbons (Color By Atom, pinK)

Colors chains in rainbow gradient (CHAINs in rainBOW)

Colors residues in rainbow from N to C terminus

Colors by secondary structure

Colors atoms by their element

Colors secondary structure elements

Displays atoms as smooth spheres

Creates a mesh isosurface

Creates a solid isosurface

Activates sculpting mode for an object

Deactivates sculpting mode for an object

Performs sculpting iterations

Manages scenes for later recall

Sets the order of scenes

Defines a sequence of states for movie playback

Starts playing the movie

Stops the movie

Sets or queries the current frame

Advances one frame

Goes back one frame

Toggles a rocking animation

Performs ray-tracing

Uses OpenGL renderer (faster but lower quality)

Saves a series of PNG images for movie frames

Generates symmetry-related copies

Sets symmetry parameters for an object

Creates a peptide chain from a sequence

Loads a molecular fragment

Toggles fullscreen mode

Sets the viewport size

Changes the current directory

Prints the current directory

Lists files in the current directory

Executes a system command

Shows help for a command

Chunky β-arrow ribbons plus a continuous backbone "spine", tuned for rigid, gap-free 3D printing.

Configures the look developed for FDM printing: thick β-strand arrows and a fat helix on the main object with loop cartoon hidden, plus a separate <obj>_spine object showing PyMOL's cartoon tube (which ignores secondary structure) running unbroken through the whole backbone. The spine threads through the strand bodies, so when the two objects are exported together the voxel step fuses them into one watertight solid with no strand→loop discontinuity. The spine also acts as internal rebar, reinforcing the thin junctions for print rigidity.

The style is set on the object and its spine only; other objects and PyMOL's global settings are left alone. The spine is carried through residues with no CA atom, such as GFP's chromophore, without renaming anything.

PyMOL draws a strand √2 times the strand_width and strand_thickness settings, so the defaults (2.8, 2.0) give strands about 4.0 x 2.8 Å, and a β-barrel's wall closes up. To see into a barrel, use strand_width=2.0, strand_thickness=1.0, spine_in_strands=False. Measured on GFP (2b3p): the see-through share of the barrel wall goes from 8% to 29%; thinner strands alone leave 399 ų of spine bulging out of them, which spine_in_strands=False takes to 1 ų; and it still exports as one solid (unbridged at the chromophore, it split 69:31).

After calling this, export the fused solid with::

print_export(obj_name="<obj>",
             groups="<obj>=(<obj> or <obj>_spine)",
             representation="cartoon",
             method="voxel", voxel_pitch=0.2)

Exports a structure as watertight STL files ready for multi-colour 3D printing.

Each colour group becomes one STL file. PyMOL's exporters write the whole visible scene, so each group is isolated on its own before export, then rebuilt into a watertight solid. Every STL is written in PyMOL model coordinates (Å, the numbers get_coords reports) whatever the camera view, so groups from one call, or from separate calls, line up; the camera is left as it was. A slicer can load them as aligned multi-material parts (e.g. add the second STL as a "part" of the first in Bambu Studio).

representation="displayed" prints what PyMOL shows, sticks and spheres included; "cartoon" keeps to cartoon and surface triangles and names what it left out. A group keeps every separate piece (two chains that do not touch print as two pieces) unless bodies="largest". The voxel method's growth of about 0.62 voxel per surface is undone unless undo_voxel_growth=False, but gaps narrower than about 2.5 voxels fuse while voxelising and cannot be reopened: a clearance needs voxel_pitch <= gap / 2.5.

STL has no units and slicers read it as millimetres, so mm_per_angstrom sets the print size. The result gives each part's size in mm and warns about any part small enough for a slicer to take for inches and enlarge 25.4x.

Requires the optional print extra (trimesh, pymeshlab, manifold3d); see the install hint returned if the libraries are missing.

Renders the current scene and returns the image, so you can see it.

Use this instead of calling ray and png separately — those leave you holding a filename you cannot look at. Call this after setting up a view to check what it actually looks like, and iterate.

Every render is ray-traced, which takes seconds to minutes on a large assembly. ray_trace=False is accepted but ignored: PyMOL's fast unshaded frame grab needs its GUI thread, which this plugin does not run on, so that path wrote blank images. Render smaller to render faster.

Renders a full 360° rotation as a numbered PNG sequence.

Spins the camera around the vertical axis in equal steps and writes one frame per step, ready to assemble into a GIF or MP4 (e.g. ffmpeg -i turntable_0000.png out.mp4).

Every frame is ray-traced, which is slow — 36 frames of a large assembly can take an hour, so start with few frames and a small width/height. The unshaded OpenGL renderer would be far faster but does not work over this bridge (it needs PyMOL's GUI thread), and silently produced blank frames until this was found.

Fetches a protein structure from the PDB, or a predicted model from AlphaFold DB.

By default, it attempts to fetch the first biological assembly (multimer), and removes any unrelated chains/states that are not part of the primary multimer.

A UniProt accession or an AF- prefixed identifier routes to AlphaFold DB instead and is coloured by pLDDT confidence — see :func:fetch_alphafold.

Loads a structure from a local file path and applies the BFS multimer heuristic.

Fetches a predicted structure from AlphaFold DB by UniProt accession.

These are predictions, not experimental structures, so the model is coloured by pLDDT confidence rather than the usual style — dark blue is reliable, orange is essentially unmodelled. Read the orange and yellow regions as "probably disordered or wrong", not as flexible loops.

Note that pLDDT rides in the B-factor column, so bfactor_view and putty_view will mis-colour these models (they assume low = rigid, which is backwards for confidence). Use plddt_view instead.

Summarises what a loaded structure actually is, in one call.

Answers the question you ask before any analysis: what protein is this, how was it determined, at what resolution, what is in the file. Combines what PyMOL knows (chains, residue and atom counts, ligands, symmetry) with entry metadata from the RCSB (title, method, resolution, release date, source organism).

Metadata lookup is best-effort — it is skipped silently if the object is not named after a PDB entry, or the API is unreachable.

Returns the amino-acid sequence of a loaded structure, in FASTA.

Also reports how the sequence positions line up with the residue numbers in the file, and where the chain is broken. Both matter: PDB numbering rarely starts at 1, so "residue 50" in a paper and position 50 in the sequence are usually different residues — and unmodelled loops leave gaps in the structure that the sequence alone does not reveal.

Reads per-atom properties, which nothing else in the tool set can reach.

Object-level facts come back through structure_info and list_chains, and per-residue values through get_sequence or the view presets. But properties that live on individual atoms — occupancy, alternate conformations, per-atom B-factor, formal charge — have no other route: the PyMOL call that exposes them returns an object that cannot cross the bridge.

Use it to check what you are actually looking at: partial occupancy where a sidechain has two conformations, per-atom pLDDT inside a predicted model, or which atoms carry a formal charge before reasoning about electrostatics.

properties is evaluated by PyMOL once per atom, so it accepts any expression valid in iterate — the names above are the useful subset.

Saves the entire PyMOL session to a .pse file.

A session captures everything — every object, selection, representation, colour, scene and the camera — so the work can be reopened exactly as it was. Use this before experimenting with a scene you would not want to rebuild, and to hand a finished figure to a colleague.

Unlike save, which writes bare coordinates, this preserves the whole visual state.

Restores a PyMOL session from a .pse file.

By default this replaces everything currently loaded, exactly as opening the file in PyMOL would. Set merge=True to add its objects to the current session instead, which is how you get two saved scenes side by side — though note that objects with the same name will collide.

Lists all loaded PyMOL objects.

Call this when you don't know what's currently in the session — for example before composing a selection or running a view tool that needs an obj_name.

Lists the chain IDs present in an object (or in all objects).

Useful before calling :func:interface_view, :func:conservation_view or any tool that needs a specific chain ID.

Lists the small-molecule (organic) ligand residue names in an object.

Call this before :func:ligand_view, :func:pocket_view, or :func:pharmacophore_view when you don't already know the ligand's residue name (three characters, or five for newer CCD codes).

Shows a binding-site view focused on a ligand.

Protein rendered as a semi-transparent cartoon. Pocket residues (within 5Å of the ligand) shown as sticks with element coloring and lightblue carbons. Ligand shown as thick sticks with yellow carbons. H-bonds drawn as yellow dashes. Pocket residues labeled. View zooms to the ligand.

Colors the structure by crystallographic B-factor (temperature factor).

Blue = rigid/ordered (low B), white = intermediate, red = flexible/disordered (high B). Useful for identifying dynamic loops, disordered termini, and rigid structural cores. Shown as cartoon on black background.

Colors an AlphaFold model by pLDDT confidence, using the official palette.

Dark blue = very high (>90), light blue = confident (70-90), yellow = low (50-70), orange = very low (<50). Regions below 70 are usually intrinsically disordered or simply unreliable — read them as "the model does not know", not as a flexible loop.

AlphaFold stores pLDDT in the B-factor column, which is why bfactor_view and putty_view get these models backwards: they assume low = rigid, whereas low pLDDT = low confidence. Use this instead for predicted models.

Highlights the protein-protein binding interface between two chains.

Chain A shown in marine blue, chain B in salmon. Interface residues (within 4Å of the partner chain) shown as a solid surface patch with sticks. H-bonds across the interface drawn as yellow dashes.

Visualizes protein flexibility using a putty (tube-width) representation.

The cartoon tube radius scales linearly with crystallographic B-factor: thin/blue = rigid/ordered regions, thick/red = flexible/disordered regions. A 70%-transparent surface is shown, also colored by B-factor. Organic ligands are shown as sticks with yellow carbons. Black background.

Colors the molecular surface by amino acid hydrophobicity.

Orange = hydrophobic (ILE, VAL, LEU, PHE, MET, ALA, TRP, PRO), white = polar (SER, THR, CYS, TYR, ASN, GLN, GLY), sky blue = positively charged (ARG, LYS, HIS), salmon = negatively charged (ASP, GLU). A white cartoon is shown beneath a semi-transparent surface. Organic ligands shown as sticks with yellow carbons.

Colors the molecular surface by approximate residue-based electrostatics.

Surface is colored red→white→blue via a B-factor spectrum. A white cartoon is shown beneath a semi-transparent surface. Organic ligands shown as sticks with yellow carbons.

For a more accurate Poisson-Boltzmann electrostatic surface, use poisson_boltzmann_view (requires APBS and PDB2PQR to be installed).

Colors the molecular surface by true Poisson-Boltzmann electrostatic potential.

Runs PDB2PQR (AMBER force field, pH 7.0) then APBS to compute the full electrostatic potential map. Surface is colored red→white→blue over the range ±20 kT/e. A white cartoon is shown beneath a semi-transparent surface. Organic ligands shown as sticks with yellow carbons.

Requires APBS and PDB2PQR to be installed on the system: brew install brewsci/bio/apbs pip install pdb2pqr

Highlights structural cross-links: disulfide bonds, metals, and their coordination.

Protein backbone shown as a thin grey cartoon. Cysteine side chains (CA→CB→SG) shown as yellow sticks, labeled by residue. Disulfide bonds drawn as yellow dashes. Metal ions shown as orange spheres. Metal coordination bonds drawn as dashed lines to nearby protein atoms. Black background.

Visualizes the binding pocket cavity around a ligand as a colored surface.

The pocket (all residues within 5 Å of the ligand) is shown as a semi-transparent surface colored by chemical character: orange=hydrophobic, white=polar, skyblue=positive, salmon=negative. Pocket residue sidechains are shown as sticks. The ligand is shown as yellow sticks. H-bonds between the ligand and pocket are drawn as cyan dashes. The protein backbone is shown as a thin grey cartoon for context.

Colors a ligand by pharmacophore feature type.

The ligand is shown as sticks color-coded by pharmacophore property: violet=ring/aromatic carbon, yellow=aliphatic carbon, skyblue=nitrogen (H-bond donor/acceptor), salmon=oxygen (H-bond acceptor), gold=sulfur, palegreen=halogen (F/Cl/Br/I). H-bonds to protein are shown as cyan dashes. Interacting residue sidechains are shown as element-colored sticks with CA labels. The pocket is shown as a semi-transparent grey surface for cavity context. The protein backbone is shown as a thin grey cartoon.

Highlights mutated residues on the protein structure.

Given a comma-separated list of mutations in standard notation (e.g. "A123G,V45L,T200S"), the mutated residues are shown as magenta sticks and labeled. Nearby residues (within 4 Å) are shown as thin grey sticks for packing context. The protein backbone is shown as a grey cartoon. Organic ligands are shown as yellow sticks.

Mutation format: <wildtype_aa><mutant_aa>, e.g. "A123G" (Ala→Gly at position 123). Chain can optionally be prefixed: "A:A123G".

Configures PyMOL for a crisp, cel-shaded illustrative look ("Textbook Illustration").

This view transforms the structure into a bold, 2D illustrative style with sharp black outlines, ideal for presentations or textbook-style diagrams. It hides the interior complexities, showing a solid white cartoon and surface with heavy black edge contours. Ligands are styled similarly as opaque white sticks with outlines.

Configures PyMOL for a depth-cued, cinematic look with dramatic lighting.

This view emphasizes volume and scale using deep shadows, fog, and depth-cueing. The core of the structure emerges from a dark background, making massive complexes (like ribosomes or viral capsids) look dramatic and imposing. Protein uses standard coloring but with altered material properties.

Renders the structure as an artistic, abstract pointillist/starfield cloud.

The continuous surface is replaced by thousands of individual dots representing the solvent-accessible surface, resembling a galaxy or pointillist painting. The protein backbone is hidden to emphasize the scattered volume. Ligands are shown as bright yellow spheres (stars) embedded in the cloud.

Colour and scale a structure by per-atom crystallographic occupancy (q).

Alternates at q<1 are visually de-emphasised in proportion, so a half-occupied conformer looks half-there instead of looking like a confident model.

This is occupancy in the crystallographic sense — the fraction of unit cells in which an atom sits at this position. It is NOT the fraction of imaged particles containing a subunit; a model can be q=1.0 everywhere while the subunit is present in half the particles. Both are true and they are different questions, so this tool never reports the other sense.

Show every altloc group at once, one colour per group, occupancies labelled.

A multiconformer model says "at this site, these discrete alternatives, in these proportions". PyMOL shows one of them by default, which quietly turns a statement about heterogeneity into a single structure.

Colour and thicken a multi-state object by how much its states disagree.

Per-residue RMS deviation across states, pushed into the B-factor column and spectrum-coloured blue (rigid) to red (variable).

Spread is a description of how much the deposited members differ. It is NOT a calibrated uncertainty and NOT an error bar: the number of members and the refinement protocol both shape it, so a wider tube means these models disagree more, not that the true position is less well determined.

Interpolate between states, refusing when interpolation is ill-posed.

The value here is the refusal, not the interpolation — PyMOL morphs natively. A morph is only meaningful when every state shares a topology, so that atom i in state 1 is the same atom as atom i in state 2. That holds for a deformation-model ensemble (3DFlex, DynaMight). It does not hold for volumes reconstructed and modelled independently, and a morph across those animates a correspondence nobody established.

Note that cmd.morph is Incentive-only. On open-source PyMOL the topology check still runs and reports; only the interpolation is unavailable.

Colour a model by per-residue Q-score parsed from its wwPDB validation report.

No network, no map, and no computation — Q-scores are already published, and this reads the numbers rather than re-deriving them.

Two things to expect from real data: entries deposited before the September 2023 validation rollout carry no Q-scores at all, which is the common case for older EM structures; and real Q-scores go negative, so the published 0–1 framing is the intended range and not the observed one.

Restore the B-factors a Wiggles view overwrote.

occupancy_view, ensemble_spread_view and qscore_view all push their values into the B-factor column so PyMOL can spectrum-colour by them. The originals are stashed first; this puts them back in one pass.

Report an MRC/CCP4 map's geometry, above all its voxel size.

Reads only the 1024-byte header — the map data is never loaded, PyMOL is never touched, and nothing goes over the network.

Voxel size is not stored in the header, it is derived, and the derivation has a trap: it is cella/m (the grid sampling), not cella/n (the stored extent). Those differ on any boxed or cropped map, and dividing by n gives a wrong answer of the right order of magnitude. The nominal value is only expected to be accurate to ±5–15% in the first place, which at 1.2 Å is a systematic stretch of every distance in the model. Anisotropy, cropping and axis permutation are all flagged loudly.

Load a volume into PyMOL, recording where it came from and reporting its geometry.

The header is parsed before PyMOL is touched, so a malformed file fails without leaving a half-loaded object in the session, and the load is confirmed rather than assumed.

Provenance defaults to unknown and is never guessed. A measured reconstruction, a sharpened map, a network-enhanced map and a decoder output all render identically once they are an isosurface, so defaulting to "measured" would quietly assert that somebody observed a generated volume. The report shows what the file says about itself — MRC labels, filename tokens — so the caller can declare it.

Draw an isomesh around a selection, stating the contour level in both units.

PyMOL normalises MRC/CCP4 maps on load, so an isomesh level is in sigma. EMDB's author-recommended contour is an absolute map value. They are not interchangeable and the difference is not subtle: EMD-30913 publishes 0.05, which is 3.16 sigma — used directly as a sigma level it contours noise.

So the level is reported in sigma AND absolute units every time, an absolute level is converted before it reaches PyMOL, and EMDB depositions get a pointer to their published contour with the units named. Requires the map to have been loaded through load_map, because the conversion needs the header's mean and RMS.

Colour a map's isosurface by a local-resolution volume instead of by chain.

A single global resolution number misrepresents almost every map: a rigid core at 2.5 Å and a flexible periphery at 5 Å live in the same volume, and one isosurface invites the reader to believe all of it is equally real.

Two things make this harder than it looks, and both are handled. The volumes must share a voxel grid — colouring one map by another samples it at the first map's coordinates, so a mismatch in extent, spacing, origin or axis order draws colour from the wrong place and renders smooth, plausible and wrong. This tool refuses and names what differs. And PyMOL normalises maps on load, so ramp breakpoints given in Ångström must be converted to sigma against the RESOLUTION map's own header — a different sigma scale from the contour level, which comes from the density map's. Every breakpoint is reported in both units.

Local resolution is an estimate. Estimators disagree with each other on the same map, and the value at a voxel depends on the window and the mask as much as on the data.

Load a cryo-EM heterogeneity job's volumes in trajectory order.

Every method in this space writes the same thing: a directory of maps plus a table of latent coordinates. This reads them in trajectory order — naturally, so frame 10 does not sort between 1 and 2 and silently reorder the motion.

The generating method is identified from documented on-disk markers and is never guessed. A directory that matches nothing loads its volumes fine and stays unidentified, which makes latent views refuse to render: an unlabelled latent plot is what SPEC invariant I2 forbids, because each method's caveat is different and they are not interchangeable. Pass method= if you know.

Provenance defaults to "generated" rather than "unknown" — nothing observed a decoder's output — and the report says it declared that and on what evidence.

Step through an ensemble's conformations as a contoured trajectory.

Refuses when the generating method was never identified. That is SPEC invariant I2 working, not a failure: cryoDRGN's latent density can bear no relation to the truth while 3DVA's frames are linear interpolations no particle occupied, and rendering both the same way asserts something for one that holds only for the other.

The contour is held at a constant ABSOLUTE value and converted to each frame's own sigma. PyMOL normalises every map independently on load, so a fixed sigma level would contour each frame at its own scale and flatten away the density change the traversal exists to show.

No latent scatter and no density estimate are drawn, deliberately. In a 41-submission blind challenge most methods missed a genuinely present middle state, so an empty region of latent space is a region of unknown occupancy — never evidence that a conformation does not occur.

Colour and arrow a model by how far each residue moved between two states.

This is the well-supported tool in the tier. A 41-submission blind challenge found the molecular motions these methods recover resemble both each other and the ground truth; it was relative populations that fell apart. So the arrows mean: density moved this way. They do not mean: this fraction of particles moved this way, and no population can be read out of them.

Refuses when the two states differ in atom count — atoms cannot be paired across them, so a displacement field would be meaningless rather than approximate.

Where a method estimates deformation on independent half-sets, pass that table and the arrows are coloured by the disagreement. Without it every arrow is drawn with identical confidence and they do not have identical confidence, which the report says rather than leaving the picture to imply otherwise.

Colour parts of a structure by the fraction of particles containing them.

This is occupancy in SENSE 2 — compositional. A ligand at 40% here means 40% of imaged complexes had it bound. It is not the per-atom crystallographic occupancy q, and it is never derived from q: a model can be q=1.0 at every atom while the subunit it belongs to is present in half the particles. Both statements are true and they answer different questions, so the table must be supplied and this tool never reads an atom property at all. For sense 1, use occupancy_view.

A selection matching no atoms is refused rather than skipped — PyMOL would accept it silently, colour nothing, and leave a render that looks like a fully-present structure.