GIS Tools - Layer Packaging Tool

What Is a Layer Packaging Tool?

A layer packaging tool bundles one or more GIS layers — vector geometry, attributes, and styling — into a single downloadable archive that can be shared, archived, or restored later. Instead of emailing a folder of loose files and hoping nothing gets lost, you produce one ZIP that contains everything needed to recreate the original layers exactly. The Layer Packaging Tool on gis.tools is the browser-based equivalent of QGIS layer packages or ArcGIS layer files: select the layers you have loaded in your session, optionally include style JSON, and download a ZIP that other gis.tools users (or you, on a different machine) can re-import in one step.

The tool exists because GIS data is rarely just one file. A typical layer is geometry plus attributes plus a CRS plus a colour scheme plus labels plus filters. Bundling all of that into one archive guarantees that the recipient sees what you saw.

How Layer Packaging Works

The packager walks the list of layers currently loaded in your session, serialises each one as GeoJSON (with the CRS standardised to WGS84 for portability), captures the current style configuration, writes a manifest describing the contents, and zips everything into a single archive. Each layer becomes its own file inside the archive; styles and metadata live alongside in JSON files; the manifest at the root describes the bundle.

The resulting ZIP can be uncompressed by any tool that handles ZIP archives, but the gis.tools loader can also re-import the entire package in one drag-and-drop, restoring layer order, visibility, and styling.

Manifest Structure

The manifest is a small JSON file listing every layer in the package, its file path within the archive, its display name, its CRS, its style file (if any), and any custom metadata. This is what allows round-tripping a package back into the application without losing context.

Style Capture

If you've used the Symbology Editor, Categorical Styling, or Graduated Styling tools to apply styling, the configuration is captured in a JSON file inside the package. The format is a simplified style schema based on the Mapbox style spec.

Practical Applications

Project Handoff

When handing a project to a colleague or client, packaging all the layers in one ZIP guarantees they see the same data with the same styling.

Reproducible Research

Academic papers that include map figures benefit from publishing the underlying layer package as supplementary material, so reviewers and readers can recreate the figure exactly.

Backup and Versioning

A single ZIP per project state is easier to back up than a sprawling directory of files. Drop them in cloud storage, Git LFS, or an institutional repository.

Cross-Tool Migration

A package produced by gis.tools can be reopened by any tool that reads GeoJSON, with the bonus that the manifest and style files survive for tools that recognise them.

Education

Instructors distributing exercise data can ship a single layer package per assignment instead of a folder of confusing parts.

Field Deployment

A technician heading out to a remote site can pack everything they need into one ZIP and load it on a tablet without worrying about missing files.

Offline Map Tiles

For scenarios where you need vector tiles plus styling for offline use, the packager can include a PMTiles/MBTiles Inspector tile archive alongside the vector layers.

Step-by-Step Workflow in gis.tools

Load the layers you want to package using the GeoJSON, KML, Shapefile & GIS File Viewer or any conversion tool.
Open the Layer Packaging Tool.
Select the layers to include from a checklist of currently loaded layers.
Choose whether to include style JSON, metadata, and any non-spatial assets.
Optionally rename the package and add a description.
Click Build Package — the tool zips everything client-side.
Download the resulting .zip and store, share, or upload it as needed.

Worked Example

A city planner has loaded three layers — parcels, zoning, and traffic counts — and applied custom categorical styling to each. They need to send the complete project to a colleague for review. Instead of emailing six files (three GeoJSONs and three style JSONs), they open the packager, select all three layers, include styles and metadata, name the bundle westside_review_2024.zip, and click Build Package. The 4.8 MB ZIP arrives in their downloads folder. They email it to the colleague, who drops it back into the gis.tools loader and sees an exact replica of the original session: same layers, same colours, same labels.

Common Pitfalls and Gotchas

Style format mismatch — A package built with one version of the style schema may need migration to load in a future version.
Large embedded raster — Including a multi-gigabyte GeoTIFF in a package makes it too big to share. Reference an external URL instead.
CRS coercion — All layers are normalised to WGS84 inside the package, which means a high-precision local survey will lose sub-millimeter precision.
Forgotten metadata — If you don't fill in the description field, the package's purpose can be unclear when you find it months later.
Path collisions — If two layers have the same file name in the package, the manifest disambiguates but human readers may be confused.
Unicode in filenames — Non-ASCII layer names may not survive zipping on some platforms.
Privacy — A package may include layers you forgot about; review the contents before sharing.

Tips for Best Results

Always add a meaningful description and date to the package.
Use the Metadata Generator before packaging so each layer has lineage information.
Validate each layer with the GeoJSON Validator & Fixer before bundling.
Pair with the Coordinate Precision Reducer to keep package size manageable.
Keep packages under 50 MB for easy email and storage.
Use semantic file names so users browsing the archive understand what each file is.
Document any external dependencies (web tiles, basemap URLs) in the description.

Comparison with Other GIS Approaches

QGIS has a Package Layers tool that bundles selected layers into a GeoPackage. ArcGIS Pro produces .lpkx layer packages with embedded data and symbology. The browser-based gis.tools packager is conceptually similar but uses open formats (ZIP + GeoJSON + JSON) so the contents can be opened by any tool, not just gis.tools.

Performance Considerations

Packaging is fast — a few seconds for typical projects, longer for larger raster contents. The main constraint is browser memory while zipping, which caps the practical package size at around 500 MB on a desktop browser.

Data Privacy and Browser-Based Processing

The entire packaging operation runs in your browser tab. The ZIP is built locally and downloaded directly to your machine. No data is uploaded, no telemetry is collected, and no temporary copies are stored on a server.

Related GIS Concepts

GeoPackage (.gpkg) — An OGC standard SQLite-based container format for GIS data. A modern alternative to layer packages.

QGIS Project (.qgz) — A compressed XML project file with references to data files (and optionally embedded data).

ArcGIS Layer Package (.lpkx) — A proprietary archive format with embedded data and symbology.

Mapbox Tilesets — Cloud-hosted tile bundles that serve a similar purpose for online use.

Frequently Asked Questions

Can I open a gis.tools package in QGIS?

You can extract the ZIP and load the individual GeoJSON files in QGIS. The styling will not transfer automatically because QGIS uses its own style format.

What's the maximum package size?

Around 500 MB on a desktop browser before performance becomes an issue.

Does the package include the basemap?

No — basemaps are typically referenced from external URLs rather than embedded.

Can I add my own files to the package?

You can attach arbitrary files via the Add Asset option, which copies them into the archive alongside the layers.

Layer Packaging Tool

About Layer Packaging