The GeoServer team is making great progress on our 2025 roadmap plans, with CITE Certification Achieved, and GeoServer 3 underway, the project is going well.

Thanks to GeoServer 2025 sponsors:

CITE Certification

We are really happy to the see the CITE Certified banner restored to the main GeoServer website for calendar year 2025. Andrea continues to work on certifying the new OGCAPI services:

• OGCAPI - Tiles: Passing tests on Team Engine 2.0 Engine

• OGCAPI - Process: Making progress on certification

A reminder that if CITE Certification is valuable to you GeoServer will need to pay OGC each year - which requires sponsorship. We are certified for calendar year 2025 thanks to the prior sponsorship. We find that many organizations assume GeoServer is certified, this is not be the case without your financial support.

Thanks to Gaia3D and OSGeo:UK for sponsoring 2025 CITE Certification.

Security

We continue to be in need of resources, both developer resources and funding, to address the expectations placed on open source projects. If you are in a position to support this activity, please contact us at geoserver-security@lists.osgeo.org .

GeoServer 3

The big news is the completion of Milestone 1 : Preparation with the release of GeoServer 2.28.0, allowing the Milestone 2 : Migration activities to proceed as scheduled.

For more information on GeoServer 3 development, review the project plan and GeoServer 3 Crowdfunding FAQ.

GeoServer 3 Milestone 1 Completed

The release of GeoServer 2.28.0 represents the end of Milestone 1: Preparation:

• Upgrade from Java Advanced Imaging 1.1.3 to Eclipse ImageN 0.9.0.

• Java 17 LTS minimum, ending support for Java 11.

• Lots of build improvements, with the highlight being a bill-of-materials “geotools” pom.xml file to manage versions across GeoTools, GeoWebCache, and GeoServer.

• A new community module, gs-sec-oidc-plugin, replacing gs-oauth2 plugins.

GeoServer 3 Milestone 2 Underway

GeoServer 3 Milestone 2: Migration is underway:

• Friday 17 October: Code Freeze

  We will be freezing the main branches of the related projects on Friday 17 Oct 2025, in preparation for the Milestone 2 code sprint. Please follow the announcement on Discourse.

• Monday 20 October: Code Sprint

  With the branches frozen, the GeoServer 3 team is assembling for an intensive code sprint to start the migration to Spring Framework 3.

Crowdfunding

Thanks to sponsors for supporting GeoServer 3 crowdfunding, we hope you are pleased with the progress thus far and look forward to sharing GeoServer 3 with you in the months ahead.

GeoServer 3 is supported by the following organisations:

Individual donations: Abhijit Gujar, Hennessy Becerra, Ivana Ivanova, John Bryant, Jason Horning, Jose Macchi, Peter Smythe, Sajjadul Islam, Sebastiano Meier, Stefan Overkamp.

GeoSpatial Techno is a startup focused on geospatial information that is providing e-learning courses to enhance the knowledge of geospatial information users, students, and other startups. The main approach of this startup is providing quality, valid specialized training in the field of geospatial information.

( YouTube | LinkedIn | Facebook | X )

Master GeoServer WPS - Key Input Categories You Need to Know

The WPS Request Builder is a demo page used to try out the Web Processing Service (WPS) used to execute geospatial processes for transformation, summary and analysis. This session provides a detailed overview of the various inputs and categories in the WPS Request Builder.

If you want to access the complete tutorial, click on the link.

Introduction

In GeoServer, the WPS request builder enables users to perform various geospatial processing operations with different functionality to analyze and manipulate geospatial data. Each category provides a set of specific operations tailored to a range of geospatial tasks.

Note: Be sure to download the WPS extension that corresponds exactly to your GeoServer version—mismatched versions will result in errors.

Some categories available in the WPS request builder are JTS, Geo, GS, and Vec.

• JTS: The JTS process uses the Java Topology Suite library to perform various geometry manipulation and analysis operations such as Buffer, Intersection, Union, Simplify, etc.
• Geo: This process includes geospatial operations that may involve coordinate transformations and spatial analysis. Some common functions include Reproject, Centroid, Convex Hull, etc.
• GS: The GS or ‘GeoServer Specific’ process uses the GeoTools library and provides a set of geospatial processing operations specifically designed for use in the GeoServer environment. Some common functions include Feature Count, Centroid, BufferFeatureCollection, etc.
• Vec: This process contains operations specifically designed for working with vector data, such as merge, dissolve, aggregate, etc.

The built-in GS (for GeoServer) and Vec (for Vector) processes have direct access to the layers provided by GeoServer.

The JTS (from JTS Topology Suite library) and Geo (from GeoTools library) processes are provided by external libraries. If you are interested in making your own process there is a Process Tutorial for Java Developers.

First, we will introduce the inputs of the JTS and Geo processes, and then we will delve into the GS and Vec processes.

JTS and Geo processes

The JTS and Geo processes refer to different sets of processing functions that are specifically dedicated to handling geometries and performing geospatial operations.

From the Demo menu, navigate to the WPS Request Builder. This section contains several types of processes, which you can view in the Choose Process section. They accept three inputs for execution: Text, Reference, and Subprocess.

TEXT

In Text mode, you can enter the data geometry information in one of the standard formats supported by WPS. These standard formats are:

• text/xml; subtype=gml
• application/wkt
• application/gml
• application/json

The main differences between these MIME types are:

• text/xml; subtype=gml is more suitable for human readability and debugging, while application/gml is intended for machine-to-machine interactions, APIs, and programmatic consumption.
• Use text/xml; subtype=gml for scenarios that require easy readability or manual processing, and application/gml for cases where data is consumed directly by applications without being rendered as text.

Overall, the choice between the two should depend on the intended use case: for human interaction, use text/xml; subtype=gml; for application-oriented needs, choose application/gml.

application/wkt

The application/wkt is a MIME type that represents data encoded in the Well-Known Text (WKT) format. WKT is a text-based format for representing and exchanging geospatial data, particularly geometric shapes and objects. It supports various geometric types, including: Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon.

The application/wkt and application/ewkt formats in GeoServer WPS represent geometry; WKT defines shapes without CRS, suitable for basic 2D/3D geometry. EWKT adds an SRID, embedding CRS info in the geometry string for essential context.

Here is an example of the application/wkt format:

- POINT(48.23 11.56)
- LINESTRING(45.67 9.12, 50.45 12.34, 55.89 10.67)
- POLYGON((45.67 9.12, 50.45 12.34, 55.89 10.67, 45.67 9.12))
- MULTIPOINT((45.67 9.12), (50.45 12.34), (55.89 10.67))
- MULTILINESTRING((45.67 9.12, 50.45 12.34), (55.89 10.67, 45.67 9.12))
- MULTIPOLYGON(((45.67 9.12, 50.45 12.34, 55.89 10.67, 45.67 9.12)), ((60.12 8.34, 62.45 11.67, 65.89 10.01, 60.12 8.34)))

application/json

The application/json is a MIME type used to represent data encoded in GeoJSON format for encoding geographic data structures. It is based on the JSON format and allows the representation of simple geographic features along with their associated non-spatial attributes stored in the Properties object.

This MIME type is commonly used in Web mapping applications, GIS, and various other geospatial applications because it provides a standardized way to represent and exchange geographic data.

Here is an example of the application/json document:

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Point",
        "coordinates": [-122.41, 37.78]
      },
      "properties": {
        "name": "San Francisco",
        "population": 883306,
        "elevation": 16
      }
    },
    {
      "type": "Feature",
      "geometry": {
        "type": "Polygon",
        "coordinates": [[
          [-122.4194, 37.7749],
          [-122.4244, 37.7749],
          [-122.4244, 37.7799],
          [-122.4194, 37.7799],
          [-122.4194, 37.7749]
        ]]
      },
      "properties": {
        "name": "San Francisco City Hall",
        "type": "government"
      }
    }
  ]
}  

REFERENCE

The Reference mode for specifying input geometry involves linking to an external resource containing the necessary geometry data for processing. This mode is beneficial when the geometry data is stored in a separate file or service, allowing you to provide a reference instead of including the data directly in the WPS request.

