If you want a Free work-alike, why don't /you/ put in the work and make it happen?

(And so, so many little bugs in my map thing from upthread were these odd timing quirks when a user didn't have good service and one check would run and leave something else hanging resulting in a blank map. )

The main idea was to solve the gap of how many trail systems have colored loops, or signed/colored loops made up of multiple "trails", and Trailforks (et al) has no concept of that. So the situation a user finds themselves in is being at a trail, with Trailforks up, wanting to follow the "Orange" loop (for example), and Trailforks doesn't show that.

Hopefully the "Orange" loop is documented as a route, but this stuff often gets missed, and is still awkward since the image of the map still doesn't match the signs.

So my goal was to show the map close to what's physically there, use OSM data as much as possible, and filling in gaps for what OSM doesn't capture, rendering it all into a static map that also happens to work offline. For some specific examples, compare these two systems and their print, Trailforks, and trailmaps.app maps:

RAMBA: [1], [2], [3] Shelden Trails: [4], [5], [6]

There is the same kind of gap when compared to RideWithGPS, Strava, Gaia, etc.

And also, I'm a volunteer with our local trails non-profit. I want anyone and everyone to be able to find maps so they can enjoy the trails. A /lot/ of trail clubs are starting to replace maps with a link to Trailforks, which I believe does riders a disservice because it both requires an app and account and (if a user is trying to view a map out of their home area on a phone) payment. It's literally locking the basic info about a trail -- the map -- behind a semi-paywall. By making a system like this for our local trails I've helped completely avoid that mess. And so I made the map generator open as well so other techy folks can do the same or build on this.

This generated-static-map system does have the downside of being single-person-ish manually managed, and the maps do NOT update automatically. But I also see this as a feature, just like the print maps and in-person signage they are designed to complement.

I've prattled on a little more about the what-why-etc over here on my personal blog if you're interested: https://nuxx.net/blog/2026/06/25/trailmaps-app-map-generator...

--

[1]https://static.wixstatic.com/media/9d19d2_b85c5684f54a4fdc85...

[2] https://www.trailforks.com/region/ramba-trails/

[3] https://trailmaps.app/ramba/

[4] https://www.metroparks.com/wp-content/uploads/2022/04/2022-S...

[5] https://www.trailforks.com/region/stony-creek-metropark/

[6] https://trailmaps.app/shelden/

Each map is 16MB - 20MB in total, so this is all nice and simple to do. Even on a slow 3G connection it's only a minute or so for a full map update to stream in.

The whole point of this system was to take a snapshot of data (mostly OSM), add on some local things that can't really be represented in OSM (like WHICH parking lots are most appropriate, stylistic overrides, system descriptions, etc) and display them. Because of issues I've had in the past with well-meaning-but-misguided OSM mappers wrongly editing trail systems I did not want anything that pulls live.

And then by having purely static content the hosting is very cheap and easy, there's no security concerns around... well... anything dynamic on the site. And each map is portable were I to want someone else to host them. And literally in a couple of years if I haven't updated the map it won't change yet still will work, and that's fine and accepted for this use. Sort-of like a mobile version of a traditional print map. Kinda like the print workflow of editing/design/etc and then rendering the PDF, but web.

This all aligned nicely for me to have a tool that works this way, with each map generated by a tool.

(Sort-of disclaimer: It was also a big personal project in learning to work with AI stuff for development. I knew and understood the inputs and outputs, was able to design the UI, handled/managed all the testing... But I didn't have to worry about the actual-code part. I was able to make pretty quick progress and iterate nicely on my ideas.)

Happy to talk, etc, more about it too. Either here, or contact info is on the site.

Also, apparently Apple really doesn't like approving apps that are basically wrapped PWAs (Google will, I guess?) so that is yet another check against bothering with an app.

The idea of an app really appealed to me (at first), but the more I thought about it the more I didn't want to deal with iOS and then Android and then maintaining parallel functionality on the web and all that mess just for a fairly-local hobby project that I make no money off of.

So, I just kept it as a website (which is also a PWA) with extensive testing on every platform I can think of. It's just worked out so well and is so, so, so much less complicated. And if I abandon it, should just keep working for years so long as the website stays up (or until browsers start doing something very different JS-wise.)

(You can see it at https://trailmaps.app if you're interested.)

Not as nice as an office with a door, but really not bad. Especially the taller ones.

The idea came from using the Strava heatmap in JOSM to trace the proper location of mountain bike trails. I'm trying to use Strava less, and usually have ridden the trails enough myself before mapping them that I could use my own routes... So I figured why not have my own heatmap tile server?

It's also cool to just look at.

I could take it a lot further with time boxing what's displayed and whatnot, but generating the tiles is computationally expensive, so I just stuck with what I have for now. It meets the need.

This one generates maps from OpenStreetMap data + some custom curated info in YAML: https://github.com/c0nsumer/trailmaps.app-map-generator

This one converts a basic chunk of OpenStreetMap data to an SVG so I can mark it up (by hand) in Adobe Illustrator to make specifically-styled print/PDF maps, such as what get installed at trailheads: https://github.com/c0nsumer/osm_to_ai

This one takes GPS recorded rides and builds custom/personal heatmaps serving up the map tiles so I can use them in map editing software: https://github.com/c0nsumer/local-heatmap-tile-server

And all of this has been put together to make the custom, local, specific-use-case maps that are at https://trailmaps.app (which, via local curation, are overall better mobile/online maps than many of the bigger auto-generated systems such as Trailforks, Gaia, RideWithGPS, etc, for visualizing local systems).

It's neat stuff where I understand all the inputs, outputs, and how most of it works, but AI tooling (Claude, mostly) has allowed me to bolt it together much faster than I would have writing it myself.

Just something as simple as "that ceiling fan doesn't work so well, and squeaks once in a while when on high" can easily be remedied yourself when owning the house by just going buying and installing a new ceiling fan.

Regardless of how handy one is, with a landlord that's generally not allowed without permission, the landlord often won't install as nice of one as you might like, etc.

This goes for every fixture that's not part of the rental. Major appliances, flooring, even door knobs... Like if you suddenly want an electronic keypad on your deadbolt.

Of course, this flexibility has to be something you care about. Not everyone does, but for those of us that do...

There's no reason why it couldn't be used anywhere else. This just makes maps that fit within the bounding box of a relation. The only thing US specific about it is the elevation data, and I'm sure something else could be used to get that elsewhere. Or else it could just be turned off for a given map with show_terrain: false.

So, I put together a toolchain that generates maps from OpenStreetMap data, some other open data sources, plus some manually inputted things, and produces static HTML+CSS+JS maps of individual trail systems. The map does geolocation, allows you to turn on and off markers for things like parking, points-of-interest, toilets, water, trail direction, etc. I then host these on trailmaps.app. They are simple, static, and effective for showing where you in a way you can relate to the actual trail system.

What differentiates this from a lot of other map systems (MTB Project, Trailforks, Strava, Gaia, RideWithGPS, onX, Mapy.cz) is while these these all show these trails, they either color them with difficulty designations or don't color them at all. This isn't that.

In interest of a bunch of things ranging from privacy for users to simplicity for me, there's just no tracking, no logins, no cookies (just some local storage to preserve map settings), and all libraries used are hosted on trailmaps.app. Everything gets cached locally (it's typically 15-25MB/map), which means once loaded it works when there isn't cell service. And it can be installed as a PWA. For a few of the trails I've made maps for (eg: RAMBA) and some others that I intend to... There isn't cell service over the whole area, so offline use is almost a must. And people seem to like the app-like PWA shortcut. (And yes, it does check for and prompt the user to reload the page if the map gets updated.)

Another benefit to the static, self-contained nature of the maps is that clubs and non-profits who maintain the trails can very easily link to, embed, or just host the map themselves like they would a print map. There's no login or payment required, and if they want to generate their own, they can. (A example of why they might prefer this is visitors. For example, Trailforks: unpaid users of the app can only see trails near their house on mobile devices. So if someone is traveling, doesn't subscribe, and the only map is on Trailforks... they can't see the trails. This sidesteps that.)

And yes, this does mean these maps are all hand-curated. I see this as benefit, because it means that only things relevant to the trail are shown on the map. Like, there could be dozens of "parking" areas near by, but there might only be one or two that's good for accessing the trail system. Or, the curator might know to include this local rail trail, or that multi-use trail, but not this other.) Curated, just like how a good print map is.

Because the maps are static once they are on the site, it also means that errant (or rogue) OSM modifications don't cause problems with the map. Sure, it means trail changes require manual work to update the map, but trail changes don't happen all that often, and maps can be updated and deployed in sync with the print/trailhead maps. And sure, it doesn't scale, but I'm okay with that for now.

There's still a bit to do. I could really use a logo, I want to make more maps (we've got a lot of trail networks here in Southeast Michigan), probably some refiguring of the indexing once I reach a certain threshold of maps, documentation cleanup on the generator repo, support for a new trail difficulty designation system (ITRS), and the inevitable bug fixes. But, I'm pretty happy with where it is right now. It's usable, and it works.

Comments URL: https://news.ycombinator.com/item?id=48144262

Points: 1

# Comments: 2

So while the content is in RAM on the Pi, a lot of the heavier lifting (TLS termination) is done elsewhere, which saves a ton of CPU load on the Pi.

Comments URL: https://news.ycombinator.com/item?id=47817040

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47677268

Points: 2

# Comments: 0