Version History

Distance & Bearing — place the next point by typing how far and which way, on the grid your survey was measured on.

• A Distance & Bearing tool beside Draw, for every kind of layer — lines, polygons and points. Press B, say where you are measuring from, then type each leg: 150 ↹ N45°30′E ⏎, and the vertex lands exactly there.
• Bearings in the notation your notes are already written in: azimuths, degrees-minutes-seconds, quadrant bearings like N45°30′E, deflections (L/R) and angles right. Distances in metres, feet, US survey feet, chains, miles — or type 150ft and the unit comes with it.
• Distances are geodesic on the WGS 84 ellipsoid, computed with Vincenty’s method rather than on a sphere, so a leg is the length you typed anywhere on Earth.
• A bearing off a plat means something different on a projected map, and ouRGeo now says which it is using. On a projected layer it measures on that layer’s own grid — in the layer’s own unit — so grid north and the scale factor are accounted for instead of quietly rotating your traverse by the convergence.
• On a point layer you place a reference point first — a temporary mark to measure from, not a row in your data — and every leg after it fills the row you are on and moves to the next, so the data viewer’s row indicator walks the table exactly as it does when you click. Run out of rows and it asks whether to add another, as always.
• The reference point snaps if snapping is on, carries forward from the last point you placed, and can be moved anywhere at any time by clicking the map.
• It shows its working: where the leg lands as you type, the numbers written on the leg itself on the map, a list of everything entered in the words 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.
• Finishing a traverse echoes a runnable ourgeo_traverse() call naming the origin, the legs and the CRS — because the geometry ouRGeo writes records the coordinates, not the distances and bearings they came from.
• The AI assistant can lay one out for you from a list of legs, staged for review like any drawn geometry.
• Fixed: coordinates in the R server’s replies were rounded to four decimal places — eleven metres of longitude — which no feature had needed to more than four until this one did.

A real terminal inside ouRGeo — your own shell, beside the R console, for the half of the work that was never going to be R.

• A Terminal tab beside the R console, always there. It is your own shell — bash, zsh, fish, PowerShell, whatever you use — with a real pseudo-terminal behind it, so top, vim, git and colour all work exactly as they do in a terminal window.
• Nothing starts until you click the tab. Open as many shells as you like from the + button, rename them, and pick a different shell from the arrow beside it; the tab shows a dot when a command finishes in one you are not watching.
• It opens in R’s working directory, and the path in the header is a control: click it to change directory, copy it, open it in your file manager, or reconcile the two — send R to the shell’s directory, or type cd to R’s.
• Colours follow your code theme and the surface follows your app theme, the same way the editor does, so ls looks like it belongs in the window it is in.
• Search with Ctrl+Shift+F, copy and paste with Ctrl+Shift+C/V, and resize the text with Ctrl+= and Ctrl+- — everything else goes to the shell, including Ctrl+C, Ctrl+R and Ctrl+D.
• Settings → Terminal gives it its own pane beside the console instead of a tab, so both are visible at once — and after that you can drag it anywhere and ouRGeo leaves it there.
• Reload the window and your shells are still running, with their scrollback. Close ouRGeo and they are gone: terminal output is never written to disk, not into a project bundle and not into the session file.
• The AI assistant can use it, behind a Terminal switch in the panel footer that ships OFF and works only with Autopilot on. Every command it runs is typed into a tab you are watching and written to your R console.
• It is not a sandbox and is not offered as one — R’s own system() reaches the same machine. What the switch means is that you decided, once and deliberately, that running commands on your computer is part of what the assistant does. Ask it to do things in R wherever R can do them.
• A second code editor: Settings → Workspace adds one, and documents drag between the two by their tabs or move with a right-click. Removing an editor never closes a document — they move to the one that remains.
• Panel drag grips now ship off. They appeared on every panel header on hover, which is a gesture that mostly fires by accident when you did not go looking for it; Settings → Workspace turns them on and can rearrange everything without them.
• Every on/off setting is now a switch rather than a checkbox, and the whole row is the control — a settings row takes effect the moment it moves, and there was never an OK button to press.

Dictate to the AI assistant — on your own machine by default, with nothing uploaded and no account needed.

• A microphone beside Send in the AI panel. Click it, talk, and the transcript lands in the message box at the cursor — so you can start typing a sentence and finish it out loud.
• It shows you it is listening: a ring around the microphone that moves with your voice, a timer, and a live level meter in Settings so you can check the right device is picked up before you rely on it.
• Transcription runs ON YOUR MACHINE by default. Whisper is downloaded once (43–242 MB, your choice of model) and then works offline for ever — no account, no key, and nothing you say leaves the computer.
• Prefer something else? Point it at a server you run (whisper.cpp, Speaches, LocalAI), or at OpenAI, Groq, Deepgram, ElevenLabs Scribe or AssemblyAI. Deepgram shows words as you speak them.
• Every recording sent off your machine is recorded in the R console, with how long it was and where it went. The on-device engine never appears there, because there is nothing to report.
• Pick your microphone from the button itself (right-click) or in Settings → Voice input, along with the language, how long a pause should end a recording, and whether to send the message automatically.
• Auto-send is off by default: the assistant can run R, and a misheard instruction is worth reading before it goes.
• ouRGeo now asks your operating system for the microphone and nothing else — the app previously had no permission policy at all, and could have been granted location or notifications without anything appearing on screen.

