Processing Tools¶

The Processing menu collects GeoLibre's analysis and conversion tools. It holds two separate toolboxes (why), plus the SQL Workspace, Python Console, AI Assistant, and AI Segmentation, which have their own pages.

Two toolboxes in one menu¶

This is the single most common source of confusion in the Processing menu, so it is worth reading before anything else.

The menu is laid out like this:

Processing
├─ AI Assistant
├─────────────────────────
├─ Whitebox Toolbox        ← opens the toolbox dialog
├─ Conversion       ▸  ┐
├─ Hydrology        ▸  │
├─ LiDAR            ▸  │
├─ Network          ▸  │
├─ Projection       ▸  ├  the same toolbox, browsable
├─ Raster           ▸  │  by category (1,000+ tools)
├─ Remote Sensing   ▸  │
├─ Terrain          ▸  │
├─ Vector           ▸  ┘
├─────────────────────────
├─ GeoLibre Toolbox ▸      ← GeoLibre's own built-in tools
│   ├─ Conversion         ▸
│   ├─ Vector             ▸
│   ├─ Network            ▸
│   ├─ Spatial Statistics ▸
│   ├─ Raster             ▸
│   ├─ DGGS               ▸
│   ├──────────────────────
│   ├─ Geocode Addresses
│   ├─ Batch tools
│   ├─ AI Segmentation
│   ├─ Object Detection
│   └─ Segment Everything
├─────────────────────────
├─ Model Builder
├─ SQL Workspace
├─ Python Console
├─ Jupyter Notebook
├─ Dashboard
├─ History
├─ Planetary Computer
└─ Earth Engine

The block between the first and second separators belongs to the Whitebox Toolbox; everything under GeoLibre Toolbox is GeoLibre's own. Because both toolboxes cover vector, raster, conversion, and network work, several category names appear twice. They are not duplicates, and they do not open the same thing:

The two paths that look alike¶

The pair that trips people up most often:

• Processing → Vector → GeoLibre (WASM) lists the several hundred vector tools GeoLibre contributes to the Whitebox toolbox. They are compiled from geolibre-rust to WebAssembly and sit in the same catalog as the Whitebox Next Gen tools, so the menu groups them under a GeoLibre (WASM) subheading to show where they came from. The same subheading appears under Conversion, Raster, Hydrology, and LiDAR. Every one of these opens the Whitebox Toolbox dialog.
• Processing → GeoLibre Toolbox → Vector opens GeoLibre's own Vector tools dialog: buffer, clip, spatial join, and the rest of the list below, with an engine picker (Turf.js, GeoPandas sidecar, or Pyodide).

So the first is "the vector part of the Whitebox toolbox, filtered to the tools GeoLibre wrote", and the second is "GeoLibre's own vector toolbox". Both exist because they are different implementations with different strengths, not because one is a copy of the other.

A few individual tool names collide the same way. Processing → Conversion → GeoLibre (WASM) → Vector to PMTiles is a WASM catalog tool that opens the Whitebox Toolbox dialog; Processing → GeoLibre Toolbox → Conversion → Vector to PMTiles is the Conversion dialog documented below, with its own file pickers and zoom, compression, and layer-name options. Raster to PMTiles appears in both places too. When a step in these docs or a tutorial names a Conversion tool, it means the GeoLibre Toolbox one.

GeoLibre Toolbox¶

GeoLibre's own tools, under Processing → GeoLibre Toolbox.

Vector¶

Processing → GeoLibre Toolbox → Vector opens the Vector tools dialog. Pick a tool from the list, choose the input layer and parameters, select an engine, then Run. Output appears as a new layer.

Geometry

Overlay

Join

Select

Movement & time

Data management

Data quality

Engines¶

Every vector tool can run on one of three engines, selectable in the dialog:

• Client (Turf.js): runs entirely in the browser. No setup, works offline, and operates on the layer's GeoJSON.
• Sidecar (GeoPandas): runs on the optional Python sidecar for projection-aware results, backed by GeoPandas and Shapely. The dialog falls back to the client engine when the sidecar's optional vector extra is not installed.
• Python (Pyodide): runs the same GeoPandas/Shapely code as the sidecar, but entirely in your browser via Pyodide — no server, so it works on the web build and the public demo too. The first run downloads the Python runtime once (a few tens of MB, fetched lazily from a CDN, so an internet connection is needed the first time); later runs reuse the warmed-up runtime. Because it shares the sidecar's Python, results match the Sidecar engine. By default the runtime loads from the public jsDelivr CDN, which is a trust assumption: a tampered CDN response would run unverified (Pyodide loads its own pyodide.asm.js/WASM internally, so a subresource-integrity check on the entry script alone is not sufficient). For production or offline use, self-host the runtime by pointing VITE_PYODIDE_INDEX_URL at a mirrored copy of the Pyodide distribution, which removes the CDN dependency entirely.

