Attribution and Licensing

Attribution and licensing

This page covers two separate things: the licenses of the code (vgl's own MIT license and those of its third-party dependencies, and which license files an install or package ships), and the licenses of the data (the attribution that the datasets require, how the baker records it in packs, how vgl_context_attribution_get reports it at run time, and how a host should display it). The code license and the data licenses are independent: vgl being MIT says nothing about what you must do when you show Copernicus terrain or Sentinel-2 imagery.

vgl's license

vgl is released under the MIT license, copyright (c) 2026 Jeremiah van Oosten. You may use, modify and distribute it, including linking it into closed-source and commercial products. The only condition is that the copyright notice and the license text are included in all copies or substantial portions of the software: for a binary product, ship the LICENSE file (installed as share/doc/vgl/LICENSE) with your other third-party notices. MIT is compatible with GPLv2 and GPLv3 projects.

Contributors keep the copyright to their own contributions and license them under MIT, confirmed by a Developer Certificate of Origin sign-off (git commit -s) on each commit; see CONTRIBUTING.md. Every source file starts with an SPDX-License-Identifier: MIT header. The samples' code is MIT too, so you can copy it into your application (Samples).

Third-party code

vgl keeps its dependencies small and permissively licensed (design document, section 12.3). Which of them end up in your product depends on what you build:

Dependency	Used by	Version pinned when downloaded	License	In your product when
Zstandard	Core: tile compression	1.5.7	BSD (dual-licensed BSD / GPLv2; use it under BSD)	Always. A downloaded Zstandard is compiled into vgl with hidden symbols; an installed one is linked
stb_image	Core: JPEG and PNG imagery decoding	A pinned commit of `stb_image.h`	Public domain or MIT, at your choice	Always: compiled into vgl, its allocations routed to the context's allocator
libcurl	Defaults module's HTTP reader, only with `VGL_DEFAULTS_HTTP`	8.11.1	curl license (MIT/X style)	You build with `VGL_DEFAULTS_HTTP` (not on Emscripten, which uses the browser's fetch)
Ogre 14	Ogre backend, only with `VGL_BACKEND_OGRE`	14.6.1	MIT	You use the Ogre backend
GDAL (and PROJ, through it)	The baker (`vgl-bake`) only	Found, never downloaded (3.7 or later)	MIT/X style	Never in the runtime: only in the baking tool
nlohmann/json	The baker only	Installed, else downloaded	MIT	Never in the runtime
GLFW	Samples only	3.4	zlib/libpng	Only if you ship the samples
Dear ImGui	Samples' overlay only	1.92.9b	MIT	Only if you ship the samples

The runtime core uses only the C and C++ standard libraries besides Zstandard and stb_image. The license names above are those of the upstream projects; check each project's own license file for the version you ship.

What install and packaging ship

The install rules (cmake/vgl_install.cmake) put license files in share/doc/vgl (${CMAKE_INSTALL_DATADIR}/doc/vgl):

File	Contents	Installed when
`LICENSE`	vgl's MIT license	Always
`LICENSE.stb`	stb_image's license, extracted from the comment at the end of `stb_image.h`	Always
`LICENSE.zstd`	Zstandard's license	When Zstandard was downloaded and compiled into vgl
`LICENSE.curl`	curl's license	When a downloaded curl is linked into a shared defaults module (`VGL_DEFAULTS_HTTP`)

When vgl links an installed Zstandard, that package provides its own license. The packaging forms build on the same install rules (packaging/README.md, Installing vgl):

Release archives (GitHub releases): an install prefix with share/doc/vgl holding LICENSE, LICENSE.stb and LICENSE.zstd. The archives do not include the HTTP reader, so they contain no libcurl.
vcpkg port (packaging/vcpkg/ports/vgl): installs vgl's LICENSE as the port's copyright file. Its dependencies come from vcpkg (stb, Zstandard, and libcurl with the http feature), and each carries its own copyright file.
Conan recipe (packaging/conan): copies LICENSE into the package's licenses folder; its dependencies (Zstandard, stb, and libcurl with with_http) come as Conan packages with their own licenses.

