Geospatial Machine Learning Libraries
Adam J. Stewart,1,2Caleb Robinson,3and Arindam Banerjee4
1Chair of Data Science in Earth Observation, Technical University of Munich
2Munich Center for Machine Learning
3AI for Good Research Lab, Microsoft
4Siebel School of Computing and Data Science, University of Illinois Urbana-Champaign
Abstract
Recent advances in machine learning have been supported by the emergence of domain-specific software
libraries, enabling streamlined workflows and increased reproducibility. For geospatial machine learning
(GeoML), the availability of Earth observation data has outpaced the development of domain libraries
to handle its unique challenges, such as varying spatial resolutions, spectral properties, temporal cadence,
data coverage, coordinate systems, and file formats. This chapter presents a comprehensive overview
of GeoML libraries, analyzing their evolution, core functionalities, and the current ecosystem. It also
introduces popular GeoML libraries such as TorchGeo, eo-learn, and Raster Vision, detailing their archi-
tecture, supported data types, and integration with ML frameworks. Additionally, it discusses common
methodologies for data preprocessing, spatial–temporal joins, benchmarking, and the use of pretrained
models. Through a case study in crop type mapping, it demonstrates practical applications of these tools.
Best practices in software design, licensing, and testing are highlighted, along with open challenges and
future directions, particularly the rise of foundation models and the need for governance in open-source
geospatial software. Our aim is to guide practitioners, developers, and researchers in navigating and
contributing to the rapidly evolving GeoML landscape.
Keywords:Geospatial, Machine Learning, Software Libraries, Open Source
1. Introduction
Machine learning (ML) software libraries have played a foundational role in both shaping ML re-
search and the commoditization of ML models. Libraries such asscikit-learn(Pedregosa et al. 2011),
TensorFlow(Abadi et al. 2016), andPyTorch(Paszke et al. 2019) incorporate best practices, pro-
vide composable APIs, and abstract low-level engineering complexity, allowing researchers and
practitioners to focus on experimentation, implementation of higher-level features, and conceptual
development. A well designed software library provides a platform that users can build upon to
pursue their agendas. As a result, the accessibility and maturity of ML tooling are tightly coupled
with research progress.
Beyond general-purpose frameworks, domain-specific libraries further lower the barriers to re-
search in particular subfields. These libraries often provide data loaders, evaluation metrics, pre-
trained models, and architecture templates specific to that domain. For example, thetorchvision
library (Marcel and Rodriguez 2010) simplifies experimentation in computer vision by including
standard datasets (e.g., CIFAR (Krizhevsky, Hinton, et al. 2009), ImageNet (Deng et al. 2009)),
data augmentation routines, and reference implementations of neural network architectures. In
natural language processing (NLP), theHugging Faceecosystem has standardized tokenization,
model configuration, and inference across transformer-based architectures (W olf et al. 2019), en-
abling large-scale evaluation and pretraining. Similar domain-specific tooling ecosystems exist in
reinforcement learning (e.g.,OpenAI Gym(Brockman et al. 2016)), speech (e.g.,torchaudio
(Yang et al. 2022)), and time series (e.g.,GluonTS(Alexandrov et al. 2020)), all of which have
substantially influenced research agendas and benchmarks.
In contrast, the development of libraries tailored to geospatial machine learning (GeoML) has
lagged behind. This gap is notable given the increasing volume and accessibility of satellite andarXiv:2510.02572v1  [cs.LG]  2 Oct 2025
2 Adam J. Stewartet al.
aerial imagery from public and commercial platforms. Remotely-sensed data support a wide range
of applications — including land cover mapping (Karra et al. 2021), agricultural monitoring (Mulla
2013), disaster response (Van Westen 2013), and climate modeling (Rolnick et al. 2022) — but present
a set of challenges not typically encountered in standard ML workflows. As presented in Chapter 1,
Earth observation images vary in spatial resolution (from millimeters to tens of kilometers per pixel),
spectral characteristics (e.g., 3-band RGB imagery vs. 13-band multispectral Sentinel-2 imagery vs.
242-band hyperspectral imagery), and temporal cadence (every five minutes from the NASA GOES
satellites, to on-demand tasking for commercial high-resolution satellites, to every 16 days for Land-
sat 9). Further complications include non-uniform data coverage over the Earth, cloud occlusion,
differing coordinate reference systems (CRS), and file formats optimized for spatial indexing rather
than machine learning (Rolf et al. 2024). These characteristics require preprocessing steps such as
reprojection, resampling, and cloud masking, none of which are directly supported by conventional
ML data pipelines. As a result, integrating geospatial data into an ML workflow typically requires
manual interfacing with specialized libraries such asGDAL(GDAL/OGR contributors 2022), cre-
ating substantial friction between data access and model development.
Despite these challenges, recent years have seen progress toward standardizing workflows for
GeoML through the development of libraries explicitly designed for geospatial data in machine
learning contexts.TorchGeo(A. J. Stewart et al. 2024), for example, builds on PyTorch to provide
dataset abstractions, spatial sampling utilities, and support for georeferenced imagery and vector data.
Other libraries, such aseo-learn(Aleksandrov et al. 2018) andRaster Vision(Azavea/Element 84
and Cheetham 2017), offer higher-level frameworks for remote sensing tasks, including land cover
classification, semantic segmentation, and change detection. These libraries attempt to bridge the
gap between geospatial data infrastructure and modern ML tooling, offering primitives for common
operations such as patch extraction, label alignment, and tiling. However, the ecosystem remains
fragmented, with limited support for tasks such as temporal modeling, sensor fusion, or distributed
inference over petabyte-scale datasets. Moreover, unlike domains such as vision and language mod-
eling, GeoML currently lacks a unifying toolkit that combines data curation, model training, and
deployment into an integrated framework, though considerable progress has been made in recent
years. While the current chapter primarily focuses on Python libraries as much of the active devel-
opment, GeoML developments in other languages such as R have similar or related issues.
2. Methodology
By definition, GeoML libraries must support two core tasks: processing geospatial data, and inte-
grating it into machine learning workflows. Their functionality spans input/output (I/O) opera-
tions, internal data representations, and dataset handling.
Most GeoML libraries rely on the Geospatial Data Abstraction Library (GDAL) either directly
or indirectly to support I/O operations. GDAL provides a consistent API for interacting with a wide
range of raster and vector data formats — as of September 2025, it includes 155 raster drivers and
83 vector drivers, covering formats such as GeoTIFF, Zarr, HDF5, NetCDF, Esri Shapefile, and
GeoPackage. In Python, libraries likerasterio(Gillies et al. 2013) andfiona(Gillies et al. 2024)
wrap GDAL’s API and provide an additional layer of abstraction and additional features (e.g., vec-
torization, rasterization, and fine-grained management of environment variables to control GDAL
behavior). In R,terra(Hijmans et al. 2018) andsf(Pebesma 2018) provide similar support for raster
and vector operations at a higher level of abstraction. Even higher-levels of abstraction exist through
libraries such asxarray(Hoyer and Joseph 2017),rioxarray(Snow et al. 2019), andgeopandas
(Jordahl et al. 2013), which provide array- or dataframe-based abstractions that retain coordinate
reference system (CRS) metadata and spatial transforms. Some geospatial file formats can also be ac-
cessed through alternative backends.h5py(Collette et al. 2008),zarr(Miles et al. 2015), andtifffile
(Gohlke 2018) all provide direct interfaces for HDF5, Zarr, and TIFF files, respectively. Similarly,
3
GeoJSON files can be read using any standard JSON parsers, although geospatial-aware libraries
(like fiona) ensure proper CRS interpretation and coordinate handling. A key feature throughout
all GeoML libraries is how they ensure that the geospatial metadata of inputs are taken into ac-
count — any corresponding outputs will need this information in order to be georeferenced for
downstream analysis. Machine learning libraries that do not support this require users to (a) have
knowledge of how geospatial metadata works and (b) develop ad-hoc methods for propagating
geospatial metadata, both of which can easily allow for bugs to be introduced.
Another key feature of GeoML libraries is how spatial and temporal data are represented within
the library. Spatial and temporal joins, in particular, are common operations for setting up Ge-
oML experiments. For example, training a model to predict whether land is cropland or not from
a time series of satellite imagery observations over the planting season of that area requires several
key steps. First, representing a time series of multispectral satellite imagery over the same location
requires a temporal join with corresponding decisions. Does the library itself allow for the temporal
join to be performed? How will missing observations be handled and how will the time dimension
be represented (densely in 4D, sparsely with pointers to 3D tensors)? How are layers with differing
coordinate reference systems and spatial resolutions handled? Second, a spatial join between the
resulting imagery stack and a known cropland mask is necessary in order to create labeled examples
that can be fed into a machine learning pipeline. If there are many different cropland masks, or
satellite imagery layers, then a spatial index will be needed to ensure that intersections between the
layers can be computed quickly. Further, the spatial join must also take different coordinate refer-
ence systems and/or spatial resolutions into account — some layers will likely need to be reprojected
and resampled in an appropriate manner before further analysis can be done. The cropland masks
could also be in a vector format and need to be rasterized or otherwise transformed into a format
that can be used directly in modeling.
GeoML libraries also differ in how they supportbenchmarkdatasets. The GeoML community
has proposed a growing set of benchmark datasets intended to facilitate algorithmic comparison
and standardized evaluation on a wide variety of tasks. These datasets typically pair remotely-
sensed imagery with structured labels, such as land cover classifications (Robinson et al. 2019), object
boundaries (Kerner et al. 2025), or change detection masks (Chen and Shi 2020). Unlike domains
such as computer vision or NLP, geospatial benchmark datasets often lack standardized data loaders
or preprocessing routines. As a result, researchers are frequently required to write custom scripts
for parsing, tiling, and aligning data. This introduces inconsistencies and hinders reproducibility.
GeoML libraries can substantially reduce this friction by implementing standardized, reusable data
loaders for popular benchmarks. Features that distinguish high-quality dataset support include:
•adherence to published train/validation/test splits;
•support for user-defined or random splits, including spatial stratification;
•compatibility with PyTorch or TensorFlowDatasetabstractions, enabling seamless integration
into training pipelines;
•additional utilities such as on-the-fly reprojection, resampling, normalization, augmentation, or
class remapping; and
•built-in visualization tools for inspecting inputs, labels, and predictions.
Taken together, these capabilities define the core functionality and value of a GeoML library.
By abstracting the geospatial data pipeline from raw file access and metadata handling to dataset
construction and integration with ML training loops, these libraries allow researchers and prac-
titioners to focus on model development rather than infrastructure. However, the design choices
made at each stage, such as metadata preservation, spatial joining logic, temporal indexing strategies,
and dataset standardization, directly affect model reproducibility, comparability, and deployment.
In the remainder of the chapter we highlight the history of GeoML libraries, break down existing
4 Adam J. Stewartet al.
“state-of-the-art” libraries along the dimensions we describe here, expand on our example of crop-
land mapping, and finally discuss best practices for GeoML library development from a software
engineering standpoint.
3. State of the Art and Current Developments
Before jumping in to the current state of GeoML library development, it helps to first understand
how we got there.
3.1 A Brief History
The development of GeoML software libraries has evolved alongside the rise of machine learning
in computer vision. Beginning in the early-2000s, researchers began repurposing general-purpose
machine learning frameworks to work with the unique formats and challenges of satellite and aerial
imagery. Over time, this ad hoc adaptation gave way to a more intentional, ecosystem-wide effort
to build specialized tools for Earth observation data.
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025SPy
OTB
DeepOSM
Hyperspectral
DeepNetsForEO
SITS
Raster Vision
DeepHyperX
Pyinterpolate
OTBTF
eo-learn
RoboSat
spopt
DELTA
TorchSat
Solaris
AIDE
AiTLAS
DeepForest
ML4Floods
TorchGeo
geo-bench
torchrs
Myria3D
PaddleRS
GeoTorchAI
Raster4ML
srai
Moonshine
samgeo
geodl
GeoAI
scikit-eo
TerraTorch
GeoDeep
GeoTesseraActive
Inactive
Figure 1.Timeline of GeoML library development. Libraries that are under active development (defined as a new commit
within the last year) are shown in black. Inactive libraries are shown in red. SPy and OTB development stretches back
to 2001 and 2006, respectively, and are truncated to focus on more recent developments. Bars denote earliest and most
recent commit (as of September 2025).
One of the earliest known GeoML libraries,SPy(Spectral Python), began development in 2001
with simple iterative clustering methods for hyperspectral imagery, later addingk-means clustering
5
and perceptron classifiers (Boggs et al. 2001). The library predates most modern ML frameworks,
and all methods are implemented from scratch in NumPy (Harris et al. 2020). SPy has successfully
survived several transitions (Python 2→3, CVS→SVN→Git) and is still maintained to this day.
OTB(Orfeo ToolBox) is another popular software library for processing optical, multispectral, and
radar imagery (Grizonnet et al. 2017). Initial development began in 2006 by the French national
space agency (CNES) as part of the Orfeo Program, targeting high resolution imagery from the
Orfeo constellation (Pléiades and COSMO-Skymed). OTB offered early support for support vector
machines (SVMs) via LibSVM (Chang and Lin 2011) and later added support for gradient boosted
decision trees,k-nearest neighbors (k-NNs), and multilayer perceptrons (MLPs) from OpenCV
(Bradski, Kaehler, et al. 2000) andk-means and random forests from the Shark machine learning
library (Krause et al. 2009). OTB itself is written in C++, with a command-line interface, Python
bindings, and an official QGIS plugin.
The earliest known geospatial deep learning libraries began development in 2016. TrailBe-
hind introducedDeepOSM(Johnson et al. 2016), which built on top of the now-defunct TFLearn
(Damien et al. 2016) and supported automatic downloading and preprocessing of labeled imagery for
road network detection using OpenStreetMap (OSM) (OpenStreetMap contributors 2017).Hyper-
spectralwas developed by researchers at IIT Kharagpur, with early TensorFlow-based experiments
with MLPs and CNNs on hyperspectral imagery (Santara et al. 2016). Later that year, ONERA and
IRISA releasedDeepNetsForEO(Audebert, Saux, and Lefèvre 2017), initially built on Caffe (Jia
et al. 2014) and later ported to PyTorch. Notably, it was the first library to offer pretrained models
on multispectral remote sensing imagery. All three libraries were discontinued within a few years
of release. They were never packaged for PyPI or other standard software registries, and instead
required knowledge of Git and Docker for installation. Nonetheless, they established foundational
ideas — especially the importance of pipelines for data handling — that would influence the next
generation of GeoML libraries.
In 2017, the first broadly adopted, formally maintained geospatial deep learning libraries were
introduced. In the R ecosystem,SITS(Satellite Image Time Series) was launched (Simoes et al. 2021).
SITS is a library developed by e-sensing with a focus on time series analysis and data cube construc-
tion from providers such as A WS, the Microsoft Planetary Computer, and Copernicus Data Space.
Built on R bindings to libtorch, SITS emphasizes accessibility, with formal documentation, CRAN
(and more recently PyPI) packaging, and a free online book (Camara et al. 2024). One day after
the initial commit of SITS, in the Python ecosystem, Azavea started work onRaster Vision(Aza-
vea/Element 84 and Cheetham 2017). Raster Vision is a modular framework for training and de-
ploying deep learning models on arbitrary raster datasets. Initially built on TensorFlow, it migrated
to PyTorch in 2019. The authors of DeepNetsForEO returned withDeepHyperX, a library for
hyperspectral classification using scikit-learn and PyTorch (Audebert, Le Saux, and Lefèvre 2019).
However, its development fractured across multiple forks on GitLab and GitHub and was later
abandoned.
Four influential libraries followed in 2018.Pyinterpolatewas introduced by Dataverse Labs,
with support for several geostatistical interpolation techniques and learning-based Kriging methods
(Moliński et al. 2018).OTBTFwas created as a TensorFlow and Keras plugin for Orfeo ToolBox
and provides both Python and C++ APIs, but is only distributed through Docker due to its com-
pilation requirements (Cresson 2018). Sentinel Hub releasedeo-learn, a scikit-learn-compatible
pipeline that offers strong integration with Sentinel Hub products and showed the possibility of
cloud native workflows (Aleksandrov et al. 2018). Mapbox releasedRoboSat, built on PyTorch and
torchvision, which offered a command-line interface for data preparation, training, and postpro-
cessing (Hofmann, Kowshik, et al. 2018). RoboSat was eventually discontinued and briefly revived
as RoboSat.pink, then Neat-EO.pink, before being abandoned again in 2020.
In 2019, the ecosystem diversified with several new projects. The Python Spatial Analysis Li-
6 Adam J. Stewartet al.
brary (PySAL) introducedspopt, providing several spatial optimization techniques including clus-
tering methods from scikit-learn (X. Feng et al. 2022). NASA releasedDELTA, a TensorFlow-based
toolkit for large-image tiling and semantic segmentation (Coltin et al. 2019). TheTorchSatproject
attempted to adapt torchvision to the geospatial domain (Wang 2019). CosmiQ W orks launched
Solaris, a PyTorch framework for object detection (Weir et al. 2019). Finally, Microsoft’s AI for
Earth team createdAIDE(Kellenberger, Tuia, and Morris 2020), a modular web-based annotation
interface with Detectron2 (Y. Wu et al. 2019) integration. While each offered novel features, none
of these libraries besides spopt were maintained beyond 2022.
The COVID-19 pandemic brought a slowdown in 2020. Only one major library,AiTLAS,
was released that year (Dimitrovski, Kitanovski, Panov, et al. 2023). Developed by Bias Variance
Labs, it built on PyTorch, scikit-learn, and eo-learn to support common tasks like classification and
semantic segmentation using curated datasets. It also attempted the first large-scale benchmarking
of more than 500 deep learning models on 22 EO classification datasets with its AiTLAS Benchmark
Arena (Dimitrovski, Kitanovski, Kocev, et al. 2023).
In 2021, GeoML software development entered a new phase of stability and community-driven
growth. The Weecology group at the University of Florida releasedDeepForest, targeting object
detection of tree crowns in RGB drone imagery with pretrained torchvision models (Weinstein et
al. 2020). Trillium Technologies launchedML4Floods, an end-to-end PyTorch pipeline for flood
extent estimation (Mateo-Garcia et al. 2021). Microsoft’s AI for Good Lab and the University of
Illinois Urbana-Champaign introducedTorchGeo, a PyTorch-native library combining the re-
producibility of torchvision-style datasets with raster/vector data handling capabilities similar to
Raster Vision (A. J. Stewart et al. 2024). A similar project,torchrswas launched in parallel and
was subsequently merged into TorchGeo (Corley 2021). Other major 2021 releases included Ser-
viceNow’sGEO-Bench, a foundation model benchmarking suite with 20 built-in datasets (many
curated using TorchGeo) (Lacoste et al. 2023), and IGNF’sMyria3D, uniquely focused on aerial
LiDAR segmentation (Gaydon 2022).
By contrast, most libraries launched in 2022 were eventually abandoned. Baidu’sPaddleRS
(PaddlePaddle Authors 2022) built on the PaddlePaddle deep learning framework (Ma et al. 2019),
making it the first Chinese-developed GeoML library to gain traction. Wherobots released GeoTorch,
later renamedGeoTorchAI(Chowdhury and Sarwat 2022), offering scalable spatial indexing with
Apache Sedona (Yu et al. 2015), but the project was discontinued in favor of TorchGeo.Raster4ML,
designed for agricultural research, provided over 350 spectral indices and scikit-learn compatibility
(Bhadra 2023). Finally, Kraina AI releasedsrai(Spatial Representations for Artificial Intelligence),
a library providing pre-computed embeddings and spatial data visualization and processing tools
(Gramacki et al. 2023). Among these libraries, only srai is still maintained to this day.
A new wave of tools emerged in 2023.Moonshinefocused on hosting pretrained semantic
segmentation models but was abandoned (Harada 2023). Open Geospatial Solutions launched both
samgeo(Wu and Osco 2023), a GUI wrapper for Meta’s Segment Anything Model (SAM) (Kirillov
et al. 2023), andGeoAI(Q. Wu et al. 2023), a general-purpose toolkit for satellite, LiDAR, and
vector data built atop TorchGeo and scikit-learn.Geodl, another R library built on top of the torch
and terra packages, brought 2D convolutional neural networks to the R GeoML ecosystem for the
first time (Maxwell et al. 2024).Scikit-eoalso debuted, offering another scikit-learn interface for
EO tasks (Tarazona et al. 2024).
In 2024, IBM releasedTerraTorch, a toolkit for fine-tuning foundation models, built on Torch-
Geo (Gomes et al. 2025). Together with GEO-Bench and GeoAI, TerraTorch represents a second
generation of GeoML libraries —– those that complement instead of compete with core infrastruc-
ture by extending existing GeoML libraries like TorchGeo.
Launched in 2025, UA V4GEO’sGeoDeepis focused on providing a lightweight solution for
object detection and semantic segmentation, with dependencies only on onnxruntime and rasterio
7
Table 1.Features available in popular GeoML libraries (as of September 2025). While the majority of libraries provide gen-
eral purpose data loaders and models, only a handful provide curated dataset-specific data loaders or pre-trained model
weights.
Feature Count Feature Support
Library ML Backend Datasets Weights CLI GUI Reprojection STAC Time Series
TorchGeo PyTorch 127 120 yes no yes no partial
OTB LibSVM,
OpenCV, Shark0 0 yes yes yes no no
TerraTorch PyTorch 27 1 yes no yes no partial
DeepForest PyTorch,
TensorFlow*0 4 no no no no no
Raster Vision PyTorch,
TensorFlow*0 6 yes no yes yes partial
samgeo PyTorch 0 0 no yes yes no no
spopt scikit-learn 0 0 no no yes no no
SITS R Torch 22 0 no no yes yes yes
SPy numpy 3 0 no no no no no
srai PyTorch 0 0 no no no no no
ML4Floods PyTorch 0 0 no no yes no partial
GEO-Bench PyTorch 12 0 no no no no no
scikit-eo scikit-learn,
TensorFlow0 0 no no no no partial
GeoAI PyTorch 0 6 no no yes yes no
Myria3D PyTorch 0 0 partial no no no no
GeoTessera scikit-learn 0 0 yes no yes no no
OTBTF TensorFlow 0 0 yes no yes no no
GeoDeep ONNX 0 7 yes no yes no no
*Support was dropped in newer releases.
(Toffanin et al. 2025). This library was inspired by and uses some code from Deepness (Aszkowski et
al. 2023) and DeepForest. Cambridge’sGeoTesserais the first library to focus solely on embeddings,
providing easy access to learned representations from the Tessera foundation model (Z. Feng et
al. 2025).
The evolution of GeoML software has mirrored broader trends in machine learning and open-
source development. While many early projects were short-lived, they introduced core abstractions
— data tiling, preprocessing pipelines, pretrained weights — that persist in modern libraries. In re-
cent years, the field has converged around modular, PyTorch-based tooling with strong community
support, clearer maintenance practices, and increasing interoperability.
3.2 Current Landscape
As of September 2025, the current set of popular GeoML libraries under active development in-
clude: TorchGeo, OTB, TerraTorch, DeepForest, Raster Vision, samgeo, spopt, SITS, SPy, srai,
ML4Floods, GEO-Bench, scikit-eo, GeoAI, Myria3D, GeoTessera, OTBTF, and GeoDeep. Ta-
ble 1 summarizes the machine learning backend (e.g., PyTorch, TensorFlow, scikit-learn), dataset/model
availability, and any notable features such as a command-line interfaces (CLI), graphical user in-
terfaces (GUI), support for automatic reprojection and resampling, SpatioTemporal Asset Catalogs
(STAC), or time-series analysis for each of these libraries. Tables 2 and 3 display a number of metrics
8 Adam J. Stewartet al.
Table 2.GitHub engagement statistics for popular GeoML libraries (as of September 2025). All statistics are reported by the
GitHub API. Test coverage is manually calculated when not available via Codecov and may be higher than reported in the
case of failing tests.
Library Contributors Forks Watchers Stars Issues PRs Coverage License
TorchGeo 108 473 56 3,663 173 2,339 100% MIT
OTB 41 121 40 375 3 24 56% Apache-2.0
TerraTorch 40 101 23 601 92 634 55% Apache-2.0
DeepForest 35 217 17 657 96 530 86% MIT
Raster Vision 33 393 71 2,163 40 1,465 90% Apache-2.0
samgeo 24 351 59 3,408 33 154 13% MIT
spopt 23 55 12 341 30 265 77% BSD-3-Clause
SITS 17 86 27 515 26 653 91% GPL-2.0
SPy 15 146 35 636 25 38 69% MIT
srai 15 27 12 316 104 280 92% Apache-2.0
ML4Floods 13 42 18 170 1 73 0% LGPL-3.0
GEO-Bench 13 12 12 153 8 9 51% Apache-2.0
scikit-eo 8 24 6 206 4 14 32% Apache-2.0
GeoAI 7 202 33 1,587 24 174 6% MIT
Myria3D 7 31 14 259 18 79 57% BSD-3-Clause
GeoTessera 6 14 4 146 11 9 15% ISC
OTBTF 5 39 11 166 22 19 55% Apache-2.0
GeoDeep 3 24 9 326 3 3 0% AGPL-3.0
useful for gauging the popularity and stability of each library.1While the number of GitHub stars
and PyPI downloads are useful for gauging popularity, the number of contributors and test cover-
age are much more reliable for gauging the stability and long-term success of the library. Finally
we describe the abstractions in three popular libraries: TorchGeo, eo-learn, and Raster Vision. We
also assess the typical user base, limitations, and scope of each library.
3.2.1 TorchGeo
TorchGeois a PyTorch domain library designed to unite machine learning and remote sensing
experts under a single platform. It defines two broad classes of datasets:GeoDatasetfor uncurated
raster and vector data files andNonGeoDatasetfor curated benchmark datasets.
Like other libraries on this list, users can directly useGeoDatasetand its subclasses,RasterDataset
andVectorDataset, to load and process arbitrary raster and vector data. Each dataset consists of a
geopandasGeoDataFrameindex, allowing different datasets to be intelligently composed based on
spatiotemporal intersection or union. The resulting dataset can then be queried by a spatiotemporal
slice, allowing users to quickly load small patches of imagery and masks from large collections of
raster scenes. Reprojection and resampling are automatically handled by rasterio and fiona, and users
can specify which spectral bands they want to load. To ease spatiotemporal indexing, TorchGeo
defines aGeoSamplerinterface, allowing users to select various random (for training) or sequential
(for inference) sampling strategies.
1. All tables are maintained in perpetuity at https://torchgeo.rtfd.io/en/latest/user/alternatives.html. If any metrics are out
of date, please open a pull request to update them.
9
Table 3.Download statistics for popular GeoML libraries (as of September 2025). Note that weekly download metrics may
be volatile. OTB and OTBTF are not distributed on any package index and therefore download statistics are not available.
SITS includes both CRAN and PyPI downloads.
PyPI/CRAN Conda Total
Library Last Week Last Month All Time All Time All Time
TorchGeo 69,430 200,906 845,353 40,949 886,302
OTB 0 0 0 0 0
TerraTorch 3,870 29,514 130,473 0 130,473
DeepForest 2,483 6,526 988,841 97,503 1,086,344
Raster Vision 4,666 8,613 221,409 5,872 227,281
samgeo 2,319 6,692 274,609 54,307 328,916
spopt 13,289 44,498 1,122,138 251,912 1,374,050
SITS 477 1,967 22,502 136,850 159,352
SPy 17,720 59,792 1,445,738 150,137 1,595,875
srai 661 1,962 51,103 0 51,103
ML4Floods 90 195 10,254 0 10,254
GEO-Bench 609 1,818 58,756 0 58,756
scikit-eo 515 598 22,281 0 22,281
GeoAI 1,765 7,277 63,399 16,747 80,146
Myria3D 13 33 4,429 0 4,429
GeoTessera 348 1,218 3,725 0 3,725
OTBTF 0 0 0 0 0
GeoDeep 229 920 18,540 0 18,540
TorchGeo also includes a number of curated ML-ready benchmark datasets designed to train
and evaluate models for specialized tasks such as crop type mapping, biomass estimation, or disaster
response. Each of these datasets provides an input image and an output target, such as a semantic
segmentation mask or object detection bounding box. In total, TorchGeo provides over 125 built-in
geospatial and benchmark datasets, more than all other libraries combined.
Another primary focus of TorchGeo is on providing pretrained foundation models capable of
being finetuned for any task. TorchGeo provides over 120 such model weights, including models
pretrained on Landsat, NAIP, and Sentinel imagery and newer “sensor-agnostic” foundation models
like Scale-MAE (Reed et al. 2023), DOFA (Xiong et al. 2024), CROMA (Fuller, Millard, and Green
2023), Panopticon (Waldmann et al. 2025), and Copernicus-FM (Wang et al. 2025).
TorchGeo places a great deal of emphasis on documentation and testing, with 100% test cover-
age on three Python versions, three platforms, and the minimum and maximum supported depen-
dency versions. It also has more than double the number of contributors as any other library on this
list, demonstrating its widespread adoption by the community. Its component-based nature, pro-
viding PyTorch-compatible datasets and models for the community, naturally allows other libraries
like TerraTorch and GeoAI to build on top of TorchGeo, extending its features and capabilities.
3.2.2 eo-learn
eo-learnis a Python library that aims to bridge the gap between the remote sensing and data sci-
ence ecosystems. It is highly coupled with the commercial Sentinel Hub library and ecosystem, and
enables users to build reusable workflows based around theEOPatch,EOTask, andEOWorkflow
abstractions. AnEOPatchcontains all types of data for a given bounding box location — raster data
with time series support, vector data, and one-off masks like land cover information.EOTasks oper-
10 Adam J. Stewartet al.
ate onEOPatches and transform them, for example performing cloud masking, computing spectral
indices, classical feature extraction pipelines, and/or classification. Finally,EOTasks are organized
into computational graphs that exchange patch objects and run inEOWorkflows, allowing for par-
allelization and record keeping.
For data I/O, eo-learn relies on GDAL (typically through rasterio) for reading geospatial raster
data, and also uses OpenCV, pandas, SciPy, and Zarr under the hood. This means it can handle
common raster formats and even work with large out-of-core datasets (Zarr provides chunked, on-
disk array storage). For vector data and geometric operations, eo-learn uses GeoPandas, enabling
integration of shapefiles or GeoJSON data for tasks like sampling points or computing zonal statis-
tics. NumPy is used as the primary foundation for array transformations and manipulations within
tasks.
Time-series modeling is not explicitly provided as a specialized feature, although eo-learn can
certainly process time-indexed imagery (e.g., stacking time frames in anEOPatchobject) — but
it lacks specialized time-series ML models or temporal analysis tools out-of-the-box. eo-learn is
best suited for Earth observation practitioners and data scientists who need to preprocess satellite
imagery and derive features for modeling. Its ease of integration with scikit-learn makes it ideal for
prototyping land cover classifications or regressions on remote sensing data when deep learning is
not required.
3.2.3 Raster Vision
Raster Visionis a Python library for training and deploying deep learning models with satellite
imagery. It was originally developed by Azavea and has been maintained by Element 84 since
February of 2023. Similar to eo-learn, Raster Vision is built around the idea of data pipelines. The
input to a Raster Vision pipeline is imagery and labels over given areas of interest (AOIs) while the
output is a trained model formatted in a “bundle” for deployment. The pipeline steps include:
1.Analyze- compute dataset-level statistics
2.Chip- convert geospatial data into uniformly sized patches that can be input into a model in a
batched manner
3.Train- train a machine learning model via aLearnerabstraction (typically using a PyTorch
backend)
4.Predict and Evaluate- run inference with a trained model over validation and test data and
compute performance metrics
5.Bundle- Create a model bundle to be used in deployments
Raster Vision creates abstractions for every step in the above pipeline. For example, input
data is represented by source classes:RasterSource, with subclasses such asRasterioSourceor
XarraySource,VectorSource, andLabelSource. Different sources are combined intoScenes
— collections of data over the same area of interest — and finally a PyTorch DataLoader-compatible
GeoDatasetobject that can be used with various training pipelines (e.g., PyTorch Lightning).
4. Application Example
In order to demonstrate the power and potential of GeoML libraries, let us consider the follow-
ing example. A researcher has access to hundreds (or even thousands) of raster images and one or
more vector files containing polygon labels. They would like to train a model to perform semantic
segmentation, assigning a class label to every pixel in the image. Each raster and vector file in the
dataset may have a different CRS or resolution, and may or may not have spatiotemporal overlap.
This example is representative of a broad class of tasks in remote sensing, and can apply to anything
from building or road segmentation, to land use/land cover mapping, to deforestation and natural
disaster analysis.
11
Figure 2.A common use case for GeoML practitioners is joining raster data, such as satellite imagery (top left), with vector
data, such as crop masks (bottom left), then randomly sampling patches from the intersection of these datasets to use in
modeling pipelines (right).
To make this more concrete, let us say that the raster images are from Sentinel-2 (Drusch et
al. 2012) and the vector files are from EuroCrops (Schneider et al. 2023) (see Figure 2). The goal
is to perform crop type mapping, with each pixel being assigned to one of∼200 crop classes. This
requires reprojection, rasterization, and chipping of each image and vector file into smaller image
patches that can be passed through the model. For the model, we will use a simple U-Net (Ron-
neberger, Fischer, and Brox 2015) architecture with a ResNet-50 (He et al. 2016) backbone.
Now, let us see how this task can be solved with various levels of abstraction using TorchGeo.
TorchGeo is available on PyPI and Conda Forge, and can easily be installed using:
> pip install torchgeo
TorchGeo is designed with the same API as other PyTorch domain libraries. The below code should
look familiar to anyone with experience using libraries like torchvision and PyTorch Lightning.
The following examples demonstrate three different levels of abstraction, each with their own pros
and cons.2
4.1 Pure PyTorch
For maximum control and customization, TorchGeo datasets, samplers, and pre-trained models can
be used directly. While the data loader setup is a bit custom, the rest of the training and evaluation
pipeline is identical to other PyTorch domain libraries.
2. Maintained and well-tested notebooks for many of these application examples can be found at: https://torchgeo.rtfd.io/
en/latest/tutorials/getting_started.html.
12 Adam J. Stewartet al.
First, we import everything we will later require.
import segmentation_models_pytorch as smp
import torch
from torch import nn, optim
from torch.utils.data import DataLoader
from torchgeo.datasets import (
EuroCrops, Sentinel2, random_grid_cell_assignment
)
from torchgeo.models import ResNet50_Weights
from torchgeo.samplers import (
GridGeoSampler, RandomGeoSampler
)
Given a user-defined local directory or list of remote file paths, we next instantiate PyTorchDataset
objects for Sentinel-2 and EuroCrops data. Given a spatiotemporal slice, this dataset is responsible
for loading the data at that time and location from disk. We then compute the spatiotemporal
intersection of these datasets. All data is automatically reprojected to a shared CRS and rasterized
on the fly.
sentinel2 = Sentinel2(paths='...')
eurocrops = EuroCrops(paths='...', download=True)
dataset = sentinel2 & eurocrops
Next, we overlay a 10×10 grid over the dataset. Each grid cell is randomly assigned to a train,
validation, or test split using an 80:10:10 split. Note that TorchGeo has other geospatial splitting
strategies that may be more suitable for out-of-distribution evaluation.
train_ds, val_ds, test_ds = random_grid_cell_assignment(
dataset, [0.8, 0.1, 0.1], grid_size=10
)
Next, we instantiate PyTorchSamplerobjects for each split. The sampler is responsible for telling
the dataset where and when to load data from. Here, we use random sampling at training time
to maximize the diversity of the training data and grid-based sampling at evaluation time to avoid
overlap or missing locations.
train_sr = RandomGeoSampler(train_ds, size=224)
val_sr = GridGeoSampler(val_ds, size=224, stride=224)
test_sr = GridGeoSampler(test_ds, size=224, stride=224)
All TorchGeo datasets and samplers are compatible with PyTorch’s built-inDataLoaderclass. Here,
we set the batch size and tell the data loader where it is allowed to sample from.
batch_size = 64
train_dl = DataLoader(train_ds, batch_size, sampler=train_sr)
val_dl = DataLoader(val_ds, batch_size, sampler=val_sr)
test_dl = DataLoader(test_ds, batch_size, sampler=test_sr)
Next, we instantiate our model. TorchGeo comes with 120+ model weights pre-trained on SAR,
RGB, MSI, and HSI remote sensing imagery. In this case, we use a model pre-trained on all 13
bands of Sentinel-2 imagery using self-supervised learning (Wang et al. 2023).
model = smp.Unet('resnet50', in_channels=13, classes=200)
weights = ResNet50_Weights.SENTINEL2_ALL_DINO
model.encoder.load_state_dict(weights.get_state_dict())
13
We next transfer our model to the GPU. Note that this step may look different for NVIDIA, AMD,
and Apple Silicon GPUs.
device ='cuda'if torch.cuda.is_available() else'cpu')
model = model.to(device)
For our loss function, we choose cross-entropy loss, which works well for multiclass classification
and semantic segmentation tasks. For our optimizer, we choose stochastic gradient descent (SGD).
Users can and should experiment with fancier optimizers here.
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=1e-2)
We define a train function containing the forward and backward pass of our model for a single
epoch.
def train(dataloader):
model.train()
total_loss = 0
for batch in dataloader:
x = batch['image'].to(device)
y = batch['mask'].to(device)
# Forward pass
y_hat = model(x)
loss = loss_fn(y_hat, y)
total_loss += loss.item()
# Backward pass
loss.backward()
optimizer.step()
optimizer.zero_grad()
print(f'Loss: {total_loss:.2f}')
We define a similar evaluation function containing the forward pass of our model and compute the
overall accuracy of a single epoch.
def evaluate(dataloader):
model.eval()
correct = 0
with torch.no_grad():
for batch in dataloader:
x = batch['image'].to(device)
y = batch['label'].to(device)
# Forward pass
y_hat = model(x)
y_hat_hard = y_hat.argmax(1) == y
correct += y_hat_hard.sum().item()
correct /= len(dataloader.dataset)
print(f'Accuracy: {correct:.0%
14 Adam J. Stewartet al.
Finally, we combine everything and train and evaluate our model over 100 epochs. Validation
accuracy can be used for early stopping and for hyperparameter tuning. Once an optimal set of
hyperparameters is found, we report the final test accuracy.
for epoch in range(100):
print(f'Epoch: {epoch}')
train(train_dataloader)
evaluate(val_dataloader)
evaluate(test_dataloader)
4.2 PyTorch Lightning
While the above code has the most flexibility and can be easily customized to add preprocessing or
data augmentation, it can be daunting for many users. Beginners are likely to make mistakes when
computing accuracy metrics, while experts may require a lot of code duplication if they want to,
for example, evaluate several model architectures on dozens of different datasets. To simplify the
training and evaluation pipeline, TorchGeo offers PyTorch Lightning (Falcon and The PyTorch
Lightning team 2019) integration. PyTorch Lightning introduces two ideas:data modules, col-
lections of train/val/test datasets and the transforms applied to them, andmodules, reusable recipes
for tasks like classification, regression, or semantic segmentation. TorchGeo provides built-in data
modules for many datasets and modules for:
•Classification (binary, multiclass, multilabel)
•Regression (imagewise, pixelwise)
•Semantic Segmentation (binary, multiclass, multilabel)
•Change Detection (binary, multiclass, multilabel)
•Object Detection
•Instance Segmentation
•Self-Supervised Learning (BYOL (Grill et al. 2020), MoCo (He et al. 2020), SimCLR (Chen
et al. 2020))
The following code can be easily extended to support TensorBoard logging (Lee et al. 2015), early
stopping, and model checkpointing, and implements all of the steps from the previous section with
significantly fewer lines of code.
from lightning.pytorch import Trainer
from torchgeo.datamodules import Sentinel2EuroCropsDataModule
from torchgeo.models import ResNet50_Weights
from torchgeo.trainers import SemanticSegmentationTask
model = SemanticSegmentationTask(
model='unet',
backbone='resnet50',
weights=ResNet50_Weights.SENTINEL2_ALL_DINO,
in_channels=13,
num_classes=200,
lr=1e-2,
)
datamodule = Sentinel2EuroCropsDataModule(
sentinel2_paths='...',
eurocrops_paths='...',
15
batch_size=64,
patch_size=224,
)
trainer = Trainer(max_epochs=100)
trainer.fit(model=model, datamodule=datamodule)
trainer.test(model=model, datamodule=datamodule)
4.3 Command Line
In the research community, easy experimentation and reproducibility are paramount. TorchGeo
offers a command-line interface based on LightningCLI, with support for command-line, Y AML,
and JSON configuration. The following Y AML file can be used to reproduce an experiment from a
paper without writing a single line of code.
model:
class_path: SemanticSegmentationTask
init_args:
model:'unet'
backbone:'resnet50'
weights:'ResNet50_Weights.SENTINEL2_ALL_DINO'
in_channels: 13
num_classes: 200
lr: 1e-2
data:
class_path: Sentinel2EuroCropsDataModule
init_args:
batch_size: 64
patch_size: 224
dict_kwargs:
sentinel2_path:'...'
eurocrops_path:'...'
Once TorchGeo is installed, the user simply needs to run commands likefitortestto train and
evaluate their model.
> torchgeo fit --config config.yaml
> torchgeo test --config config.yaml --ckpt_path=...
5. Best Practices and Open Issues
With so many successful or abandoned GeoML libraries over the years, there is a wealth of in-
formation on best practices to follow (and also what to avoid). Despite significant progress towards
forming a consensus on code and data hosting repositories, there are still many open issues for future
generations to tackle.
5.1 File Formats
One of the primary purposes of GeoML libraries is to load and preprocess data. Thus, choosing the
right file format is critical to achieve efficient I/O and keep the GPU busy. While GeoML libraries
themselves are often agnostic to file format and support a wide range of file types,usersof GeoML
libraries can drastically improve the speed of training and inference by choosing the right file type.
For uncurated raster and vector data layers, GeoTIFF and ESRI Shapefile have long been stan-
dard. In particular, so-called “cloud optimized GeoTIFFs” (COGs) support fast and efficient win-
dowed reading, allowing tools like TorchGeo to load small image patches without reading the entire
16 Adam J. Stewartet al.
file from disk. Preprocessing, including manual reprojection, target aligned pixels (TAP), and com-
pression, can all improve I/O performance (A. J. Stewart et al. 2024).
For curated ML-ready benchmark datasets, geospatial metadata is often unnecessary or absent.
Typical file formats include PNG and JPEG, with newer file formats like Parquet and Zarr becoming
more common for larger datasets. Language- or software-specific file formats like PyTorch’s .pth,
NumPy’s .npy, or Python’s pickle should be avoided to ensure cross-language support.
Large-scale datasets commonly used for self-supervised learning and foundation model pretrain-
ing require their own careful consideration. Datasets such as SSL4EO (Wang et al. 2023; A. Stewart
et al. 2023), SatlasPretrain (Bastani et al. 2023), and CopernicusPretrain (Wang et al. 2025) consist of
anywhere from millions to billions of files, easily enough to overwhelm all but the largest compute
clusters. Modern formats like WebDataset (Breuel et al. 2019) and LitData (Chaton and Lightning
AI 2023) offer support for sharding and streaming data, avoiding inode and storage limits.
5.2 Distribution
GitHub is the primary hosting platform for GeoML libraries, with every single library on the list
being developed or mirrored on GitHub. While many geospatial software packages are still hosted
on private servers like OSGeo and bug reports are filed through TRAC, GitHub has long been
popular within the ML community. Having a single shared platform for everything from version
control to continuous integration to bug reporting makes it easier for potential users to find your
software and potential contributors to improve your software.
While GitHub can be used for release distribution, the vast majority of successful GeoML li-
braries are distributed through language-specific servers like PyPI (Python), CRAN (R), or Conda-
Forge (Python/R). In fact, most of the abandoned GeoML libraries on our list either never had stable
releases, or were only distributed throughgit cloneordocker pull. In the Python ecosystem,
pre-compiled binaries (bdists) such as wheels are critical for ease of installation, especially on Win-
dows.
GeoML datasets and pre-trained model weights can be found on a variety of platforms, with
personal Google Drive, OneDrive, and Baidu Drive being common. However, these platforms
should be avoided for serious scientific advances, as it is too easy to accidentally delete the wrong
file or directory. Instead, dedicated data hosting platforms like Zenodo or Hugging Face should be
used instead. While A WS S3 buckets and Source Cooperative repositories are useful for extremely
large datasets, they lack stable download URLs and checksumming capabilities required to ensure
reproducibility.
5.3 Licensing
One of the most important considerations for developers and users of GeoML software is the license
under which it is distributed. Often overlooked by researchers, the license allows the owner of the IP
(copyright, trademark, and/or patent) to explicitly grant certainpermissions, with certainlimitations,
subject to certainconditions. For example, the popular MIT license grants the userpermissionto
redistribute and modify the software, including commercial and private use,limitingliability and
warranty of the developer, under theconditionthat the user preserves the license and copyright
notice. In this sense, licenses protect both the users and contributors.
There are two broad families of licenses: permissive and copyleft. Permissive licenses like MIT
and Apache-2.0 are generally more relaxed, with the onlyconditionthat the license must be pre-
served. Copyleft licenses like the GNU Public License (GPL), on the other hand, impose strict
constraints on users such that any code bundled with the software must be released under the same
license. Copyleft licenses are generally incompatible with industry, limiting adoption by many
communities. With the exception of SITS, ML4Floods, and GeoDeep, every single GeoML library
under active development is released under a permissive license (see Table 2), reflecting the broader
17
Python and ML communities. SITS, like R itself, is licensed under GPL, restricting its use primarily
to academic settings.
While software licenses can technically be used for data and models, many of the clauses in these
licenses are not applicable to data or models. Instead, the Creative Commons family of licenses is
more common, including CC0 (public domain), CC-BY (Attribution), CC-BY-SA (Attribution-
ShareAlike), and CC-BY-NC (Attribution-NonCommercial). Responsible AI Licenses (RAIL) are
another family of licenses tailored specifically for the AI community, with subcategories for Data,
Apps, Models, and Source code. However, it is worth noting that CC-BY-NC and OpenRAIL are
not considered to be open source licenses, as they restrict certain usage.
The important thing for both code and data is to choose a license3and stick with it. In particular,
datasets without licenses are unfortunately pervasive and challenging for GeoML libraries. While
rarely enforced, it is technically illegal to even download let alone use or redistribute data without
a license.
5.4 Continuous Integration
A good software library is not complete withoutcontinuous integration(CI), suites of checks and tests
to ensure software quality that typically run on every commit, branch, pull request, and release.
GitHub Actions is currently the dominant CI platform for free, public libraries, replacing Travis CI
and CircleCI which dominated before its release.
CI can and should consist of a variety of different types of testing. The most obvious is unit test-
ing, designed to ensure that individual functions and classes behave as they are designed to. Testing
frameworks, including pytest for Python and testthat for R, handle the heavy lifting, allowing one
to quickly add test cases (expected output given a certain input). Many libraries also run integration
tests on release branches, ensuring that functions and classes can be integrated into a larger frame-
work. Test coverage is particularly important as it ensures that the majority of the library is touched
by unit tests. Test coverage can be reported by services including Codecov and Coveralls. Software
libraries with less than 80% test coverage are generally not recommended for production use and
should be considered unstable.
Even more important than unit testing is documentation. Tools like Sphinx can be used to
build and test the documentation, and documentation hosting sites like ReadTheDocs provide CI
support, allowing developers to see the documentation generated by each pull request. Sphinx can
also automatically generate API documentation from function and class docstrings, allowing you to
easily maintain high-quality documentation.
Dynamically typed languages like Python can also benefit from type hints. Tools like mypy,
pytype, pyright, pyre, and ty can be used to enforce strict static typing, preventing a number of bugs
caused by bad typing practices. Tools like Sphinx can even use these type hints when generating
API documentation. Similarly, tools like flake8, isort, black, and ruff can be used to enforce style
guides, resulting in well-formatted code. While these may not seem important for single-author
projects, they become critical for maintaining projects with hundreds of contributors.
5.5 Open Issues
Testing and reproducibility (Heil et al. 2021) remain the biggest challenges faced by GeoML libraries
at the moment. While many actively maintained GeoML libraries have over 90% test coverage (see
Table 2), the majority fall far below, with some having no testing at all. A lack of tests puts these
projects at risk of both bugs (unexpected or incorrect behavior) and regressions (when a fixed bug
resurfaces later). In addition, tests can ensure software stability, warning developers of unintentional
backwards-incompatible changes and allowing them to mitigate or document the change before
making a release.
3. https://choosealicense.com/
18 Adam J. Stewartet al.
Test coverage itself is not the only important metric. Just because a line of code can be exe-
cuted without raising an error does not mean it produces a desirable result. Machine learning is
inherently stochastic, with non-determinism originating from the data (cross validation split, data
augmentation, random shuffling), the model (initial weights, dropout layers), and the optimiza-
tion process (SGD, momentum, learning rate scheduler). While setting a random seed can alleviate
some of these sources of non-determinism, reproducibility is not guaranteed across software ver-
sions, platforms, and accelerators (CPU, GPU, TPU). This makes testing challenging for developers
and perfect reproducibility practically impossible for users.
As datasets and models continue to grow in size, computational performance becomes increas-
ingly important. Maximizing I/O and data transfer speeds, especially for parallel filesystems and
on distributed compute, remains an important challenge. Libraries like Kornia (Riba et al. 2020)
address some of these challenges by implementing data augmentations directly in PyTorch or Rust,
providing significant speedups over pure Python implementations. It may be possible to achieve
similar speedups for reprojection and resampling, often the biggest bottlenecks for geospatial data
processing, by implementing these operations in PyTorch or CUDA and performing them on the
GPU.
6. Future Implications
With increased interest in and funding for geospatial intelligence by industry, the future of GeoML
libraries looks promising. Below, we list our own predictions for what the next five years will look
like.
6.1 Foundation Models to Embeddings
Foundation models (Bommasani et al. 2021) — large, task-agnostic deep learning models pretrained
on massive amounts of data — have dominated the last few years of research. We expect this dom-
inance to continue, especially in the geospatial domain where scientists so often deal with limited
labeled data. While most current research focuses on EO foundation models for SAR and MSI satel-
lite imagery, we expect foundation models to expand to a greater number of modalities, including
HSI, UA V, and LiDAR data.
We also anticipate the development of unified foundation models for the land surface, ocean, and
atmosphere (Zhu et al. 2024). This is especially important in the area of weather and climate mod-
eling, where these processes are all interconnected and cannot be individually modeled. Application
domains like air pollution and nowcasting provide new challenges for GeoML libraries, forcing the
incorporation of real-time point data in unstructured graphs instead of curated raster data.
The recent release of a number of high-profile foundation model embeddings, including Ma-
jor TOM (Czerkawski, Kluczek, Bojanowski, et al. 2024) and AlphaEarth Foundations (Brown et
al. 2025), raises the question: are GeoML libraries still necessary? Deep learning can be very com-
putationally demanding and requires technical expertise that many users lack, while pre-computed
global embeddings allow users to run simple linear probing layers ork-NN models directly on
foundation model outputs. However, GeoML libraries are still necessary to generate new embed-
dings, and foundation model fine-tuning still offers higher performance. Conversely, embeddings
have opened the door for a new type of GeoML library, like GeoTessera, which ease the use of
large-scale embeddings.
6.2 Growing Focus on Reuse and Ease of Use
The majority of the history of GeoML libraries has seen a “reinvention of the wheel”, with new li-
braries introducing clever ideas and solutions for common challenges without reusing older libraries.
This is especially true for pipeline-based libraries like Raster Vision and eo-learn, which are easy to
use but difficult to build on top of. The introduction of component-based libraries like TorchGeo
19
has changed this, with libraries like GEO-Bench, TerraTorch, and GeoAI supplementing instead
of replacing TorchGeo.
Foundation models and embeddings have shown us that ease of use is often more important than
accuracy. We expect further abstractions on top of component-based libraries providing low-code
or no-code solutions for GIS domain experts. A handful of machine learning plugins already exist for
ArcGIS and QGIS, but lack the power and features of existing GeoML libraries. Vision–language
foundation models like DOFA-CLIP (Xiong et al. 2025) present an interesting opportunity for
zero-shot learning, in which the user can ask the model to perform a task using natural language.
6.3 Independent Governance and Software Foundations
However, successful software is often made by multiple people working together on behalf of a
company or research institution. This incubation process provides the necessary funding and ad-
vertising needed for the project to take off. After gaining popularity, successful software can quickly
outgrow the organization that created it. Once this happens, independent governance is required to
allow the project to continue to grow. Examples of this include PyTorch (developed by Meta) and
TensorFlow/Keras/JAX (developed by Google), which are now governed by independent teams of
maintainers.
Several GeoML libraries have graduated beyond this incubation status and achieved open and
independent governance. OTB gained independence from CNES and announced its new open
governance model in March of 2015. PySAL has always been independent and adopted a formal
governance structure in February of 2019. TorchGeo gained independence from Microsoft in Au-
gust of 2025 and now holds monthly Technical Steering Committee meetings open to the public.
All three of these libraries have cultivated successful open source ecosystems, with further GeoML
libraries extending their capabilities: OTB (OTBTF), PySAL (spopt), and TorchGeo (GEO-Bench,
GeoAI, TerraTorch).
An interesting question is what role software foundations should play in this incubation pro-
cess. Many geospatial and ML software foundations exist, including the Open Source Geospatial
Foundation (OSGeo), the PyTorch Foundation, the Linux Foundation AI & Data, and the AI Al-
liance. OTB and TorchGeo already belong to OSGeo, while TerraTorch recently joined the AI
Alliance. These foundations provide advertising, financial support, and legal support for a variety of
software projects, promoting collaboration between member projects. These software foundations
could provide a neutral home for many such GeoML libraries.
Acknowledgments
The authors would like to thank the contributors to and maintainers of all GeoML software for their
tireless efforts in building much-needed software infrastructure for this domain. In particular, we
would like to thank Nicolas Audebert (author of DeepNetsForEO and DeepHyperX) and Gilberto
Camara (author of SITS) for sharing their knowledge about the early history of GeoML software.
We would also like to thank Robin Cole and Eduardo Lacerda for maintaining listings of all major
GeoML libraries throughout recent years. The work was supported in part by the National Science
Foundation (NSF) through awards IIS 21-31335, OAC 21-30835, DBI 20-21898, as well as a C3.ai
research award.
References
Abadi, Martín, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat,
Geoffrey Irving, Michael Isard, et al. 2016. TensorFlow: a system for large-scale machine learning. In12th usenix
symposium on operating systems design and implementation (osdi 16),265–283.
Aleksandrov, Matej, et al. 2018.Eo-learn: Earth observation processing framework for machine learning in Python.https://github.
com/sentinel-hub/eo-learn.
20 Adam J. Stewartet al.
Alexandrov, Alexander, Konstantinos Benidis, Michael Bohlke-Schneider, Valentin Flunkert, Jan Gasthaus, Tim Januschowski,
Danielle C Maddix, Syama Rangapuram, David Salinas, Jasper Schulz, et al. 2020. GluonTS: probabilistic and neural
time series modeling in Python.Journal of Machine Learning Research21 (116): 1–6.
Aszkowski, Przemysław, Bartosz Ptak, Marek Kraft, Dominik Pieczyński, and Paweł Drapikowski. 2023. Deepness: deep
neural remote sensing plugin for QGIS.SoftwareX23:101495.ISSN: 2352-7110. https://doi.org/https://doi.org/10.
1016/j.sof tx.2023.101495. https://www.sciencedirect.com/science/article/pii/S2352711023001917.
Audebert, N., B. Le Saux, and S. Lefèvre. 2019. Deep learning for classification of hyperspectral data: a comparative review.
IEEE Geoscience and Remote Sensing Magazine7, no. 2 (June): 159–173.ISSN: 2373-7468. https://doi.org/10.1109/
MGRS.2019.2912563.
Audebert, Nicolas, Bertrand Le Saux, and Sébastien Lefèvre. 2017. Beyond RGB: very high resolution urban remote sensing
with multimodal deep networks.ISPRS Journal of Photogrammetry and Remote Sensing,ISSN: 0924-2716. https://doi.org/
https://doi.org/10.1016/j.isprsjprs.2017.11.011.
Azavea/Element 84 and Robert Cheetham. 2017.Raster Vision: An open source library and framework for deep learning on satellite
and aerial imagery (2017-2023).https://github.com/azavea/raster-vision.
Bastani, Favyen, Piper W olters, Ritwik Gupta, Joe Ferdinando, and Aniruddha Kembhavi. 2023. SatlasPretrain: a large-scale
dataset for remote sensing image understanding. InProceedings of the ieee/cvf international conference on computer vision,
16772–16782.
Bhadra, Sourav. 2023.Raster4ML: a geospatial raster processing library for machine learning.https://github.com/souravbhadra/
raster4ml.
Boggs, Thomas, et al. 2001.Spectral Python (SPy): Python module for hyperspectral image processing.https : / / github . com /
spectralpython/spectral.
Bommasani, Rishi, Drew A Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von Arx, Michael S Bernstein, Jean-
nette Bohg, Antoine Bosselut, Emma Brunskill, et al. 2021. On the opportunities and risks of foundation models.arXiv
preprint arXiv:2108.07258.
Bradski, Gary, Adrian Kaehler, et al. 2000. OpenCV.Dr. Dobb’s Journal of Software Tools3 (2).
Breuel, Thomas, et al. 2019.W ebDataset: a high-performance Python-based I/O system for large (and small) deep learning problems,
with strong support for PyTorch.https://github.com/webdataset/webdataset.
Brockman, Greg, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and W ojciech Zaremba.
2016. OpenAI Gym.arXiv preprint arXiv:1606.01540.
Brown, Christopher F, Michal R Kazmierski, Valerie J Pasquarella, William J Rucklidge, Masha Samsikova, Chenhui Zhang,
Evan Shelhamer, Estefania Lahera, Olivia Wiles, Simon Ilyushchenko, et al. 2025. AlphaEarth Foundations: an em-
bedding field model for accurate and efficient global mapping from sparse label data.arXiv preprint arXiv:2507.22291.
Camara, Gilberto, Rolf Simoes, Felipe Souza, Felipe Carlos, Charlotte Pelletier, Pedro R. Andrade, Karine Ferreira, and
Gilberto Queiroz. 2024.SITS - satellite image time series analysis on Earth observation data cubes.National Institute for
Space Research (INPE), Brazil.
Chang, Chih-Chung, and Chih-Jen Lin. 2011. LIBSVM: a library for support vector machines.ACM transactions on intelligent
systems and technology (TIST)2 (3): 1–27.
Chaton, Thomas, and Lightning AI. 2023.LitData: transform datasets at scale. optimize datasets for fast ai model training.https:
//github.com/Lightning-AI/litdata.
Chen, Hao, and Zhenwei Shi. 2020. A spatial-temporal attention-based method and a new dataset for remote sensing image
change detection.Remote Sensing12 (10): 1662.
Chen, Ting, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. 2020. A simple framework for contrastive learn-
ing of visual representations. InInternational conference on machine learning,1597–1607. PmLR.
Chowdhury, Kanchan, and Mohamed Sarwat. 2022. GeoTorch: a spatiotemporal deep learning framework. InSigspatial ’22.
Seattle, Washington: Association for Computing Machinery.ISBN: 9781450395298. https://doi.org/10.1145/3557915.
3561036. https://doi.org/10.1145/3557915.3561036.
Collette, Andrew, et al. 2008.HDF5 for Python – the h5py package is a Pythonic interface to the HDF5 binary data format.
https://github.com/h5py/h5py.
Coltin, Brian, et al. 2019.DELT A: deep learning for satellite imagery.https://github.com/nasa/delta.
21
Corley, Isaac. 2021.Torchrs: PyTorch implementation of popular datasets and models in remote sensing.https : / / github . com /
isaaccorley/torchrs.
Cresson, Rémi. 2018. A framework for remote sensing images processing using deep learning techniques.IEEE Geoscience
and Remote Sensing Letters16 (1): 25–29.
Czerkawski, Mikolaj, Marcin Kluczek, JÄ Bojanowski, et al. 2024. Global and dense embeddings of Earth: Major TOM
floating in the latent space.arXiv preprint arXiv:2412.05600.
Damien, Aymeric, et al. 2016.TFLearn: deep learning library featuring a higher-level API for TensorFlow.https://github.com/
tf learn/tf learn.
Deng, Jia, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. 2009. ImageNet: a large-scale hierarchical image
database. In2009 ieee conference on computer vision and pattern recognition,248–255. IEEE.
Dimitrovski, Ivica, Ivan Kitanovski, Dragi Kocev, and Nikola Simidjievski. 2023. Current trends in deep learning for Earth
observation: an open-source benchmark arena for image classification.ISPRS Journal of Photogrammetry and Remote
Sensing197:18–35.ISSN: 0924-2716.
Dimitrovski, Ivica, Ivan Kitanovski, Panče Panov, Ana Kostovska, Nikola Simidjievski, and Dragi Kocev. 2023. AiTLAS:
artificial intelligence toolbox for Earth observation.Remote Sensing15 (9).ISSN: 2072-4292. https://doi.org/10.3390/
rs15092343.
Drusch, Matthias, Ugo Del Bello, Séverine Carlier, Olivier Colin, Viviana Fernandez, Ferran Gascon, Bernhard Hoersch, et
al. 2012. Sentinel-2: ESA’s optical high-resolution mission for GMES operational services.Remote Sensing of Environment
120:25–36. https://doi.org/10.1016/j.rse.2011.11.026.
Falcon, William, and The PyTorch Lightning team. 2019.PyTorch Lightning.https://github.com/Lightning-AI/lightning.
Feng, Xin, Germano Barcelos, James D. Gaboardi, Elijah Knaap, Ran Wei, Levi J. W olf, Qunshan Zhao, and Sergio J. Rey.
2022. Spopt: a Python package for solving spatial optimization problems in PySAL.Journal of Open Source Software7
(74): 3330. https://doi.org/10.21105/joss.03330. https://doi.org/10.21105/joss.03330.
Feng, Zhengpeng, Clement Atzberger, Sadiq Jaffer, Jovana Knezevic, Silja Sormunen, Robin Young, Madeline C Lisaius, et
al. 2025.TESSERA: temporal embeddings of surface spectra for Earth representation and analysis.arXiv: 2506.20380[cs.LG].
https://arxiv.org/abs/2506.20380.
Fuller, Anthony, Koreen Millard, and James Green. 2023. CROMA: remote sensing representations with contrastive radar-
optical masked autoencoders.Advances in Neural Information Processing Systems36:5506–5538.
Gaydon, Charles. 2022.Myria3D: deep learning for the semantic segmentation of aerial lidar point clouds.https://github.com/
IGNF/myria3d.
GDAL/OGR contributors. 2022.GDAL/OGR geospatial data abstraction software library.Open Source Geospatial Foundation.
https://doi.org/10.5281/zenodo.5884351. https://gdal.org.
Gillies, Sean, et al. 2013.Rasterio: geospatial raster I/O for Python programmers.https://github.com/rasterio/rasterio.
Gillies, Sean, René Buffat, Joshua Arnott, Mike W. Taves, Kevin Wurster, Alan D. Snow, Micah Cochran, Elliott Sales de
Andrade, and Matthew Perry. 2024.Fiona.V. 1.10.0, September. https://github.com/Toblerity/Fiona.
Gohlke, Christoph. 2018.Tifffile: read and write TIFF files.https://github.com/cgohlke/tif f f ile.
Gomes, Carlos, Benedikt Blumenstiel, Joao Lucas de Sousa Almeida, Pedro Henrique de Oliveira, Paolo Fraccaro, Francesc
Marti Escofet, Daniela Szwarcman, Naomi Simumba, Romeo Kienzler, and Bianca Zadrozny. 2025. TerraTorch: the
geospatial foundation models toolkit.arXiv preprint arXiv:2503.20563.
Gramacki, Piotr, Kacper Leśniara, Kamil Raczycki, Szymon W oźniak, Marcin Przymus, and Piotr Szymański. 2023. SRAI:
towards standardization of geospatial AI. InProceedings of the 6th acm sigspatial international workshop on ai for geographic
knowledge discovery.Association for Computing Machinery, November. https://dl.acm.org/doi/10.1145/3615886.
3627740.
Grill, Jean-Bastien, Florian Strub, Florent Altché, Corentin Tallec, Pierre Richemond, Elena Buchatskaya, Carl Doersch,
Bernardo Avila Pires, Zhaohan Guo, Mohammad Gheshlaghi Azar, et al. 2020. Bootstrap your own latent-a new
approach to self-supervised learning.Advances in Neural Information Processing Systems33:21271–21284.
Grizonnet, Manuel, Julien Michel, Victor Poughon, Jordi Inglada, Mickaël Savinaud, and Rémi Cresson. 2017. Orfeo Tool-
Box: open source processing of remote sensing images.Open Geospatial Data, Software and Standards2 (1): 15.
22 Adam J. Stewartet al.
Harada, Nate. 2023.Moonshine: pretrained remote sensing models for the rest of us.https : / / github . com / moonshinelabs - ai /
moonshine.
Harris, Charles R., K. Jarrod Millman, Stéfan J van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser,
et al. 2020. Array programming with NumPy.Nature585:357–362. https://doi.org/10.1038/s41586-020-2649-2.
He, Kaiming, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. 2020. Momentum contrast for unsupervised visual
representation learning. InProceedings of the ieee/cvf conference on computer vision and pattern recognition,9729–9738.
He, Kaiming, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. 2016. Deep residual learning for image recognition. InProceed-
ings of the ieee conference on computer vision and pattern recognition,770–778.
Heil, Benjamin J, Michael M Hoffman, Florian Markowetz, Su-In Lee, Casey S Greene, and Stephanie C Hicks. 2021.
Reproducibility standards for machine learning in the life sciences.Nature Methods18 (10): 1132–1135.
Hijmans, Robert J., Márcia Barbosa, Roger Bivand, Andrew Brown, Michael Chirico, Emanuele Cordano, Krzysztof Dyba,
Edzer Pebesma, Barry Rowlingson, and Michael D. Sumner. 2018.Terra: R package for spatial data handling.https :
//doi.org/10.32614/CRAN.package.terra.
Hofmann, Daniel J., Bhargav Kowshik, et al. 2018.RoboSat: generic ecosystem for feature extraction from aerial and satellite imagery.
https://github.com/mapbox/robosat.
Hoyer, Stephan, and Hamman Joseph. 2017. Xarray: N-D labeled arrays and datasets in Python.Journal of Open Research
Software5, no. 1 (April). https://doi.org/10.5334/jors.148.
Jia, Yangqing, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and
Trevor Darrell. 2014. Caffe: convolutional architecture for fast feature embedding. InProceedings of the 22nd acm inter-
national conference on multimedia,675–678.
Johnson, Andrew L., et al. 2016.DeepOSM: train a deep learning net with OpenStreetMap features and satellite imagery.https:
//github.com/trailbehind/DeepOSM.
Jordahl, Kelsey, et al. 2013.GeoPandas: Python tools for geographic data.https://github.com/geopandas/geopandas.
Karra, Krishna, Caitlin Kontgis, Zoe Statman-Weil, Joseph C Mazzariello, Mark Mathis, and Steven P Brumby. 2021. Global
land use/land cover with Sentinel 2 and deep learning. In2021 ieee international geoscience and remote sensing symposium
igarss,4704–4707. Brussels, Belgium: IEEE.
Kellenberger, Benjamin, Devis Tuia, and Dan Morris. 2020. AIDE: accelerating image-based ecological surveys with inter-
active machine learning.Methods in Ecology and Evolution11 (12): 1716–1727.
Kerner, Hannah, Snehal Chaudhari, Aninda Ghosh, Caleb Robinson, Adeel Ahmad, Eddie Choi, Nathan Jacobs, Chris
Holmes, Matthias Mohr, Rahul Dodhia, et al. 2025. Fields of the world: a machine learning benchmark dataset for
global agricultural field boundary segmentation. InProceedings of the aaai conference on artificial intelligence,39:28151–
28159.
Kirillov, Alexander, Eric Mintun, Nikhila Ravi, Hanzi Mao, Chloe Rolland, Laura Gustafson, Tete Xiao, Spencer Whitehead,
Alexander C Berg, Wan-Yen Lo, et al. 2023. Segment anything. InProceedings of the ieee/cvf international conference on
computer vision,4015–4026.
Krause, Oswin, et al. 2009.The Shark machine learning library.https://github.com/Shark-ML/Shark.
Krizhevsky, Alex, Geoffrey Hinton, et al. 2009. Learning multiple layers of features from tiny images. Master’s thesis, Uni-
versity of Toronto.
Lacoste, Alexandre, Nils Lehmann, Pau Rodriguez, Evan Sherwin, Hannah Kerner, Björn Lütjens, Jeremy Irvin, David Dao,
Hamed Alemohammad, Alexandre Drouin, et al. 2023. GEO-Bench: toward foundation models for Earth monitoring.
Advances in Neural Information Processing Systems36:51080–51093.
Lee, Stephan, et al. 2015.TensorBoard: TensorFlow’s visualization toolkit.https://github.com/tensorf low/tensorboard.
Ma, Yanjun, Dianhai Yu, Tian Wu, and Haifeng Wang. 2019. PaddlePaddle: an open-source deep learning platform from
industrial practice.Frontiers of Data and Computing1 (1): 105–115.
Marcel, Sébastien, and Yann Rodriguez. 2010. Torchvision the machine-vision package of torch. InProceedings of the 18th
acm international conference on multimedia,1485–1488.
23
Mateo-Garcia, Gonzalo, Joshua Veitch-Michaelis, Lewis Smith, Silviu Vlad Oprea, Guy Schumann, Yarin Gal, Atılım Güneş
Baydin, and Dietmar Backes. 2021. Towards global flood mapping onboard low cost satellites with machine learning.
Scientific Reports11, no. 1 (March): 7249.ISSN: 2045-2322, accessed April 1, 2021. https://doi.org/10.1038/s41598-
021-86650-z.
Maxwell, Aaron E, Sarah Farhadpour, Srinjoy Das, and Yalin Yang. 2024. Geodl: an R package for geospatial deep learning
semantic segmentation using torch and terra.PloS one19 (12): e0315127.
Miles, Alistair, et al. 2015.Zarr: an implementation of chunked, compressed, N-dimensional arrays for Python.https://github.com/
zarr-developers/zarr-python.
Moliński, Szymon, et al. 2018.Pyinterpolate: Kriging | Poisson Kriging | variogram analysis.https://github.com/DataverseLabs/
pyinterpolate.
Mulla, David J. 2013. Twenty five years of remote sensing in precision agriculture: key advances and remaining knowledge
gaps. Special Issue: Sensing Technologies for Sustainable Agriculture,Biosystems Engineering114 (4): 358–371.ISSN:
1537-5110. https://doi.org/10.1016/j.biosystemseng.2012.08.009.
OpenStreetMap contributors. 2017.OpenStreetMap.https://www.openstreetmap.org.
PaddlePaddle Authors. 2022.PaddleRS, awesome remote sensing toolkit based on PaddlePaddle.https://github.com/PaddlePaddle/
PaddleRS.
Paszke, Adam, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, et al. 2019.
PyTorch: an imperative style, high-performance deep learning library. InAdvances in neural information processing sys-
tems,edited by H. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. Fox, and R. Garnett, vol. 32. Curran
Associates, Inc. https://proceedings.neurips.cc/paper_f iles/paper/2019/f ile/bdbca288f ee7f 92f 2bf a9f 7012727740-
Paper.pdf .
Pebesma, Edzer. 2018. Simple Features for R: standardized support for spatial vector data.The R Journal10 (1): 439–446.
https://doi.org/10.32614/RJ-2018-009. https://doi.org/10.32614/RJ-2018-009.
Pedregosa, Fabian, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blon-
del, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al. 2011. Scikit-learn: machine learning in Python.Journal of
Machine Learning Research12:2825–2830.
Reed, Colorado J, Ritwik Gupta, Shufan Li, Sarah Brockman, Christopher Funk, Brian Clipp, Kurt Keutzer, Salvatore
Candido, Matt Uyttendaele, and Trevor Darrell. 2023. Scale-MAE: a scale-aware masked autoencoder for multiscale
geospatial representation learning. InProceedings of the ieee/cvf international conference on computer vision,4088–4099.
Riba, E., D. Mishkin, D. Ponsa, E. Rublee, and G. Bradski. 2020. Kornia: an open source differentiable computer vision
library for PyTorch. InWinter conference on applications of computer vision.https://arxiv.org/pdf /1910.02190.pdf .
Robinson, Caleb, Le Hou, Kolya Malkin, Rachel Soobitsky, Jacob Czawlytko, Bistra Dilkina, and Nebojsa Jojic. 2019. Large
scale high-resolution land cover mapping with multi-resolution data. InProceedings of the ieee/cvf conference on computer
vision and pattern recognition,12726–12735.
Rolf, Esther, Konstantin Klemmer, Caleb Robinson, and Hannah Kerner. 2024. Position: mission critical–satellite data is a
distinct modality in machine learning. InForty-first international conference on machine learning.
Rolnick, David, Priya L Donti, Lynn H Kaack, Kelly Kochanski, Alexandre Lacoste, Kris Sankaran, Andrew Slavin Ross,
Nikola Milojevic-Dupont, Natasha Jaques, Anna Waldman-Brown, et al. 2022. Tackling climate change with machine
learning.ACM Computing Surveys (CSUR)55 (2): 1–96.
Ronneberger, Olaf, Philipp Fischer, and Thomas Brox. 2015. U-Net: convolutional networks for biomedical image segmen-
tation. InMedical image computing and computer-assisted intervention–miccai 2015,234–241. Springer.
Santara, Anirban, Ankit Singh, Pranoot Hatwar, Kaustubh Mani, and Pabitra Mitra. 2016.Hyperspectral: deep learning for
land-cover classification in hyperspectral images.https://github.com/KGPML/Hyperspectral.
Schneider, Maja, Tobias Schelte, Felix Schmitz, and Marco Körner. 2023. EuroCrops: the largest harmonized open crop
dataset across the European Union.Scientific Data10 (1): 612.
Simoes, Rolf, Gilberto Camara, Gilberto Queiroz, Felipe Souza, Pedro R Andrade, Lorena Santos, Alexandre Carvalho, and
Karine Ferreira. 2021. Satellite image time series analysis for big Earth observation data.Remote Sensing13 (13): 2428.
Snow, Alan D., et al. 2019.Rioxarray: geospatial xarray extension powered by rasterio.https://github.com/corteva/rioxarray.
24 Adam J. Stewartet al.
Stewart, Adam, Nils Lehmann, Isaac Corley, Yi Wang, Yi-Chia Chang, Nassim Ait Ali Braham, Shradha Sehgal, Caleb
Robinson, and Arindam Banerjee. 2023. SSL4EO-L: datasets and foundation models for Landsat imagery.Advances in
Neural Information Processing Systems36:59787–59807.
Stewart, Adam J., Caleb Robinson, Isaac A. Corley, Anthony Ortiz, Juan M. Lavista Ferres, and Arindam Banerjee. 2024.
TorchGeo: deep learning with geospatial data.ACM Transactions on Spatial Algorithms and Systems(December). https:
//doi.org/10.1145/3707459. https://doi.org/10.1145/3707459.
Tarazona, Yonatan, Fernando Benitez-Paez, Jakub Nowosad, Fabian Drenkhan, and Martín E Timaná. 2024. Scikit-eo: a
Python package for remote sensing data analysis.Journal of Open Source Software9 (99): 6692.
Toffanin, Piero, et al. 2025.GeoDeep: free and open source library for AI object detection and semantic segmentation in geospatial
rasters.https://github.com/uav4geo/GeoDeep.
Van Westen, Cees J. 2013. Remote sensing and GIS for natural hazards assessment and disaster risk management.Treatise on
Geomorphology3:259–298.
Waldmann, Leonard, Ando Shah, Yi Wang, Nils Lehmann, Adam J Stewart, Zhitong Xiong, Xiao Xiang Zhu, Stefan Bauer,
and John Chuang. 2025. Panopticon: advancing any-sensor foundation models for Earth observation.arXiv preprint
arXiv:2503.10845.
Wang, Shuai. 2019.TorchSat: an open-source deep learning framework for satellite imagery analysis based on PyTorch.https://github.
com/sshuair/torchsat.
Wang, Yi, Nassim Ait Ali Braham, Zhitong Xiong, Chenying Liu, Conrad M Albrecht, and Xiao Xiang Zhu. 2023.
SSL4EO-S12: a large-scale multimodal, multitemporal dataset for self-supervised learning in Earth observation.IEEE
Geoscience and Remote Sensing Magazine11 (3): 98–106.
Wang, Yi, Zhitong Xiong, Chenying Liu, Adam J Stewart, Thomas Dujardin, Nikolaos Ioannis Bountos, Angelos Zavras,
Franziska Gerken, Ioannis Papoutsis, Laura Leal-Taixé, et al. 2025. Towards a unified Copernicus foundation model
for Earth vision.arXiv preprint arXiv:2503.11849.
Weinstein, Ben G, Sergio Marconi, Mélaine Aubry-Kientz, Gregoire Vincent, Henry Senyondo, and Ethan P White. 2020.
DeepForest: a Python package for RGB deep learning tree crown delineation.Methods in Ecology and Evolution11 (12):
1743–1751.
Weir, Nick, et al. 2019.Solaris: CosmiQ W orks geospatial machine learning analysis toolkit.https://github.com/CosmiQ/solaris.
W olf, Thomas, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault,
Rémi Louf, Morgan Funtowicz, et al. 2019. HuggingFace’s transformers: state-of-the-art natural language processing.
arXiv preprint arXiv:1910.03771.
Wu, Qiusheng, et al. 2023.GeoAI: artificial intelligence for geospatial data.https://github.com/opengeos/geoai.
Wu, Qiusheng, and Lucas Prado Osco. 2023. Samgeo: a Python package for segmenting geospatial data with the Segment
Anything Model (SAM).Journal of Open Source Software8, no. 89 (September): 5663. https://doi.org/10.21105/joss.
05663. https://joss.theoj.org/papers/10.21105/joss.05663.
Wu, Yuxin, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. 2019.Detectron2.https://github.com/
f acebookresearch/detectron2.
Xiong, Zhitong, Yi Wang, Weikang Yu, Adam J Stewart, Jie Zhao, Nils Lehmann, Thomas Dujardin, Zhenghang Yuan,
Pedram Ghamisi, and Xiao Xiang Zhu. 2025. DOFA-CLIP: multimodal vision-language foundation models for Earth
observation.arXiv preprint arXiv:2503.06312.
Xiong, Zhitong, Yi Wang, Fahong Zhang, Adam J Stewart, Joëlle Hanna, Damian Borth, Ioannis Papoutsis, Bertrand Le
Saux, Gustau Camps-Valls, and Xiao Xiang Zhu. 2024. Neural plasticity-inspired multimodal foundation model for
Earth observation.arXiv preprint arXiv:2403.15356.
Yang, Yao-Yuan, Moto Hira, Zhaoheng Ni, Artyom Astafurov, Caroline Chen, Christian Puhrsch, David Pollack, Dmitriy
Genzel, Donny Greenberg, Edward Z Yang, et al. 2022. Torchaudio: building blocks for audio and speech processing.
InIcassp 2022-2022 ieee international conference on acoustics, speech and signal processing (icassp),6982–6986. IEEE.
Yu, Jia, et al. 2015.Apache Sedona: a cluster computing framework for processing large-scale geospatial data.https://github.com/
apache/sedona.
Zhu, Xiao Xiang, Zhitong Xiong, Yi Wang, Adam J Stewart, Konrad Heidler, Yuanyuan Wang, Zhenghang Yuan, Thomas
Dujardin, Qingsong Xu, and Yilei Shi. 2024. On the foundations of Earth and climate foundation models.arXiv preprint
arXiv:2405.04285.