See the Vector Analysis tutorial.

Raster¶

Processing → GeoLibre Toolbox → Raster opens the Raster tools dialog. Most raster tools run on the rasterio Python sidecar: they take a file path in and write a file path out, then add the result to the map.

Eight of them also offer a Client (browser) engine that computes on the loaded raster with no sidecar at all, so they work on the web build and on mobile: Hillshade, Slope, Aspect, Clip by extent, Raster calculator, Spectral index, Reclassify, and Focal statistics. The rest — Reproject, Resample, Clip by mask layer, Polygonize, Contour, Interpolation, Zonal statistics, and Mosaic / merge — need the sidecar. The engine picker in the dialog shows which engines a tool accepts, and the line beneath it says what the selected one will do.

Terrain

Reproject

Clip

Raster to Vector

Vector to Raster

Analysis

Georeferencing sits at the bottom of the same submenu: it pins a non-georeferenced image to the map with ground control points using a least-squares affine fit, reporting per-GCP and RMS residuals.

See the Terrain Analysis tutorial.

Conversion¶

Processing → GeoLibre Toolbox → Conversion writes data to cloud-native formats:

Every one of these has a client-side engine, so all of them work in the browser and on the Mac App Store build. On desktop they run on the Python sidecar instead, which reads and writes native file paths and, for Vector to Vector, can write any format GDAL supports rather than the browser's shorter list. Raster to PMTiles is the exception: it has no sidecar endpoint at all and always runs in WebAssembly. The dialog names the engine it is about to use in its status line.

The sidecar can also confine conversion inputs and outputs to an allowlist of directories, set through GEOLIBRE_CONVERSION_ROOTS. It is unset on the desktop app, where the paths are your own filesystem and there is nothing to confine. The Docker image sets it, because there the sidecar is reachable same-origin through the nginx proxy and must not be able to read or overwrite arbitrary container paths. See Self-Hosting.

Network¶

Processing → GeoLibre Toolbox → Network runs routing analysis against a Valhalla server (the public FOSSGIS instance by default, so the coordinates you submit leave your device; self-hosted deployments can point at their own, see Self-Hosting).

Spatial Statistics¶

Processing → GeoLibre Toolbox → Spatial Statistics runs pattern analysis on a point or polygon layer and adds the result to the map.

The Composite score builder is the suitability and index workflow: pick two or more numeric fields, give each a normalization (min-max, z-score, rank, or quantile), a relative weight, and the end of its range that scores well, then combine them with a weighted arithmetic mean, or a geometric mean when a strong field should not be able to compensate for a weak one. The weights are shown as the share of the total each field carries, so their effect is legible while editing.

Two choices decide what the map means, so the dialog asks rather than assumes:

• Features missing a value either drop out of the result or have their weights renormalized over the fields they do have. There is no default; both produce plausible maps, and only one of them is the index you meant.
• Keep normalized components writes each field's normalized value as its own column, so a score can be audited instead of taken on trust.

Score range writes the index on 0 to 100 by default; switch it to 0 to 1 when the score feeds another calculation rather than a legend. Score field name decides the column it lands in, and the normalized components, when kept, are written on the same scale beside it.

Rank and quantile normalization share ranks across ties (the mid-rank convention), so equal inputs always score equally. The result lands as a new layer already styled by the graduated renderer on the score.

DGGS¶

Processing → GeoLibre Toolbox → DGGS works with discrete global grid systems (H3, S2, A5, DGGRID, DGGAL).

Geocode Addresses and Batch tools¶

Two more entries sit below the separator in the GeoLibre Toolbox submenu:

• Geocode Addresses turns a table of addresses into a point layer.
• Batch tools runs one tool across many input layers (Batch), or chains tools so each step's output feeds the next and saves the chain with the project (Models). Both modes draw on the Vector tools above and run on the client engine. For a graphical way to build the same kind of chain, see Model Builder.

AI Segmentation, Object Detection, Segment Everything¶

• AI Segmentation turns imagery into vector features with segment-geospatial (SamGeo) and Meta's SAM 3 model: choose a GeoTIFF, type a text prompt ("trees", "buildings") or run automatic segmentation, and the resulting polygons are added as a new layer. It runs the model in a separate samgeo-api server (a GPU is recommended) that the sidecar proxies. See the dedicated AI Segmentation page for setup and usage.
• Object Detection and Segment Everything run client-side in the browser on onnxruntime-web, so they need no sidecar and stay available on the web build and on mobile.

Whitebox Toolbox¶

Processing → Whitebox Toolbox opens the geoprocessing toolbox: 1,000+ tools covering vector, raster, remote sensing, hydrology, terrain, LiDAR, conversion, network, and projection analysis.

