molpy

A programmable toolkit for molecular simulation workflows

Documentation  ·  Quick start  ·  Examples  ·  Ecosystem

MolPy is a Python toolkit for the full molecular-system workflow — parsing, building, editing, typing, analyzing, and reading/writing simulation formats. Packing a box is the job of the companion package molpack.

Under active development. Public APIs may change between minor releases.

Vision

Molecular modeling is fragmented. Every simulation code has its own file formats and conventions; every task — parsing, building, typing, analysis, visualization — lives in a separate library; and moving a system between them means writing throwaway glue.

molpy aims to be the common foundation beneath that workflow: one explicit, programmable representation of a molecular system that every stage can share. Parse a structure into it, build on it, type and analyze it — then hand the same object onward, with no conversion step in between.

That representation is meant to be built on, not just used. It is the data model the MolCrafts ecosystem extends — visualization, experiment management, agent access — and it reads the same whether a human writes it or an agent calls it.

Capabilities

Every name is reached through import molpy as mp, and molpy is a thin layer over the native core (molrs): every native name is the molrs object. Every molrs subsystem is mirrored by a molpy module (mp.core for molrs.core — stores, graphs, box, neighbour search and units — then mp.io, mp.ff, mp.perceive, mp.compute, mp.builder, …). The core data classes you handle directly (mp.Frame, mp.Block, mp.Trajectory, mp.Box, mp.Atomistic, …) are promoted to the root, as the same objects.

Where	Capability
mp.*, core, perceive, conformer, optimize	Explicit data model — Frame / Block columnar arrays, Trajectory, editable Atomistic / CoarseGrain graphs and Box on the root; regions, neighbour search, units, molpy's selectors and trajectory splitters in mp.core; perception and SMARTS (mp.perceive.SmartsPattern), 3D conformers (mp.conformer.Conformer), the mp.optimize.Lbfgs minimizer
ff	Force fields, mirroring molrs.ff — forcefield (the ForceField data model), potential (kernels), compile (PotentialCompiler), typifier (OPLS-AA, MMFF94, GAFF natively; GAFF / GAFF2 via AmberTools), charge, ir (the IR's vocabulary), style_registry (your own styles from Python), params, clpol_scaling
builder	Site-graph assembly (Assembler), graphene and nanotubes, polymer planning and polydispersity, crystals, virtual sites, packing templates
compute · signal	Analysis — Rdf, Msd, conductivity, order parameters, Voronoi, dielectric and vibrational spectra, … (native kernels); FFT correlation and windows
io	Read/write — PDB, GRO, LAMMPS data, XYZ, AMBER, SMILES / CGsmiles, trajectories, *.mrec records, …
engine	MD input generation & run management — LAMMPS, GROMACS, OpenMM, CP2K
wrapper · adapter	External CLIs (Antechamber, tleap, …) and optional RDKit in-memory bridge

Install

pip install molcrafts-molpy

# Browser (Pyodide) — needs molcrafts-molrs Pyodide wheel on PyPI:
# await micropip.install("molcrafts-molrs")
# await micropip.install("molcrafts-molpy")

Core dependencies: NumPy and molrs (molcrafts-molrs>=0.17.0,<0.18) plus the MolCrafts logging/config packages. Optional: RDKit (adapter example), AmberTools (GAFF charges).

Nightly builds. Bleeding-edge snapshots are published to the separate project molcrafts-molpy-nightly (versioned X.Y.Z.devN) on every push to the nightly branch. Install with pip install --pre molcrafts-molpy-nightly. It imports as molpy, so it cannot be installed alongside the stable molcrafts-molpy (same as tensorflow vs tf-nightly).

Install from source (development)

git clone https://github.com/MolCrafts/molpy.git
cd molpy
uv sync --extra dev
pre-commit install --hook-type pre-commit --hook-type pre-push
# the two gates (same as the hooks / CI):
uv run --no-project --with 'tox>=4.23' --with ruff==0.16.1 --with ty==0.0.65 tox -e lint
uv run --extra dev python -m pytest tests/ -n auto

uv sync installs molcrafts-molrs from PyPI within the pinned minor line. To develop against a local molrs checkout instead, see Building molrs from source.

See docs/developer/development-setup for the full workflow.

Quick start

Parse a SMILES string, assign OPLS-AA types, and write LAMMPS input files:

import molpy as mp

from pathlib import Path

mol       = mp.io.smiles.SmilesIr("CCO").to_atomistic()     # ethanol from SMILES
mol3d, _  = mp.conformer.Conformer(seed=42).generate(mol)   # hydrogens + 3D coordinates

typifier  = mp.ff.typifier.OplsAaTypifier()          # carries the OPLS-AA library
typed     = typifier.typify(mol3d)
ff        = typifier.forcefield()                 # parameters of the assigned types

system    = typed.to_frame()
system.box = mp.Box.cube(30.0)
system["atoms"]["mol_id"] = mp.Topology.from_frame(system).connected_components() + 1

# the pair cutoff is a run setting: you declare it, molpy never invents one
ff.get_style("pair", "lj/cut")["cutoff"] = 10.0
ff.get_style("pair", "coul/cut")["cutoff"] = 10.0

out = Path("output"); out.mkdir(exist_ok=True)
mp.io.write_lammps_data(out / "system.data", system)
mp.io.write_lammps_forcefield(out / "system.ff", ff, system)

More workflows — packed solvent boxes, virtual-site models, polymer architectures (the stress test for MolPy's editing machinery), AmberTools parameterization — are in the Example Gallery and the task-oriented Guides.

Documentation

Full documentation, including executable notebooks: docs.molcrafts.org/molpy

• Getting Started — install and first example
• Example Gallery — short copy-paste workflows
• Guides — task-oriented notebooks
• Concepts — data model deep dives
• API Reference — full API

MolCrafts ecosystem

Project	Role
molpy	Python toolkit — the shared molecular data model & workflow layer — this repo
molrs	Rust core — molecular data structures & compute kernels (native + WASM)
molpack	Packmol-grade molecular packing (Rust + Python)
molvis	WebGL molecular visualization & editing
molexp	Workflow & experiment-management platform
molnex	Molecular machine-learning framework
molq	Unified job queue — local / SLURM / PBS / LSF
molcfg	Layered configuration library
mollog	Structured logging, stdlib-compatible
molhub	Molecular dataset hub
molmcp	MCP server for the ecosystem
molrec	Atomistic record specification

Contributing

Issues and pull requests are welcome — see Contributing.

License

BSD-3-Clause — see LICENSE.

---

_{Crafted with 💚 by MolCrafts}