To use this option, you can choose between the GET or POST method. The choice depends on the size and nature of the referenced data, as well as any security considerations.

• GET: This method includes the reference to an external resource, such as a URL pointing to a file or service endpoint, directly in the request URL. It’s ideal for retrieving small to moderate-sized data, as the data is transmitted via URL query parameters.
• POST: This method includes the reference to the external resource in the body of the HTTP request, rather than in the URL. The POST method preferred for larger datasets or confidential data, because it’s more secure and allow larger amounts of data to be transferred without URL length limitations.

SUBPROCESS

Using the Subprocess mode for input geometry in a WPS request, allows for seamless chaining of multiple processes. It enables you to reference data from another process without writing intermediate results to disk, significantly enhancing workflow efficiency.

This approach is particularly beneficial when managing large datasets or executing multiple processing tasks rapidly, as it eliminates unnecessary handling steps and facilitates direct data transfer between interconnected processes.

Select Subprocess from the Process Inputs dropdown menu in the WPS Request Builder section. Then, click the Define/Edit link to open a new page where you can choose an additional process for chaining.

OUTPUT

The result output refers to a spatial data layer, typically represented in a vector format such as GML, GeoJSON, or WKT. This output can be processed further, visualized, or utilized in various spatial analyses. When generating the WPS result geometry, you can choose from several standard spatial data formats, each described in detail.

These formats are:

• text/xml; subtype=gml
• application/wkt
• application/gml
• application/json

Selecting the appropriate format allows you to tailor the output to suit your specific use case or workflow.

GS and Vec processes

These processes are specifically designed to integrate seamlessly with GeoServer layers, thereby enhancing the utilization of geospatial data. The GS process includes various GeoServer-specific operations for interacting with and managing GeoServer resources, while the Vec process specializes in vector data processing, offering tools for analyzing and transforming vector geometries.

They accept four inputs for execution: Text, Reference, Subprocess, and Vector layers.

TEXT

In this mode, you can use various standard formats supported by WPS. These formats are:

• text/xml;subtype=wfs-collection
• application/wfs-collection
• application/zip
• text/csv
• application/json
• application/vnd.google-earth.kml+xml

text/xml;subtype=wfs-collection

Using this format allows you to submit a collection of geometries directly from a WFS request to a WPS process in GeoServer. When you use a WFS-Collection as input, you reference a set of geometries that the WPS operation can manipulate directly.

Here’s an example of how to use a WFS collection 1.1 in a WPS request:

<wfs:FeatureCollection xmlns:wfs="http://www.opengis.net/wfs" xmlns:feature="http://www.openplans.org/topp" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc" xmlns:ows="http://www.opengis.net/ows" xmlns:xlink="http://www.w3.org/1999/xlink">
  <gml:boundedBy>
    <gml:Envelope srsDimension="2" srsName="http://www.opengis.net/gml/srs/epsg.xml#4326">
      <gml:lowerCorner>147.291 -42.851002</gml:lowerCorner>
      <gml:upperCorner>147.291 -42.851002</gml:upperCorner>
    </gml:Envelope>
  </gml:boundedBy>
  <gml:featureMember>
    <feature:tasmania_cities gml:id="tasmania_cities.1">
      <gml:boundedBy>
        <gml:Envelope srsDimension="2" srsName="http://www.opengis.net/gml/srs/epsg.xml#4326">
          <gml:lowerCorner>147.291 -42.851002</gml:lowerCorner>
          <gml:upperCorner>147.291 -42.851002</gml:upperCorner>
        </gml:Envelope>
      </gml:boundedBy>
      <feature:the_geom>
        <gml:Point srsDimension="2" srsName="http://www.opengis.net/gml/srs/epsg.xml#4326">
          <gml:pos>147.291 -42.851002</gml:pos>
        </gml:Point>
      </feature:the_geom>
      <feature:CITY_NAME>Hobart</feature:CITY_NAME>
      <feature:ADMIN_NAME>Tasmania</feature:ADMIN_NAME>
      <feature:CNTRY_NAME>Australia</feature:CNTRY_NAME>
      <feature:STATUS>Provincial capital</feature:STATUS>
      <feature:POP_CLASS>100,000 to 250,000</feature:POP_CLASS>
    </feature:tasmania_cities>
  </gml:featureMember>
