moderndid 0.4.0

Modern Difference-in-Differences in Python

Install guide | Features | Changelog | Documentation

What is ModernDiD?

ModernDiD is a Python library for difference-in-differences (DiD), designed for applied researchers, economists, and data scientists who estimate the effects of policies and treatments.

A two-way fixed effects regression, long the default way to run DiD in applied settings, can give misleading answers when treatment effects differ across groups or change over time. ModernDiD implements the estimators that recent research developed to avoid that problem.

Every estimator reports analytical or bootstrap standard errors for the effects it estimates. Most can also cluster those errors by a variable such as state. The staggered, triple-difference, continuous-treatment, and nonparametric IV estimators can build simultaneous confidence bands too. Estimation runs in parallel threads on one machine and supported estimators also run on NVIDIA GPUs for large panels. Staggered DiD also runs on Spark clusters for panels too large for one machine.

ModernDiD is under active development so expect sharp edges. Please help by trying it out, reporting bugs, and telling us what you think. If you're new to DiD, the introduction covers the ideas behind the methods before any code.

Installation

ModernDiD requires Python 3.12 or later. In a project managed by uv, add it as a dependency.

uv add moderndid

With pip, install it into your environment instead.

pip install moderndid

Extras add optional dependencies and work the same way with either tool.

uv add "moderndid[plots]"            # Core estimators and plotting
uv add "moderndid[all]"              # All estimator extras and plots
uv add "moderndid[didcont,plots]"    # Choose individual extras
uv add "moderndid[gpu]"              # CUDA 12 GPU dependencies
uv add "moderndid[spark]"            # PySpark for staggered DiD on Spark

The all extra includes didml and leaves out gpu and spark. The installation guide covers every extra, GPU setup, and troubleshooting. The development version installs straight from GitHub.

uv add "moderndid[all] @ git+https://github.com/jordandeklerk/moderndid.git"

Features

ModernDiD covers the main research designs in the modern DiD literature.

• Staggered DiD: att_gt and aggte, based on Callaway and Sant'Anna (2021)
• Two-period DiD: drdid, ipwdid, and ordid, based on Sant'Anna and Zhao (2020)
• Triple differences: ddd and agg_ddd, based on Ortiz-Villavicencio and Sant'Anna (2025)
• Continuous treatment: cont_did, based on Callaway, Goodman-Bacon, and Sant'Anna (2025)
• Intertemporal treatment: did_multiplegt, based on de Chaisemartin and D'Haultfoeuille (2024)
• Dynamic covariate balancing: dyn_balancing, based on Viviano and Bradic (2026)
• Machine learning DiD: didml, based on Hatamyar, Kreif, Rocha, and Huber (2023)
• Extended TWFE: etwfe and emfx, based on Wooldridge (2023, 2025)
• Sensitivity analysis: honest_did, based on Rambachan and Roth (2023)
• Nonparametric IV: npiv, based on Chen, Christensen, and Kankanala (2024)

Every estimator also comes with the tools the rest of an analysis needs.

• Estimators accept any Arrow-compatible DataFrame, such as polars, pandas, pyarrow, or a DuckDB result.
• Inference covers analytical and bootstrap standard errors, plus clustering and simultaneous confidence bands where the estimator supports them.
• Plots return plotnine ggplot objects that take any further plotnine layer or theme.
• Results work directly with maketables to build LaTeX, HTML, Word, and Typst tables.
• Parallel threads speed up estimation on one machine.

Quickstart

The example below estimates how state minimum wage increases that took effect in different years affected teen employment. The staggered adoption example works through the same question at a deeper level.

import moderndid as did

# County teen employment and state minimum wage increases from 2003 to 2007
data = did.load_mpdta()

# An average effect for each treatment cohort and year
result = did.att_gt(
    data=data,
    yname="lemp",
    tname="year",
    idname="countyreal",
    gname="first.treat",
)

# An event study by time relative to treatment, plotted with the plots extra
event_study = did.aggte(result, type="dynamic")
did.plot_event_study(event_study)

Large panels

The quickstart's call moves to an NVIDIA GPU or a Spark cluster with a single change.

NVIDIA GPUs

With the gpu extra, passing backend="cupy" to att_gt, ddd, or cont_did runs its supported numerical work on the GPU. Since moving arrays to the GPU takes time too, a small panel such as the county data can fit faster on the CPU. The GPU guide shows how to check your CUDA setup and time a fit.

# The quickstart's fit with its numerical work on the GPU
result = did.att_gt(
    data=data,
    yname="lemp",
    tname="year",
    idname="countyreal",
    gname="first.treat",
    backend="cupy",
)

Spark clusters

Passed a Spark DataFrame, att_gt fits it on the cluster without gathering its rows on one machine. That suits a panel that already sits in a Spark table or holds more units than one machine can keep in memory. Since Databricks runtimes already include PySpark, you need the spark extra only where you run Spark yourself. The Spark guide walks through a fit and the options a Spark fit supports. The Spark setup guide shows how to install ModernDiD on Databricks, a cluster you manage, or your own machine.

from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

# The county data stands in for a large panel stored in a Spark table
data = spark.createDataFrame(did.load_mpdta().to_pandas())

# The same calls as in the quickstart
result = did.att_gt(
    data=data,
    yname="lemp",
    tname="year",
    idname="countyreal",
    gname="first.treat",
)
event_study = did.aggte(result, type="dynamic")

Documentation

• User Guide: installation, a first analysis, data preparation, results, and computation.
• Examples: analyses for each treatment design.
• API Reference: function signatures, parameters, and result objects.
• Background: the assumptions, identification, and inference behind each estimator.
• Comparisons with R: each estimator's results beside those of the R package for the same method.
• FAQ: answers to common questions about data, estimators, and results.
• Development: setup, workflow, testing, releases, architecture, new estimators, debugging, and benchmarking.
• Changelog: changes between versions.

Acknowledgements

ModernDiD builds on methods and implementations developed by researchers across the DiD literature. The acknowledgements list the papers and software behind each estimator.