Features

01 sfarc — Exact Geometry on Curves

The problem every sf quietly ignores: real-world features have arcs, and everyone else fakes them.

Roads, parcels, cul-de-sacs, pipelines and survey plats are full of true circular arcs — CIRCULARSTRING, COMPOUNDCURVE, CURVEPOLYGON. Ask R sf/GEOS for the length or area of one and it silently linearizes the curve into hundreds of tiny straight segments first — introducing error — or refuses the geometry outright.

ouRGeo ships with sfarc, an R package built for this project that computes on curves analytically. It derives the circle centre, radius and swept angle straight from the arc's control points and returns a closed-form, exact answer — no densification, no approximation.

What sfarc computes exactly

• Analytic, not approximate — overlay operations trace boundaries through closed-form circle–circle and circle–line intersections and return true curved geometry, not a polyline imitation.
• Cross-validated against GEOS — results are checked against the industry-standard engine, with linearization used only as a warned last resort.
• Correct on the globe — geometries in geographic coordinates are measured on the sphere or ellipsoid by adaptive quadrature of the exact curve, not by chopping it into chords.
• Zero disruption — non-curved geometries are delegated straight to sf, so nothing changes except where curves are actually present.

02 The Geoprocessing Toolbox

87 point-and-click tools across seven categories — and every one writes clean R.

Fill in a form, pick your layers and columns, hit run. The toolbox handles the geoprocessing you reach for every day — and instead of hiding the work, it generates the exact R code in your console so the result is always reproducible.

Full tool reference — all 87 tools, their parameters and the R they emit →

03 Industry-Standard Drawing & Editing

Digitizing that feels like professional CAD — snapping, precision entry, and full geometry editing.

Drawing in ouRGeo isn't a toy sketch tool. It's a real digitizing environment built for accuracy, with the conventions surveyors and CAD users expect.

Smart snapping engine

As you draw, ouRGeo snaps to vertices, edges, midpoints and true intersections across every visible layer — plus the shape you're currently drawing. It's backed by a spatial index (R-tree), so snapping stays instant even over dense data, with a sensible priority order (vertex > intersection > midpoint > edge).

Precise input, not eyeballing

Type an absolute coordinate straight into the ribbon, or place the next vertex by distance and bearing. For a whole traverse there is a dedicated tool with its own entry strip — Distance & Bearing, below.

# Absolute coordinate
-122.42, 37.77

# Relative: 150 m at 45° clockwise from north
d150 a45

• Full geometry editing — move, add and delete vertices on existing features through the geometry-edit ribbon.
• True curves — circular arcs stored as real CIRCULARSTRING geometry, not densified polylines.
• Staged edits — everything you draw waits in a Save Edits badge and is written by one batched R statement you can read first.
• Undo-friendly — remove the last vertex, cancel a curve point, or finish the feature with a keystroke.

04 Distance & Bearing — and Curved Courses

A deed, a plat and an alignment are lists of numbers. Type the numbers; the geometry lands where they say.

Press B and a traverse strip opens beside the map. Say where you are measuring from, then enter each course the way your notes are already written — 150 ↹ N45°30′E ⏎ — and the vertex lands exactly there. Bearings in azimuths, degrees-minutes-seconds, quadrant bearings, deflections (L/R) or angles right; distances in metres, feet, US survey feet, chains or miles, or just type 150ft and the unit comes with it.

Curved courses

Every real deed mixes lines with curves, so press U and type the call as it is written: “along a curve to the right, radius 250.00 feet, central angle 45°30′”. Tangent and non-tangent curves, clothoid spirals, the spiral–curve–spiral a highway plan quotes as one unit, and a free curve between two headings.

Give any two of radius, arc length, chord, tangent, external, mid-ordinate, central angle or degree of curve, and ouRGeo solves the rest and prints all of them back — a plat quotes them redundantly precisely so they can be checked against the page. Where two perfectly ordinary curves fit the pair you typed, it says so and names both rather than quietly picking one.

On the grid your survey was measured on

A bearing off a plat in a projected CRS is measured from grid north, and its distance is a grid distance. Measure that on the ellipsoid instead and the whole figure rotates by the grid convergence — up to 3° at a UTM zone edge — and scales by about 1:2500. Both are invisible: the figure still closes, it is just in the wrong place. So ouRGeo offers both bases, always names which is in force, and a projected layer defaults to its own grid in its own unit. Geodesic distances use Vincenty’s method on the WGS 84 ellipsoid rather than a sphere.

• It shows its working — where the leg lands as you type, the numbers written on the leg on the map, every entry listed in the notation you entered it in, and, once a figure could close, how far it is from closing and the 1:N a surveyor judges it by. A curve contributes its arc, never its chord.
• Real curved geometry — what reaches your layer is CIRCULARSTRING / COMPOUNDCURVE, so the radius survives a reprojection and a GeoPackage round trip.
• Points walk the table — on a point layer you place a reference point to measure from (a temporary mark, not a row), and each leg fills the row you are on and moves to the next, exactly as clicking does.
• Reproducible — finishing a traverse echoes a runnable ourgeo_traverse() call naming the origin, the courses and the CRS, because the saved geometry records coordinates, not the measurements they came from.

05 The In-App AI Agent + Autopilot

An assistant that understands your session — and can drive it, if you let it. Cloud or fully local.

Open the AI panel and ask, in plain language, for the analysis you want. The agent knows about your R environment and can write the code to get you there. Turn on Autopilot and it goes further — executing R directly in your live session and iterating toward the result.

Your model, your rules