Plugins, and a workspace that goes where you put it — ouRGeo can now gain capabilities it did not ship with, without being rebuilt.

• Plugins (Settings → Plugins): data connectors, geoprocessing tools, actions, toolbar buttons, panels and documentation, added while the app is running. Most are pure JSON and run no code at all.
• Ask the AI assistant for one in prose — "add a connector for this API" — and it probes the API, writes the spec, tests it against the real server, and asks you to turn it on.
• A plugin that ships code is compiled on the spot, runs with ouRGeo’s own privileges, and arrives switched OFF. Enabling one is a decision you make, the way you decide to run install.packages().
• Plugins export and import as portable .ourgeoplugin files. One that fails to load is reported and skipped, never fatal — and one that takes the app down disables itself on the next launch rather than leaving you locked out.
• A workspace you arrange: four zones — left, centre, right and bottom — and any panel can go in any of them, split or tabbed, at whatever size you like. Drag a panel by the grip in its corner.
• Panels sharing a zone share it evenly — two take half each, three a third each — until you drag a divider between them. Double-click a divider to even them out again, and every zone starts each session evenly shared.
• Your arrangement is remembered between sessions, and you can save several as named presets and switch between them.
• Toolbar buttons can be reordered and hidden, and the assistant can rearrange all of it on request — with layout:reset always the way back.
• Fixed: opening a project restored its R objects but showed an empty Environment panel — everything the bundle loaded was being treated as though it were ouRGeo’s own rather than yours.
• Fixed: the helper functions ouRGeo defines for generated code no longer end up in your project bundles, in your Environment panel, or deleted the moment you open a project.
• Fixed: when the assistant moved the map for you — zooming from landmark to landmark on a tour — the view never changed. Every map:setView now moves the map you are looking at, and the export extent follows it.
• Console recording gained a destination: the assistant can now record into a new document, or into a saved file that offers to write itself back when you stop.
• The Environment panel: right-clicking an environment offers Export, Make Copy, Rename and Delete, and Save is now called Export — it writes an .RData file to your computer.
• Environments you can work IN: right-click one and choose “Work in this environment”, and everything you run — console, toolbox, assistant — evaluates inside it. R looks names up outwards and never into an environment, so this is what lets you type x * a instead of env2$x; .GlobalEnv stays visible through it, and the prompt shows where you are. Switching echoes the R for it — evalq({ ... }, env2) — so the same move works in a script.
• Creating an environment now says how to reach what you put in it, in the console, at the moment you make it.
• Objects gained Copy To beside Move To — same name, another environment, the original left where it is.
• An environment is listed beside .GlobalEnv by default; Show in its right-click menu lists it inside .GlobalEnv instead, where R actually keeps it.
• Move To now offers the environments you can actually see: .GlobalEnv and your own while the eye is hiding what is not yours, every environment in the session when it is not.
• Fixed: “Make Copy” on an environment made a second name for the same environment rather than a copy — editing either one changed both.
• Fixed: R’s refusals reach you. Naming an environment after a data frame, moving an object into a package environment, copying onto a name already taken — each one used to do nothing and say nothing.
• Fixed: exporting an environment no longer writes ouRGeo’s own internal functions into your .RData file, and the console shows the exact save() that was run.
• Settings → Workspace: save the panel arrangement by name and switch between arrangements, export and import them as .ourgeolayout.json files, turn the drag grips off if you would rather they weren’t there, and restore the shipped default in one click.
• Fixed: the grip in a panel’s corner did nothing when you dragged it — dropping a panel into another zone now works, and an empty zone offers itself as a target so a panel can always be moved back.
• Move a dataset between panels from wherever you are: Add to Map in the data viewer’s header sends a table to the spatial editor, and right-clicking a layer in Contents opens its attribute table.
• Sending an object that is already on the map now asks first — and offers to show you the layer you already have instead of adding a second copy of it.

The Theme Studio — build your own themes on all three axes, with your own artwork, and share them as files.

• Theme Studio (Settings → Appearance): create app themes, code themes and markdown themes of your own, always by copying one that already works.
• Every colour is editable and labelled with what it actually paints — ten interface colours and six editor-surface colours for an app theme — with live contrast warnings and a preview that updates as you type without touching the running app.
• Bring your own artwork: a backdrop image behind the code editor with its own opacity and grey-scale, and a card image for the theme picker. Both are embedded in the theme, so it travels with its pictures.
• An app theme also chooses the code and markdown palettes it starts with, and the basemap the Spatial Editor opens with under it.
• Themes export and import as portable .ourgeotheme.json files — and a file meant for one axis can never land in another’s list.
• The AI assistant can build a theme to your description, check its own contrast, and switch you to it.
• Fixed a settings-file race that could corrupt theme.json and quietly reset the app to the Dark theme on the next launch.

