Bluegraph
/Strandline/Developer guide

Strandline

Developer guide

How to add the Strandline base map to a web page, theme it, and draw data on it.

Overview

Strandline is a base map of coastal regions, intended as a background for data such as buoys, currents, survey sites, and the positions and tracks of uncrewed surface vehicles (USVs) and other autonomous vessels. It contains reference geography (land, shoreline, depths, wetlands, beaches, kelp, harbor structures, roads and place names) and no observational data.

Coverage today

The map is detailed for most of the U.S. and for Canada's coasts. In the U.S., the detailed area is the fifty states, Puerto Rico and the U.S. Virgin Islands, excluding the western Aleutians. In Canada, it is all coasts: the Atlantic provinces, Quebec, Ontario's side of the Great Lakes, Hudson Bay, the Arctic and British Columbia. The rest of North America is covered at small scales only. Guam, American Samoa and the rest of the world are not covered. See Coverage and limits for details.

Plans and contributions

Coverage is planned to expand region by region, with the goal of covering the world's coasts.

Strandline is a free public service from Bluegraph. Contributions are welcome: coastal data sources for areas not yet covered, corrections, and help with building and hosting. To contribute, contact Bluegraph.

How it works

  • Tiles. Each tileset is a single PMTiles file. The browser fetches the parts it needs with HTTP range requests. There is no tile server or API.
  • Style. A JavaScript module, style.js, builds a MapLibre style from a theme and a release. The tiles contain no colors. All rendering is done in the browser, which is what makes theming possible.
  • Releases. A release identifies an exact set of tileset files, the schema they follow and the style built for them. A published release does not change, so a page that pins a release shows the same map until it moves to a newer release.

The style module requires MapLibre GL JS 6.6.0 or later and the PMTiles client. The pages on this site are tested with MapLibre GL JS 6.19.0 and pmtiles 4.5.0 in Chromium. MapLibre 6 requires WebGL 2, which all current browsers support.

No API key or account is required, and the map can be used from any website. The data is in the public domain, with two exceptions: Canada's coasts and Arctic depths north of 64° N. Both require attribution while they are in view. The quick start shows how it is added.

Quick start

The following is a complete page. It pins one release, renders the map in the dark theme, and restricts the view to the area the tiles cover.

The example loads MapLibre GL JS 6.19.0 and PMTiles 4.5.0 from map.bluegraph.io. MapLibre 6 is an ES module, so it is imported rather than loaded with a script tag. Any MapLibre version from 6.6.0 works, loaded from any source.

<!doctype html>
<meta charset="utf-8">
<link rel="stylesheet" href="https://map.bluegraph.io/vendor/maplibre-gl.css">
<div id="map" style="height: 480px"></div>

<script src="https://map.bluegraph.io/vendor/pmtiles.js"></script>
<script type="module">
  import * as maplibregl from "https://map.bluegraph.io/vendor/maplibre-gl.mjs";
  import { createMap, ABYSSAL }
    from "https://map.bluegraph.io/releases/2026-11-20/style.js";

  const map = createMap(maplibregl, pmtiles, {
    container: "map",
    theme: ABYSSAL,
    center: [-117.25, 32.85],
    zoom: 10.5,
  });
</script>

The map below is created the same way. The switch changes the theme in both the code above and the map.

La Jolla and Mission Bay. On this page, zooming requires Ctrl or ⌘ with the scroll wheel, or two fingers, so that the page can still be scrolled.

