Skip to content
BranchesTags

Repository files navigation

OpenMapTiles Build Status

OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.

We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.

Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.

Styles

You can start from several GL styles supporting the OpenMapTiles vector schema.

🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.

We also ported over our favorite old raster styles (TM2).

🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.

Schema

OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt. Together the layers make up the OpenMapTiles tileset.

🔗 Study the vector tile schema

Develop

To work on OpenMapTiles you need Docker.

Build

Build the tileset.

git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make

You can execute the following manual steps (for better understanding) or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.

./quickstart.sh <area>

Prepare the Database

Now start up the database container.

make start-db

Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.

make import-data

Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).

make download area=albania

Import OpenStreetMap data with the mapping rules from build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.

make import-osm
make import-borders

Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.

This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.

make import-wikidata

Work on Layers

Each time you modify layer SQL code run make and make import-sql.

make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.

make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License

All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.

Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.

For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the credit should appear in the corner of the map. For example:

© OpenMapTiles© OpenStreetMap contributors

For printed and static maps a similar attribution should be made in a textual description near the image, in the same fashion as if you cite a photograph.

About

OpenMapTiles Vector Tile Schema Implementation

openmaptiles.org/schema/

Resources

Readme
License

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - vmarc/openmaptiles: OpenMapTiles Vector Tile Schema Implementation · GitHub
Skip to content
BranchesTags
Repository files navigation
OpenMapTiles Build Status
OpenMapTiles is an extensible and open tile schema based on the OpenStreetMap. This project is used to generate vector tiles for online zoomable maps. OpenMapTiles is about creating a beautiful basemaps with general layers containing topographic information. More information openmaptiles.org and maptiler.com/data/.
We encourage you to collaborate, reuse and adapt existing layers, or add your own layers. You may use our approach for your own vector tile project. Feel free to fork the repo and experiment. The repository is built on top of the openmaptiles/openmaptiles-tools to simplify vector tile creation.
Please keep in mind that OpenMapTiles schema should display general topographic content. If creating a new layer or expanding an existing layer with a specific theme, please create a fork and invite other community members to cooperate on your topic. OpenMapTiles schema is used in many projects all over the world and the size of the final vector tiles needs to be considered in any update.
Styles
You can start from several GL styles supporting the OpenMapTiles vector schema.
🔗 Learn how to create Mapbox GL styles with Maputnik and OpenMapTiles.
We also ported over our favorite old raster styles (TM2).
🔗 Learn how to create TM2 styles with Mapbox Studio Classic and OpenMapTiles.
Schema
OpenMapTiles consists out of a collection of documented and self contained layers you can modify and adapt.
Together the layers make up the OpenMapTiles tileset.
🔗 Study the vector tile schema
Develop
To work on OpenMapTiles you need Docker.
Build
Build the tileset.
git clone https://github.com/openmaptiles/openmaptiles.git
cd openmaptiles
# Build the imposm mapping, the tm2source project and collect all SQL scripts
make
You can execute the following manual steps (for better understanding)
or use the provided quickstart.sh script to automatically download and import given area. If area is not given, albania will be imported.
./quickstart.sh <area>

Prepare the Database
Now start up the database container.
make start-db
Import external data from OpenStreetMapData, Natural Earth and OpenStreetMap Lake Labels.
make import-data
Download OpenStreetMap data extracts from any source like Geofabrik, and store the PBF file in the ./data directory. To use a specific download source, use download-geofabrik, download-bbbike, or download-osmfr, or use download to make it auto-pick the area. You can use area=planet for the entire OSM dataset (very large). Note that if you have more than one data/*.osm.pbf file, every make command will always require area=... parameter (or you can just export area=... first).
make download area=albania
Import OpenStreetMap data with the mapping rules from
build/mapping.yaml (which has been created by make). Run after any change in layers definition. Also create borders table using extra processing with osmborder tool.
make import-osm
make import-borders
Import labels from Wikidata. If an OSM feature has Key:wikidata, OpenMapTiles check corresponding item in Wikidata and use its labels for languages listed in openmaptiles.yaml. So the generated vector tiles includes multi-languages in name field.
This step uses Wikidata Query Service to download just the Wikidata IDs that already exist in the database.
make import-wikidata
Work on Layers
Each time you modify layer SQL code run make and make import-sql.
make clean
make
make import-sql

Now you are ready to generate the vector tiles. By default, ./.env specifies the entire planet BBOX for zooms 0-7, but running generate-bbox-file will analyze the data file and set the BBOX param to limit tile generation.
make generate-bbox-file # compute data bbox -- not needed for the whole planet
make generate-tiles # generate tiles

License
All code in this repository is under the BSD license and the cartography decisions encoded in the schema and SQL are licensed under CC-BY.
Products or services using maps derived from OpenMapTiles schema need to visibly credit "OpenMapTiles.org" or reference "OpenMapTiles" with a link to https://openmaptiles.org/. Exceptions to attribution requirement can be granted on request.
For a browsable electronic map based on OpenMapTiles and OpenStreetMap data, the
credit should appear in the corner of the map. For example:
© OpenMapTiles© OpenStreetMap contributors
For printed and static maps a similar attribution should be made in a textual
description near the image, in the same fashion as if you cite a photograph.
About
OpenMapTiles Vector Tile Schema Implementation
openmaptiles.org/schema/
Resources
Readme
License
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages