Building Modular Hex Maps with Obsidian

To my mind, the traditional hex map is bogged down by (at least) three problems: illegibility, inaccessibility, and information insufficiency. Call these the Three Big Interesting Problems if you’d like.

Illegibility: where am I? What’s around me?

Because hex maps give equally granular detail about every 6-or-whatever-mile slice of your world, it can be difficult to keep track of what’s important at any given moment. Consider, for example, any of those to-scale, real-world, x-mile-hex maps of [insert country here]. They can be very pretty (especially with some of the more aesthetically inclined software packages)—but how useful are they, really, at the table? Do I really want to zoom in to one 20x20 region of my 4k resolution 300x600 map of southwest England? Especially for larger maps, the usual coordinate coding method (00,00) might become pretty unwieldy, since you either have to clutter your pretty map with thousands of these codes, or put them all along the edges—where they’ll be effectively invisible when you’ve zoomed in to the appropriate 20x20 region of the map that is actually relevant to play.

Inaccessibility: how do I even make this thing? how do I add to it?

Making hex maps can be a little bit annoying. Editing or expanding them can be even moreso. If you’re working digitally, there are free software options (I’ll be recommending one shortly), but in my experience they don’t make it easy to add more rows of hexes, or to copy small areas into a new map, or anything like that. This effectively means that you’ll spend a lot of time making maps (which are too-damn-big anyways) and then discarding them for a newer, equally inadequate successor made more or less entirely from scratch.

Information Insufficiency: what was here again?

Finally, hex maps in and of themselves rarely bundle information about the hexes in with the presentation of the hexes themselves. If I want to check whether there are any dungeons at hex (01,05), for example, I’m probably zooming out to get the index, and then cross-referencing a separate document. Or flipping pages in a binder, or leafing through an unbound stack of notes.

---

Now, it may very well be that the perfect all-inclusive software package exists somewhere out there just waiting to solve the Three Big Interesting Problems. But I was lazy, and loathe to part with twenty or so dollars, so I’ve cooked up my own (fully open-source!) solution.

To begin with: what we want from a hex map is locality and modularity. I.e., we want our attention to be on what’s right in front of us, and we want this local representation to fit together with other local representations to create a single macro-scale composite—like puzzle pieces, or tiles in a mosaic. In an old blog post, The Welsh Piper gives a pretty good example of how we might accomplish this: by breaking the map into hexagonal sub-regions, or what I’ll call modules. Note that some hexes will be shared between modules; I’ve indicated them below in color. When it comes to making neighboring modules, all we have to do is ensure that the two “joint” hexes are consistent; so, for example, if 0303 on the bottom hex is a mountain, 0308 on the top hex should also be a mountain. The Welsh Piper post linked above also gives a nice visual representation, so feel free to check that out as well.

So that’s the general idea. I’m implementing this in Obsidian with the text mapper plugin. Obsidian has a few nice features for our purposes here: for one, it allows us to save our local maps in a file alongside the relevant information about the region; it also allows for hyperlinks between files, which provides all sorts of utility; and—most importantly—the canvas feature allows us to arrange all of our local map files spatially with respect to one another. Furthermore, since canvas shows actual instances of the maps themselves, the composite map will update automatically alongside the local hex map files. This allows us to easily update and expand our maps, but also to sketch out high-level details about far-off regions in a way which is perfectly consistent with our pre-existing mapping procedure. I.e., there’s no need to mess with scale, or try to figure out how exactly this sketch fits together with this 20x20 square hexmap fits together with…—since you just plop the point of interest down in whatever module strikes you as most appropriate. The end result might look something like this:

Did I mention that it’s entirely free?

Implementation, more exhaustively

Great, I hear you saying. But how do I actually go about doing this?

First, obviously, you’re going to need to download Obsidian. The text mapper plugin is, to my knowledge, not available within Obsidian’s native plugin installer, so you’ll have to go through the github link I provided above, which helpfully provides instructions regarding manual installation.

When it comes to actually making our maps, the text mapper plugin converts text-based information into a visual representation. The github, again, provides more thorough documentation, but for our purposes, we’ll want to start by creating a new file in our obsidian vault. Name it whatever you want. Then, paste in the following template:

```text-mapper
0105 zone
0106 zone

0203 zone
0204 zone 
0205 zone 
0206 zone 
0207 zone

0303 zone
0304 zone
0305 zone 
0306 zone 
0307 zone
0308 zone

0403 zone
0404 zone 
0405 zone 
0406 zone
0407 zone 

0503 zone
0504 zone
0505 zone
0506 zone
0507 zone
0508 zone

0603 zone
0604 zone
0605 zone
0606 zone 
0607 zone

0705 zone
0706 zone
```

Which will generate the following (approximately-macro-hexagonal) map:

The contents of individual hexes can then be edited simply by replacing the word “none” in the markdown text with the appropriate information. Here’s a side-by-side comparison of one of my own modules in map- and text- form:

In order to include further information about a region or hex (say, a random encounter table, or some information about a dungeon in a hex) we can just write it down in the same file as our map, ensuring that the text is below the map for the purposes of our canvas composite.

Speaking of the composite: all we have to do here is 1) make an Obsidian canvas (on the leftmost column; see pic related) and 2) drag the file names of our map files into the canvas. Arrange as you please.

And there we have it! You’re ready to start making modular, local hexmaps to your hearts content.

Afterword, or, Pro and Contra

I’ll be the first to admit that this is neither the most intuitive nor most visually appealing solution for your hex mapping needs; if you try it out, you’ll find that it takes you a minute to get hold of the relationship between the text data and the map output. The template I’ve provided above is meant to make things as intuitive as possible, but still, it might take a minte.¹ Useful or no, this was a fun little afternoon project, and it does seem to me to outperform traditional hex maps when it comes to the Three Big Interesting Problems that we started with. Maybe you’ll agree; maybe not. In any case: until next time!

1. As a word to the wise, note that the top- and bottom-most rows of every column (save for column 4!) will be shared with a neighboring hex. So if you’re looking for the map edges that need to be kept consistent, focus on the “edges” of the blocks of text.