NavCore SDK v1.0.11 - structured state, typed events, Expo-ready hooks.
NCSD500+
Trusted by 500+ developers5.0 developer rating

Build production-grade navigation without reinventing the engine

NavCore v2 is the navigation intelligence layer that plugs into any map renderer. Core gives you structured state, typed events, profile presets, route loading, Expo location updates, GPS smoothing, route snapping, and directions providers. Pro unlocks dead reckoning, parallel-road intelligence, offline ETA, voice triggers, and geofencing.

No spam ยท Unsubscribe any time ยท SDK docs

v1.0.11Current SDK
5Public Packages
4Directions Providers
0Runtime Dependencies
V2 showcase

Try the React web showcase

The current SDK ships two complete examples: an Expo showcase and a React web showcase. The browser example uses NavCore v2, MapLibre, OSRM, simulator input, ETA, voice, and geofencing.

examples / react-web-showcase / src / App.tsxTypeScript

V2 showcase with structured state, renderer adapters, simulator data, and Pro companions.

Open in StackBlitz

Prefer the reference path? Browse the v2 examples

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 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.

Core
๐Ÿ—๏ธ

Custom Route Builder

Create routes from coordinates, GPX, or GeoJSON, then chunk long waypoint sets for providers like Mapbox or OpenRouteService.

Core
๐Ÿงญ

Directions Providers

OSRM, Valhalla, and OpenRouteService ship from Core. Add @ingissa/navcore-mapbox when you need Mapbox Directions.

Core
๐Ÿ›ฃ๏ธ

Licensed Road Intelligence

Pro unlocks parallel-road resolution, compound deviation detection, advanced bearing, and dead reckoning.

Pro
โฑ๏ธ

Offline ETA & Voice

ETAEngine and VoiceTriggerEngine run locally from NavCoreState, with graceful fallback behavior when no Pro license is active.

Pro
๐Ÿ“

Geofencing Engine

Circle and polygon zones emit enter, exit, and dwell events without calling external geofencing APIs.

Pro
๐ŸŽฎ

Simulator & Headless Testing

Use the simulator for replay, noise, scenarios, and fleet runs. Use the headless adapter for Node.js assertions.

Tools
๐Ÿ”Œ

Adapter Ecosystem

MapLibre, Leaflet, Google Maps, React Native, and Headless adapters keep the engine independent from your renderer.

Adapters

โœจ Not a map renderer. The brain behind your map. Core stays usable without a key; Pro modules unlock through signed offline licensing.

Architecture: The Brain + The View

NavCore is not a map renderer. It is 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. Profile presets       Core   pedestrian, vehicle, high-speed tuning
 2. KalmanFilter2D        Core   GPS smoothing
 3. RouteSnapper          Core   route projection + bearing/inertia scoring
 4. DynamicCorridor       Core   speed/accuracy corridor sizing
 5. ProgressTracker       Core   anti-regression route progress
 6. RouteOffsetPredictor  Core   smooth offset between GPS pulses
 7. BearingEngine         Pro    speed-adaptive bearing smoothing
 8. DeviationDetector     Pro    compound off-route confirmation
 9. NavigationFSM         Engine lifecycle state
10. InstructionResolver   Engine next instruction window
11. DeadReckoning         Pro    prediction during GPS gaps

        |
        v
Structured NavCoreState
  position:   rawCoord, snappedCoord, bearing, speed
  navigation: routeIndex, distanceToDestination, nextInstructionIndex, hasArrived
  status:     lifecycleState, offRouteState, corridor, distanceToRoute
  meta:       gpsAgeMs, isGpsStale, licenseStatus

        |
        v
Your app
  MapLibre / Leaflet / Google Maps / React Native / Headless
  ETAEngine / VoiceTriggerEngine / GeofencingEngine consume NavCoreState

Renderer Adapters

MapLibre GLLeafletGoogle Maps JSHeadless CI

Directions Providers

OSRMValhallaOpenRouteServiceMapbox Directions

MapLibre GL Integration

Load a provider result, subscribe to structured state, and render through the adapter.

import { NavCore, OSRMDirectionsProvider } from '@ingissa/navcore-core'; import { MapLibreAdapter } from '@ingissa/navcore-maplibre'; const provider = new OSRMDirectionsProvider({ baseUrl: 'https://router.project-osrm.org', }); const result = await provider.getRoute(waypoints, { profile: 'driving', steps: true, }); const engine = new NavCore({ profile: 'vehicle', licenseKey: process.env.NAVCORE_LICENSE_KEY, }); const adapter = new MapLibreAdapter(map); engine.loadRoute(result); adapter.drawRoute(result.geometry); engine.startNavigation(); engine.subscribe((state) => { const coord = state.position.snappedCoord; if (!coord) return; adapter.updateVehicle(coord, state.position.bearing, state); adapter.panCamera(coord, state.position.bearing, { zoom: 15, pitch: 45 }); }); navigator.geolocation.watchPosition(({ coords }) => { engine.update({ coord: [coords.longitude, coords.latitude], accuracy: coords.accuracy, bearing: coords.heading, speed: coords.speed ?? 0, timestamp: Date.now(), }); });

