Every GIS veteran has received the wounded shapefile: a .shp with no .dbf, so the geometry arrives mute; a .prj gone missing, so the coordinates arrive homeless; a field name truncated to ten characters by a format older than some of its users. The shapefile was a fine format for its decade, but its decade ended, and the GeoPackage is the successor the whole field agreed on: an Open Geospatial Consortium standard, built on a single SQLite database file, able to hold many vector layers and rasters together with their styles, and adopted by QGIS as its default format since the 3.x generation. One file, whole project, no sidecars to lose. This guide teaches the format the way QGIS users actually live with it: creating a GeoPackage and its first layer properly, adding and organizing layers, moving data between packages in the Browser panel, and the sharing habits that make a .gpkg the unit of exchange it was designed to be.
Home / GIS and Open Map Data for Beginners
QGIS GeoPackage: One File for Every Layer, From Creation to Sharing

Photo: Jakub Zerdzicki / Pexels
One File, Every Layer: The GeoPackage Checklist
Check off each step as you finish it. Your progress stays on this page.
0 of 7 complete
0% done
What a GeoPackage Actually Is
Strip the mystique away and a GeoPackage is a database file with a geography habit. SQLite, the same single-file database inside countless apps, stores each layer as a table whose rows carry a geometry column, and the standard defines how those geometries, their coordinate systems, and their metadata are recorded so that any compliant software, QGIS, ArcGIS, GDAL, web tools, can open the same file and agree about what is inside. The practical consequences are the ones that matter daily. A package can hold many layers at once, points, lines, polygons, and rasters side by side, so a whole project's data can live in one file. There are no ten-character field name limits and no 2 GB ceiling of the old format's imagination. Attribute types behave like a real database's, because they are one. And the file is a file: copy it, email it, version it, back it up, with none of the folder-of-fragments fragility our guides to adding a shapefile and exporting a shapefile must keep apologizing for. QGIS treats the format as home turf: new layers default to it, and the Browser panel browses inside packages as if they were folders.
Create One Properly: Database First, Then the Table
Creating a GeoPackage layer teaches the format's one conceptual step: the dialog asks for the database and the table name separately, because the file and the layer inside it are different things. In the New GeoPackage Layer dialog, point at a new or existing .gpkg file as the database, then name this layer as its table. Choose the geometry type, points, lines, polygons, or none for a pure attribute table, and set the CRS deliberately: the package records it, every compliant reader will trust it, and a wrong CRS recorded confidently is worse than the shapefile's honest missing .prj. Then define the fields, name and type each, text, whole number, decimal, date, with the care you would give a schema you intend to live in, because you are designing one: field names can finally say what they mean in full sentences of characters. Create, and the layer appears in your project backed by the new file. Add a second layer to the same database through the same dialog and the package begins to be what it promises: open the file in the Browser and both layers sit inside it, one file on disk, a project in miniature.

Filling and Organizing: Package Layers and the Browser Panel
Real packages accumulate layers from real work, and two tools do the heavy lifting. Package Layers, a Processing algorithm, takes existing layers from anywhere, shapefiles, other packages, temporary layers, and writes them into a single GeoPackage of your naming: the great gathering-in, ideal at a project's end or before handing data to anyone. The Browser panel is the daily instrument: it expands a .gpkg like a folder, lets you drag layers from the browser into the canvas, and, the move that reorganizes whole archives, drag layers from one package into another, consolidating the seven shapefiles of a 2016 survey into one file in an afternoon. Organization inside a package is naming and intention: layers named for content and date, a package per project or per theme rather than one swelling archive of everything, and styles saved into the package where QGIS offers it, so the file opens looking like the map its author meant. When layers arrive from a merge or a join baked for delivery, the package is where the results should land: permanent, portable, and self-describing.
Sharing: The Single File as a Social Contract
The GeoPackage changes the etiquette of exchanging GIS data. Instead of a zip of sidecars and a prayer, you send one file, and the recipient opens it in QGIS, ArcGIS, or a dozen other tools and sees the same layers, fields, and coordinate systems you saw. The contract has a few clauses worth honoring. Send the package, not a screenshot of it. Include in the file, or a small readme beside it, the provenance a stranger needs: who made these layers, from what sources, on what date, in what CRS, with what known gaps. Remember that a package can carry more than you intend: check which layers are inside before sending, because the draft layer and the embarrassing intermediate from March travel with the deliverable if you let them. And respect the format's database nature on the receiving end too: a GeoPackage opened by two people at once over a network share can sulk, since SQLite expects a single writer at a time; copy it locally to work, and treat shared drives as distribution, not as a workbench. Honored this way, the .gpkg becomes what the shapefile never could: a unit of GIS work that survives being sent.
GeoPackage vs Shapefile: The Honest Summary
The comparison deserves one plain paragraph, because migration questions deserve plain answers. The shapefile is a multi-file format from the 1990s: geometry in one file, attributes in a dBase table with ten-character field names and fragile encoding, projection in an optional sidecar, one geometry type per file, size limits that modern data meets. The GeoPackage is a single-file OGC standard on SQLite: many layers per file, full field names, real data types, recorded CRS, rasters welcome, styles portable, size limits beyond any ordinary project. The only honest argument for minting new shapefiles in this decade is a recipient whose toolchain demands one, and even then the working copy should live as a package and be exported at the gate. Everywhere else in this site's QGIS guides, when a layer must be saved, shared, or archived, the GeoPackage is the assumed destination, from corrected geometry to drawn polygons. Learn it once and the rest of your QGIS life gets simpler: one file, every layer, nothing left behind.
Styles, Versions, and the Package as an Archive
Two mature habits complete the GeoPackage craft. The first is styles inside the file: QGIS can save a layer's symbology and labeling into the GeoPackage itself, so the package opens on a colleague's machine wearing the map's intended face rather than a default fill, and for deliverables whose whole point is to be read, that stored style is the difference between data and communication. Save the style when the layer settles, and re-save it when the style changes, because a package faithfully preserves the last style you stored with the same loyalty it preserves your fields. The second habit is archival discipline: a GeoPackage is the right final form for a finished project's data, one file in the archive where a folder of shapefiles used to sprawl, but only if the file is genuinely final. Freeze a copy at delivery, name it with the project and date, and let the working package keep evolving under a working name. The archive copy's immutability is a social rule, not a technical one, since the file will accept edits from anyone who opens it in edit mode; treat it the way you would treat a signed PDF, stored read-only where your systems allow it. Projects archived this way can be reopened years later with their layers, styles, and coordinate systems intact and self-describing, which is the entire promise of the standard, kept by nothing more exotic than consistent habits.
Moving Day: Retiring a Shapefile Archive Without Tears
Most GeoPackage adoptions begin as a migration, and the migration has a calm order of operations. Start with inventory: list the archive's shapefiles, and for each, note its encoding wounds, its truncated field names in their full intended form, and its coordinate system, including the ones whose .prj files went missing years ago and must be identified from knowledge or metadata. Convert a pilot first, one well-understood dataset, through Package Layers or a save-as, then inspect the package the way this guide taught: fields whole, types sane, CRS declared, row counts equal. Fix the pilot's surprises in your procedure, not in the data. Then convert in families, thematic groups together, verifying each package before its source retires to the cold archive, because the shapefiles are not deleted on moving day; they are demoted to read-only history, kept until the packages have survived a season of real work. The deliverable habit changes last and matters most: from the first project after the migration, the package is what leaves the building, and the archive's sprawl stops growing. Teams that run this sequence report the same small astonishment a month later, opening the project folder and finding files they can count on one hand, each one complete. That is the whole pitch of the format, experienced at folder scale.
Related Guides
Readers working through this topic usually need its closest companions too. These GIS and open data guides cover the neighboring ground:
- How to Add a Shapefile in QGIS: The Whole File Family, the CRS Prompt, and the Zip Trick: The old format handled well, sidecars and all, for the data that still arrives wearing it.
- How to Export a Shapefile From QGIS: Save Features As, Without Losing Data: Exporting at the gate for recipients who demand shapefiles, from a working copy that should live as a package.
- How to Merge Layers in QGIS: One Layer, Same Geometry, Shared CRS: Combining layers into one, the kind of result that belongs in a package the moment it exists.
- QGIS Vertex Tool: Move, Add, and Delete Vertices Without Redrawing: Where the corrections inside shared packages get made, vertex by vertex.
Frequently Asked Questions
What is a GeoPackage?
An OGC standard format for geospatial data built on a single SQLite file. It holds many vector and raster layers in one file, with full field names, real data types, and recorded coordinate systems, and it has been the QGIS default format since the 3.x line.
What is the difference between the database and the table name in the New GeoPackage Layer dialog?
The database is the .gpkg file itself; the table name is the layer you are creating inside it. One database holds many tables, which is to say many layers, and the dialog asks for both because they are different things.
How do I put existing layers into a GeoPackage?
Use the Package Layers algorithm to write selected layers into one .gpkg, or drag layers between packages in the Browser panel. Both consolidate scattered files, including shapefiles, into a single portable package.
Can other software open a GeoPackage?
Yes. As an OGC standard it opens in ArcGIS, GDAL-based tools, and many web and mobile applications. That interoperability, in one self-describing file, is the point of the standard.
Why use a GeoPackage instead of a shapefile?
One file instead of a fragile family of sidecars, no ten-character field name limit, many layers per file, real data types, and a recorded CRS. Mint new shapefiles only when a recipient's toolchain demands one, and export at the gate from a package working copy.
Photo credits: Jakub Zerdzicki (Pexels); Jakub Zerdzicki (Pexels). Photos are served from this site; follow the credit to the library page for the original.