The tools come from the Whitebox Next Gen suite together with GeoLibre's own WASM tools from geolibre-rust, which the dialog mixes into the same catalog (use the source dropdown to filter to one or the other). The category and subcategory names, and the tool names themselves, come straight from the tool manifests and are generated automatically, so they follow upstream naming rather than GeoLibre's.

Where the tools run¶

They run in the browser, through a WebAssembly runtime with raster and vector I/O — no Python sidecar, no server, and no data leaving your machine. That means the full toolbox is available on GeoLibre Web and on Android and iOS, not just the desktop app.

The Run locally (WASM) checkbox controls the engine:

• Checked runs the tool in WebAssembly on the layer or file you pick. This is the default in the browser build, where no sidecar can be started. The Mac App Store build has no sidecar to switch to at all, so the checkbox does not appear there — WebAssembly is the only runtime.
• Unchecked sends the job to the Python sidecar instead. This is the default on desktop, where the sidecar is available. The sidecar can read native file paths that the in-browser runner cannot fetch, and is the better choice for batch runs across a directory of files on disk.

Either way the tool list is the same; only the executing engine changes.

Finding and running a tool¶

• Search by name at the top of the tool list, or narrow with the category and source dropdowns.
• Browse by category without opening the dialog at all: the Processing menu has a submenu per category (Conversion, Hydrology, LiDAR, Network, Projection, Raster, Remote Sensing, Terrain, Vector) with nested subcategory submenus, including the GeoLibre (WASM) subheading for GeoLibre's own tools. Picking a tool opens the dialog with it preselected. The catalog is bundled offline, so the menu works with no network.
• Fill in the form — the dialog builds it from the tool's own parameter manifest, with a file picker for path inputs and an output-format dropdown for vector outputs. Parameters that are ground distances get a metric unit picker.
• Run, and the output is added to the map. Raster outputs are Cloud Optimized GeoTIFFs.

Every run is recorded in Processing → History, newest first, with the tool, the engine it ran on, how long it took, and the layers in and out. Each entry offers Re-run, Edit & re-run (reopens the tool with the same parameters), Copy JSON, and Copy Python. Both toolboxes write to the same history, and so do the quick analyses.

Model Builder¶

Processing → Model Builder opens an ArcGIS-style canvas for building a processing workflow as a graph instead of running one tool at a time.

• Drag a tool from the palette onto the canvas to add it as a node, then wire one node's output into the next node's input. + Input and + Output add the model's own entry and exit points, so the same graph can be re-run against different layers.
• The palette draws on the same catalog as everything else in this menu: the client-side GeoLibre Toolbox tools plus the full Whitebox catalog, so a raster chain such as fill depressions → flow accumulation → extract streams is a valid model.
• Select a node to edit its parameters in the right-hand panel. Arrange lays the graph out automatically.
• Run validates the whole graph first — cycles, missing connections, parameters that do not exist on the tool, and wrong parameter types are all reported before anything executes — then runs the chain as one job, with progress in the message log at the bottom.
• Save stores the model with the project, Import / Export move it between projects as a file, and Copy Python script puts the equivalent geolibre Python code on the clipboard.

The AI Assistant can author a model from a plain-language description and open it here for review before you run it.

Dashboard¶

Processing → Dashboard opens a panel of chart widgets below the map that summarize the layers in the project. Unlike the attribute table's Charts dialog, dashboard widgets are saved with the project and cross-filter each other.

Add widget asks for a layer, a widget type, and the fields to plot:

Each widget carries a title and a color, and the Columns control sets how many sit side by side. A selector never filters itself, so a choice can always be changed or cleared, and selections start empty each time the dashboard opens — they are a way of looking at the data rather than a property of it.

Any vector or DuckDB query layer can be charted; the panel says so when the project holds none yet.

Jupyter Notebook¶

Processing → Jupyter Notebook docks a notebook beside the map: JupyterLite on a Pyodide kernel in the web build, and a real JupyterLab server on the desktop app, which gives you full CPython with geopandas, rasterio, and GDAL. Either way a geolibre client is preloaded, so a cell can drive the live map next to it. See Notebook Panel.

Planetary Computer and Earth Engine¶

The Processing menu also opens the Planetary Computer and Earth Engine panels for browsing and loading cloud datasets. See Data Integrations.

The Python sidecar¶

The raster tools, the sidecar conversion tools, and the optional GeoPandas vector engine use a local FastAPI sidecar that the desktop app starts on demand. The Whitebox Toolbox can optionally use it too, but does not need it — it runs in WebAssembly by default. The vector tools' client engine and the browser-based conversions need no sidecar either. See Getting Started for setup and Reference → Architecture for how it works.