LensingETC optimizes observing strategies for multi-filter imaging campaigns of galaxy-scale strong lensing systems. It uses the lens modelling software lenstronomy (ascl:1804.012) to simulate and model mock imaging data, forecasts the lens model parameter uncertainties, and optimizes observing strategies.

Cloud Killer recovers surface albedo maps by using reflected light photometry to map the clouds and surface of unresolved exoplanets. For light curves with negligible photometric uncertainties, the minimal top-of-atmosphere albedo at a location is a good estimate of its surface albedo. On synthetic data, it shows little bias, good precision, and accuracy, but slightly underestimated uncertainties; exoplanets with large, changing cloud structures observed near quadrature phases are good candidates for Cloud Killer cloud removal.

paltas conducts simulation-based inference on strong gravitational lensing images. It builds on lenstronomy (ascl:1804.012) to create large datasets of strong lensing images with realistic low-mass halos, Hubble Space Telescope (HST) observational effects, and galaxy light from HST's COSMOS field. paltas also includes the capability to easily train neural posterior estimators of the parameters of the lensing system and to run hierarchical inference on test populations.

cuvarbase provides a Python library for performing period finding (Lomb-Scargle, Phase Dispersion Minimization, Conditional Entropy, Box-least squares) on astronomical time-series datasets. Speedups over CPU implementations depend on the algorithm, dataset, and GPU capabilities but are typically ~1-2 orders of magnitude and are especially high for BLS and Lomb-Scargle.

PTAfast calculates the overlap reduction function in Pulsar Timing Array produced by the stochastic gravitational wave background for arbitrary polarizations, propagation velocities, and pulsar distances.

The analytic propagator Kepler-Collisions calculates collisions for Keplerian systems. The algorithm maintains a list of collision possibilities and jumps from one collision to the next; since collisions are rare in astronomical scales, jumping from collision to collision and calculating each one is more efficient than calculating all the time steps that are between collisions.

AMBER (Abundance Matching Box for the Epoch of Reionization) models the cosmic dawn. The semi-numerical code allows users to directly specify the reionization history through the redshift midpoint, duration, and asymmetry input parameters. The reionization process is further controlled through the minimum halo mass for galaxy formation and the radiation mean free path for radiative transfer. The parallelized code is over four orders of magnitude faster than radiative transfer simulations and will efficiently enable large-volume models, full-sky mock observations, and parameter-space studies.

PAHDecomp models mid-infrared spectra of galaxies; it is based on the popular PAHFIT code (ascl:1210.009). In contrast to PAHFIT, this model decomposes the continuum into a star-forming component and an obscured nuclear component based on Bayesian priors on the shape of the star-forming component (using templates + prior on extinction), making this tool ideally suited for modeling the spectra of heavily obscured galaxies. PAHDecomp successfully recovers properties of Compact Obscured Nuclei (CONs) where the inferred nuclear optical depth strongly correlates with the surface brightness of HCN-vib emission in the millimeter. This is currently set up to run on the short low modules of Spitzer IRS data (5.2 - 14.2 microns) but will be ideal for JWST/MIRI MRS data in the future.

unTimely Catalog Explorer searches for and visualizes detections in the unTimely Catalog, a full-sky, time-domain catalog of detections based on WISE and NEOWISE image data acquired between 2010 and 2020. The tool searches the catalog by coordinates to create finder charts for each epoch with overplotted catalog positions and light curves using the unTimely photometry, to overplot these light curves with AllWISE multi-epoch and NEOWISE-R single exposure (L1b) photometry, and to create image blinks with overlaid catalog positions in GIF format.

baobab generates images of strongly-lensed systems, given some configurable prior distributions over the parameters of the lens and light profiles as well as configurable assumptions about the instrument and observation conditions. Wrapped around lenstronomy (ascl:1804.012), baobab supports prior distributions ranging from artificially simple to empirical. A major use case for baobab is the generation of training and test sets for hierarchical inference using Bayesian neural networks (BNNs); the code can generate the training and test sets using different priors.

mgcnn is a Convolutional Neural Network (CNN) architecture for classifying standard and modified gravity (MG) cosmological models based on the weak-lensing convergence maps they produce. It is implemented in Keras using TensorFlow as the backend. The code offers three options for the noise flag, which correspond to noise standard deviations, and additional options for the number of training iterations and epochs. Confusion matrices and evaluation metrics (loss function and validation accuracy) are saved as numpy arrays in the generated output/ directory after each iteration.

The Population Monte-Carlo (PMC) sampling code pmclib performs fast end efficient parallel iterative importance sampling to compute integrals over the posterior including the Bayesian evidence.

ovejero conducts hierarchical inference of strongly-lensed systems with Bayesian neural networks. It requires lenstronomy (ascl:1804.012) and fastell (ascl:9910.003) to run lens models with elliptical mass distributions. The code trains Bayesian Neural Networks (BNNs) to predict posteriors on strong gravitational lensing images and can integrate with forward modeling tools in lenstronomy to allow comparison between BNN outputs and more traditional methods. ovejero also provides hierarchical inference tools to generate population parameter estimates and unbiased posteriors on independent test sets.

BlackJAX is a sampling library designed for ease of use, speed, and modularity and works on CPU as well as GPU. It is not a probabilistic programming library (PLL), though it integrates well with PPLs as long as they can provide a (potentially unnormalized) log-probability density function compatible with JAX. BlackJAX is written in pure Python and depends on XLA via JAX (ascl:2111.002). It can be used by those who have a logpdf and need a sampler or need more than a general-purpose sampler. It is also useful for building a sample on GPU and for users who want to learn how sampling algorithms work.

fastSHT performs spherical harmonic transforms on a large number of spherical maps. It converts massive SHT operations to a BLAS level 3 problem and uses the highly optimized matrix multiplication toolkit to accelerate the computation. GPU acceleration is supported and can be very effective. The core code is written in Fortran, but a Python wrapper is provided and recommended.

gsf fits photometric data points, simultaneously with grism spectra if provided, to get posterior probability of galaxy physical properties, such as stellar mass, dust attenuation, metallicity, as well as star formation and metallicity enrichment histories. Designed for extra-galactic science, this flexible, python-based SED fitting code involves a Markov-Chain Monte-Carlo (MCMC) process, and may take more time (depending on the number of parameters and length of MCMC chains) than other SED fitting codes based on chi-square minimization.