If you ship vgl in a product, collect: vgl's LICENSE, LICENSE.stb, Zstandard's license, and, if used, libcurl's and Ogre's. The install rules install curl's license only for a downloaded curl linked into vgl, and never Ogre's: an installed libcurl or Ogre comes with its own.

Data licenses and required attribution

Baked datasets carry the attribution requirements of their sources, independently of the code license. The project hosts no data: you bake packs from the sources yourself with the Baker and host them yourself (Hosting packs), so you are the one who must honour the source licenses, both when you redistribute packs and when your application shows them.

The default datasets (design document, section 9) and the credit lines used in the repository's bake configurations:

Dataset	Layer	License and conditions	Credit line used by vgl's configurations
Copernicus DEM GLO-30 (and GLO-90)	Elevation, land	Free license; adapted data must be credited	Short form (`tools/baker/examples/glo30-norway.json`): `Produced using Copernicus WorldDEM-30 © DLR e.V.` Full form (`samples/data/glo30-sample.json`): `Produced using Copernicus WorldDEM-30 © DLR e.V. 2010-2014 and © Airbus Defence and Space GmbH 2014-2018 provided under COPERNICUS by the European Union and ESA; all rights reserved`
GEBCO grid	Elevation, global including oceans	Public domain; commercial use permitted; the source must be acknowledged	`GEBCO Compilation Group (2026) GEBCO 2026 Grid`
EGM2008	Geoid	Distributed by NGA, here through PROJ's `us_nga_egm08_25.tif`	`EGM2008 geoid model, National Geospatial-Intelligence Agency (NGA)`
NASA Blue Marble: Next Generation	Imagery, global	NASA imagery, free of copyright restrictions; NASA asks for credit	`NASA Earth Observatory, Blue Marble: Next Generation (Reto Stöckli)`
Sentinel-2 cloudless 2016 by EOX	Imagery, global land, about 10 m	CC BY 4.0	`Sentinel-2 cloudless by EOX IT Services GmbH (Contains modified Copernicus Sentinel data 2016)`
NASADEM (alternative to GLO-30)	Elevation, 60 N to 56 S	Public domain	Not used by the repository's configurations

Points to watch:

Sentinel-2 cloudless: only the 2016 mosaic is CC BY 4.0. EOX's later yearly mosaics are CC BY-NC-SA, so they are not for commercial use without a license from EOX. vgl's configurations use the 2016 layer for this reason, including its known flaw (a flat near-black fill over some glaciers and snowfields).
Copernicus DEM is a surface model. This is about suitability, not licensing, but worth knowing: buildings and vegetation are part of the surface.
FABDEM, a bare-earth alternative, appears to have a non-commercial license and is not a default.
The samples' cloud image (samples/data/clouds.jpg) is NASA's Blue Marble cloud composite: "NASA Earth Observatory, Blue Marble: Clouds (Reto Stöckli)". It is not a pack, so the runtime does not report its credit; if you use it, credit it yourself.
Stars. vgl ships no star catalogue. The samples' --stars option reads a copy of the Yale Bright Star Catalogue that you download yourself; the repository does not hold it (Samples).

The sample data in samples/data is baked from these sources; its README lists the credits and how each source was obtained. If you redistribute it, keep the credits.

How the baker records attribution

A bake configuration has an optional metadata object of strings or lists of strings. Every entry becomes a key and value in the pack manifest's METADATA section (docs/pack-format.md, section 4.6, and Pack format overview). A list repeats the key, once per value. The baker adds a generator entry, such as vgl-bake 1.0.0, itself.

Key	Repeats	Meaning
`name`	No	Short name of the pack
`description`	No	Longer description
`attribution`	Yes	A credit line that the host must be able to display while the pack's data is visible, verbatim
`license`	Yes	The data's license terms, or a URL to them
`source`	Yes	A source dataset and its original vertical datum
`generator`	No	Tool and version that wrote the pack (written by the baker)
`created`	No	Creation time in ISO 8601 UTC; optional, since it makes otherwise identical bakes differ

Readers ignore unknown keys. Only attribution entries are reported at run time; the others are for people and tools.

A configuration for a pack stacked from two sources credits both:

{
    "output": "packs/europe",
    "layer": "elevation",
    "metadata": {
        "name": "Europe, GLO-30 over GEBCO",
        "attribution": [
            "Produced using Copernicus WorldDEM-30 © DLR e.V.",
            "GEBCO Compilation Group (2026) GEBCO 2026 Grid"
        ],
        "license": "https://example.org/data-licenses",
        "source": [
            "Copernicus DEM GLO-30 2021_1 (EGM2008)",
            "GEBCO 2026 Grid, ice surface elevation (mean sea level)"
        ]
    },
    "geoid": "packs/egm2008-geoid",
    "sources": [
        { "name": "GLO-30", "files": "sources/glo30/*.tif", "datum": "egm2008" },
        { "name": "GEBCO", "files": "sources/gebco-cog/*.tif", "datum": "egm2008", "fill_only": true }
    ]
}

Check what a pack carries with vgl-bake inspect <pack>, which prints the metadata entries. Write each credit line exactly as the source's terms ask for it: hosts display it verbatim.

How the runtime reports attribution

When a pack's manifest loads, the context copies its attribution lines. vgl_context_attribution_get then lists the credits of the data in view:

the lines of every ready pack whose tiles the current view selects or the last frame drew; for an imagery pack, whose imagery the selected tiles wanted in the last update or the last frame drew;
in pack priority order, each distinct line once, even when several packs carry it;
not the lines of an imagery pack at opacity 0 (vgl_pack_opacity_set), since its layer is hidden;
with the two-call pattern of the C API: call with null to count, then with an array.

The strings are UTF-8 and stay valid until the pack they come from is destroyed. The result is VGL_RESULT_INCOMPLETE when the array is too small; the first lines are still written.

In C:

/* Collects the credits for this frame into lines, up to 16. */
const char* lines[16];
uint32_t count = 16;
vgl_result r = vgl_context_attribution_get(context, &count, lines);
if (VGL_SUCCEEDED(r)) /* VGL_RESULT_INCOMPLETE still wrote count lines */
{
    for (uint32_t i = 0; i < count; ++i)
    {
        draw_credit_line(lines[i]); /* The host's own text rendering. */
    }
}

Or sized exactly:

uint32_t count = 0;
if (vgl_context_attribution_get(context, &count, NULL) == VGL_RESULT_SUCCESS && count > 0)
{
    const char** lines = malloc(count * sizeof(*lines));
    if (lines != NULL)
    {
        if (VGL_SUCCEEDED(vgl_context_attribution_get(context, &count, lines)))
        {
            for (uint32_t i = 0; i < count; ++i)
            {
                draw_credit_line(lines[i]);
            }
        }
        free(lines);
    }
}

In C++, vgl::context::attribution_get returns a std::vector<const char*>:

for (const char* line : ctx.attribution_get())
{
    draw_credit_line(line);
}

The samples show the credits in their panel's Credits section; vgl-gl prints the last ones on exit, and the headless sample prints them and checks that GEBCO and Blue Marble are credited.

Displaying credits in your application

attribution lines are lines "that the host must be able to display while the pack's data is visible". vgl gives you the right lines at the right time; showing them is up to your application. Recommendations:

Query every frame, or whenever the view changes. The set changes as you move: the Sentinel-2 credit appears only where its imagery is in view. The C call is cheap and allocates nothing.
Show them while the data is visible, in a place users can see without searching: a small text overlay in a corner of the globe view, as map applications do, or a credits control that expands to the full lines. Keep the text legible over imagery.
Show the lines verbatim. Do not shorten, translate or merge them, unless the source's terms allow it.
The geoid is credited with the terrain. A geoid pack has no tiles of its own to select, but it shapes every elevation tile, so vgl_context_attribution_get reports its lines whenever any terrain is in view.
Credit what vgl does not report. Data that is not in a pack, such as a cloud coverage image, stars from a catalogue, or your own overlays, needs credits of your own. Add them to the same display.
Also credit in documentation or an about box where a dataset's terms ask for acknowledgement in accompanying material as well.
Publish the attribution where you host packs. The hosting guide asks operators to publish the attribution each dataset's license requires, next to the packs.

Navigation Menu

Repository navigation

Attribution and Licensing

Attribution and licensing

vgl's license

Third-party code

What install and packaging ship

Data licenses and required attribution

How the baker records attribution

How the runtime reports attribution

Displaying credits in your application

See also

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Clone this wiki locally