.md, .Rmd and .qmd become first-class documents — written, run, knitted and published without leaving ouRGeo.

• Markdown and R Markdown documents in the code editor, with a formatting ribbon, a slash-command menu, and full R autocomplete inside chunks.
• Runnable chunks with inline output: run a chunk and its plots and printed results appear beneath it, right in the document.
• A Visual mode that edits the rendered document directly and round-trips back to source without reformatting what you wrote.
• “Chunk: current map” generates real tmap or ggplot2 code from the layers, symbology and view currently on the map — the same code the Export dialogs produce.
• Knit to HTML, PDF or Word in a clean R session, with each format pre-disabled and explained when its dependencies (pandoc, LaTeX) are missing.
• Publish an R Markdown document straight to the community forum as a new discussion, figures and all.
• Separate code-editor and markdown editor themes: 26 syntax palettes and 16 prose palettes, chosen independently of the app theme.

Rasters become a first-class data type — rendered, styled, analyzed, imported, and stored like everything else.

• Rasters on the map: SpatRasters render as crisp, server-tiled layers in the Spatial Editor, with a band viewer and full symbology (RGB/pseudocolor/categorical, stretch controls, color ramps, histograms).
• A complete raster toolbox — 30+ tools covering processing (reproject, clip, resample, focal, terrain, hillshade, raster calculator), band math (NDVI and friends), and raster↔vector work like zonal statistics and extract-to-points.
• GeoTIFF and Cloud-Optimized GeoTIFF import: local files, COGs streamed by URL, and STAC raster assets from satellite catalogs.
• Tiled raster storage in .Rgeo databases (format v3): rasters save as compressed block pyramids and connect back instantly as lazy, file-backed objects.
• Map export parity — ggplot2 and tmap exports reproduce on-map raster symbology exactly (band, stretch, ramp).

A real project workflow plus a top-to-bottom refresh of the Settings and theming experience.

• Project workflow: save and load portable .ourgeoproj bundles that snapshot the R environment and full UI state, with a scratch workspace that always launches clean.
• Redesigned Settings: collapsible, icon-led sections and an in-app version history.
• Scenic theme picker — each theme is shown as its own themed illustration, with subtle grey-scaled artwork painted behind the code editor.
• Retired the standalone Map Preview panel; all map-making now lives in the Spatial Editor.
• Package name autocompletion inside library()/require(), with the Packages pane auto-refreshing on install.
• Stability: fixed a black-screen restore after sleep and tightened memory cleanup on exit.

The largest release — a ground-up architecture overhaul plus databases and much richer map export.

• Database support: connect to .Rgeo (DuckDB) databases, manage datasets, and edit database-backed spatial objects directly.
• First-class curved geometry via sfarc, plus auto-detected calculation CRS and configurable default CRS for new geometry.
• Expanded Data Connector with a Web APIs framework (Esri, OGC, WFS, STAC, SDMX, OData, CKAN, Socrata, ERDDAP, and more).
• Map export to both tmap and ggplot2 with legends, north arrows, scale bars, and graticules.
• Local model harness support (llama.cpp and others) for the AI assistant.
• Under the hood: modular R server, AI calls proxied through the main process, and a Vitest test suite — plus many data-editor and console improvements.

Connected ouRGeo to the outside world and added guided, code-free workflows.

• Data Connector for importing from popular open-data portals.
• Kaggle integration for pulling datasets straight into R.
• AI Assistant panel for in-app coding help.
• Toolbox: a GUI over a large set of classic R spatial and tabular operations, with the ability to pipe tools together.
• Plotting preview pane, a ggplot GUI editor, and an in-app Help panel.

Turned the workspace into a polished spatial app with real map editing.

• Settings with switchable themes applied across the editor, data viewer, and map.
• Create-dataset dialog for vectors, matrices, data.frames, tibbles, and data.tables.
• Geometry drawing with snapping, a symbology editor, and multiple concurrent spatial editor sessions with user-defined extents.
• Map zoom and fit-to-extent controls, plus selection syncing between the data viewer and the map.
• Switchable R installation path, console recording, and zoomable UI text and icons.

Grew from an editor into a full R workspace with packages, environment, and data.

• Package Manager to install and load packages, with actions echoed to the console.
• Environment pane to browse R objects, expandable by data type.
• First Spatial Editor pane for adding sf objects to a map.
• Inline data editing with smooth spreadsheet-style editing and column creation.

A clean restart — the distilled core that everything else is built on.

• A Monaco code editor wired to a live, embedded R console.
• File management: open, edit, create, and save .R files.
• Editor tabs that persist across sessions.