Mantle Place — DCC host plugins
Open-source plugins that bring real-world terrain, imagery, buildings and site vectors into the
tools designers actually work in.
Licensed under Apache 2.0, except the prose in spec/, which is CC BY 4.0. The name is not covered — see TRADEMARK.md.
Draw the area and watch the price follow it. Every capture on this page is the live platform and the
released plugin, recorded in one unattended pass.
The whole pass, as one film (1:48, silent): Mantle Place for Unreal Engine: draw a site, own it
in UE.
What these plugins do
A Mantle Place Bundle (MPB) is a zip of pre-derived, host-ready geospatial artifacts — a
heightmap or terrain mesh, an imagery drape, building geometry, road centrelines, land use and land cover,
tree points — plus a Metadata/manifest.json that describes them. The plugins read that manifest
and place the artifacts correctly in the host's own coordinate system. The format is specified in
public, in spec/. Which host does what with each of them — and, where one does not, why —
is the host support matrix.
The client is deliberately thin. It applies numbers the platform already derived; it does not
re-derive them. The plugin never computes a survey point, a UTM zone, a landscape scale or a drape
extent of its own — it reads what the manifest publishes and applies it verbatim. That boundary is a
rule enforced at review, not an accident of the current design, and it is why this repository can be
open without anything important leaking out of it.
Importing a local bundle needs no account. No sign-in, no licence check, no server call. Point the
plugin at a bundle zip on disk and it imports. The vault browser — sign in, list your bundles,
prepare and download — is a convenience on top of that, not a gate under it.
The contract is published, not private
MPB is a specified format, and a release of it is three artifacts published together:
- The schema — a JSON Schema series served from
https://mantle.place/.well-known/schemas/bundle-manifest/, the authority on what a manifest may
contain. Two filename families: v{N}.json for the integer pre-history, and {X.Y.Z}.json for
the MPB semver era — a consumer tells them apart by the JSON type of the manifest's own version
field, a number meaning pre-history and a string meaning MPB.
- The prose —
spec/ in this repository: the format, the compatibility policy, the
consolidated changelog, and what conformance means. It describes; the schema decides. Nothing in
this repository restates a value the schema owns, and the version each host is verified against
lives in
tools/manifest-conformance/verified-against.json
where CI checks it.
- The conformance corpus — language-neutral test vectors
that every host runs against its own parser: accept and reject shapes, derived placement
expectations, RFC known answers for PKCE and base64url, NIST FIPS 180-4 digests, the vault
client's response vocabulary. A conforming reader passes it.
That means a second implementer is possible, and welcome. If you write a third-party consumer,
spec/ is the document and the corpus is the test you can run against it — neither
requires reading a line of our plugin code.
Install a built plugin
Releases carry a built plugin per
host, so trying one needs no compiler. Which host has a release, and which is the newest, is the
Releases page's to say; this README does not keep it.
Each host has its own release track, with its own version series and its own cadence — the hosts
share the manifest contract, not a version number, and their release gates have nothing in common
(Unreal's is a private licensed engine compile; Revit's is a human launching three Revit versions).
Tags name the track: unreal-0.4.0, revit-0.1.0. There is no v — the version in a tag is the
exact string the artifact itself declares. The reasoning, and why the first three tags are bare
v0.1.0–v0.3.0, is in ADR 0001.
| Host | Asset | Install |
|---|
| Unreal | MantlePlace-UE5.8-Win64-<version>.zip | Extract into a project's Plugins/ directory and open the project. No compilation step; Windows only. Then read unreal/README.md — in particular, the plugin saves nothing. |
| Revit | MantlePlace-Revit-<version>.zip | Copy the Contents folder's files into %APPDATA%\Autodesk\Revit\Addins\<year>\, for each of 2025/2026/2027 you use — or double-click Install.cmd. No admin rights, and no .NET install: Revit brings its own. Building from source is in revit/README.md. |
The Revit package leads with the manual copy rather than the script on purpose
(ADR 0005) — Windows blocks downloaded scripts by
default, and a folder copy works on every machine including the locked-down ones.
Each release body is that track's changelog and its provenance record: the source commit, the
artifact's sha256, and what was and was not verified. Building from source stays fully supported and
is what Building below covers.
Get a real bundle in minutes
Four MPB 2.0 sample bundles are published at mantle.place/mpb-samples,
one per delivery frame: UTM metres (Austin), State Plane US survey feet (Charlotte), a local site grid in
feet (St. Louis) and one outside the US (Zurich). Each comes with CheckPoints.json and CheckPoints.csv,
known coordinates to test a reader's placement against. They carry ODbL data (OpenStreetMap, Overture):
every ODbL file holds its notice and the licence link inside it, so keep them with any file you pass on.
The bundles are served from there; this repository still ships none, because a repository that carries a
bundle redistributes its data. To make one over your own ground, the free tier takes minutes, not a
purchase decision.
Small areas of interest are free: $0, full paid-tier quality, an account but no payment method.
The size limit is on the pricing page. That is the intended way to
evaluate these plugins: a real bundle over ground you know, produced by the same pipeline as a paid
order.
- Create an account at mantle.place and draw an area of interest within the
free size.
- Order a bundle for your host. The platform packages the artifacts and publishes a manifest.
- Either sign in from inside the plugin and use the vault browser, or download the zip and use the
local-import path:
- Unreal: Window ▸ Mantle Place, then Browse... to pick the zip and Import. The
plugin saves nothing — use File ▸ Save All (Ctrl+Shift+S) before closing the editor or
the import is lost. The rest is in
unreal/README.md.
- Revit:
Mantle Place ▸ Bundles ▸ Import Bundle, or set MANTLEPLACE_BUNDLE_ZIP and the
picker is skipped entirely, so the import runs unattended from a script.
The same order in UE 5.8 a few minutes later: one ALandscape with its imagery drape, the buildings
and splines on it, and the vault panel that pulled it in docked like any other tab.
What a downloaded bundle obliges you to do
A bundle is built from licensed geospatial sources, and some of those licences carry obligations —
most commonly an attribution requirement — that travel with the data into your project. Which
sources a given bundle used, which licences apply, and the exact attribution text they require are
stated by the platform, per bundle, not by this repository:
mantle.place/licensing describes the licences bundle data may
carry, and mantle.place/attributions is where the required
attribution statements live. Nothing here restates those values — the platform's pages are the
authority, and they are the ones kept current.
Stream to compare, import to keep
The Unreal plugin can show you the same bundle two ways in one viewport, and the pairing is the
clearest statement of what it is for.
The import path is the product: the bundle becomes engine-native assets you keep on your disk — a
single ALandscape with painted weight layers, the imagery drape, meshes, splines. It works offline,
needs no token, and survives the platform not being reachable, because after the download nothing is
streamed from anywhere.
Beside that, the plugin ships a streaming path built as a QA tool:
mantleplace_cesium_stream.py
starts a local loopback tile server that hosts the bundle's own Cesium-ready quantized-mesh
terrain and imagery, then spawns a Cesium3DTileset pointed at it — so
Cesium for Unreal (validated against 2.22.1)
streams your bundle next to the imported copy. Cesium for Unreal is a prerequisite for this path —
installed and enabled in the project — and the path is driven from the editor's Python console:
import mantleplace_cesium_stream as mp
mp.stream_into_cesium() # newest cached vault bundle (the one just imported)
A separate helper in the same script can add Cesium World Terrain alongside for an apples-to-apples
check; that one needs a Cesium ion account, the loopback stream does not. Nothing streams from the
Mantle Place platform; the server reads only the local zip you already keep.
The two paths do different jobs, and that is the point. Streaming answers look at it now; the
import answers keep it — offline, forever, no token. Cesium for Unreal is the natural companion
for the first job, and this plugin exists for the second.
One bundle, two delivery models, one viewport: the loopback tileset streams the bundle's own terrain
and imagery beside the imported Landscape.
Repository layout
The layout, directory by directory, is in CLAUDE.md, which keeps it current.
Start with each host's own docs: unreal/README.md for Unreal,
revit/README.md for Revit, and blender/README.md for the
Blender plugin, which reads a bundle on disk and does not sign in. Sign-in is shared by both hosts and documented once,
in docs/platform-auth-contract.md.
Building
Revit — no Revit install needed for the tests:
dotnet run --project revit/tests/MantlePlace.Revit.Core.Tests/MantlePlace.Revit.Core.Tests.csproj -f net8.0
dotnet run --project revit/tests/MantlePlace.Revit.Core.Tests/MantlePlace.Revit.Core.Tests.csproj -f net10.0
Building the plugin shim itself needs Revit 2025's API present — see
revit/README.md for why the oldest supported version is the
compile target.
Unreal — drop unreal/MantlePlace/ into a UE 5.8 project's Plugins/ directory and let the
editor build it. Its engine dependencies are Epic's built-in Interchange, PCG and SQLiteCore.
Blender — the plugin's core suite needs no Blender, and its end-to-end check runs Blender with
no window (blender/README.md):
python -m unittest discover -s blender/tests -t blender
The contract gate — Python 3.12, standard library only:
python -m unittest discover -s tools/manifest-conformance # offline
python tools/manifest-conformance/check_manifest_conformance.py --mode pinned # pull requests; no network
python tools/manifest-conformance/check_manifest_conformance.py --mode live # scheduled poll; compares with the published schema
The bundle validator and reader — pip install mantleplace-mpb, then mpb validate <zip or folder> or
read_bundle in Python, the same standard library only
(tools/mantleplace-mpb/).
CI, and what it does not cover
Every pull request runs the public CI gates, on free hosted runners. What each checks, and which are
required, is the CI guide; the process for a change is in
CONTRIBUTING.md and CLAUDE.md. The public gates are the objective merge bar.
The Unreal compile is not among the gates. It needs a licensed engine on Windows, and attaching a
self-hosted runner to a public repository would let a fork's pull request execute on the build
machine. So the engine build runs privately and at integration time. A pull request here can go green
and still break the Unreal compile; releases gate on that private build being green. This is a real,
accepted lag rather than a gap we would rather you not notice.
Roadmap
When each thing is planned is ROADMAP.md. What each host does today is the
host support matrix.
Contributing
Read CONTRIBUTING.md first — it is short, and it names the things that get a pull
request closed unread. In summary: DCO sign-off, no CLA, no binaries, no sample bundles, and auth and
the secret store are report, don't patch (SECURITY.md).
Maintenance is best-effort with a weekly triage batch and no SLA. That is stated here rather than
discovered later.
Security
Report vulnerabilities privately through this repository's
Security tab, or to [email protected]. Full policy:
SECURITY.md.
Why the history starts here
This repository's history begins at its first commit, on purpose. It is not a scrub, and nothing
was removed from a past that used to be here.
These plugins grew up inside a private monorepo that also vendors paid marketplace plugins — licensed
to us, and not ours to redistribute. Those files entered at that repository's root commit, which
is the fact that decides everything downstream: there is no edit at the tip that makes such a history
publishable, and a filtered import would rewrite every hash anyway. What it would produce is not
continuity but a costume — a commit graph you cannot check out, cannot build, and cannot bisect.
Given the choice between a fabricated lineage and an honest first commit, we took the first commit.
The timestamped record of independent creation stays in the private repositories, which is where it
does the job it exists for.
So there is no contributor graph here and no archaeology to read. The things that carry the weight
instead are the ones you can check yourself: public CI green on the merge bar, the conformance corpus
and the published schema it tests against, and documentation that states the gaps — the Unreal-compile
lag above is in this README because it is real, not because we ran out of places to hide it. The record
also reaches back further than this repository: the bundle-manifest schema series is published with an
append-only freeze ledger under https://mantle.place/.well-known/schemas/bundle-manifest/, so the
contract's iteration history is dated, externally served, and checkable without trusting a commit graph.
How this code is written
Much of this code is written with AI assistance under human review, and the commit trailers say so.
We neither lead with that nor hide it. The questions worth asking about a patch are the same either
way: does the conformance suite still pass, does the thin-client boundary hold, and does the comment
explain why rather than restate the line beneath it. Those are the questions this project's review
asks of its own changes, and the ones it will ask of yours.
Third-party notices
Autodesk, Revit, Epic Games, Unreal Engine and Cesium are marks of their respective owners.
