- Beautiful, realistic renders
- Reasonably fast
- Works with huge worlds
- Works on servers (requires admins and a web server, but no Minecraft server plugins)
- Rendering scale: 1 pixel : 1 block
- An interactive GUI viewer made with JavaFX
- Pins on the map show points of interest like players, generated structures and villages
- Different color maps and shaders that highlight exactly what you are looking for (including an underground caves and an ocean ground view)
- A command line interface to render your worlds from scripts
- The core rendering code as library to use in your own projects
- Works with 1.18 worlds (with limited support down to 1.13)
- Minecraft 1.13+ worlds. Chunks from before the release (even from 1.13 snapshots) will be ignored. Please optimize your worlds in Minecraft before rendering them (or use other map viewer, like TMCMR).
- Java 17+
- While BlockMap should run on any Java, using the OpenJDK is recommended.
- If you won't hack on the code itself, the JRE should suffice (in the downloads section, choose JRE over JDK)
- Past experience has shown that Java updates are not as backwards-compatible as they could be. So while any newer Java version should work just fine, it has currently only been tested up to Java 17. If you encounter any problems that go away by downgrading Java, please open up an issue.
Download the latest version from the Release page.
Arch Linux users can install BlockMap directly from the AUR.
BlockMap hasn't been packaged for other distros yet (looking for maintainers).
The GUI version should just run by (double)clicking it. Otherwise run it through:
java -jar BlockMap-gui-2.4.1.jar
to start. If you installed BlockMap through a package manager, search for it in your launcher or menu.
- Mouse wheel to zoom in and out
- Drag with the left mouse button to pan the view
If you drag to the edge, the mouse will wrap around so you can drag indefinitely. Blender users will appreciate this- Currently broken, sorry
- When loading a world, you can select either a world folder, a region folder or a single region file
- You can only load remote worlds (from servers) if the server owner supports it.
If you want to use BlockMap through the command line without,
# For general usage help
java -jar BlockMap-cli-2.4.1.jar help
# For help about rendering worlds to a folder
java -jar BlockMap-cli-2.4.1.jar help render
will get you started. On Linux even with colors!
If your world has been created before the Minecraft 1.13 release, please optimize it. To do this, start Minecraft, select your world, go to "Edit" and then "Optimize World".
This feature is not stabilized yet. Backwards-incompatible changes may occur even on minor releases. Any feedback welcome.
The new server mode is based around the following concept:
- Declare a configuration file with all your worlds and how you want to render them. An example configuration can be found here.
- Call
blockmap render-manyand pass the configuration file as argument. - An output directory will be created with all the rendered files. You can view them in BlockMap.
- Host that folder using the web server of your choice (e.g.
miniserve). Clients will now be able to view your worlds across the Internet. - Call this on a scheduled basis (e.g. Systemd timer, or from a server plugin). Subsequent runs will update the folder without re-rendering everything.
- You can control which pins will be generated and included in the output and which not. Omitting any of these options will always default to true.
The "old" way of doing server support: a simple shell script that calls the CLI.
The bash script server.sh is an example of how this could be used in a server environment. Simply set the paths at the top of the file and call this script regularly on the server. It has a few different render settings pre-configured, but they are easy to adapt to your needs.
If you have trouble getting the library as dependency into your build system, please open up an issue. We generally recommend using JitPack.
The main action happens in the RegionRenderer class. It takes some RenderSettings (color map, height bounds, etc.) and renders whole RegionFiles at once. The result will be a Region object, which contains not only the pixel data but also extensive metadata about the structure of the world. The RegionFolder class helps you manage rendering whole worlds, especially with regards to keeping a rendered world up to date and other caching problems. Example usage:
MinecraftDimension dimension = MinecraftDimension.OVERWOLRD;
RenderSettings settings = new RenderSettings();
RegionRenderer renderer = new RegionRenderer(settings);
Path input; // <-- must point to a Minecraft world folder
Path inputRegion = input.resolve(dimension.getRegionPath());
Path output; // <-- must point to an empty folder
/* Actual rendering
*
* We could simply start loading `RegionFile`s per hand and feeding them into the `renderer`, but the `RegionFolder`s will help us
* with most of the dirty work. A `CachedRegionFolder` will be used to actually (and automatically) save the images on disk.
*/
WorldRegionFolder world = WorldRegionFolder.load(inputRegion, renderer, dimension == MinecraftDimension.NETHER);
CachedRegionFolder cached = CachedRegionFolder.create(world, false, output);
for (Vector2ic pos : world.listRegions()) {
cached.render(pos);
}For more detailed examples (including all the possible settings and a "merge everything into a huge PNG" mode), look at the CLI code (CommandLineMain.java).
Due to technical, legal and performance reasons, some resources required to run and test BlockMap are not included in this repository, but generated locally. The Gradle task regenerate will download all required files (you only need an internet connection the first time and after a clean) and generate and compile a bunch of stuff. Without this, nothing will work. On a freshly cloned repository, use initEclipse or initIdea to transform the repository into a project you can simply open in your favorite IDE. (Warning: The eclipse and idea tasks have to be called each time some dependencies changed. Furthermore, they link to some folders in the build directory. This means that they won't work as intended until regenerate has been called.)
All screenshots from above are generated automatically through the Gradle task generateScreenshots. This way, they are always up to date with the latest version. Be aware that this task needs to generate a fairly large Minecraft world first and then render it, which takes both time and space and will cause Gradle to slow down a lot.
To run from code:
./gradlew regenerate
# For the CLI
./gradlew :BlockMap-cli:run
# For the GUI
./gradlew :BlockMap-gui:runIf you want to create a release jar and run it, use ./gradlew :BlockMap-gui:runShadow and ./gradlew :BlockMap-cli:runShadow.
./gradlew regenerate
./gradlew generateScreenshots # Optional
./gradlew release- Bump the version in
build.gradle - Update
README.md- Bump the version information in file paths
- Bump the Minecraft version (if applicable)
- Check the feature list and read through it
- Update the
changelog.md - Regenerate all resources (see above)
- If something in the UI changed, regenerate the screenshots
- If some dependencies changed: Run
./gradlew licenseReportand copy the generated JSON file to./BlockMap-gui/src/main/resources/de/piegames/blockmap/gui/standalone/about/licenseReport.json
- Commit the changes as
Version bump: $VESRION. Add a tag with the version. Don't forget to push the tag as well! (git push --tags) - Generate the release binaries (need to be called on each target platform)
- This will create two executable fat (=containing all needed dependencies) jars in
./BlockMap-{gui,cli}/build/libs/fat/.
- This will create two executable fat (=containing all needed dependencies) jars in
- Release on GitHub
- Update all packaged versions (currently only AUR)
- Update to the currently latest minor version, according to the instructions below, before going on with the next major update.
- Update and start Minecraft. Create a new debug world. Copy it to
./BlockMap-internal/src/test/resources. Delete theplayerdata,statsandadvancementsfolders in it. - Copy the current block color instructions in
./BlockMap-internal/src/main/resources/to match the new Minecraft version. - Copy the current
ChunkRendererinde.piegames.blockmap.renderer(inBlockMap-core) to match the new Minecraft version. - Commit as
Minecraft $VERSION: Update preparation - Run
./gradlew checkMinecraftVersionsand updatede.piegames.blockmap.MinecraftVersionaccordingly. - Update the Minecraft version of
ChunkRenderer_$VERSIONin the constructor - Update
de.piegames.blockmap.renderer.RegionRendererto use the newChunkRenderer - Run
./gradlew regenerateand make it work - Run all the tests (
./gradlew test) and make them work- If Minecraft changed something on the save format, the
ChunkRendererwill fail - If Minecraft added new blocks, the color map needs to be updated. The failing tests will tell which blocks are missing. Additional information can be retrieved from the default resource pack.
- If Minecraft added or changed biomes, manual checking and updating is required
- If Minecraft changed something on the save format, the
- Generate a Minecraft vanilla world and test the GUI
- Implement any new features of the update (e.g. new data that can be shown as GUI pin)
- Don't forget
./BlockMap-internal/src/main/resources/biome-color-instructions.json
- Don't forget
- Regenerate the screenshots
- Optimize the BlockMapWorld in Minecraft
./gradlew clean && ./gradlew regenerate && ./gradlew generateScreenshots
- Update version references in
README.md(and elsewhere) - Release it 🎉
Currently, no Minecraft mods are supported, but the rendering engine is built in an extensible way. Mod support will only be implemented on request.
- Portalruinen Nether
- Map pins buggy
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent