Build production-grade navigation
without reinventing the engine
NavCore is the navigation intelligence layer that plugs into any map renderer. Core gives you GPS smoothing, route snapping, progress tracking, route building, and directions providers. Pro unlocks dead reckoning, parallel-road intelligence, offline ETA, voice triggers, and geofencing.
Try NavCore in 30 seconds
No npm install, no config. Open in StackBlitz and see GPS smoothing live in the browser.
Full example with map rendering, waypoints & live GPS simulation →
Open in StackBlitzPrefer the full docs? Browse the NavCore SDK docs →
Reality Check
The problems we solve
Building real-time navigation from scratch is a nightmare. You're not alone — every team hits the same walls.
GPS Jitter
Raw GPS data jumps around. Your vehicle marker dances instead of smoothly following the road.
Parallel Road Traps
On dual carriageways and motorway slip roads, naive snapping picks the wrong lane. Your marker teleports across the median.
Route Snapping
Getting location to snap to the correct road is harder than it looks. Complex interchanges trap naive implementations.
Vehicle Lag
GPS updates come slowly. Users see their marker lag behind as they drive, breaking immersion.
GPS Loss
When GPS signal weakens or disappears, you have seconds to keep the experience smooth. Dead reckoning is complex to build.
Voice Timing
TTS announced too early or too late destroys user trust. Calculating the right trigger distance per speed is non-trivial.
Rerouting Logic
Detecting off-route, fetching a new route, managing re-entry — this shouldn't be your problem.
State Management
Navigation state is complex: progress, bearing, alerts, corridor detection, speed profiles — too much to handle alongside UI.
The Solution
The NavCore answer
Every problem above has a purpose-built answer inside the SDK.
Core Navigation Engine
The NavCore orchestrator handles GPS smoothing, route snapping, progress tracking, route offset prediction, lifecycle state, and distance-based deviation fallback.
Custom Route Builder
Create routes from coordinates, GPX, or GeoJSON, then chunk long waypoint sets for providers like Mapbox or OpenRouteService.
Directions Providers
OSRM, Valhalla, and OpenRouteService ship from Core. Add @ingissa/navcore-mapbox when you need Mapbox Directions.
Licensed Road Intelligence
Pro unlocks parallel-road resolution, U-turn protection, compound deviation detection, advanced bearing, and dead reckoning.
Offline ETA & Voice
ETAEngine and VoiceTriggerEngine run locally from NavCoreState, with graceful fallback behavior when no Pro license is active.
Geofencing Engine
Circle and polygon zones emit enter, exit, and dwell events without calling external geofencing APIs.
Simulator & Headless Testing
Use the simulator for replay, noise, scenarios, and fleet runs. Use the headless adapter for Node.js assertions.
Adapter Ecosystem
MapLibre, Leaflet, Google Maps, React Native, and Headless adapters keep the engine independent from your renderer.
✨ Not a map renderer. The brain behind your map. Core stays usable without a key; Pro modules unlock through signed offline licensing.
Under the Hood
Architecture: The Brain + The View
NavCore is not a map renderer. It's the navigation intelligence layer that sits between GPS and your UI.
GPS Device
raw lng/lat + accuracy + bearing + speed
|
v
NAVCORE ENGINE - engine.update(gps)
1. KalmanFilter2D Core GPS smoothing
2. RouteSnapper Core route projection + bearing/inertia scoring
3. DynamicCorridor Core speed/accuracy corridor sizing
4. ProgressTracker Core anti-regression route progress
5. RouteOffsetPredictor Core smooth offset between GPS pulses
6. BearingEngine Pro advanced bearing, raw-bearing fallback
7. DeviationDetector Pro compound deviation, distance fallback
8. NavigationFSM Engine route lifecycle
9. InstructionResolver Engine next instruction window
10. Arrival detection Engine destination/circuit handling
11. DeadReckoning Pro prediction anchor + tick() updates
|
v
NavCoreState
{ snappedCoord, bearing, routeIndex, distance, offRoute, licenseStatus }
|
v
Your renderer + optional Pro companions
MapLibre GL / Leaflet / Google Maps / React Native / Headless
ETAEngine / VoiceTriggerEngine / GeofencingEngine consume NavCoreStateRenderer Adapters
Directions Providers
MapLibre GL Integration
Feed GPS into the engine, receive clean state, render on any map library.
import { NavCore } from '@ingissa/navcore-core';
import { MapLibreAdapter } from '@ingissa/navcore-maplibre';
const engine = new NavCore({
licenseKey: process.env.NAVCORE_LICENSE_KEY
});
const adapter = new MapLibreAdapter(map);
engine.setRoute(route.geometry, instructions);
engine.startNavigation();
adapter.drawRoute(route.geometry);
// Push raw GPS - engine outputs clean NavCoreState.
navigator.geolocation.watchPosition(({ coords }) => {
const state = engine.update({
coord: [coords.longitude, coords.latitude],
accuracy: coords.accuracy,
bearing: coords.heading,
speed: coords.speed ?? 0,
timestamp: Date.now()
});
if (!state.snappedCoord) return;
adapter.updateVehicle(state.snappedCoord, state.bearing, state);
adapter.panCamera(state.snappedCoord, state.bearing, { zoom: 15, pitch: 45 });
});React Native Maps
Same engine, different renderer. Swap adapters without touching engine logic.
import { useNavCore } from '@ingissa/navcore-react-native';
const nav = useNavCore({
gpsCoord,
gpsBearing,
gpsAccuracy,
gpsTimestamp,
speed,
routeGeometry,
instructions,
isNavigating,
options: {
licenseKey: process.env.EXPO_PUBLIC_NAVCORE_LICENSE_KEY
},
onDeviation: ({ anchorIndex }) => requestNewRoute(anchorIndex),
onArrival: () => showArrivalScreen()
});
useEffect(() => {
if (!nav.snappedCoord) return;
mapRef.current?.animateCamera({
center: {
latitude: nav.snappedCoord[1],
longitude: nav.snappedCoord[0]
},
heading: nav.bearing,
});
}, [nav.snappedCoord, nav.bearing]);Key Insight
You provide the route and GPS stream. NavCore outputs clean, real-time navigation state. You render it. This separation of concerns makes your code simpler, faster, and straightforward to test with @ingissa/navcore-simulator and @ingissa/navcore-headless.
Ecosystem
The @ingissa/* packages
One engine, Core and Pro subpaths, official adapters, simulator tooling, and shared types.
@ingissa/navcore-coreEngineThe full NavCore orchestrator, Core subpath, Pro subpath, directions providers, and license manager.
npm install @ingissa/navcore-core@ingissa/navcore-mapboxDirectionsMapbox Directions provider for token-based routing and waypoint chunking workflows.
npm install @ingissa/navcore-mapbox@ingissa/navcore-react-nativeMobileReact Native bindings with the useNavCore hook and NavCoreProvider lifecycle helpers.
npm install @ingissa/navcore-react-native@ingissa/navcore-simulatorDev ToolGPS route simulator with replay, noise, scenarios, fleet simulation, and dev/CI entrypoints.
npm install @ingissa/navcore-simulator@ingissa/navcore-maplibreRenderer adapter for MapLibre GL JS. Handles vehicle marker, route layer, and camera panning.
npm install @ingissa/navcore-maplibre@ingissa/navcore-leafletRenderer adapter for Leaflet.js with route drawing, marker updates, and camera following.
npm install @ingissa/navcore-leaflet@ingissa/navcore-google-mapsRenderer adapter for the Google Maps JavaScript API with marker and polyline support.
npm install @ingissa/navcore-google-maps@ingissa/navcore-headlessTestingHeadless renderer for Node.js and CI assertions without a browser or visual map.
npm install @ingissa/navcore-headless@ingissa/navcore-typesTypesShared TypeScript type definitions for SDK ecosystem integrations.
npm install @ingissa/navcore-typesCapabilities
Powerful features
Everything you need to build world-class navigation experiences — batteries included.
KalmanFilter2D
Configurable GPS smoothing for stable route snapping without adding runtime dependencies.
RouteSnapper
Nearest-route projection with bearing and inertia scoring for practical map matching.
Progress Tracking
Anti-regression route progress keeps the active segment moving forward, including circuit routes.
Route Offset Predictor
Frame-rate route offset prediction keeps markers smooth between slower GPS updates.
CustomRouteBuilder
Build routes from coordinates, GPX, or GeoJSON, then chunk waypoint-heavy requests cleanly.
Core Directions
OSRM, Valhalla, and OpenRouteService providers ship from the Core package.
Renderer Interface
MapRendererAdapter types make map integrations swappable without coupling UI to the engine.
Offline Licensing
LicenseManager verifies signed keys locally and exposes granular feature status.
Pricing
Simple, transparent pricing
Start with the Core tier, then unlock licensed Pro modules when your product needs them.
Core
For Core navigation, evaluation, and development
- No license key required
- Kalman GPS smoothing and route snapping
- Progress tracking and route offset prediction
- OSRM, Valhalla, and OpenRouteService providers
- CustomRouteBuilder and core TypeScript APIs
NavCore SDK Pro
Production navigation intelligence
- 15-day free trial — no card charged until day 16
- Graceful fallback to Core if license expires
- Commercial production license
- Dead reckoning and advanced bearing
- Compound deviation and parallel-road resolver
- Offline ETA, voice triggers, and geofencing
- InstructionEditor and official adapter ecosystem
- Priority email support
Need a custom enterprise volume? Contact us →
Ready to ship better navigation?
Start free today. No infrastructure, no GPS APIs to glue together, no navigation PhD required.
No credit card required · Start building in minutes