Install on Linux
MapCore ships for Linux as native packages in both formats:
| Format | Package | Architectures |
|---|---|---|
.rpm | mapcore7 | x86_64, aarch64 |
.deb | mapcore7 | amd64, arm64 |
A debug build is published in parallel as mapcore7-debug, from the same repositories. The Map
Layer Server is a separate package, maplayerserver — see
its install guide.
The reference platform is AlmaLinux 8.10. Other distributions of comparable vintage generally work, but that is the one the packages are built and tested against.
Install from the MapCore repository
Installing from MapCore's package repository means updates arrive with the rest of your system. Access needs credentials, which are issued per customer — if you do not have them, ask MapCore support rather than guessing.
There are two repositories, one per format:
| Format | Repository | Distributions | Architectures |
|---|---|---|---|
.deb | c4i-mapcore-debian-local | focal (20.04), jammy (22.04), noble (24.04) | amd64, arm64 |
.rpm | c4i-mapcore-rpm-local | one neutral path, no per-release variants | x86_64, aarch64 |
The same binary serves every distribution in that list — it is built against an older glibc and bundles its own dependencies — so the codename selects the right index, not a different build.
Neither repository is GPG-signed, so both configurations below switch signature checking off:
trusted=yes for apt, gpgcheck=0 for dnf. Without it, neither tool will use the repository at
all.
The cost is real. HTTPS still protects the connection and your credentials, but your package manager will no longer verify that what it installs is what MapCore published — and it installs it as root. Until the repositories are signed, that URL has to be infrastructure you trust. If it cannot be, use a downloaded package instead and check it against a checksum obtained separately.
Debian and Ubuntu
1. Store the credentials where apt looks for them — not in the repository URL, where a password is world-readable and ends up in logs:
sudo nano /etc/apt/auth.conf.d/mapcore.conf
machine mapcore.jfrog.io/artifactory/c4i-mapcore-debian-local
login <your-login>
password <your-password>
Naming the repository path, and not just the host, keeps apt from offering your credentials to any other path that happens to live on the same server.
2. Make the file readable only by root, which is what apt runs as:
sudo chmod 600 /etc/apt/auth.conf.d/mapcore.conf
3. Add the repository — the whole file, with no credentials in it:
sudo nano /etc/apt/sources.list.d/mapcore.list
deb [arch=amd64 trusted=yes] https://mapcore.jfrog.io/artifactory/c4i-mapcore-debian-local jammy main
Replace jammy with the codename matching your release, from the table above. arch=amd64 is
worth keeping even on a machine that only runs amd64: without it, a system with i386 enabled asks
for an index that is not published, and apt-get update fails on it.
4. Refresh and install:
sudo apt-get update
sudo apt-get install mapcore7
apt-cache policy mapcore7 afterwards confirms which repository the package came from and which
version you got. It is worth the one command, because a missing or misnamed credentials file fails
as "package not found" rather than as anything about authentication.
RHEL, AlmaLinux and Rocky
Create /etc/yum.repos.d/mapcore.repo. The credentials go in this file, so it needs the same
protection as apt's:
[mapcore]
name=MapCore
baseurl=https://mapcore.jfrog.io/artifactory/c4i-mapcore-rpm-local/main/$basearch/
username=<your-login>
password=<your-password>
enabled=1
gpgcheck=0
sudo chmod 600 /etc/yum.repos.d/mapcore.repo
sudo dnf install mapcore7
Leave $basearch as written — dnf expands it to x86_64 or aarch64, which is exactly how the
repository is laid out.
Right after a new version is published, an install can fail with a 404 or a checksum mismatch on a
package that plainly exists. The repository indexes are recalculated asynchronously, so for a short
window the index and the files disagree. sudo dnf clean all and retry — MapCore's own container
build retries for the same reason.
Pinning a version
Package versions use a tilde where the release name uses a hyphen: release 12.5.0-alpha11 is
package version 12.5.0~alpha11. That is deliberate — both dpkg and rpm sort ~ before the
plain version, so 12.5.0~alpha11 correctly ranks below 12.5.0, and a prerelease never looks
newer than the release it precedes.
sudo apt-get install mapcore7=12.5.0~alpha11 # Debian, Ubuntu
sudo dnf install mapcore7-12.5.0~alpha11 # RHEL, AlmaLinux, Rocky
Install from a downloaded package
MapCore 12.5.0. Downloads are credential-gated by Artifactory itself — the first one opens its sign-in page.
Downloads are not available on this network. Ask your administrator where to obtain MapCore releases.
Map Layer Server, AlmaLinux and RHEL
Map Layer Server, AlmaLinux and RHEL
Map Layer Server, Debian and Ubuntu
Map Layer Server, Debian and Ubuntu
Pull, do not download
docker pull mapcore.jfrog.io/c4i-mapcore-docker-release-local/mcmaplayerserver:12.5.0-alma8.10
If you have the package file itself, install it directly and let the package manager resolve the dependencies:
# RPM-based
sudo dnf install ./mapcore7-<version>.x86_64.rpm
# Debian-based
sudo apt install ./mapcore7_<version>_amd64.deb
Prerequisites
The dependencies resolve themselves either way. They are all graphics libraries; for reference, in case you are building a container image and want them in a layer of their own:
| RPM | Debian equivalent | Provides |
|---|---|---|
libglvnd | libglvnd0 | libGLdispatch.so.0 |
libglvnd-opengl | libopengl0 + libgl1 | libOpenGL.so.0, libGL.so.1 |
| — | libglx0 | GLX dispatcher |
libglvnd-gles | libgles2 | libGLESv2.so.2 |
mesa-libGLU | libglu1-mesa | libGLU.so.1 |
libXrandr | libxrandr2 | libXrandr.so.2 |
Debian splits into more packages than RPM does for the same libraries, which is why the two columns do not line up one to one.
libXrandr is easy to miss because nothing in MapCore's own API suggests it. It is linked by the
render-system libraries, and without it the failure is a startup error naming
libXrandr.so.2: cannot open shared object file rather than anything about a display.
What you get
The package installs into the standard locations:
/usr/include/mapcore7/ headers
/usr/lib/mapcore7/ shared libraries
/usr/bin/mapcore7/ executables and their working directory
/usr/share/mapcore7/ configuration, media and sample maps
/usr/src/mapcore7/ example sources
/usr/bin/LinuxTester wrapper that runs the test application
Installation also registers /usr/lib/mapcore7 with the dynamic linker — it writes
/etc/ld.so.conf.d/mapcore7.conf and runs ldconfig — so you do not need to set
LD_LIBRARY_PATH to link or run against it.
Verify
LinuxTester
That wrapper changes into /usr/bin/mapcore7 before running, because the tester expects to find
its configuration files in the working directory. It creates a device, a terrain from a sample
raster map under /usr/share/mapcore7/Maps, and a viewport — the same sequence your own code
will follow. If a map appears, MapCore and your GL drivers are both working.
If it fails, read MapCore.log in the working directory before anything else.
Set up a project
g++ myapp.cpp -I/usr/include/mapcore7 -L/usr/lib/mapcore7 -lMcSceneManager ...
Link the libraries you actually use from /usr/lib/mapcore7. Because the postinstall step
registered that directory with the linker, no -Wl,-rpath is needed.
At run time, MapCore reads plugins.cfg, resources.cfg and fxplugin.cfg from the directory
named by SInitParams::strConfigFilesDirectory, defaulting to the current working directory.
Point it at where those files live — the packaged copies are under /usr/share/mapcore7 — or your
device creation will fail on a machine where nothing about your code changed.
Choose ERS_OPEN_GL, ERS_OPEN_GL_3PLUS or ERS_OPEN_GLES as the rendering system; the Direct3D
options are Windows-only.
Headless and server use
For a server or batch tool that needs MapCore's data handling and geometry but no display, create
the device with ERS_NONE. It has no rendering system, so viewports and GPU-based queries are
unavailable, but everything else works and no GL driver or X display is required. See
Threading and lifecycle.
HTTPS
Map layers read from https:// servers with no setup. Other HTTPS requests verify the server's
certificate and need the system's CA bundle — automatic on Debian and Ubuntu, one environment
variable on RHEL, AlmaLinux and Rocky. See Read data over HTTPS.
Next steps
- Quickstart — device, viewport, layer, camera, in about thirty lines
- Architecture — what those objects are and how they relate