createMap takes MapLibre, the PMTiles client and an options object. It does the following:

  • Registers the PMTiles protocol with MapLibre by calling connect, once per page. Without this call MapLibre cannot read the tilesets and the map is empty. connect also handles relief: where no fine depth tile exists, which is the case away from the coasts, it uses the continental tile.
  • Builds the style with buildStyle, from the options theme, hide, depthLabels and annotations (see the style module reference).
  • Registers the fill patterns for marsh, tidal flat, wetland, kelp and rocky shore in the same theme, with addPatterns.
  • Restricts the view to the area the tiles cover, with maxBounds: BOUNDS.
  • Shows the two required attributions with creditControl, which replaces MapLibre's attribution control. Canada's coasts come from Canadian federal data under the Open Government Licence – Canada, which requires its attribution statement where the data is used. The control shows the statement while Canada's coasts are in view. North of 64° N, depths and heights come from the International Bathymetric Chart of the Arctic Ocean (IBCAO), which also requires attribution. The control shows it while the view extends north of 64° N. The remaining data requires no attribution, and the control is empty elsewhere.

All other options are passed to maplibregl.Map unchanged. Pass maxBounds or attributionControl to override the values createMap sets. Pass credit: false on a page that never shows Canada or the Arctic.

The individual calls

createMap is equivalent to the following calls:

import { buildStyle, connect, addPatterns, creditControl, BOUNDS, ABYSSAL }
  from "https://map.bluegraph.io/releases/2026-11-20/style.js";

// Call once per page, before creating a map.
connect(maplibregl, pmtiles);

const map = new maplibregl.Map({
  container: "map",
  style: buildStyle({ theme: ABYSSAL }),
  center: [-117.25, 32.85],
  zoom: 10.5,
  maxBounds: BOUNDS,            // North America, the area the tiles cover
  attributionControl: false,    // replaced by creditControl below
});
// Shows the Canada and IBCAO attributions while those areas are in view.
map.addControl(creditControl(), "bottom-right");
// Fill patterns. Pass the same theme as buildStyle.
addPatterns(map, ABYSSAL);

Releases

A release is named for the date it was created, for example 2026-11-20. Its files are in /releases/<release>/:

FileContents
release.jsonFor each tileset: file name, checksum, size, zoom range and bounds. Also the schema version.
style.jsThe style module as of the release
release.jsThe contents of release.json as a module, imported by style.js
schema.jsonThe schema the tilesets were validated against

A tileset's file name includes the first characters of its checksum, for example relief-62a092f45440.pmtiles. A rebuilt tileset has different contents and therefore a different file name. The previous file remains available to the releases that reference it.

Pin a release

Specify the release in the import URL. This fixes the style, the release metadata and the tileset files. To upgrade, change the release name in that URL.

import { buildStyle, addPatterns, SLOTS }
  from "https://map.bluegraph.io/releases/2026-11-20/style.js";

Follow the newest release

/releases/v0/latest.json is the release.json of the newest release with schema version 0. A page that loads it receives updated data and coverage without code changes. The URL is specific to one schema version, so a release with a breaking schema change is not served from it.

const host = "https://map.bluegraph.io";
const { release } = await (await fetch(`${host}/releases/v0/latest.json`)).json();
const { buildStyle, addPatterns } = await import(`${host}/releases/${release}/style.js`);

Pin a release when the map must stay the same, for example in a published figure. Otherwise, follow the newest release.

Using a bundler

In a project with a bundler, install the two libraries from npm and copy a release's style.js and release.js into the same directory in your source tree. Both are ES modules with no dependencies. MapLibre 6.6.0 or later is required. With a bundler, MapLibre 6 needs the URL of its worker file, which is set once with setWorkerUrl. MapLibre's installation guide gives the line for each bundler.

npm install maplibre-gl pmtiles
curl -O https://map.bluegraph.io/releases/2026-11-20/style.js
curl -O https://map.bluegraph.io/releases/2026-11-20/release.js

A local copy cannot determine the map's host from its own URL, so pass it as origin:

import * as maplibregl from "maplibre-gl";
import "maplibre-gl/dist/maplibre-gl.css";
import * as pmtiles from "pmtiles";
import { createMap } from "./strandline/style.js";