</wfs:FeatureCollection>

application/vnd.google-earth.kml+xml

It is a MIME type used for representing geospatial data in the Keyhole Markup Language (KML) format which primarily associated with Google Earth and various mapping applications. KML enables the encoding of diverse geographic features, such as points, lines, and polygons, along with their associated attributes.

Here’s an example of how to use an application/vnd.google-earth.kml+xml mime type in a WPS request:

  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <kml xmlns="http://www.opengis.net/kml/2.2" xmlns:ns2="http://www.google.com/kml/ext/2.2" xmlns:ns3="http://www.w3.org/2005/Atom" xmlns:ns4="urn:oasis:names:tc:ciq:xsdschema:xAL:2.0">
      <Document>
          <Schema name="poi" id="poi">
              <SimpleField type="string" name="NAME"/>
          </Schema>
          <Folder>
              <name>poi</name>
              <Placemark id="poi.1">
                  <ExtendedData>
                      <SchemaData schemaUrl="#poi">
                          <SimpleData name="NAME">museam</SimpleData>
                      </SchemaData>
                  </ExtendedData>
                  <Point>
                      <coordinates>-74.01046109936333,40.707587626256554</coordinates>
                  </Point>
              </Placemark>
              <Placemark id="poi.2">
                  <ExtendedData>
                      <SchemaData schemaUrl="#poi">
                          <SimpleData name="NAME">stock</SimpleData>
                      </SchemaData>
                  </ExtendedData>
                  <Point>
                      <coordinates>-74.0108375113659,40.70754683896324</coordinates>
                  </Point>
              </Placemark>
              <Placemark id="poi.3">
                  <ExtendedData>
                      <SchemaData schemaUrl="#poi">
                          <SimpleData name="NAME">art</SimpleData>
                      </SchemaData>
                  </ExtendedData>
                  <Point>
                      <coordinates>-74.01053023879955,40.70938711687079</coordinates>
                  </Point>
              </Placemark>            
          </Folder>
      </Document>
  </kml>

Vector Layer

This mode in GeoServer allows users to utilize predefined geographical data for advanced spatial analyses, including overlay analysis, buffering, and spatial querying. This access to well-organized data, such as points, lines, and polygons, significantly enhances analytical capabilities compared to relying solely on JTS or Geo processes.

By integrating vector layers into the WPS request builder, users can perform sophisticated geospatial analyses, enabling deeper insights from their datasets and making GeoServer a preferred choice for complex spatial processing tasks.

OUTPUT

The result output typically provides a spatial data layer in various vector formats, including GML, GeoJSON, CSV, and Shapefile. This output can be further processed, visualized, or used in other spatial analyses, making it highly versatile for different applications.

When generating geometry, you can choose the result in a variety of standard data formats, including:

• text/xml;subtype=wfs-collection
• application/wfs-collection
• application/zip
• text/csv
• application/json
• application/vnd.google-earth.kml+xml

This flexibility allows you to choose the most appropriate format for your specific use case or workflow, ensuring compatibility with your analysis tools and visualization platforms. By offering these multiple output formats, GeoServer effectively supports a wide range of geoprocessing needs, facilitating seamless integration and analysis of spatial data.

In this session, we discussed the types of different categories and various inputs in the WPS Request Builder. To access the full tutorial, click on this link.

Reference:

• Web Processing Service (WPS) (User Manual)
• Process Cookbook (User Manual)

GeoServer 2.28-M0 release is now available with downloads (bin, war, windows), along with docs, extensions, and data directory.

This is a milestone release previewing the GeoServer 2.28.x series to let everyone try out our new ImageN raster processing engine.

This release is made as part of the GeoServer 3 “Milestone 1” activity. It is made in conjunction with ImageN 0.4.0, ImageIO-Ext 2.0.0-M0, GeoTools 34-M0, mapfish-print-v2 2.4-M0, and GeoWebCache 1.28-M0.

