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

Running on macOS and mobile (Android, iOS):

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):

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

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

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

• [ ] Integrate a simple search

• [ ] 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)

In root folder:

cargo run --package winit-run --release

• 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"

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

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.

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

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.

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