For most GIS work in 2026, store vector data in GeoPackage, publish large or analytical datasets as GeoParquet, serve map layers over HTTP as FlatGeobuf, and keep GeoJSON for small web payloads and APIs. On the same 998,473 polygons, GeoParquet took 110 MB, FlatGeobuf 314 MB, GeoPackage 335 MB, the shapefile 494 MB and GeoJSON 637 MB. Reading the whole layer took 1.2 seconds from GeoParquet and 19.7 seconds from GeoJSON.
This article compares the five formats you are most likely to meet (plus KML and CSV with WKT geometry) on limits, standards, tool support and cloud-native access, then reports a benchmark I ran on real hexagon data with the code to reproduce it, conversion commands for ogr2ogr, GeoPandas and DuckDB, and a decision table.
What are the main geospatial vector file formats?
There are five vector formats that cover nearly every project, and they differ mostly in whether they are a single file, whether they carry a spatial index and who maintains the specification.
| Format | Maintained by | Structure | Spatial index | Main limits |
|---|---|---|---|---|
| Shapefile (.shp) | Esri technical description (1998) | 3+ files (.shp, .shx, .dbf, usually .prj, .cpg) | Optional separate file | 2 GB per file, 10-character field names, no time in dates |
| GeoPackage (.gpkg) | OGC standard, current version 1.4 | One SQLite database, many layers | R-tree inside the file | Single writer at a time; awkward in object storage |
| GeoJSON (.geojson) | IETF RFC 7946 | One text file | None | Large and slow above a few MB; WGS 84 only under the RFC |
| FlatGeobuf (.fgb) | Open community specification | One binary file | Optional packed Hilbert R-tree | One layer per file; not designed for editing in place |
| GeoParquet (.parquet) | Community specification under an OGC Standards Working Group | One columnar file (or a folder of them) | Row-group bounding boxes, optional bbox column | Append-only; desktop GIS support still catching up |
Two more come up often:
- KML, an OGC standard built for Google Earth. GDAL read my KML back with 12 extra KML fields, booleans as integers and timestamps as text.
- CSV with a WKT column, which opens in any spreadsheet, but every attribute comes back as text unless you supply types.
GeoParquet versions matter. Version 1.0.0 was released in 2023, and 1.1.0 (June 2024) added the bounding-box "covering" column that makes spatial filtering fast. A 2.0.0 release candidate moves geometry onto the native GEOMETRY and GEOGRAPHY types that Apache Parquet added in 2025. The GeoParquet repository describes the specification as pending OGC approval, so check ogc.org for its current status before quoting it as an OGC standard in a contract.
Is the shapefile obsolete?
The shapefile still works, and every GIS reads it, but its limits make it a poor primary format for new data. The GDAL shapefile driver documentation lists them:
- Size: each of the .shp and .dbf files is limited to 2 GB.
- Field names: 10 characters, from the dBASE format underneath.
- Field types: no date-time. A Date field holds a day with no time and no time zone.
- Text fields: at most 254 characters.
- Encoding: text encoding lives in a separate .cpg file. Lose it and accented or Urdu text turns into garbage.
- Many files: lose the .shx, .dbf or .prj in an email and the dataset is broken or has no coordinate system.
I saw two of these happen in my benchmark without any error, only warnings. GDAL renamed population_estimate to population and population_density_km2 to populati_1, and wrote the updated_at timestamp as a text field. GeoPackage, GeoJSON, FlatGeobuf and GeoParquet all returned the original names and a time-zone-aware timestamp.
That is why the GIS contractor checklist on this site puts GeoPackage first in the statement of work and accepts shapefiles only as a secondary copy with a field-name crosswalk.
How did I benchmark the formats?
I started from the population hexagons behind the Site Selection Showdown map: Kontur Population (1 November 2023 release) on H3 resolution-8 hexagons for Calgary, Islamabad and Bahawalpur. To get larger datasets with realistic geometry, I split each hexagon into its H3 children and divided its population equally among them. (The H3 resolution guide covers how the levels nest.)
| Dataset | How it was built | Polygons |
|---|---|---|
| Small | Calgary, H3 resolution 8, as published | 1,205 |
| Medium | All three cities, children at resolution 10 (49 per parent) | 142,639 |
| Large | All three cities, children at resolution 11 (343 per parent) | 998,473 |
Every layer has seven attributes, including a long field name and a UTC timestamp. Rows were sorted along a Hilbert curve so that features near each other on the map sit near each other in the file.
Method:
- Write each format once with GeoPandas and pyogrio (GeoParquet with GeoPandas' own writer, with the bounding-box column and 10,000-row row groups).
- Read the whole file back, and separately read only a downtown Calgary box (114.10°W to 114.04°W, 51.03°N to 51.06°N) that holds 7,023 of the large layer's polygons.
- Report the median of 7 reads (small), 5 (medium) or 3 (large). The file was already in the operating system's cache, so these are warm reads from local disk.
Software: Python 3.13, GeoPandas 1.2.0, pyogrio 0.13.0, GDAL 3.12.4, pyarrow 26.0.0, shapely 2.2.0 and DuckDB 1.5.5, on a 4-core Intel Xeon virtual machine at 2.1 GHz with 15 GB of RAM. Your timings will differ, sometimes by a lot. File sizes will not.
Which format is smallest and fastest to read?
GeoParquet was the smallest at every size and the fastest to read in full at the medium and large sizes, while FlatGeobuf and GeoPackage were fastest for small map-window queries.

Large dataset, 998,473 polygons. Red bars are the formats with a spatial index or row-group bounding boxes.
Full results for the large dataset:
| Format | Size on disk | Write | Read whole file | Read downtown box |
|---|---|---|---|---|
| GeoParquet | 110 MB | 2.6 s | 1.16 s | 57 ms |
| FlatGeobuf | 314 MB | 12.7 s | 1.94 s | 15 ms |
| GeoPackage | 335 MB | 11.7 s | 1.73 s | 27 ms |
| CSV (WKT) | 353 MB | 28.5 s | 7.73 s | 4,996 ms |
| Shapefile | 494 MB (5 files) | 18.1 s | 3.54 s | 251 ms |
| GeoJSON | 637 MB | 32.7 s | 19.68 s | 16,145 ms |
The medium dataset (142,639 polygons) told the same story at a smaller scale: GeoParquet 16 MB, FlatGeobuf 45 MB, GeoPackage 48 MB, CSV 50 MB, shapefile 71 MB, GeoJSON 91 MB and KML 143 MB. KML took 5.0 seconds to read, GeoJSON 2.6 seconds, and the shapefile 0.57 seconds.
At 1,205 polygons none of this matters: every format read in under 41 ms. Choose for speed only once files reach tens of megabytes.
GeoJSON file size deserves a note, because it is the most common complaint. GDAL writes up to 15 significant digits per coordinate by default. Rounding to 6 decimal places, which is about 10 cm on the ground, cut the medium file from 91 MB to 73 MB. Gzip, which most web servers apply automatically, took it to 6.6 MB. If a GeoJSON is still too big after both, it is the wrong format for the job.
Which formats work for cloud-native access over HTTP?
FlatGeobuf, GeoPackage and spatially sorted GeoParquet can all answer a map-window query by downloading a small slice of a large file with HTTP range requests, while GeoJSON has to be downloaded in full. I served the large files from a local web server that logs every byte, then ran the same downtown query against each one through GDAL's /vsicurl/ reader (GeoParquet through pyarrow).
| File (998,473 polygons) | Requests | Bytes transferred | Share of file |
|---|---|---|---|
| FlatGeobuf, 314 MB | 57 | 5.5 MB | 1.7% |
| GeoPackage, 335 MB | 201 | 3.8 MB | 1.1% |
| GeoParquet, Hilbert-sorted, 10,000-row groups, 110 MB | 4 | 4.6 MB | 4.2% |
| GeoParquet, unsorted, default row groups, 162 MB | 5 | 162 MB | 100% |
| GeoJSON, 637 MB | 518 | 1,274 MB | 200% |
Three lessons:
- Request count matters as much as bytes. GeoPackage moved the fewest bytes but needed 201 round trips, because SQLite reads small pages. At 50 ms of latency to cloud storage, run one after another, that is about 10 seconds, against about 3 seconds for FlatGeobuf and a fraction of a second for GeoParquet.
- GeoParquet is only cloud-friendly if you write it that way. The same rows, shuffled and written with default settings, put everything into one row group, so the query downloaded the whole file. Sort spatially and use row groups of a few thousand to tens of thousands of rows.
- GeoJSON has no index. GDAL transferred the 637 MB file twice, because its GeoJSON reader makes a first pass to work out the fields before it returns features.
Shapefile vs GeoPackage: which should you use?
Use GeoPackage for anything you store, edit or deliver, and keep shapefiles as an export for software that cannot read anything else. GeoPackage is one file with as many layers as you like, keeps long field names, date-times and UTF-8 text, and has a built-in R-tree. In the benchmark it was 32% smaller than the shapefile, read in half the time and answered the downtown query nine times faster.
GeoPackage is the default format for new layers in QGIS, and ArcGIS Pro reads, edits and creates GeoPackages. GDAL reads and writes both through the GPKG and ESRI Shapefile drivers.
GeoParquet vs GeoPackage: when does GeoParquet win?
GeoParquet wins when the data is large, mostly read, and analysed with code or SQL. It is columnar and compressed, so it was a third of the GeoPackage's size, wrote in 2.6 seconds against 11.7, and loads directly into DuckDB, Apache Spark, BigQuery, pandas and GeoPandas without a GIS in between.
GeoPackage wins when people edit the data, when a delivery has several related layers with styles, or when the recipient works in desktop GIS. QGIS reads GeoParquet through GDAL's Parquet driver (GDAL builds that include Apache Arrow). ArcGIS Pro can add GeoParquet 1.0 and 1.1 files for display and query in recent releases, and handles FlatGeobuf through the Data Interoperability extension. Check the exact version your client runs before you promise either.
A common pattern is to keep both: GeoParquet as the analytical master in object storage, and GeoPackage extracts for the people who edit or map.
FlatGeobuf vs GeoJSON for web maps?
Use GeoJSON for small payloads, API responses and anything a person might open in a text editor. Use FlatGeobuf when a layer is too large to send to the browser in one go. In my test FlatGeobuf was half the size of GeoJSON, read ten times faster in full, and answered a map-window query with 1.7% of the file. Its index is a packed Hilbert R-tree at the front of the file, so the FlatGeobuf JavaScript library can stream just the features in view from any web host or bucket that supports range requests.
One more GeoJSON rule: RFC 7946 fixes coordinates to WGS 84 longitude and latitude in degrees. Store projected data in another format, and do not measure distances or areas on those degrees directly, as the Web Mercator distortion article explains.
How do you convert between formats?
GDAL's ogr2ogr converts between all of them on the command line, and GeoPandas does the same in Python.
# Shapefile to GeoPackage. SHAPE_ENCODING tells GDAL the .dbf encoding
# when the .cpg file is missing or wrong
ogr2ogr -f GPKG parcels.gpkg parcels.shp -nln parcels --config SHAPE_ENCODING UTF-8
# GeoPackage layer to FlatGeobuf, with its spatial index (on by default)
ogr2ogr -f FlatGeobuf parcels.fgb parcels.gpkg parcels
# GeoPackage to GeoParquet (needs GDAL built with Arrow/Parquet)
ogr2ogr -f Parquet parcels.parquet parcels.gpkg parcels \
-lco COMPRESSION=ZSTD -lco ROW_GROUP_SIZE=10000 -lco SORT_BY_BBOX=YES
# Lean GeoJSON for the web: WGS 84, 6 decimal places
ogr2ogr -f GeoJSON parcels.geojson parcels.gpkg parcels \
-t_srs EPSG:4326 -lco RFC7946=YES -lco COORDINATE_PRECISION=6
import geopandas as gpd
gdf = gpd.read_file("parcels.gpkg", layer="parcels", engine="pyogrio", use_arrow=True)
# Sort along a Hilbert curve so nearby features share row groups
gdf = gdf.iloc[gdf.geometry.hilbert_distance().argsort()]
gdf.to_parquet("parcels.parquet", write_covering_bbox=True,
row_group_size=10_000, compression="zstd")
gdf.to_file("parcels.fgb", driver="FlatGeobuf", engine="pyogrio")
# Read only what you need
window = (-114.10, 51.03, -114.04, 51.06)
sub = gpd.read_parquet("parcels.parquet", bbox=window)
sub = gpd.read_file("parcels.fgb", bbox=window, engine="pyogrio")
Zstandard compression shrank the medium GeoParquet from 16.0 MB (the default Snappy) to 12.8 MB.
DuckDB queries GeoParquet in place with SQL. This query uses only the bounding-box column, runs on core DuckDB with no extensions, and returned 7,023 cells and 87,161 people from the large file in 16 ms:
SELECT city, count(*) AS cells, round(sum(population_estimate)) AS people
FROM 'hexes_large.parquet'
WHERE bbox.xmax >= -114.10 AND bbox.xmin <= -114.04
AND bbox.ymax >= 51.03 AND bbox.ymin <= 51.06
GROUP BY city;
For exact geometry tests, load the spatial extension:
INSTALL spatial; LOAD spatial;
SELECT h3_id, population_estimate
FROM 'hexes_large.parquet'
WHERE ST_Intersects(geometry,
ST_GeomFromText('POLYGON((-114.10 51.03, -114.04 51.03, -114.04 51.06,
-114.10 51.06, -114.10 51.03))'));
Which format should you use for which job?
| Job | Use | Why |
|---|---|---|
| Deliverable to a client or another team | GeoPackage | One file, many layers, open OGC standard, opens everywhere |
| Editing in QGIS or ArcGIS Pro | GeoPackage (or a file geodatabase in ArcGIS shops) | Supports edits, indexes, long names, date-times |
| Large analytical master in a data lake or bucket | GeoParquet, Hilbert-sorted, row groups of 10,000 to 100,000 | Smallest, fastest full reads, SQL-ready |
| Large layer streamed to a web map from static hosting | FlatGeobuf | Fetches only the features in view over HTTP |
| Small layer in a web app or API response | GeoJSON (6 decimals, gzip) | Native to JavaScript, readable |
| Legacy software that only reads shapefiles | Shapefile export plus field crosswalk | Compatibility only |
| A few placemarks for Google Earth users | KML | Opens in Google Earth with no GIS |
| Points for a spreadsheet user | CSV with lat/lon or WKT, plus a data dictionary | Opens in Excel; types are lost |
Whatever you pick, write the format, the coordinate system and the field definitions into the contract or the README. A format choice without a data dictionary just moves the confusion somewhere else.
What should you take from this?
GeoPackage is the safe default and should replace the shapefile for anything stored or delivered. Once a layer reaches hundreds of thousands of features, GeoParquet is several times smaller and faster, provided you sort it spatially and keep row groups modest. FlatGeobuf is the simplest way to put a large layer on a web map without a tile server. GeoJSON is for small things. And timings vary by machine, but the size and indexing differences in this test are large enough that they will show up on yours.
If you need a data pipeline, a delivery specification or a cloud-native layer built for your organisation, email me at mahad.imran29@gmail.com.