Thanks to Jody Garnett (GeoCat) and Ian Turton for making this release.

Milestone Release

Milestone releases are a chance to share what we have been working on, and ask you to try it with your own data:

• A new Eclipse ImageN (pronounced “imagine”) processing engine.

  This project combining Java Advanced Imaging (donated by Oracle) and JAI-Ext (donated by GeoSolutions) into a single image processing engine optmized for a modern Java environment.

• Speaking of modern Java Environment GeoServer now requires Java 17 minimum. Java 11 is no longer supported. GeoServer is testing with Long Term Support releases: Java 17 LTS and Java 21 LTS.

• Lots of build improvements with the highlight being a bill-of-materials “geotools” pom.xml file to share managing versions across GeoTools, GeoWebCache and GeoServer

• A new community module gs-sec-oidc-plugin under active development.

  This plugin will be taking over the responsibilities of gs-oauth2 plugins as they are being retired for GeoServer 3.

This is a milestone release so we welcome your feedback, we already know of a couple of things:

• javadocs download is empty

  This is due to changing to JDK 17, and a large number of javadoc warrnings we now need to resolve.

• GeoServer 2.28-M0 artifacts were not published to repo.osgeo.org

About GeoServer 2.28

Release notes: ( 2.28-M0 )

GeoServer 2.26.4 release is now available with downloads (bin, war, windows), along with docs and extensions.

This is a maintenance (now archive) release of GeoServer, providing existing installations with minor updates and bug fixes. GeoServer 2.26.4 is made in conjunction with GeoTools 32.4, and GeoWebCache 1.26.4. Please note that this is the final scheduled release in the 2.26.x series - it is time to upgrade to a supported version.

Thanks to Peter Smythe (AfriGIS) for making this release, and to Jody for testing it.

Security Considerations

This release addresses security vulnerabilities and is considered an important update for existing installations.

The use of the CVE system allows the GeoServer team to reach a wider audience than blog posts. See project security policy for more information on how security vulnerabilities are managed.

Upgrade instructions

Please take note of the Upgrade Instructions, specifically:

• The global setting Unrestricted XML External Entity Resolution has been replaced with the ENTITY_RESOLUTION_UNRESTRICTED application property.

  This change primarily affects application schema users that have not yet adopted ENTITY_RESOLUTION_ALLOWLIST. See update instructions for details.

• Due to a user interface change, it is no longer necessary to generate a masterpw.info when upgrading an older data directory.

  If this file is present from an earlier upgrade, it is still considered a security warning and is noted on the welcome page.

Release notes

New Feature:

• GEOS-11805 Option to disable the management of stored queries
• GEOS-11911 Application property ROOT_LOGIN_ENABLED

Improvement:

• GEOS-11867 Improve entity resolution
• GEOS-11877 Improve CoverageView composition to support noData fill on missing bands/coverages
• GEOS-11892 Column mentioning user that performed last modification for layers and stores list UI

Bug:

• GEOS-10728 Cannot download GeoPackage if the source data contains UUID types
• GEOS-11820 WCS spatial sub-setting does not work when native CRS != declared CRS
• GEOS-11832 count=0 service exception for some formats
• GEOS-11866 Prevent requests setting variables that should only be set by GeoServer
• GEOS-11896 WPS map download flips east/west coordinates
• GEOS-11900 CRS:XY syntax builds isolated CRSs that do not leverage the EPSG database transformation library

Task:

• GEOS-11831 OseoDispatcherCallback improvements
• GEOS-11852 Remove master password info page
• GEOS-11853 Clarify keystore vs master vs root password
• GEOS-11854 Generation of security/masterpw.info no longer required
• GEOS-11869 Replace entity resolution setting with application property

For the complete list see 2.26.4 release notes.

Community Updates

Community module development:

• GEOS-11829 Features templating ability to override schema
• GEOS-11830 Smart data loader create store page fails when environment variables are in use
• GEOS-11839 New Community Module for WPS Download in NetCDF output format for spatiotemporal coverages
• GEOS-11847 Next link is missing in “Search” OGC API - Features proposal implementation when startIndex is not set
• GEOS-11871 Allow native execution of group by in DGGS store, when grouping on geometries
• GEOS-11876 WPS Vertical Longitudinal Profile: Support automatic distance computation
• GEOS-11878 WFS HITS request returns the whole data records on a GML feature templated layer
• GEOS-11880 OGC API Maps is not showing up in GeoServer home page

Community modules are shared as source code to encourage collaboration. If a topic being explored is of interest to you, please contact the module developer to offer assistance.

About GeoServer 2.26 Series

Additional information on GeoServer 2.26 series:

• GeoServer 2.26 User Manual
• GeoServer 2024 Q3 Developer Update
• Raster Attribute Table extension
• Community module graduation, amending generality rule
• Individual contributor clarification
• Migrate geoserver-users from SourceForge to discourse

Release notes: ( 2.26.4 | 2.26.3 | 2.26.2 | 2.26.1 | 2.26.0 | 2.26-M0 )

GeoSpatial Techno is a startup focused on geospatial information that is providing e-learning courses to enhance the knowledge of geospatial information users, students, and other startups. The main approach of this startup is providing quality, valid specialized training in the field of geospatial information.

( YouTube | LinkedIn | Facebook | X )

Exploring Types of WPS Operations in GeoServer

This session covers the various Web Processing Service (WPS) operations available in GeoServer, emphasizing their roles within spatial data processing workflows.

For the complete video tutorial, click here.

Introduction

The OGC WPS interface defines three mandatory operations that every compliant server must implement:

• GetCapabilities: Retrieves metadata about the server’s available processes.
• DescribeProcess: Provides detailed information about a specific process.
• Execute: Runs a selected geospatial process with user-defined inputs.

These operations form the foundation of WPS-based geospatial analysis over the web.

Note: GeoServer does not include the WPS functionality by default. Follow this tutorial to download and install the WPS extension.

Note: This tutorial uses GeoServer version 2.25.3. Ensure that the WPS extension matches your GeoServer version precisely to prevent compatibility issues.

GetCapabilities

The GetCapabilities operation enables clients to query the server for service metadata, including available processes, supported versions, and provider details.

An example HTTP GET request for GetCapabilities:

  http://localhost:8080/geoserver/ows?service=wps&version=1.0.0&request=GetCapabilities

Key parameters:

• service = wps: Indicates a WPS request.
• version = 1.0.0: Specifies the WPS version.
• request = GetCapabilities: Defines the operation.

The resulting XML document provides a comprehensive overview of the WPS service, including server info, available processes, supported languages, and operational metadata.

DescribeProcess

The DescribeProcess operation allows clients to request detailed information about specific processes available on the WPS server. It includes descriptions of required inputs, allowable formats, and expected outputs.

Here is an example of how this operation can be used for the Buffer process:

  http://localhost:8080/geoserver/ows?service=wps&version=1.0.0&request=DescribeProcess&identifier=JTS:buffer

There are four required parameters and values being passed to the WPS server:

• The service parameter is WPS.
• The version parameter is 1.0.0.
• The request parameter tells the server that the operation requested is DescribeProcess.
• The identifier parameter tells the server what specific process is being described. Here is JTS:buffer.

The response XML details the process, including identifiers, title, abstract, inputs, outputs, data formats, and constraints.

Execute

The Execute operation lets clients initiate geospatial processes or algorithms. It typically involves sending a request with process details, input data, parameters, and output preferences, after which the server processes the request and returns results.

For example, you can use a pre-defined demo request such as WPS_aggregate_1.0.xml from the demo section to test execution. To do this, navigate to the Demos section and select the Demo Requests option. From the Request drop-down list, select WPS_aggregate_1.0.xml request.

This operation provides a flexible, standardized method for running geospatial analyses via the web, making advanced processing tools accessible to a broader audience.

In this session, we covered the OGC WPS interface standard and its main operations. To explore the full tutorial, watch the video.