The Python module 2DFFTUtils implements tasks associated with measuring spiral galaxy pitch angle with 2DFFT (ascl:1608.015). Since most of the 2DFFT utilities are implemented in one place, it makes preparing images for 2DFFT and dealing with 2DFFT data interactively or in scripts event easier.

PDFchem models the cold ISM at moderate and large scales using functions connecting the quantities of the local and the observed visual extinctions and the local number density with probability density functions. For any given observed visual extinction sampled with thousands of clouds, the algorithm instantly computes the average abundances of the most important species and performs radiative transfer calculations to estimate the average emission of the most commonly observed lines.

H-FISTA (Hierarchical Fast Iterative Shrinkage Thresholding Algorithm) retrieves the phases of the wavefield from intensity measurements for pulsar spectroscopy. The code accepts input data in ASCII format as produced by PSRchive's (ascl:1105.014) psrflux function, a FITS file, or a pickle. If using a notebook, any custom reader can be used as long as the data ends up in a NumPy array. H-FISTA obtains sparse models of the wavefield in a hierarchical approach with progressively increasing depth. Once the tail of the noise distribution is reached, the hierarchy terminates with a final unregularized optimization, resulting in a fully dense model of the complex wavefield that permits the discovery of faint signals by appropriate averaging.

Korg computes stellar spectra from 1D model atmospheres and linelists assuming local thermodynamic equilibrium and implements both plane-parallel and spherical radiative transfer. The code is generally faster than other codes, and is compatible with automatic differentiation libraries and easily extensible, making it ideal for statistical inference and parameter estimation applied to large data sets.

BiGONLight (Bi-local geodesic operators framework for numerical light propagation) encodes the Bi-local Geodesic Operators formalism (BGO) to study light propagation in the geometric optics regime in General Relativity. The parallel transport equations, the optical tidal matrix, and the geodesic deviation equations for the bilocal operators are expressed in 3+1 form and encoded in BiGONLight as Mathematica functions. The bilocal operators are used to obtain all possible optical observables by combining them with the observer and emitter four-velocities and four-accelerations. The user can choose the position of the source and the observer anywhere along the null geodesic with any four-velocities and four-accelerations.

ODNet uses a convolutional neural network to examine frames of a given observation, using the flux of a targeted star along time, to detect occultations. This is particularly useful to reliably detect asteroid occultations for the Unistellar Network, which consists of 10,000 digital telescopes owned by citizen scientists that is regularly used to record asteroid occultations. ODNet is not costly in term of computing power, opening the possibility for embedding the code on the telescope directly. ODNet's models were developed and trained using TensorFlow version 2.4.

APERO (A PipelinE to Reduce Observations) performs data reduction for the Canada-France-Hawaii Telescope's near-infrared spectropolarimeter SPIRou and offers different recipes or modules for performing specific tasks. APERO can individually run recipes or process a set of files, such as cleaning a data file of detector effects, collecting all dark files and creating a master dark image to use for correction, and creating a bad pixel mask for identifying and dealing with bad pixels. It can extract out flat images to measure the blaze and produced blaze correction and flat correction images, extract dark frames to provide correction for the thermal background after extraction of science or calibration frames, and correct extracted files for leakage coming from a FP (for OBJ_FP files only). It can also take a hot star and calculate telluric transmission, and then use the telluric transmission to calculate principle components (PCA) for correcting input images of atmospheric absorption, among many other tasks.

EXCEED-DM (EXtended Calculation of Electronic Excitations for Direct detection of Dark Matter) provides a complete framework for computing DM-electron interaction rates. Given an electronic configuration, EXCEED-DM computes the relevant electronic matrix elements, then particle physics specific rates from these matrix elements. This allows for separation between approximations regarding the electronic state configuration, and the specific calculation being performed.

Many fields in science and engineering measure data that inherently live on non-Euclidean geometries, such as the sphere. Techniques developed in the Euclidean setting must be extended to other geometries. Due to recent interest in geometric deep learning, analogues of Euclidean techniques must also handle general manifolds or graphs. Often, data are only observed over partial regions of manifolds, and thus standard whole-manifold techniques may not yield accurate predictions. In this thesis, a new wavelet basis is designed for datasets like these.

Although many definitions of spherical convolutions exist, none fully emulate the Euclidean definition. A novel spherical convolution is developed, designed to tackle the shortcomings of existing methods. The so-called sifting convolution exploits the sifting property of the Dirac delta and follows by the inner product of a function with the translated version of another. This translation operator is analogous to the Euclidean translation in harmonic space and exhibits some useful properties. In particular, the sifting convolution supports directional kernels; has an output that remains on the sphere; and is efficient to compute. The convolution is entirely generic and thus may be used with any set of basis functions. An application of the sifting convolution with a topographic map of the Earth demonstrates that it supports directional kernels to perform anisotropic filtering.

Slepian wavelets are built upon the eigenfunctions of the Slepian concentration problem of the manifold - a set of bandlimited functions which are maximally concentrated within a given region. Wavelets are constructed through a tiling of the Slepian harmonic line by leveraging the existing scale-discretised framework. A straightforward denoising formalism demonstrates a boost in signal-to-noise for both a spherical and general manifold example. Whilst these wavelets were inspired by spherical datasets, like in cosmology, the wavelet construction may be utilised for manifold or graph data.

GWFAST forecasts the signal-to-noise ratios and parameter estimation capabilities of networks of gravitational-wave detectors, based on the Fisher information matrix approximation. It is designed for applications to third-generation gravitational-wave detectors. It is based on Automatic Differentiation, which makes use of the library JAX (ascl:2111.002). This allows efficient parallelization and numerical accuracy. The code includes a module for parallel computation on clusters.

Eventdisplay reconstructs and analyzes data from the Imaging Atmospheric Cherenkov Telescopes (IACT). It has been primarily developed for VERITAS and CTA analysis. The package calibrates and parametrizes images, event reconstruction, and stereo analysis, and provides train boosted decision trees for direction and energy reconstruction. It fills and uses lookup tables for mean scaled width and length calculation, energy reconstruction, and stereo reconstruction, and calculates radial camera acceptance from data files and instrument response functions such as effective areas, angular point-spread function, and energy resolution. Eventdisplay offers additional tools as well, including tools for calculating sky maps and spectral energy distribution, and to plot instrument response function, spectral energy distributions, light curves, and sky maps, among others.

