Best Self-hosted Alternatives to Mapbox

Open Source Routing Machine (OSRM) is a high-performance routing engine written in C++ that computes routes on OpenStreetMap data. It provides a production-oriented HTTP API and can also be used as a C++ library or via Node.js bindings.

Key Features

• Fast route computation optimized for large road networks
• HTTP API services for routing, nearest-point lookup, and distance/duration matrices
• Map matching for snapping noisy GPS traces to the road network
• Trip optimization endpoint using a traveling-salesman-style heuristic
• Generates vector tiles containing internal routing metadata
• Customizable routing profiles (e.g., car, bicycle, walking)

Use Cases

• Powering turn-by-turn navigation and routing in web or mobile applications
• Batch travel-time or distance matrix generation for logistics and dispatch
• Cleaning and matching GPS tracks to roads for analytics or data processing

Limitations and Considerations

• Requires an offline preprocessing pipeline (e.g., MLD or CH) on OSM extracts before serving requests
• Custom behavior depends on maintaining Lua-based profiles and understanding OSM tagging

OSRM is a strong choice when you need low-latency routing on OpenStreetMap data with a well-established API surface. It is especially suited to backend routing services and GIS workflows that require fast, repeatable computations at scale.

GraphHopper is a fast, memory-efficient routing engine for road networks, primarily using OpenStreetMap data. It can be embedded as a Java library or run as a standalone server that exposes HTTP endpoints for routing and related geospatial calculations.

Key Features

• Multi-profile routing (e.g., car, bike, walking) with support for custom routing profiles
• Turn-by-turn instructions plus distance/time calculation and road attribute handling
• Isochrone generation for travel-time or travel-distance reachability analysis
• Map matching (“snap to road”) for aligning noisy GPS tracks to the road network
• Optional public transit support using GTFS data
• Designed for high performance on large datasets through preprocessing and efficient graph storage

Use Cases

• Self-hosted routing backend for web or mobile navigation applications
• Logistics, fleet, and field-service systems that need fast route and ETA computation
• Geospatial analytics such as service-area and accessibility analysis using isochrones

Limitations and Considerations

• Importing and preprocessing large OpenStreetMap extracts can require significant RAM, CPU, and disk
• Offline mobile usage is not officially supported in newer versions (though it may still work)

GraphHopper is well-suited for teams that want control over routing behavior and data sources while keeping performance high. It fits both embedded Java use and service-oriented deployments that need reliable, customizable routing at scale.

Nominatim is an open-source geocoding engine that searches OpenStreetMap (OSM) data by name and address and generates addresses from OSM objects (reverse geocoding). It provides both a REST API and a Python library surface for embedding search functionality and supports structured queries and configurable result ranking.

Key Features

• Forward geocoding (free-form and structured queries) and reverse geocoding for latitude/longitude pairs
• REST API and Python library for programmatic use, plus a web UI for manual lookups
• Import and update tooling for OSM data (osm2pgsql-based workflows and minutely/osc updates)
• Configurable tokenizers, ranking, and importance scoring (supports external data like TIGER/Wikidata for ranking)
• Scalable installs: from single-city setups to full-planet imports with tuned PostgreSQL/PostGIS databases
• Customization hooks for import styles, address handling, and API result formatting

Use Cases

• Powering a site or app search box to resolve user-entered addresses and place names
• Reverse-geocoding GPS traces to human-readable addresses for mapping or logging
• Bulk-geocoding address lists as part of data integrations or ETL pipelines

Limitations and Considerations

• Full-planet imports are resource-intensive (large RAM/disk requirements and long import times); adequate hardware and PostgreSQL tuning are required
• Relies on PostgreSQL/PostGIS and external import tools; version compatibility (PostgreSQL/PostGIS/osm2pgsql) should be verified before install
• Public instance enforces usage policy and rate limits; high-volume use requires a self-hosted instance or commercial provider

Nominatim is a mature, OSM-native geocoder used by the OpenStreetMap project itself. It is suitable for projects that need control over geocoding data, custom ranking, or on-premises operation, provided the deployer accounts for its operational requirements.

Kriti Images is a high-performance image transformation service built in Go, providing a URL-based API for real-time image processing. It is an open-source alternative to Cloudflare Images and ImageKit, designed for CDN-friendly delivery.

Key Features

• URL-based transformations via simple URL parameters for on-the-fly image manipulation
• Output formats JPEG, PNG and WebP with adjustable quality
• Resizing, cropping, rotating, blurring, and brightness/contrast/gamma adjustments
• Smart resizing modes: contain, cover, crop, pad, squeeze, and scaledown; supports background colors and rounded corners
• CDN-friendly caching and high performance due to a Go-based backend
• AWS S3 integration for storage and retrieval; ability to source images via URL
• Source images can be provided via URL (no local upload required)

Use Cases

• Build responsive images for multiple devices by transforming and serving on-the-fly
• Integrate with existing CDNs to optimize external images by URL rewriting
• Provide rapid image endpoints for apps without implementing their own image processing

Limitations and Considerations

• Upload Images feature is experimental and disabled by default; enabling requires configuration changes and may be moved or removed in future updates

Conclusion

Kriti Images provides a lightweight, self-hosted solution for real-time image transformation via URL requests, with Go-based performance, S3 support, and CDN-friendly delivery. It is designed to be integrated into existing web stacks as a backend image service.