const map = createMap(maplibregl, pmtiles, {
  container: "map",
  origin: "https://map.bluegraph.io",
  center: [-117.25, 32.85],
  zoom: 10.5,
});

To upgrade, replace both files with those of the newer release.

In a component framework, create the map after its container element exists, and call map.remove() when the component unmounts. createMap calls connect only once per page, regardless of the number of maps. When making the calls individually, call connect once per page, not once per map.

Themes

A theme is a plain object containing the map's colors, the depth ramp, the fonts and the patterns for coastal features. The style module includes two: ABYSSAL (dark) and LITTORAL (light). The default is ABYSSAL.

import { createMap, LITTORAL }
  from "https://map.bluegraph.io/releases/2026-11-20/style.js";

const map = createMap(maplibregl, pmtiles, { container: "map", theme: LITTORAL });

When making the calls individually, pass the theme to both buildStyle and addPatterns.

Custom themes

theme(changes, base) returns a copy of base with the given changes applied. The example below starts from the light theme, changes four land colors to lower-contrast values, reduces the kelp tint and removes three patterns. The result is a plainer background for overlaid data.

import { createMap, theme, LITTORAL }
  from "https://map.bluegraph.io/releases/2026-11-20/style.js";

const quiet = theme({
  name: "Quiet",
  palette: { land: "#f4f2ee", green: "#e6eadd", greenDark: "#dde4d2", landUrban: "#eeece7" },
  strength: { kelp: 0.15 },
  patterns: { kelp: null, wetland: null, saltmarsh: null },
}, LITTORAL);

const map = createMap(maplibregl, pmtiles, { container: "map", theme: quiet });
PropertyContentsEffect of setting it
nameThe theme's name, recorded in the style's metadataReplaced
paletteAll colors, keyed by what they color (listed below)Merged: the keys you set change, the rest are kept
depthRampPairs of a depth in meters (negative below sea level) and a color, deepest firstReplaced as a whole
fontsThe regular, medium and italic font stacksMerged
strengthOpacity of the kelp and reef tints on the water, 0 to 1Merged
patternsFor each coastal feature, a pattern and its color, or null for no patternMerged
patternStrengthOpacity of the patterns, 0 to 1Replaced
edgeA color and a fraction. The outline of a filled feature is its fill color mixed toward this color by that fraction.Replaced

An unknown key is an error. For example, theme({ palette: { lnad: "#000" } }) throws, so a misspelled key is not silently ignored.

The host serves glyphs for Noto Sans only, in three ranges: Latin, Latin Extended and punctuation. A theme that uses another font needs a style whose glyphs URL serves that font.

The palette

Each palette key, with its color in the two built-in themes of this release.

NameAbyssalLittoral
Loaded with the page.

Adding your data

The style is a standard MapLibre style, so data is added with map.addSource and map.addLayer. The second argument of addLayer sets the layer's position in the drawing order. The style provides two insertion points, named in SLOTS.

PositionDrawing orderTypical use
SLOTS.underLandAbove the water, the depth tint and the depth contours, and below the land. The land covers any part of the layer that extends ashore.Data at sea: currents, model output, survey areas
SLOTS.underLabelsAbove the land, shoreline features and roads, and below all labelsStations, sites, vessel and USV tracks
None givenAbove everything, including labelsYour own labels
import { ABYSSAL, SLOTS }
  from "https://map.bluegraph.io/releases/2026-11-20/style.js";

map.on("load", () => {
  map.addSource("sites", { type: "geojson", data: "/my/sites.geojson" });

  // Above the land and roads, below all labels.
  map.addLayer({
    id: "sites", type: "circle", source: "sites",
    paint: {
      "circle-radius": 6, "circle-color": "#ff8a70",
      "circle-stroke-color": "#0a111d", "circle-stroke-width": 2,
    },
  }, SLOTS.underLabels);

  // Site labels, above everything, in the theme's font.
  map.addLayer({
    id: "site-names", type: "symbol", source: "sites",
    layout: {
      "text-field": ["get", "name"], "text-font": ABYSSAL.fonts.medium,
      "text-size": 12, "text-offset": [0, 1.2],
    },
    paint: { "text-color": "#ffb3a1", "text-halo-color": "#0a111d", "text-halo-width": 1.5 },
  });
});

Use the theme's fonts for your labels, as above. A label in a font the host has no glyphs for is not drawn.

The example page shows these steps in one file with sample data. It loads a release, applies a theme, and draws a polygon below the land and three sites below the labels.

Hiding and restyling layers

Omit groups

Every layer belongs to a group. buildStyle({ hide: [...] }) omits the listed groups from the style.

GroupContents
bathymetryThe depth tint
isobathsDepth contours and their labels
reliefThe hillshade, on land and on the seafloor
coastalMarsh, tidal flat, wetland, rocky shore, kelp, breakwaters, harbor areas, and the labels of bays, capes and islands
builtRoads, rail, piers and ferry routes
labelsThe labels of towns, neighborhoods, roads and inland water

A group can also be shown or hidden after the map is created. Each layer has its group in metadata.group:

function show(group, visible) {
  for (const layer of map.getStyle().layers) {
    if (layer.metadata?.group !== group) continue;
    map.setLayoutProperty(layer.id, "visibility", visible ? "visible" : "none");
  }
}
show("built", false);

Restyle one layer

Layer ids are part of a release's interface, so a page can restyle or hide any layer by its id. Within a schema version, ids are added but not renamed or removed.

map.setPaintProperty("coastline", "line-color", "#0b3d5c");
map.setLayoutProperty("label-road", "visibility", "none");

The layer ids of this release, by group:

GroupLayer ids
Loaded with the page.

A legend for the coastal features

keyFor("pd", theme) returns the legend entries, each with the color the map uses. coastPattern returns a pattern as an image for a swatch.

import { keyFor, coastPattern, ABYSSAL }
  from "https://map.bluegraph.io/releases/2026-11-20/style.js";

for (const entry of keyFor("pd", ABYSSAL)) {
  const swatch = document.createElement("i");
  swatch.style.backgroundColor = entry.color;
  const pattern = entry.pattern && coastPattern(`coast-${entry.pattern[0]}`, ABYSSAL);
  if (pattern) {
    swatch.style.background = `${entry.color} url(${pattern.url}) 0 0 / ${pattern.size}px`;
  }
  // entry.label is "Salt marsh", "Tidal flat", "Wetland", "Mangrove", "Beach",
  // "Kelp", "Sea grass", "Rocky shore" or "Breakwater".
}

Style module reference

createMap(maplibregl, pmtiles, options)

Returns a MapLibre map with the Strandline style, as in the quick start. It accepts the buildStyle options below and the following:

OptionDescriptionDefault
creditThe corner for the attribution control, as accepted by map.addControl, or false to omit the control"bottom-right"
Any otherPassed to maplibregl.Map unchanged: container, center, zoom and so onMapLibre's default, except maxBounds (BOUNDS) and attributionControl (false)

buildStyle(options)

Returns a MapLibre style. All options are optional.

OptionDescriptionDefault
originThe map's host, https://map.bluegraph.ioThe origin the module was loaded from. A copy served from another site must set it.
releaseThe tileset files to read, as a release.json objectThe release the module belongs to
themeABYSSAL, LITTORAL, or a theme made with theme()ABYSSAL
hideA list of groups to omitNo groups omitted
depthLabelsWhich contours are labeled with their depth: "all", "main" (50, 100, 200, 500 and 1,000 meters, and every 1,000 meters below that) or "none". The contours are drawn in all three cases."all". The contours between the main ones are labeled from zoom 10.
annotationsThe URL of a GeoJSON file of annotations, drawn above everything else and labeled with their name propertyNo annotations

Exports

