GPlately 2.0 is here

I’m really pleased to announce that GPlately 2.0 has been published on GitHub. This has been a huge collaborative effort — 303 commits, 224 changed files, and 13 contributors — and it represents a major step forward for our open-source plate tectonics toolkit.

GPlately is a Python library that wraps pyGPlates to make deep-time plate tectonic reconstructions accessible, scriptable, and reproducible. If you’ve ever wanted to reconstruct where continents, ocean basins, or fossil sites were hundreds of millions of years ago, this is the tool for the job.

What’s new in v2

The headline additions:

• Plate Model Manager — a new integrated package that handles downloading and managing plate reconstruction models so you don’t have to wrangle files manually.
• PyGMT integration — early-stage support for plotting with PyGMT alongside the existing Cartopy backend.
• Command-line interface — run reconstructions directly from your terminal.
• Docker images — docker pull gplates/gplately and you’re ready to go.
• Python 3.12 & 3.13 support, plus performance improvements across the board.

Full release notes are on GitHub.

GPlately in action

Here’s a quick tour of what you can do with a few lines of code.

Loading a plate model

The new Plate Model Manager makes it trivial to grab a published reconstruction model:

import gplately
from plate_model_manager import PlateModelManager

pm_manager = PlateModelManager()
muller2019 = pm_manager.get_model("Muller2019", data_dir="plate-model-repo")

model = gplately.PlateReconstruction(
    muller2019.get_rotation_model(),
    muller2019.get_topologies(),
    muller2019.get_static_polygons(),
)

No more hunting for rotation files and topology datasets — the model manager fetches everything you need.

Plotting a paleomap

Reconstructing and plotting plate boundaries at any point in Earth history takes just a few lines:

import cartopy.crs as ccrs
import matplotlib.pyplot as plt

coastlines = muller2019.get_layer("Coastlines")
continents = muller2019.get_layer("ContinentalPolygons")

gplot = gplately.PlotTopologies(
    model, coastlines=coastlines, continents=continents, time=100
)

fig = plt.figure(figsize=(16, 10))
ax = fig.add_subplot(111, projection=ccrs.Mollweide())

gplot.plot_continents(ax, facecolor="palegoldenrod", alpha=0.2)
gplot.plot_coastlines(ax, color="DarkKhaki")
gplot.plot_ridges(ax, color="red")
gplot.plot_trenches(ax, color="k")
gplot.plot_subduction_teeth(ax, color="k")

ax.set_global()
ax.set_title("100 Ma")
plt.show()

Reconstructing point data

Got a dataset of fossil localities or geochemical samples with modern coordinates? GPlately can send them back in time:

import numpy as np

# Some present-day coordinates
lons = np.array([140., 150., 160.])
lats = np.array([-30., -40., -50.])

gpts = gplately.Points(model, lons, lats)

# Where were these points 100 million years ago?
rlons, rlats = gpts.reconstruct(100, return_array=True)

# What's the plate velocity at present day? (cm/yr)
vel_x, vel_y = gpts.plate_velocity(0)

Working with rasters

Reconstruct entire grids — age grids, topography, anything — through deep time:

from plate_model_manager import PresentDayRasterManager

raster_manager = PresentDayRasterManager()
etopo = gplately.Raster(data=raster_manager.get_raster("ETOPO1_tif"))
etopo.plate_reconstruction = model

# Reconstruct global topography to 50 Ma
etopo_50ma = etopo.reconstruct(50, threads=4)
etopo_50ma.imshow(projection=ccrs.Mollweide())

Get started

Install or upgrade with:

pip install gplately --upgrade

Or via conda, or pull the Docker image:

docker pull gplates/gplately

The documentation has been completely overhauled for v2, and the example notebooks walk through everything from basic reconstructions to raster analysis and animations.

If you use GPlately in your research, please cite our paper: Mather et al. (2023), Deep time spatio-temporal data analysis using pyGPlates with PlateTectonicTools and GPlately, Geoscience Data Journal. DOI: 10.1002/gdj3.185. You can also find it on the publications page.