MGCosmoPop implements a hierarchical Bayesian inference method for constraining the background cosmological history, in particular the Hubble constant, together with modified gravitational-wave propagation and binary black holes population models (mass, redshift and spin distributions) with gravitational-wave data. It includes support for loading and analyzing data from the GWTC-3 catalog as well as for generating injections to evaluate selection effects, and features a module to run in parallel on clusters.

FastDF (Fast Distribution Function) integrates relativistic particles along geodesics in a comoving periodic volume with forces determined by cosmological linear perturbation theory. Its main application is to set up accurate particle realizations of the linear phase-space distribution of massive relic neutrinos by starting with an analytical solution deep in radiation domination. Such particle realizations are useful for Monte Carlo experiments and provide consistent initial conditions for cosmological N-body simulations. Gravitational forces are calculated from three-dimensional potential grids, which are obtained by convolving random phases with linear transfer functions using Fast Fourier Transforms. The equations of motion are solved using a symplectic leapfrog integration scheme to conserve phase-space density and prevent the build-up of errors. Particles can be exported in different gauges and snapshots are provided in the HDF5 format, compatible with N-body codes like SWIFT (ascl:1805.020) and Gadget-4 (ascl:2204.014). The code has an interface with CLASS (ascl:1106.020) for calculating transfer functions and with monofonIC (ascl:2008.024) for setting up initial conditions with dark matter, baryons, and neutrinos.

MTNeedlet uses needlets to filter spherical (Healpix) maps and detect and analyze the maxima population using a multiple testing approach. It has been developed with the CMB in mind, but it can be applied to other spherical maps. It pivots around three basic steps: 1.) The calculation of several types of needlets and their possible use to filter maps; 2.) The detection of maxima (or minima) on spherical maps, their visualization and basic analysis; and 3.) The multiple testing approach in order to detect anomalies in the maxima population of the maps with respect to the expected behavior for a random Gaussian map. MTNeedlet relies on Healpy (ascl:2008.022) to efficiently deal with spherical maps.

GPry efficiently obtains marginal quantities from computationally expensive likelihoods. It works best with smooth (continuous) likelihoods and posteriors that are slow to converge by other methods, which is dependent on the number of dimensions and expected shape of the posterior distribution. The likelihood should be low-dimensional (d<20 as a rule of thumb), though the code may still provide considerable improvements in speed in higher dimensions, despite an increase in the computational overhead of the algorithm. GPry is an alternative to samplers such as MCMC and Nested Sampling with a goal of speeding up inference in cosmology, though the software will work with any likelihood that can be called as a python function. It uses Cobaya's (ascl:1910.019) model framework so all of Cobaya's inbuilt likelihoods work, too.

PyMCCF (Python Modernized Cross Correlation Function), also known as MCCF, cross correlates two light curves that are unevenly sampled using linear interpolation and measures the peak and centroid of the cross-correlation function. Based on PyCCF (ascl:1805.032) and ICCF, it introduces a new parameter, MAX, to reduce the number of interpolated points used to just those which are not farther from the nearest real one than the MAX. This significantly reduces noise from interpolation errors. The estimation of the errors in PyMCCF is exactly the same as in PyCCF.

panco2 extracts measurements of the pressure profile of the hot gas inside galaxy clusters from millimeter-wave observations. The extraction is performed using forward modeling the millimeter-wave signal of clusters and MCMC sampling of a posterior distribution for the parameters given the input data. Many characteristic features of millimeter-wave observations can be taken into account, such as filtering (both through PSF smearing and transfer functions), point source contamination, and correlated noise.

Hazma enables indirect detection of sub-GeV dark matter. It computes gamma-ray and electron/positron spectra from dark matter annihilations, sets limits on sub-GeV dark matter using existing gamma-ray data, and determines the discovery reach of future gamma-ray detectors. The code also derives accurate CMB constraints. Hazma comes with several sub-GeV dark matter models, for which it provides functions to compute dark matter annihilation cross sections and mediator decay widths. A variety of low-level tools are provided to make it straightforward to define new models.

sf_deconvolve performs PSF deconvolution using a low-rank approximation and sparsity. It can handle a fixed PSF for the entire field or a stack of PSFs for each galaxy position. The code accepts Numpy binary files or FITS as input, takes the observed (i.e. with PSF effects and noise) stack of galaxy images and a known PSF, and attempts to reconstruct the original images. sf_deconvolve can be run in a terminal or in an active Python session, and includes options for initialization, optimization, low-Rank approximation, sparsity, PSF estimation, and other attributes.

The xwavecal library automatically wavelength calibrates echelle spectrographs for high precision radial velocity work. The routines are designed to operate on data with extracted 1D spectra. The library provides a convienience function which returns a list of wavelengths from just a list of spectral feature coordinates (pixel and order) and a reference line list. The returned wavelengths are the wavelengths of the measured spectral features under the best fit wavelength model. xwavecal also provides line identification and spectral reduction utilities. The library is modular; each step of the wavelength calibration is a stage which can be disabled by removing the associated line in the config.ini file. Wavelength calibrating data which already have spectra means only using the wavelength calibration stages. Using the full experimental pipeline means enabling the other data reduction stages, such as overscan subtraction.

The BANZAI-NRES pipeline processes data from the Network of Robotic Echelle Spectrographs (NRES) on the Las Cumbres Observatory network and provides extracted, wavelength calibrated spectra. If the target is a star, it provides stellar classification parameters (e.g., effective temperature and surface gravity) and a radial velocity measurement. The automated radial velocity measurements from this pipeline have a precision of ~ 10 m/s for high signal-to-noise observations. The data flow and infrastructure of this code relies heavily on BANZAI (ascl:2207.031), enabling BANZAI-NRES to focus on analysis that is specific to spectrographs. The wavelength calibration is primarily done using xwavecal (ascl:2212.011). The pipeline propagates an estimate of the formal uncertainties from all of the data processing stages and includes these in the output data products. These are used as weights in the cross correlation function to measure the radial velocity.

PACMAN (Planetary Atmosphere, Crust, and MANtle geochemical evolution) runs a coupled redox-geochemical-climate evolution model. It runs Monte Carlo calculations over nominal parameter ranges, including number of iterations and number of cores for parallelization, which can be altered to reproduce different scenarios and sensitivity tests. Model outputs and corresponding input parameters are saved in separate files which are used to plot results; the the user can choose which outputs to plot, including all successful outputs, nominal Earth outputs, waterworld false positives, desertworld false positives, and high CO2:H2O false positives. Among other functions, PACMAN contains functions for interpolating the pre-computed Outgoing Longwave Radiation (OLR) grid, the atmosphere-ocean partitioning grid, and the stratospheric water vapor grid, calculating bond albedo and outgassing fluxes.

