# GeoLibre Android App vs. Web/Desktop Builds: Key Differences Explained

> Discover GeoLibre Android app differences vs web/desktop builds. Learn about feature limitations and the powerful Tauri v2 desktop build with Whitebox geoprocessing and PostgreSQL support.

- Repository: [Open Geospatial Solutions/GeoLibre](https://github.com/opengeos/GeoLibre)
- Tags: deep-dive
- Published: 2026-08-03

---

**GeoLibre's Android app shares the same React codebase as its web and desktop builds but hides features that require a local Python side-car, while the Tauri v2 desktop build includes full Whitebox geoprocessing, PostgreSQL support, and unrestricted file system access.**

The opengeos/GeoLibre project delivers a unified geospatial workspace across three platforms—web, desktop, and Android—using a single React source tree. According to the GeoLibre source code, Tauri v2's mobile tooling wraps the identical UI components for Android distribution, while the desktop build runs inside a native Tauri v2 shell configured in [`apps/geolibre-desktop/src-tauri/tauri.conf.json`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src-tauri/tauri.conf.json). This architecture maximizes code reuse but forces platform-specific compromises where Android's sandboxed environment cannot host the Python side-car required for advanced processing.

## Shared Core Features

All three builds run the same foundational capabilities without modification:

- **Map workspace** with layer management and styling
- **Vector tools** powered by Turf.js and in-browser GeoPandas via Pyodide
- **DuckDB-WASM SQL workspace** for analytical queries
- **Python console** (Pyodide-based, browser-compatible subset)
- **Geocoding, statistics, AI assistant, and story-maps**
- **Plugin architecture** for extensibility

These features operate entirely within the WebAssembly sandbox or browser APIs, making them portable across platforms.

## Platform-Specific Differences

The GeoLibre Android app diverges from web/desktop builds in seven critical areas enforced at build time and runtime.

### Full Whitebox Geoprocessing (Raster, Conversion, AI Segmentation)

**Desktop/Web:** Available via local Python side-car  
**Android:** Hidden—no side-car shipped

The WhiteboxTools integration providing 1,000+ raster analysis tools requires native Python bindings that cannot run in Android's restricted environment. The `isMobile()` guard prevents these menu items from rendering.

```tsx
// From the UI source: hide raster tools on Android
import { isMobile } from '@geolibre/ui/utils';

function ProcessingMenu() {
  return (
    <Menu>
      {!isMobile() && <MenuItem label="Raster Processing" />}
      <MenuItem label="Vector Processing" />
    </Menu>
  );
}

```

### PostgreSQL Data Sources with Local Martin Tile Server

**Desktop/Web:** Full PostgreSQL/PostGIS connectivity via local Martin server  
**Android:** Hidden—no local server capability

The "Add Data → PostgreSQL" option registers only when `isMobile()` returns false:

```ts
// Conditional registration pattern in data source initialization
if (!isMobile()) {
  registerDataSource(new PostgreSQLSource());
}

```

### Local File System Access

**Desktop/Web:** Full file path support for MBTiles, GeoTIFFs, and project files  
**Android:** Limited—scoped storage returns content URIs requiring conversion

Android 10+ scoped storage restrictions prevent direct filesystem path access. The app receives content URIs through the Storage Access Framework, which are not yet fully mapped to the workspace's file handling.

### Offline Area Downloads

**Desktop/Web:** Functional via service worker caching  
**Android:** Non-functional—Tauri native shells lack PWA service worker support

The offline download tool depends on Progressive Web App infrastructure that exists in browser builds but not in Tauri's native Android wrapper.

### Earth Engine Authentication Flow

**Desktop/Web:** Complete OAuth loopback and multi-window flow  
**Android:** Desktop-style flow only—deep-link redirect implementation is future work

Google Earth Engine integration currently assumes desktop authentication patterns. Mobile-optimized OAuth redirect handling remains on the roadmap per [`docs/android.md`](https://github.com/opengeos/GeoLibre/blob/main/docs/android.md).

### Application Identity and Data Isolation

| Property | Android | Desktop |
|----------|---------|---------|
| Bundle identifier | `org.geolibre.app` | `org.geolibre.desktop` |
| Configuration file | [`tauri.android.conf.json`](https://github.com/opengeos/GeoLibre/blob/main/tauri.android.conf.json) | [`tauri.conf.json`](https://github.com/opengeos/GeoLibre/blob/main/tauri.conf.json) |
| Data directory | Isolated Android storage | Standard OS application data |

These separate identifiers ensure settings and caches do not collide when both builds run on the same development machine.

### Build Artifacts and Distribution

**Android:** ~40 MB per ABI (ARM64, x86_64), distributed via Google Play or sideloaded APKs with Play signing gatekeeping updates.

**Desktop:** Similar base size but includes Python side-car binaries, inflating installer packages. Distributed as Tauri-generated installers or served at `http://localhost:5173` in development mode.

## Configuration Files Controlling Platform Differences

The same codebase produces divergent builds through Tauri's configuration layering:

- **[`apps/geolibre-desktop/src-tauri/tauri.conf.json`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src-tauri/tauri.conf.json)** — Global desktop configuration with `org.geolibre.desktop` identifier and side-car inclusion
- **[`apps/geolibre-desktop/src-tauri/tauri.android.conf.json`](https://github.com/opengeos/GeoLibre/blob/main/apps/geolibre-desktop/src-tauri/tauri.android.conf.json)** — Android overrides excluding the Python side-car and setting `org.geolibre.app`
- **[`docs/android.md`](https://github.com/opengeos/GeoLibre/blob/main/docs/android.md)** — Complete feature matrix, build instructions, and CI workflow documentation
- **[`package.json`](https://github.com/opengeos/GeoLibre/blob/main/package.json)** — Workspace scripts (`npm run tauri android build`, `npm run tauri:dev`)

## Summary

- GeoLibre Android is **not a separate codebase**—it reuses 100% of the React UI through Tauri v2 mobile tooling
- The **Python side-car absence** drives all major Android limitations: no Whitebox raster processing, no PostgreSQL, restricted file access
- Runtime environment detection via **`isMobile()`** gates feature visibility without code duplication
- **Scoped storage, missing service workers, and incomplete OAuth flows** create additional Android-specific constraints
- Separate **Tauri configuration files** enforce platform boundaries at build time

## Frequently Asked Questions

### Why can't Android run WhiteboxTools raster processing?

WhiteboxTools requires a native Python environment with compiled extensions that cannot execute in Android's sandboxed app architecture. The Tauri Android build excludes this side-car entirely, and the UI hides dependent features using the `isMobile()` helper to prevent runtime errors.

### Does GeoLibre Android support offline maps?

Partially. Vector tiles and cached data layers work offline, but the dedicated offline-area download tool is non-functional on Android. This tool relies on PWA service workers for background fetching, which Tauri's native Android shell does not implement.

### How does file import work on GeoLibre Android?

Android uses the Storage Access Framework to return content URIs instead of filesystem paths. GeoLibre accepts these URIs for display, but full project file persistence and direct raster analysis requiring path-based access remain limited compared to desktop builds.

### Can I switch between Android and desktop builds without losing data?

No—the apps use different identifiers (`org.geolibre.app` vs. `org.geolibre.desktop`) and isolated storage locations. Settings, projects, and cached data do not synchronize between platforms. Export GeoJSON or project archives manually for cross-platform workflow continuity.