NameDescription
createMap(maplibregl, pmtiles, options)Creates a map with the Strandline style. See above.
buildStyle(options)Returns the style. See above.
connect(maplibregl, pmtiles)Registers the PMTiles protocol with MapLibre so that it can read the tilesets. Call it once, before creating a map.
addPatterns(map, theme)Registers the pattern images the style uses. Call it once, immediately after creating the map, with the theme passed to buildStyle.
creditControl()A MapLibre control that shows Canada's attribution while Canada's coasts are in view, and the IBCAO attribution while the view extends north of 64° N. It is empty otherwise. Add it with map.addControl.
credits(map)The attributions required for the map's current view, as an array of { text, link }: empty, Canada's, IBCAO's, or both. For pages that display attribution themselves.
CANADA, CANADA_CREDITThe names of the tilesets that contain Canada's coasts, and the attribution statement their licence requires with the licence's URL
ARCTIC, ARCTIC_CREDITThe name of the tileset that contains Arctic relief north of 64° N, and the attribution for its source (IBCAO 5.0) with the source's URL
ARCTIC_ISOBATHSThe name of the tileset that contains Arctic depth contours, derived from the same source
theme(changes, base)Returns a theme derived from base. The default base is ABYSSAL.
ABYSSAL, LITTORALThe dark theme, which is the default, and the light theme
THEMESBoth themes, keyed abyssal and littoral
belowDatum(rgba), GREAT_LAKESbelowDatum converts a relief tile's RGBA pixels, in place, to depths for the tint. In a Great Lake the result is the depth below the lake's datum. connect applies it to URLs that end in /depths. GREAT_LAKES maps the lake number stored in the pixels to that lake's low water datum in meters.
BOUNDSThe area the tiles cover, for maxBounds: 180° W to 50° W and 5° N to 84° N
SLOTSThe two insertion points for your layers: underLand and underLabels
keyFor(base, theme)The legend entries for the coastal features
coastPattern(id, theme)One pattern as an image: picture (the image data), size and url (a data URL for a swatch)
mix(color, strength, over)Returns a color at the given opacity composited over another color, as the map blends them

Style metadata

A style returned by buildStyle records its release, schema version and theme in its metadata:

map.getStyle().metadata
// { "strandline:release": "2026-11-20", "strandline:schema": 0,
//   "strandline:theme": "Abyssal" }

Tile contents

The tilesets of release 2026-11-20, from its release.json:

TilesetTypeZoomsSizeContents
Loaded with the page.

The vector tilesets contain the layers below. Most features have a kind attribute and many have kind_detail. Styles filter on these. The tables are generated from the release's schema.json.

Loaded with the page.

Heights and depths

Three tilesets contain elevation data rather than imagery. relief_frame covers North America to zoom 8, relief covers the detailed regions from zoom 9 to 12, and relief_arctic covers the area north of 64° N at zoom 9. Each pixel encodes a height in meters, negative below sea level, which allows each theme to color the depths and shade the terrain differently. The encoding is Terrarium: height = red × 256 + green + blue ÷ 256 − 32768.

The surface of a Great Lake is not at sea level. A lake's pixels encode the height of the lake bed, and the lowest three bits of the blue channel identify the lake: 1 Superior, 2 Michigan and Huron, 3 St. Clair, 4 Erie, 5 Ontario. A lake's depth is its low water datum minus the bed height. GREAT_LAKES has the datums. As a result, the hillshade is continuous from the land into a lake, and the tint shows each lake's depth below its own datum, in the same way that sea depths are shown below sea level.

The style combines these tilesets into one surface. Where a finer tile exists the map uses it. Elsewhere it uses the continental tile, upsampled.

Writing your own style

style.js is optional. The tilesets are standard MapLibre sources, and a release's release.json lists their files:

const host = "https://map.bluegraph.io";
const release = await (await fetch(`${host}/releases/2026-11-20/release.json`)).json();
const file = (tileset) => `${host}/tiles/${release.tilesets[tileset].file}`;
const tiles = (tileset) => `pmtiles://${file(tileset)}`;
const part = (tileset) => encodeURIComponent(file(tileset));

const style = {
  version: 8,
  glyphs: `${host}/fonts/{fontstack}/{range}.pbf`,          // Noto Sans Regular, Medium, Italic
  sources: {
    frame: { type: "vector", url: tiles("frame") },         // North America, to zoom 8
    basemap: { type: "vector", url: tiles("basemap_pd") },  // the detailed regions
    coastal: { type: "vector", url: tiles("coastal_pd") },
    isobaths: { type: "vector", url: tiles("isobaths") },
    // Heights and depths: relief_frame below zoom 9 and relief from zoom 9, as one source.
    relief: {
      type: "raster-dem", encoding: "terrarium", tileSize: 256, maxzoom: 12,
      tiles: [`strandline://${part("relief_frame")}/9/${part("relief")}/{z}/{x}/{y}`],
    },
  },
  layers: [
    // your layers
  ],
};
  • The depth tint is a color-relief layer on the relief source, which requires a recent MapLibre GL JS 5 or later.
  • The strandline:// URL is handled by connect, so call connect with your own style as well. The URL gives the tileset to read below a zoom level, that zoom level, and the tileset to read from that zoom level up. Either tileset can also be used alone as a standard source: set url: tiles("relief_frame") instead of tiles.
  • To tint and shade from the same tiles, declare the source twice, as style.js does: once for the color-relief layer and once for the hillshade layer.
  • For the tint's source, append /depths to the strandline:// URL. connect then returns each Great Lake's depth below its datum instead of the bed height. Use the URL without /depths for the hillshade's source.
  • The Great Lakes are rendered like the sea, by depth. The land polygons exclude them, and their water polygons have a datum attribute. Do not fill those polygons, because the fill would hide the tint.
  • From zoom 7, the frame's tiles omit the detailed regions, whose own tilesets start at that zoom. For this reason style.js starts every basemap, coastal and isobaths layer at zoom 7.
  • The tables above list each layer's contents and its kind values.

Offline use

An area of the map can be copied for use without a connection to map.bluegraph.io, for example aboard a vessel, in the field or on an isolated network. Tilesets are read by byte range, so the tiles within a bounding box can be extracted without downloading the whole file.

curl -O https://map.bluegraph.io/offline.sh
sh offline.sh -117.6,32.5,-117.0,33.0 san-diego

The bounding box is west, south, east, north, in degrees. The script requires curl and the pmtiles CLI. It writes a directory containing the newest release for that box: the tiles at all zooms, the release's style, the fonts, the two libraries, and an index.html that displays the map. The example box, San Diego's coast, is about 30 MB and takes about two minutes.