pyTANSPEC extracts XD-mode spectra automatically from data collected by the TIFR-ARIES Near Infrared Spectrometer (TANSPEC) on India's ground-based 3.6-m Devasthal Optical Telescope at Nainital, India. The TANSPEC offers three modes of observations, imaging with various filters, spectroscopy in the low-resolution prism mode with derived R~ 100-400 and the high-resolution cross-dispersed mode (XD-mode) with derived median R~ 2750 for a slit of width 0.5 arcsec. In the XD-mode, ten cross-dispersed orders are packed in the 2048 x 2048 pixels detector to cover the full wavelength regime. The XD-mode is most utilized; pyTANSPEC provides a dedicated pipeline for consistent data reduction for all orders and to reduces data reduction time. The code requires nominal human intervention only for the quality assurance of the reduced data. Two customized configuration files are used to guide the data reduction. The pipeline creates a log file for all the fits files in a given data directory from its header, identifies correct frames (science, continuum and calibration lamps) based on the user input, and offers an option to the user for eyeballing and accepting/removing of the frames, does the cleaning of raw science frames and yields final wavelength calibrated spectra of all orders simultaneously.

SImMER (Stellar Image Maturation via Efficient Reduction) reduces astronomical imaging data. It performs standard dark-subtraction and flat-fielding operations on data from, for example, the ShARCS camera on the Shane 3-m telescope at Lick Observatory and the PHARO camera on the Hale 5.1-m telescope at Palomar Observatory; its object-oriented design allows the software to be extended to other instruments. SImMER can also perform sky-subtraction, image registration, FWHM measurement, and contrast curve calculation, and can generate tables and plots. For widely separated stars which are of somewhat equal brightness, a “wide binary” mode allows the user to selects which star is the primary around which each image should be centered.

The AbundanceMatching Python module creates (interpolates and extrapolates) abundance functions and also provides fiducial deconvolution and abundance matching.

powspec provides functions to compute power and cross spectral density of 2D arrays. Units are properly taken into account. It can, for example, create fake Gaussian field images, compute power spectra P(k) of each image, shrink a mask with regard to a kernel, generate a Gaussian field, and plot various results.

SourceXtractor++ extracts a catalog of sources from astronomical images; it is the successor to SExtractor (ascl:1010.064). SourceXtractor++ has been completely rewritten in C++ and improves over its predecessor in many ways. It provides support for multiple “measurement” images, has an optimized multi-object, multi-frame model-fitting engine, and can define complex priors and dependencies for model parameters. It also offers efficient image data caching and multi-threaded processing, and has a modular design with support for third-party plug-ins.

m2mcluster performs made-to-measure modeling of star clusters, and can fit target observations of a Galactic globular cluster's 3D density profile and individual kinematic properties, including proper motion velocity dispersion, and line of sight velocity dispersion. The code uses AMUSE (ascl:1107.007) to model the gravitational N-body evolution of the system between time steps; GalPy (ascl:1411.008) is also required.

