Flatiron Software

The EXP C++ library is an efficient N-body simulation toolkit that implements basis-function methods using hybrid CPU and GPU code alongside Python bindings.

Pyia is a Python package for interacting and working with data from the Gaia Mission.

We are building an “astrometry engine” to create correct, standards-compliant astrometric meta data for every useful astronomical image ever taken, past and future, in any state of archival disarray. The astrometry engine will take any image and return the astrometry world coordinate system (WCS)—ie, a standards-based description of the (usually nonlinear) transformation between image coordinates and sky coordinates—with absolutely no “false positives” (but maybe some “no answers”). It will do its best, even when the input image has no—or totally incorrect—meta-data. We intend to install the engine for real-time operation on the web, at observatories, at plate-scanning projects, and at data archives.

celerite is a library for fast and scalable Gaussian Process (GP) Regression in one dimension with implementations in C++, Python, and Julia. The Python implementation is the most stable and it exposes the most features but it relies on the C++ implementation for computational efficiency. This documentation won’t teach you the fundamentals of GP modeling but the best resource for learning about this is available for free online: Rasmussen & Williams (2006).

Daft is a Python package that uses matplotlib to render pixel-perfect probabilistic graphical models for publication in a journal or on the internet. With a short Python script and an intuitive model-building syntax you can design directed (Bayesian Networks, directed acyclic graphs) and undirected (Markov random fields) models and save them in any formats that matplotlib supports (including PDF, PNG, EPS and SVG).

emcee is an MIT licensed pure-Python implementation of Goodman & Weare’s Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble sampler and these pages will show you how to use it. This documentation won’t teach you too much about MCMC but there are a lot of resources available for that (try this one). We also published a paper explaining the emcee algorithm and implementation in detail.

George is a fast and flexible Python library for Gaussian Process Regression. It capitalizes on the Hierarchical Off-Diagonal Low-Rank formalism to make controlled approximations for fast execution.

starry enables the computation of fast and precise light curves for various applications in astronomy: transits and secondary eclipses of exoplanets, light curves of eclipsing binaries, rotational phase curves of exoplanets, light curves of planet-planet and planet-moon occultations, and more.

MESA is a suite of open-source, robust, efficient, thread-safe libraries extensively used in computational stellar astrophysics. Its wide-ranging capabilities allow the simulation of diverse stellar evolution scenarios, from low-mass to massive stars, including advanced evolutionary stages and binary interactions. It uses adaptive mesh refinement and sophisticated timestep controls and supports shared memory parallelism based on OpenMP. State-of-the-art modules provide equations of state, opacity, nuclear reaction rates, element diffusion data, and atmosphere boundary conditions. Each module is constructed as a separate Fortran 95 library with its own explicitly defined public interface to facilitate independent development.

Dedalus is a python-based framework for solving and manipulating partial differential equations using sparse spectral methods. It can represent tensorial quantities in cartesian, cylindrical, and spherical coordinates, and has been used to run parallel simulations on hundreds of thousands of cores. There are over 700 papers published using Dedalus across many fields including astrophysics, atmospheric science, biology, oceanography, and plasma physics.

Entity is an open-source curvilinear particle-in-cell plasma simulation code designed to model a wide range of plasma environments: from neutron stars and black holes, to Solar wind and planetary magnetospheres, to interstellar and intracluster medium. Entity is written in C++20 and employs the Kokkos library for performance portability, targeting all hardware architectures including GPUs. The code is designed to be beginner-friendly, emphasizing flexibility to streamline the addition of new physics modules and algorithms, while having a heavily optimized core of kernels, making Entity (arguably) the fastest astrophysical particle-in-cell code. Curvilinear solvers in the code allow it to model arbitrary grid geometries, while a dedicated general-relativistic module enables studying global-scale flows around black holes.

Galactic Dynamics is the study of the formation, history, and evolution of galaxies using the orbits of objects — numerically-integrated trajectories of stars, dark matter particles, star clusters, or galaxies themselves. Gala is an Astropy-affiliated Python package that aims to provide efficient tools for performing common tasks needed in Galactic Dynamics research. Much of this code uses Python for flexible, user-friendly interfaces that interact with wrappers around low-level code (primarily C) to enable fast computations. Common operations include gravitational potential and force evaluations, orbit integrations, dynamical coordinate transformations, and computing chaos indicators for nonlinear dynamics. Gala heavily uses the units and astronomical coordinate systems defined in the Astropy core package.

jaxoplanet is a functional-programming-forward implementation of many features from the exoplanet and starry packages built on top of JAX.

nuance uses linear models and Gaussian processes (using the JAX-based tinygp) to simultaneously search for planetary transits while modeling correlated noises (e.g. stellar variability) in a tractable way.

Pasta (Platform Agnostic Simulation Tools for Astrophysics) is a task-based, Kokkos-portable(radiation-)magnetohydrodynamics code: One source tree runs on CPUs (serial, OpenMP) and GPUs (CUDA, HIP, SYCL), with MPI domain decomposition. It works in Cartesian, cylindrical, and spherical-polar coordinates, on uniform grids or with static/adaptive mesh refinement, and offers a range of Riemann solvers, reconstruction schemes, and equations of state. Ideal MHD uses constrained transport, keeping div B at machine precision in every coordinate system. Beyond hydro and MHD, Pasta provides explicit and implicit multi-group radiation transport with implicit radiation–matter coupling, multi-size dust with drag and coagulation, passive scalars, driven turbulence, and self-gravity through either an FFT or a BiCGSTAB Poisson solver, the latter working in general (curvilinear) coordinates with multiple boundary conditions. Local time stepping lets each MeshBlock advance on its own dyadic time-step rung — including all the physical modules that are implemented.

ringdown is a Python package for the Bayesian analysis of black hole ringdowns in data from gravitational-wave detectors, like LIGO and Virgo. It is used to measure properties of the remnant black hole formed in black hole collisions, and to probe the nature of the merger. It relies on Hamiltonian Monte Carlo as implemented in Numpyro, using jax to accelerate computations. It has been used in multiple LIGO publications, including GW250114.

State Space Models for O(Linear/Log) Gaussian Processes (smolgp) is a Python/JAX standalone extension of the tinygp package that uses the state space representation of Gaussian Process to achieve substantial performance boosts. Like tinygp it is built on top of jax and so can utilize just-in-time compliation, automatic differentiation, and GPU-accelerated linear algebra. It can even be parallelized for a further performance boost.

A custom Monte Carlo sampler for the two-body problem.

wobble is an open-source python package for analyzing time-series spectra. It was designed with stabilized extreme precision radial velocity (EPRV) spectrographs in mind, but is highly flexible and extensible to a variety of applications. It takes a data-driven approach to deriving radial velocities and requires no a priori knowledge of the stellar spectrum or telluric features.