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). Note: this accepts the PyMOL cmd.do mini-language, not Python.

Shows one representation while hiding all others for the specified selection

Sets a PyMOL setting to a specified value

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.

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 OBJ exporter writes the whole visible scene, so each group is isolated on its own before export, then rebuilt into a single watertight, manifold solid. All groups share the same coordinate frame, so 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).

Requires the optional print extra (trimesh, pymeshlab); 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.