ouRGeo isn't locked to one vendor. Use a cloud provider, or point it at a model running on your own machine for a 100% offline, private assistant — nothing leaves your computer.

• Autopilot mode — the model creates, modifies and runs R objects for you; a clear warning explains the trade-offs before you enable it.
• Streaming answers — responses arrive live, with the code it runs shown inline so you can review every step.
• You stay in control — Autopilot is opt-in, and the generated code lands in your console like any other action: inspectable, editable, savable.
• It can drive the app, not only describe it — around ninety interface actions plus every toolbox tool, so it can walk you through a workflow in your own session, or point at the button instead of pressing it. Each action is screen-only, Autopilot-gated or confirm-first, and you can change any of those in Settings.
• As many conversations as you like — start a new chat and the last one is still there. Save the session as a project and its chats are kept with it, and travel inside the .ourgeoproj to whoever you send it to. Each chat remembers the model it was held with.
• Your Claude subscription counts as a provider — ouRGeo runs the Claude Code command-line tool you already installed and signed in to. No API key to paste, and ouRGeo never sees a credential of yours.
• Web access is a switch — turn it off and the assistant has no network tool at all. Every web call it does make is logged to your R console, so the console stays a complete record of what it did.

06 The Data Connector

Reach into the world's public data catalogs without leaving the app — and get reproducible import code.

The Data Connector browses live web APIs and open-data portals, lets you build a query visually, previews the result, and then generates the R to import it. Only metadata and previews run in the UI — the actual import is R code echoed to your console, so your data pull is always reproducible.

Built-in providers

• Vector, raster & tabular — pull features as sf, imagery/elevation as SpatRaster, or plain data frames.
• Visual query builder — cascade to the resource you want, add filters, preview, then load.
• Add straight to the map — raster imports can register with the tile engine and zoom to extent automatically.
• User-extensible — add your own servers per provider; they're remembered between sessions, and a plugin can contribute a whole new provider as JSON.
• A Help button on every connector — straight to that API's own documentation, because that is where the questions a connector cannot answer are answered.
• Curated sources too — a Browse Sources tab with ready-made datasets (USGS NWIS gauges, Census, FRED, open-data portals and more), each one narrowed by a few typed fields.

07 Code History & Session Recording

The defining idea of ouRGeo: every action has a matching R response you can keep.

This is what makes ouRGeo fundamentally different from a normal GIS. When you buffer a layer, run a join, compute a distance, or draw a feature through the GUI, the corresponding R code appears and runs in the console — the real command, not a summary. Your point-and-click session is, transparently, an R script being written for you.

Recording mode

Turn on recording and every GUI-generated command is appended to a file of your choice — the currently open tab, a new blank script, or an existing .R file on disk. Click your way through an analysis, and walk away with a clean, runnable script that reproduces it exactly.

• Run it your way — type in the console, Ctrl+Enter a single line, or Shift+Enter a selection from the Monaco editor.
• Portable projects — save everything as a self-contained .ourgeoproj bundle (code, environment, layers, databases) and reopen it anywhere.
• Crash-resilient — debounced autosave preserves your tabs and workspace across sleep, reloads and crashes.

08 A Real Terminal, Beside the Console

Your own shell, in the window where the work is — for the half of the job that was never going to be R.

A Terminal tab sits beside the R console. It is your own shell — bash, zsh, fish, PowerShell — with a real pseudo-terminal behind it, so top, vim, git, job control and colour all behave exactly as they do in a terminal window. Nothing starts until you click the tab.

• As many shells as you like — open them from +, rename them, pick a different shell per tab; a dot marks a tab where a command finished while you were looking elsewhere.
• It knows where R is — it opens in R’s working directory, and the path in the header is a control: change directory, copy it, open it in your file manager, or reconcile the two in either direction.
• It looks like the rest of the app — ANSI colours follow your code theme, the surface follows your app theme, so ls belongs in the window it is in.
• Reload-proof, disk-free — reload the window and your shells are still running with their scrollback; quit, and they are gone. Terminal output is never written to disk, not into a project bundle and not into the session file.
• Give it its own pane — Settings → Terminal puts it beside the console instead of in a tab with it, and after that you can drag it anywhere in the workspace.

09 Plugins, and a Store to Find Them In

Capabilities added while the app runs — written by you, by the assistant, or by somebody else.

A plugin can contribute data connectors, toolbox tools, actions, toolbar buttons, docs topics, R libraries and whole panels. The preferred kind is plain JSON — no code at all, and therefore no trust decision to make — with R files and compiled TypeScript available when a plugin genuinely needs them. The AI assistant can write one for you, scaffold and all, and test a connector against a live server before you ever enable it.

The plugin store

Browse it at ourgeo.dev/plugins or from Settings → Plugins → Plugin Store… inside the app. Every listing has been installed and run by a moderator before it appeared. Installing happens inside ouRGeo and needs a free ourgeo.dev account — the same one the forum uses — because plugin downloads are not public.

• What you install arrives switched off. Turning it on stays your decision, exactly as it is for a plugin somebody sent you as a file.
• Publish your own. ouRGeo builds it, uploads it and puts it in the queue; a moderator installs it, runs it, and either publishes it or sends it back with a note you can read. What people download is a built, minified bundle — your source is never published.
• Updates are offered, never applied for you, with the author’s note about what changed. If a version is withdrawn after you installed it, ouRGeo switches that plugin off and says why in the console.
• Ratings and reviews from people who have actually installed it — reviewing requires having run the thing.

10 And a Whole Lot More