Omega solves the photon equations of motion in the environment surrounding a black hole. This black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user. The software offers numerous options, such as the geometrical setup of the accretion disk around the black hole (including no disk, band, slab, wedge, among others, the spin parameter of the central black hole, and the thickness of the accretion disk. Other options that can be set includ the azimuthal angle of the photon emission/reception, the poloidal angle of the photon emission/reception, and how far away or close to the system to look.

Infinity sets an observer in a black hole - accretion disk system. The black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user. This observer can be on the surface of the disk, in its exterior or its interior (if the disk is not opaque). Infinity then scans the entire sky around the observer and investigates whether photons emitted by the hot accretion disk material can reach them. After recording the incoming radiation, the program calculates the stress-energy tensor of the radiation. Afterwards, the program calculates the radiation flux and hence, the radiation force exerted on target particles of various velocity profiles.

Elysium creates an observing screen at the desirable distance away from a black hole system. Observers set on every pixel of this screen then photograph the area toward the black hole - accretion disk system and report back what they record. This can be the accretion disk (incoming photons bring in radiation and thus energy), the black hole event horizon, or the empty space outside and beyond the system (there are no incoming photons or energy). The central black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user.

Tranquillity creates an observing screen looking toward a black hole - accretion disk system, seeks the object, then searches and locates its contour. Subsequently, it attempts to locate the first Einstein "echo" ring and its location. Finally, it collates the retrieved information and draws conclusions; these include the accretion disk level inclination compared to the line of sight and the main disk and the first echo median. The displacement, and thus the divergence of the latter two, is the required information in order to construct the divergence plots. Other programs can later on automatically read these plots and provide estimations of the central black hole spin.

Burning Arrow determines the destabilization of massive particle circular orbits due to thermal radiation, emitted in X-ray, from the hot accretion disk material. This code requires the radiation forces exerted on the material at the point of interest found by running the code Infinity (ascl:2212.021). Burning Arrow begins by assuming a target particle in the disk that moves in a circular orbit. It then introduces the recorded radiation forces from Infinity code for the target region. The forces are subsequently introduced into the target particle equations of motion and the trajectory is recalculated. Burning Arrow then produces images of the black hole - accretion disk system that includes the degenerated particle trajectories that obey the assorted velocity profiles.

CONTROL (CUTE autONomous daTa ReductiOn pipeLine) produces science-quality output with a single command line with zero user interference for CUTE (Colorado Ultraviolet Transit Experiment) data. It can be used for any single order spectral data in any wavelength without any modification. The pipeline is governed by a parameter file, which is available with this distribution. CONTROL is fully automated and works in a series of steps following standard CCD reduction techniques. It creates a reduction log to track processes carried out and any parameters used.

Spender establishes a restframe for galaxy spectra that has higher resolution and larger wavelength range than the spectra from which it is trained. The model can be trained from spectra at different redshifts or even from different instruments without the need to standardize the observations. Spender also has an explicit, differentiable redshift dependence, which can be coupled with a redshift estimator for a fully data-driven spectrum analysis pipeline. The code describes the restframe spectrum by an autoencoder and transforms the restframe model to the observed redshift; it also matches the spectral resolution and line spread function of the instrument.

unWISE-verse is an integrated Python pipeline for downloading sets of unWISE time-resolved coadd cutouts from the WiseView image service and uploading subjects to Zooniverse.org for use in astronomical citizen science research. This software was initially designed for the Backyard Worlds: Cool Neighbors research project and is optimized for target sets containing low luminosity brown dwarf candidates. However, unWISE-verse can be applied to other future astronomical research projects that seek to make use of unWISE infrared sky maps, such as studies of infrared variable/transient sources.

CALSAGOS (Clustering ALgorithmS Applied to Galaxies in Overdense Systems) selects cluster members and searches, finds, and identifies substructures and galaxy groups in and around galaxy clusters using the redshift and position in the sky of the galaxies. The package offers two ways to determine cluster members, ISOMER and CLUMBERI. The ISOMER (Identifier of SpectrOscopic MembERs) function selects the spectroscopic cluster members by defining cluster members as those galaxies with a peculiar velocity lower than the escape velocity of the cluster. The CLUMBERI (CLUster MemBER Identifier) function select the cluster members using a 3D-Gaussian Mixture Modules (GMM). Both functions remove the field interlopers by using a 3-sigma clipping algorithm. CALSAGOS uses the function LAGASU (LAbeller of GAlaxies within SUbstructures) to search, find, and identify substructures and groups in and around a galaxy cluster; this function is based on clustering algorithms (GMM and DBSCAN), which search areas with high density to define a substructure or groups.

Pyxel hosts and pipelines models (analytical, numerical, statistical) simulating different types of detector effects on images produced by Charge-Coupled Devices (CCD), Monolithic, and Hybrid CMOS imaging sensors. Users can provide one or more input images to Pyxel, set the detector and model parameters, and select which effects to simulate, such as cosmic rays, detector Point Spread Function (PSF), electronic noises, Charge Transfer Inefficiency (CTI), persistence, dark current, and charge diffusion, among others. The output is one or more images including the simulated detector effects combined. The Pyxel framework, written in Python, provides basic image analysis tools, an input image generator, and a parametric mode to perform parametric and sensitivity analysis. It also offers a model calibration mode to find optimal values of its parameters based on a target dataset the model should reproduce.

WF4Py implements frequency-domain gravitational wave waveform models in pure Python, thus enabling parallelization over multiple events at a time. Waveforms in WF4Py are built as classes; the functions take dictionaries containing the parameters of the events to analyze as input and provide Fourier domain waveform models. All the waveforms are accurately checked with their implementation in LALSuite (ascl:2012.021) and are a core element of GWFAST (ascl:2212.001).

HEADSS (HiErArchical Data Splitting and Stitching) facilitates clustering at scale, unlike clustering algorithms that scale poorly with increased data volume or that are intrinsically non-distributed. HEADSS automates data splitting and stitching, allowing repeatable handling, and removal, of edge effects. Implemented in conjunction with scikit's HDBSCAN, the code achieves orders of magnitude reduction in single node memory requirements for both non-distributed and distributed implementations, with the latter offering similar order of magnitude reductions in total run times while recovering analogous accuracy. HEADSS also establishes a hierarchy of features by using a subset of clustering features to split the data.

The fitOmatic model-fitting prototyping tool tests multi-wavelength model-fitting and exploits VLTI data. It provides tools to define simple geometrical models and conveniently adjust the model's parameters. Written in Yorick, it takes optical interferometry FITS (oifits) files as input and allows the user to define a model of the source from a set of pre-defined models, which can be combined to make more complicated models. fitOmatic then computes the Fourier Transform of the modeled brightness distribution and synthetic observables are computed at the wavelengths and projected baselines of the observations. fitomatic's strength is its ability to define vector-parameters, i.e., parameters that may depend on wavelength and/or time. The self-cal (ascl:2301.006) component of fitOmatic is also available as a separate code.

Self-cal produces radio-interferometric images of an astrophysical object. The code is an adaptation of the self-calibration algorithm to optical/infrared long-baseline interferometry, especially to make use of differential phases and differential visibilities. It works together with the Mira image reconstruction software and has been used mainly on VLTI data. Self-cal, written in Yorick, is also available as part of fitsOmatic (ascl:2301.005).

LoLLiPoP is a Planck low-l polarization likelihood based on cross-power-spectra for which the bias is zero when the noise is uncorrelated between maps. It uses a modified approximation to apply to cross-power spectra and is interfaced with the Cobaya (ascl:1910.019) MCMC sampler. Cross-spectra are computed on the CMB maps from Commander component separation applied on each detset-split Planck frequency maps.

HiLLiPoP is a multifrequency CMB likelihood for Planck data. The likelihood is a spectrum-based Gaussian approximation for cross-correlation spectra from Planck 100, 143 and 217GHz split-frequency maps, with semi-analytic estimates of the Cl covariance matrix based on the data. The cross-spectra are debiased from the effects of the mask and the beam leakage using Xpol (ascl:2301.009) before being compared to the model, which includes CMB and foreground residuals. They cover the multipoles from ℓ=30 to ℓ=2500. HiLLiPoP is interfaced with the Cobaya (ascl:1910.019) MCMC sampler.

Xpol computes angular power spectra based on cross-correlation between maps and covariance matrices. The code is written in C and is fully MPI parallelized in CPU and memory using spherical transform by s2hat (ascl:1110.013). It has been used to derive CMB and dust power spectra for Archeops and CMB, dust, CIB, SZ, SZ-CIB for Planck, among others.

Fastcc returns color corrections for different spectra for various Cosmic Microwave Background experiments. Available in both Python and IDL, the script is easy to use when analyzing radio spectra of sources with data from multiple wide-survey CMB experiments in a consistent way across multiple experiments.

Rosetta runs tasks for resource-intensive, interactive data analysis as software containers. The code's architecture frames user tasks as microservices – independent and self-contained units – which fully support custom and user-defined software packages, libraries and environments. These include complete remote desktop and GUI applications, common analysis environments such as the Jupyter Notebooks. Rosetta relies on Open Container Initiative containers, allowing for safe, effective and reproducible code execution. It can use a number of container engines and runtimes and seamlessly supports several workload management systems, thus enabling containerized workloads on a wide range of computing resources.

XGA (X-ray: Generate and Analyse) analyzes X-ray sources observed by the XMM-Newton Space telescope. It is based around declaring different types of source and sample objects which correspond to real X-ray sources, finding all available data, and then insulating the user from the tedious generation and basic analysis of X-ray data products. XGA generates photometric products and spectra for individual sources, or whole samples, with just a few lines of code. Though not a pipeline, pipelines for complex analysis can be built on top of it. XGA provides an easy to use (and parallelized) Python interface with XMM's Science Analysis System (ascl:1404.004), as well as with XSPEC (ascl:9910.005). All XMM products and fit results are read into an XGA source storage structure, thus avoiding the need to leave a Python environment at any point during the analysis. This module also supports more complex analyses for specific object types such as the easy generation of scaling relations, the measurement of gas masses for galaxy clusters, and the PSF correction of images.

pyExoRaMa visualizes and manipulates data related to exoplanets and their host stars in a multi-dimensional parameter space. It enables statistical studies based on the large and constantly increasing number of detected exoplanets, identifies possible interdependence among several physical parameters, and compares observables with theoretical models describing the exoplanet composition and structure.

LBL derives velocity measurements from high-resolution (R>50 000) datasets by accounting for outliers in the spectra data. It is tailored for fiber-fed multi-order spectrographs, both in optical and near-infrared (up to 2.5µm) domains. The domain is split into individual units (lines) and the velocity and its associated uncertainty are measured within each line and combined through a mixture model to allow for the presence of spurious values. In addition to the velocity, other quantities are also derived, the most important being a value (dW) that can be understood (for a Gaussian line) as a change in the line FWHM. These values provide useful stellar activity indicators. LBL works on data from a variety of instruments, including SPIRou, NIRPS, HARPS, and ESPRESSO. The code's output is an rdb table that can be uploaded to the online DACE pRV analysis tool.

SOAP-GPU is a revision of SOAP 2 (ascl:1504.021), which simulates spectral time series with the effect of active regions (spot, faculae or both). In addition to the traditional outputs of SOAP 2.0 (the cross-correlation function and extracted parameters: radial velocity, bisector span, full width at half maximum), SOAP-GPU generates the integrated spectra at each phase for given input spectra and spectral resolution. Additional capabilities include fast spectral simulation of stellar activity due to GPU acceleration, simulation of more complicated active region structures with superposition between active regions, and more realistic line bisectors, based on solar observations, that varies as function of mu angle for both quiet and active regions. In addition, SOAP-GPU accepts any input high resolution observed spectra. The PHOENIX synthetic spectral library are already implemented at the code level which allows users to simulate stellar activity for stars other than the Sun. Furthermore, SOAP-GPU simulates realistic spectral time series with either spot number/SDO image as additional inputs. The code is written in C and provides python scripts for input pre-processing and output post-processing.

FERRE matches physical models to observed data, taking a set of observations and identifying the model parameters that best reproduce the data, in a chi-squared sense. It solves the common problem of having numerical parametric models that are costly to evaluate and need to be used to interpret large data sets. FERRE provides flexibility to search for all model parameters, or hold constant some of them while searching for others. The code is written to be truly N-dimensional and fast. Model predictions are to be given as an array whose values are a function of the model parameters, i.e., numerically. FERRE holds this array in memory, or in a direct-access binary file, and interpolates in it. The code returns, in addition to the optimal set of parameters, their error covariance, and the corresponding model prediction. The code is written in FORTRAN90.

ReACT extends the Copter (ascl:1304.022) and MG-Copter packages, which calculate redshift and real space large scale structure observables for a wide class of gravity and dark energy models. Additions to Copter include spherical collapse in modified gravity, halo model power spectrum for general theories, and real and redshift space LSS 2 point statistics for modified gravity and dark energy. ReACT also includes numerical perturbation theory kernel solvers, real space bispectra in modified gravity, and a numerical perturbation theory kernel solver up to 4th order for 1-loop bispectrum.

kderp (KCWI Data Extraction and Reduction Pipeline) reduces data for the Keck Cosmic Web Imager. Written in IDL, it performs basic CCD reduction on raw images to produce bias and overscan subtracted, gain-corrected, trimmed and cosmic ray removed images; it can also subtract the sky. It defines the geometric transformations required to map each pixel in the 2d image into slice, postion, and wavelength, and performs flat field and illumination corrections. It generates cubes, applying the transformations previously solved to the object intensity, variance and mask images output from any of the previous stages, and uses a standard star observation to generate an inverse sensitivity curve which is applied to the corresponding observations to flux calibrate them.

This pipeline has been superseded by KCWI_DRP (ascl:2301.019).

KCWI_DRP, written in Python and based on kderp (ascl:2301.018), is the official DRP for the Keck Cosmic Web Imager at the W. M. Keck Observatory. It provides all of the functionality of the older pipeline and has three execution modes: multi-threading for CPU intensive tasks such as wavelength calibration, and multi-processing for large datasets. It offers vacuum to air and heliocentric or barycentric correction and the ability to use KOA file names or original file names. KCWI_DRP also improves the provenance and traceability of DRP versions and execution steps in the headers over kderp, and has versatile sky subtraction modes including using external sky frames and ability of masking regions.

void-dwarf-analysis analyzes Keck Cosmic Web Imager datacubes to produce maps of kinematic properties (velocity and velocity dispersion), emission line fluxes, and gas-phase metallicities of void dwarf galaxies.

WALDO (Waveform AnomaLy DetectOr) flags possible anomalous Gravitational Waves from Numerical Relativity catalogs using deep learning. It uses a U-Net architecture to learn the waveform features of a dataset. After computing the mismatch between those waveforms and the neural predictions, WALDO isolates high mismatch evaluations for anomaly search.

GalCEM (GALactic Chemical Evolution Model) tracks isotope masses as a function of time in a given galaxy. The list of tracked isotopes automatically adapts to the complete set provided by the input yields. The prescription includes massive stars, low-to-intermediate mass stars, and Type Ia supernovae as enrichment channels. Multi-dimensional interpolation curves are extracted from the input yield tables with a preprocessing tool; these interpolation curves improve the computation speeds of the full convolution integrals, which are computed for each isotope and for each enrichment channel. GalCEM also provides tools to track the mass rate change of individual isotopes on a typical spiral galaxy with a final baryonic mass of 5×1010M⊙.

PoWR (Potsdam Wolf-Rayet Models) calculates synthetic spectra for Wolf-Rayet and OB stars from model atmospheres which account for Non-LTE, spherical expansion and metal line blanketing. The model data is provided through a web interface and includes Spectral Energy Distribution, line spectrum in high resolution for different wavelength bands, and atmosphere stratification. For Wolf-Rayet stars of the nitrogen subclass, there are grids of hydrogen-free models and of models with a specified mass fraction of hydrogen. The iron-group and total CNO mass fractions correspond to the metallicity of the Galaxy, the Large Magellanic Cloud, or the Small Magellanic Cloud, respectively. The source code is available as a tarball on the same web interface.

SOXS creates simulated X-ray observations of astrophysical sources. The package provides a comprehensive set of tools to design source models and convolve them with simulated models of X-ray observatories. In particular, SOXS is the primary simulation tool for simulations of Lynx and Line Emission Mapper observations. SOXS provides facilities for creating spectral models, simple spatial models for sources, astrophysical background and foreground models, as well as a Python implementation of the SIMPUT file format.

nFITSview is a simple, user-friendly and open-source FITS image viewer available for Linux and Windows. One of the main concepts of nFITSview is to provide an intuitive user interface which may be helpful both for scientists and for amateur astronomers. nFITSview has different color mapping and manipulation schemes, supports different formats of FITS data files as well as exporting them to different popular image formats. It also supports command-line exporting (with some restrictions) of FITS files to other image formats.
The application is written in C++/Qt for achieving better performance, and with every next version the performance aspect is taken into account.
nFITSview uses its own libnfits library (can be used separately as well) for parsing the FITS files.

desitarget selects targets for spectroscopic follow-up by Dark Energy Spectroscopic Instrument (DESI). The pipeline uses bitmasks to record that a specific source has been selected by a particular targeting algorithm, setting bit-values in output data files in a number of different columns that indicate whether a particular target meets specific selection criteria. desitarget also outputs a unique TARGETID that allows each target to be tracked throughout the DESI survey. This TARGETID encodes information about each DESI target, such as the catalog the target was selected from, whether a target is a sky location or part of a random catalog, and whether a target is part of a secondary program.

The 2-D wavelet transformation code MGwave detects kinematic moving groups in astronomical data; it can also investigate underdensities which can eventually provide further information about the MW's non-axisymmetric features. The code creates a histogram of the input data, then performs the wavelet transformation at the specified scales, returning the wavelet coefficients across the entire histogram in addition to information about the detected extrema. MGwave can also run Monte Carlo simulations to propagate uncertainties. It runs the wavelet transformation on simulated data (pulled from Gaussian distributions) many times and tracks the percentage of the simulations in which a given extrema is detected. This quantifies whether a detected overdensity or underdensity is robust to variations of the data within the provided errors.

Puri-Psi addresses radio interferometric imaging problems using state-of-the-art optimization algorithms and deep learning. It performs scalable monochromatic, wide-band, and polarized imaging. It also provide joint calibration and imaging, and scalable uncertainty quantification. A scalable framework for wide-field monochromatic intensity imaging is also available, which encompasses a pure optimization algorithm, as well as an AI-based method in the form of a plug-and-play algorithm propelled by Deep Neural Network denoisers.

special (SPEctral Characterization of directly ImAged Low-mass companions) characterizes low-mass (M, L, T) dwarfs down to giant planets at optical/IR wavelengths. It can also be used more generally to characterize any type of object with a measured spectrum, provided a relevant input model grid, regardless of the observational method used to obtain the spectrum (direct imaging or not) and regardless of the format of the spectra (multi-band photometry, low-resolution or medium-resolution spectrum, or a combination thereof). It analyzes measured spectra, calculating the spectral correlation between channels of an IFS datacube and empirical spectral indices for MLT-dwarfs. It fits input spectra to either photo-/atmospheric model grids or a blackbody model, including additional parameters such as (extra) black body component(s), extinction and total-to-selective extinction ratio, and can use emcee (ascl:1303.002), nestle (ascl:2103.022), or UltraNest (ascl:1611.001) samplers infer posterior distributions on spectral model parameters in a Bayesian framework, among other tasks.

ALMA3 computes loading and tidal Love numbers for a spherically symmetric, radially stratified planet. Both real (time-domain) and complex (frequency-domain) Love numbers can be computed. The planetary structure can include an arbitrary number of layers, and each layer can have a different rheological law. ALMA3 can model numerous linear rheologies, including Elastic, Maxwell visco-elastic, Newtonian viscous fluid, Kelvin-Voigt solid, Burgers and Andrade transient rheologies.

HIPP (HIgh-Performance Package for scientific computation) provides elegant interfaces for some well-known HPC libraries. Some libraries are wrapped with full-OOP interfaces, and many new extensions based on those raw-interfaces are also provided. This C++ toolkit for HPC can significantly reduce the length of your code, making programming more productive.

PREVIS is a Python module that provides functions to help determine the observability of astronomical sources from long-baseline interferometers worldwide: VLTI (ESO, Chile) and CHARA (USA). PREVIS uses data from the Virtual Observatory (OV), such as magnitudes, Spectral Energy Distribution (SED), celestial coordinates or Gaia distances. Then, it compares the target brightness to the limiting magnitudes of each instrument to determine whether the target is observable with present performances. PREVIS includes main facilities at the VLTI with PIONIER (H band), GRAVITY (K band) and MATISSE (L, M, N bands), and at CHARA array with VEGA (V band), PAVO (R bands), MIRC (H band), CLIMB (K band) and CLASSIC (H, K bands). PREVIS also uses the V or G magnitudes to check the guiding restriction or the tip/tilt correction limit. For the VLTI: if the star is too faint in G mag, PREVIS will look for the list of stars around the target (57 arcsec) with the appropriate magnitude and give the list of celestial coordinates usable as the guiding star.

nicaea calculates cosmology and weak-lensing quantities and functions from theoretical models of the large-scale structure. Written in C, it can compute the Hubble parameter, distances, and geometry for background cosmology, and linear perturbations, including growth factor, transfer function, cluster mass function, and linear 3D power spectra. It also calculates fitting formulae for non-linear power spectra, emulators, and halo model for Non-linear evolution, and the HOD model for galaxy clustering. In addition, nicaea can compute quantities for cosmic shear such as the convergence power spectrum, second-order correlation functions and derived second-order quantities, and third-order aperture mass moment; it can also calculate CMB anisotropies via CAMB (ascl:1102.026).

Deconfuser performs fast orbit fitting to directly imaged multi-planetary systems. It quickly fits orbits to planet detections in 2D images and ensures that all orbits within a certain tolerance are found. The code also tests all groupings of detections by planets (which detection belongs to which planet), and ranks partitions of detections by planets by deciding which assignment of detection-to-planet best fits the data.

PHOTOe simulates the slowing down of photoelectrons in a gas with arbitrary amounts of H, He and O atoms, and thermal electrons, making PHOTOe useful for investigating the atmospheres of exoplanets. The multi-score scheme used in this code differs from other Monte Carlo approaches in that it efficiently handles rare collisional channels, as in the case of low-abundance excited atoms that undergo superelastic and inelastic collisions. PHOTOe outputs include production and energy yields, steady-state photoelectron flux, and estimates of the 'relaxation' time required by the photoelectrons to slow down from the injection energy to the cutoff energy. The model can also estimate the pathlength travelled by the photoelectrons while relaxing.

SFQEDtoolkit implements strong-field QED (SFQED) processes in existing particle-in-cell (PIC) and Monte Carlo codes to determine the dynamics of particles and plasmas in extreme electromagnetic fields, such as those present in the vicinity of compact astrophysical objects. The code uses advanced function approximation techniques to calculate high-energy photon emission and electron-positron pair creation probability rates and energy distributions within the locally-constant-field approximation (LCFA) as well as with more advanced models.

celmech provides a variety of analytical and semianalytical tools for celestial mechanics and dynamical astronomy. The package interfaces closely with the REBOUND N-body integrator (ascl:1110.016), thus facilitating comparisons between calculation results and direct N-body integrations. celmech can isolate the contribution of particular resonances to a system's dynamical evolution, and can develop simple analytical models with the minimum number of terms required to capture a particular dynamical phenomenon.

RCR provides advanced outlier rejection that is easy to use. Both sigma clipping, the simplest form of outlier rejection, and traditional Chauvenet rejection make use of non-robust quantities, the mean and standard deviation, which are sensitive to the outliers that they are being used to reject. This limits such techniques to samples with small contaminants or small contamination fractions. RCR instead first makes use of robust replacements for the mean, such as the median and the half-sample mode, and similar robust replacements for the standard deviation. RCR has been carefully calibrated and can be applied to samples with both large contaminants and large contaminant fractions (sometimes in excess of 90% contaminated).

AnalyticLC generates an analytic light-curve, and optionally RV and astrometry data, from a set of initial (free) orbital elements and simultaneously fits these data. Written in MATLAB, the code is fast and efficient, and provides insight into the motion of the orbital elements, which is difficult to obtain from numerical integration. A Python wrapper for AnalyticLC is available separately.

HawkingNet searches for Hawking points in large Cosmic Microwave Background (CMB) data sets. It is based on the deep residual network ResNet18 and consists of eighteen neural layers. Written in Paython, HawkingNet inputs the CMB data, processes the data through its internal network trained for data classification, and outputs the result in a form of a classification score that indicates how confident it is that a Hawking point is contained in the image patch.

EXOTIC (EXOplanet Transit Interpretation Code) analyzes photometric data of transiting exoplanets into lightcurves and retrieves transit epochs and planetary radii. The software reduces images of a transiting exoplanet into a lightcurve, and fits a model to the data to extract planetary information crucial to increasing the efficiency of larger observational platforms. EXOTIC is written in Python and supports the citizen science project Exoplanet Watch. The software runs on Windows, Macintosh, and Linux/Unix computer, and can also be used via Google Colab.

SASHIMI-W calculates various subhalo properties efficiently using semi-analytical models for warm dark matter (WDM); the code is based on the extended Press-Schechter formalism and subhalos' tidal evolution prescription. The calculated constraints are independent of physics of galaxy formation and free from numerical resolution and the Poisson noise, and its results are well in agreement with those from numerical N-body simulations.

The UniverseMachine applies simple empirical models of galaxy formation to dark matter halo merger trees. For each model, it generates an entire mock universe, which it then observes in the same way as the real Universe to calculate a likelihood function. It includes an advanced MCMC algorithm to explore the allowed parameter space of empirical models that are consistent with observations.

Diffstar fits the star formation history (SFH) of galaxies to a smooth parametric model. Diffstar differs from existing SFH models because the parameterization of the model is directly based on basic features of galaxy formation physics, including halo mass assembly history, accretion of gas into the dark matter halo, the fraction of gas that is converted into stars, the time scale over which star formation occurs, and the possibility of rejuvenated star formation. The SFHs of a large number of simulated galaxies can be fit in parallel using mpi4py.

SASHIMI-C calculates various subhalo properties efficiently using semi-analytical models for cold dark matter (CDM), providing a full catalog of dark matter subhalos in a host halo with arbitrary mass and redshift. Each subhalo is characterized by its mass and density profile both at accretion and at the redshift of interest, accretion redshift, and effective number (or weight) corresponding to that particular subhalo. SASHIMI-C computes the subhalo mass function without making any assumptions such as power-law functional forms; the only assumed power law is that for the primordial power spectrum predicted by inflation. The code is not limited to numerical resolution nor to Poisson shot noise, and its results are well in agreement with those from numerical N-body simulations.

kima fits Keplerian curves to a set of RV measurements, using the Diffusive Nested Sampling (ascl:1010.029) algorithm to sample the posterior distribution for the model parameters. Additionally, the code can calculate the fully marginalized likelihood of a model with a given number of Keplerians and also infer the number of Keplerian signals detected in a given dataset. kima implements dedicated models for different analyses of a given dataset. The models share a common organization, but each has its own parameters (and thus priors) and settings.

FCFC (Fast Correlation Function Calculator) computes correlation functions from pair counts. It supports the isotropic 2-point correlation function, anisotropic 2PCF, 2-D 2PCF, and 2PCF Legendre multipoles, among others. Written in C, FCFC takes advantage of three parallelisms that can be used simultaneously, distributed-memory processes via Message Passing Interface (MPI), shared-memory threads via Open Multi-Processing (OpenMP), and single instruction, multiple data (SIMD).

swyft implements Truncated Marginal Neural Radio Estimation (TMNRE), a Bayesian parameter inference technique for complex simulation data. The code improves performance by estimating low-dimensional marginal posteriors rather than the joint posteriors of distributions, while also targeting simulations to targets of observational interest via an indicator function. The use of local amortization permits statistical checks, enabling validation of parameters that cannot be performed using sampling-based methods. swyft is also based on stochastic simulations, mapping parameters to observational data, and incorporates a simulator manager.