React Native + Expo Location

The v2 hook owns engine subscriptions and maps Expo location objects into NavCore GPS updates.

import { useEffect } from 'react'; import { useNavSelector, useNavInstruction, useNavAlert, } from '@ingissa/navcore-react-native'; export function NavigationMap({ mapRef }) { const instruction = useNavInstruction(); const alertState = useNavAlert(); const coord = useNavSelector((s) => s.snappedCoord); const bearing = useNavSelector((s) => s.bearing); useEffect(() => { if (!coord) return; mapRef.current?.animateCamera({ center: { latitude: coord[1], longitude: coord[0] }, heading: bearing, }); }, [coord, bearing]); };
01

Key Insight

You provide a route and GPS stream. NavCore outputs typed events plus clean, real-time structured state. Your renderer stays replaceable, and your navigation logic stays testable with @ingissa/navcore-simulator and @ingissa/navcore-headless.

The @ingissa/* packages

One engine, Core and Pro subpaths, public types in Core, official adapters, and simulator tooling.

@ingissa/navcore-coreEngine
1.0.11

Navigation engine, Kalman filter, snapper, FSMs, route planning, dead reckoning, and built-in OSRM, Valhalla, and ORS providers with zero runtime dependencies.

$npm install @ingissa/navcore-core
@ingissa/navcore-typesTypes
1.0.11

Shared TypeScript interfaces, navigation types, directions contracts, and state interfaces across the NavCore ecosystem.

$npm install @ingissa/navcore-types
@ingissa/navcore-mapboxDirections
1.0.11

Mapbox Directions API adapter with automatic waypoint chunking, step parsing, and seamless RoutePlan integration.

$npm install @ingissa/navcore-mapbox
@ingissa/navcore-react-nativeMobile
1.0.11

React Native bindings with NavCoreProvider and granular, tearing-free selectors powered by useSyncExternalStore.

$npm install @ingissa/navcore-react-native
@ingissa/navcore-simulatorDev Tool
1.0.11

Headless GPS simulator for Node.js, React Native, and CI with Gaussian/urban noise models, scenario injection, and GPX replay.

$npm install @ingissa/navcore-simulator

Powerful features

Everything you need to build world-class navigation experiences with the v2 SDK surface.

8 features in Core Tier
01

Structured NavCoreState

State is grouped into position, navigation, status, and meta so renderer code reads exactly what it needs.

02

Typed Events

Subscribe to routeLoaded, navigationStarted, instruction, arrival, deviation, offRouteChanged, and stateUpdate.

03

State Subscriptions

engine.subscribe() streams every state change and powers React Native hooks without polling.

04

Profiles and Tuning

Pedestrian, vehicle, and high-speed presets can be refined with nested corridor, Kalman, arrival, and bearing options.

05

Route Loading

loadRoute() accepts provider results directly, while setRoute() remains available for custom geometry and instructions.

06

Expo Location Updates

updateFromExpoLocation() maps Expo location objects into the engine GPS update format.

07

Migration Helper

flattenState() returns the v1-style state shape while apps migrate to the v2 structured API.

08

Core Directions

OSRM, Valhalla, and OpenRouteService providers ship from @ingissa/navcore-core.

Simple, transparent pricing

Start with the Core tier, then unlock licensed Pro modules when your product needs them.

Core

For Core turn-by-turn navigation, evaluation, and development

$0/mo/app
Start Core
  • No license key required for development (isDev: true)
  • Deterministic 11-stage navigation pipeline
  • Kalman filter coordinate smoothing in degrees
  • Nearest-segment route snapping and monotonic progress tracking
  • Built-in OSRM, Valhalla, and OpenRouteService providers
  • CustomRouteBuilder for GPX and GeoJSON route generation
  • Zero runtime dependencies in @ingissa/navcore-core
  • Shared TypeScript definitions in @ingissa/navcore-types
15-DAY FREE TRIAL

NavCore SDK Pro

Production navigation intelligence with advanced algorithms

$49/mo/app
Start 15-Day Free Trial
  • 15-day free trial โ€” cancel anytime before day 16
  • Commercial production license key (ECDSA P-256 offline verification)
  • Graceful fallback to Core if key expires or in offline mode
  • DeadReckoningEngine for temporary GPS tunnel and signal loss
  • Compound deviation detection & parallel-road resolver with U-turn protection
  • VoiceTriggerEngine cue scheduling with early/late thresholds for TTS
  • ETAEngine with rolling average speed and stop detection
  • Circular and polygonal GeofencingEngine with dwell monitoring
  • Mapbox directions adapter with automatic waypoint chunking
  • Priority developer support

Need a custom enterprise volume? Contact us โ†’

Join 500+ developers already shipping with NavCore โ†’

Ready to ship better navigation?

Start with Core today. Add Pro when you need licensed navigation intelligence for production apps.

No credit card required ยท Start building in minutes