Serve the directory with a web server that supports byte-range requests (nginx, Caddy, npx http-server; Python's http.server does not) and open it. It makes no requests to map.bluegraph.io. The style loads the tiles and fonts relative to its own URL, so your own page can import ./releases/<release>/style.js from the directory in the same way the quick start imports it from the host.

The copy contains one release and is not updated. Run the script again to get a newer release.

URLs and caching

All URLs are under https://map.bluegraph.io.

URLContentsCache lifetime
/releases/<release>/style.js, release.json, release.js, schema.jsonOne release's filesOne year. The files do not change.
/tiles/<tileset>-<checksum>.pmtilesOne build of a tilesetOne year. The file does not change.
/releases/v0/latest.jsonThe newest release of schema version 0Five minutes
/releases/latest.jsonThe newest release of any schema versionFive minutes
/releases/index.jsonAll releases, with the schema version and state of eachFive minutes
/fonts/{fontstack}/{range}.pbfThe glyphs, shared by all releasesOne day

"Newest" means the newest release that is complete: its files match what was published, and every tileset it references is present and matches its checksum.

Rate limits. No key is used, so limits apply per IP address. Each address is allowed a burst of 600 requests and then 40 requests per second, 200 concurrent requests, and 20 GB of tileset data per day. Opening a map takes about 100 requests and a few megabytes, so normal use of a page does not reach these limits. A request over a limit receives 429 with a Retry-After header. A connection that transfers less than 1 MB in a minute is closed.

Coverage and limits

  • Coverage. North America is covered at small scales, from 5° N to 84° N and from 180° W to 50° W: land and shoreline, depths and hillshade, lakes and large rivers, main roads, borders, cities, and the names of seas, bays and islands. These tiles end at zoom 8, and MapLibre upsamples them at higher zooms. The U.S. & Canada are covered in detail from zoom 7 to zoom 14. In the U.S., the detailed area is the fifty states, Puerto Rico and the U.S. Virgin Islands, with surveyed shoreline, streets, place names, wetlands, kelp and harbor structures. In Canada, it is all coasts (the Atlantic provinces, Quebec, Hudson Bay, the Arctic and British Columbia) and Ontario's side of the Great Lakes, with shoreline, place names and wetlands, and without streets. The rest of Canada and Mexico are covered at small scales only. The western Aleutians, Guam and American Samoa are outside the covered area. createMap restricts the view to the covered area. When making the calls individually, set maxBounds: BOUNDS.
  • Not for navigation. The map is not a nautical chart and must not be used for navigation.
  • Depths. Along the Pacific, Gulf and Atlantic coasts of the lower 48 states, and around Hawaii and Puerto Rico, depths come from a model on a 30 meter grid, lightly smoothed, and the contours are derived from it. North of 64° N, depths come from IBCAO 5.0, on a 100 meter grid. Elsewhere, including Alaska south of 64° N, they come from a global model on a grid of about 450 meters.
  • Great Lakes. Bathymetry is from NOAA's grid for each lake, at about 90 meters. Depths are measured from each lake's low water datum, as on NOAA's charts of the lakes. The rivers between the lakes are drawn as rivers, without depths. The lakes' shorelines come from Census and Canadian federal maps, not from a shoreline survey.
  • Mexico. Coverage is limited to land, depths, hillshade, main roads and the label for Tijuana. Streets are not included.
  • Beaches and rocky shores are drawn as areas where the National Wetlands Inventory maps them. Along the sea coasts they are also drawn as a line on the shore where NOAA's Environmental Sensitivity Index (ESI) classifies the shore type. The shoreline geometry is from NOAA's latest survey. The classification of each stretch dates from its ESI atlas (1996 on Florida's Atlantic coast, for example), and the shore_year attribute gives the year.
  • Mangrove is the inventory's class of tidal scrub and forest of broad-leaved evergreens, on the coasts where mangrove grows.
  • Kelp and sea grass are drawn where NOAA's charts mark a bed as an area and where the ESI maps one. Sea grass is also drawn where the National Wetlands Inventory maps a bed of submerged vegetation. Kelp is mapped from California to Washington. Sea grass is mapped on the Pacific, Gulf and Atlantic coasts, Puerto Rico and the Virgin Islands. In brackish water, such as the upper Chesapeake, the ESI's beds include submerged vegetation of any kind. ESI beds show the extent recorded in the survey years before each atlas (the atlases date from 1998 to 2016), not the current extent. Alaska and Hawaii have chart data only. Kelp is mapped only where it forms a surface canopy, as giant and bull kelp do on the Pacific coast. Atlantic kelp grows below the surface and is absent from these sources, so the absence of kelp on the map does not indicate that none grows there.
  • Hillshade inland. The 30 meter relief covers the coast. Farther inland, heights come from the continental data and the hillshade has less detail.
  • Buildings are not included.
  • Labels. City labels are ranked by population, which is available only for incorporated cities. The glyphs cover Latin scripts only.