Skip to content

About

A WIP map engine written in Rust using WGPU, with Kotlin Multiplatform and Linux KMS support

Topics

Resources

Stars

13 stars

Watchers

1 watching

Forks

Repository files navigation

Shashlik Map

A WIP map engine written in Rust using WGPU.

The initial goal of the project is to learn a new cross-platform tech stack to build a mobile and Linux KMS-ready map engine. The project focuses on rendering and navigation features, including dead reckoning and map matching.

I'm writing about the tech I've learned here

Showcases

Desktop & Mobile

Running on macOS and mobile (Android, iOS):

Screenshot 2026-10-24 at 09 41 24 613070241-59d29a03-5443-43f6-9dd1-7a451ee8ef89 Screenshot_20261024_093648

Linux (via KMS), Raspberry Pi 4

613070156-10d8f87c-6072-440c-a169-0647b0e88dad

CPU-Only Hardware

Running on CPU-only hardware using Slint as the host UI and Skia as the renderer (NXP i.MX93 chip used as a reference hardware):

Screenshot 2026-08-18 at 21 30 38

Tech stack

The stack leverages the following approaches and libraries:

  • Map vector graphics renderer written in Rust using WGPU as a low-level cross-platform graphics API and with RustyBuzz support as a vector font shaper for TextRenderer.
  • Uses custom tiles, a simple tiles generator and a tile server, separate repo. The server is running in free AWS EC2 Cloud.
  • Kotlin/Compose Multiplatfom, uniffi-rs and gobley projects enable fast and seamless integration with Android/iOS mobile apps(Android is priority for now)
  • Slint UI is used for native platforms (macOS and Linux)
  • Rust Valhalla client is used a routing clieng/engine

The component diagram:

ShashlikDiagram

Roadmap

Completed

  • Create a baseline POC with initial architecture
  • Complete README and examples
  • Initial rendering to texture
  • Better integration with SlintUI
  • A GPU-driven dotted line rendering
  • Initial SSAO(Screen Space Ambient Occlusion)
  • Running on pure Linux via KMS with Slint UI
  • Simple shadow mapping
  • Integration with WESL
  • Initial MVT tiles support
  • Initial renderer for CPU-only hardware
  • Globe view

Now

  • In progress General Renderer refactoring
  • In progress Integration with shashlik-tiles
  • In progress Explore Mesh Shader

Next

  • Integrate a simple search

Later

  • Implement an initial geometric Map-matching POC
  • Software Dead-reckoning
  • CI for KMP mobile SDK + Screenshot rendering
  • Move TextRenderer to the separate repo
  • Post-processing AA(SMAA)

Running examples

macOS

In root folder:

cargo run --package winit-run --release

Android

  • Make sure the latest Xcode is installed!
  • Open "kmp" folder in AndroidStudio and just Run "demo" app or execute:
./gradlew :composeApp:installRelease && adb shell am start -n "com.shashlik.demo/com.shashlik.demo.MainActivity"

iOS

Open "kmp/iosApp" project in XCode and just Run it

Linux via KMS

The current version has been tested on a Raspberry Pi 4 with Raspberry Pi OS Lite. It works via KMS and doesn't require a window subsystem.

Prerequisites for the Linux device:

  • Enable SSH
  • Install and configure Vulkan:

sudo apt install mesa-vulkan-drivers vulkan-tools libvulkan1

  • Install additional required libraries:

sudo apt install libfontconfig1 libgbm1 libinput10 libxkbcommon-x11-0

Prerequisites for the building machine:

  • Install cross-rs cargo install cross --git https://github.com/cross-rs/cross --branch main --force
  • Install Docker

Execute kms_deploy.sh script:

  • chmod +x kms_deploy.sh
  • TARGET_HOST=admin@raspberrypi.local ./kms_deploy.sh. Note: Replace with your actual device user and address.

Integration with KMP apps

Using an AI coding agent? Point it at llms.txt first — it indexes the version-stamped API reference, build facts and known limitations.

Add the dependency to your version catalog:

[versions]
shashlikMap = "0.3.29"

[libraries]
shashlikmap = { module = "io.github.shashlikmap:mapshared", version.ref = "shashlikMap" }

In build.gradle.kts:

implementation(libs.shashlikmap)

Requires mavenCentral(), Android minSdk 26, and an arm64-v8a device or emulator. iOS is also supported (iosArm64, iosSimulatorArm64).

Add the rustls repository (required from 0.3.21)

From 0.3.21 the SDK declares org.rustls:rustls-platform-verifier in its POM. Earlier versions carried the verifier as a JNI method inside libffi_run.so, with no Maven coordinate at all, so nothing extra was needed.

That artifact is not on Maven Central, Google, JitPack or Sonatype. rustls distributes the Android support library from a Maven archive in their own repository, which is the setup their README documents. Add it to your settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        mavenCentral()
        maven("https://github.com/rustls/rustls-platform-verifier/raw/maven-archive/android-release-support/maven/") {
            name = "RustlsAndroidSupport"
            // Scoped like the others: a GitHub-backed repo should never be
            // consulted for anything but the one group it exists to serve.
            content { includeGroup("org.rustls") }
        }
    }
}

Without it the build fails to resolve org.rustls:rustls-platform-verifier.

Do not pick a version by hand. The support library must stay SemVer-compatible with the Rust crate compiled into the .so, and a mismatch causes runtime crashes rather than resolution failures. Take whatever version the SDK's POM pins — 0.3.29 pins 0.2.0, read from the rustls-platform-verifier-android entry in Cargo.lock.

Then place the composable anywhere in your Compose UI:

@Composable
fun App() {
    MaterialTheme {
        ShashlikMap(
            state = rememberLocationState(latitude = 35.6879, longitude = 139.7570),
        )
    }
}

Full API reference: kmp/shared/README_API.md.

  • The SDK requests location permissions itself; you do not need to declare them.
  • It must be hosted in an Activity context.

Known issues

  • Tileset on the Web Service is generated only for Japan and USA(Bay Area)
  • Android app might not work on Android Emulator with hardware GPU acceleration. Try to change GPU mode to Software one.
  • Debug build performance is significantly lower than Release build.

About

A WIP map engine written in Rust using WGPU, with Kotlin Multiplatform and Linux KMS support

Topics

Resources

Stars

13 stars

Watchers

1 watching

Forks

Releases

Contributors

Languages