Skip to content

The OSINT investigator's workbench. One case, one folder, every tool. Local-first: your media and your investigations never leave your machine.

JavaScript
44.0 KB
Raw Blame

Azimut product overview

Status: spec v0.3 (2026-09-13). Read in order: Done → Roadmap → Loose ideas. Implementation detail belongs in code and tests; see IMAGERY_PROVIDERS.md, UI.md, ONTOLOGY.md and STORAGE_AND_PERFORMANCE.md.


1. Product

Azimut is a local OSINT workspace. It keeps source media, geolocation work, proofs, notes and exports in one portable case folder.

2. Principles

  1. Local-first. No account, telemetry or upload. Network access follows a network-dependent action, except for the optional startup version check (GitHub releases, PyPI for the downloaders).
  2. Portable cases. Files hold media, notes and proofs; per-case SQLite holds the graph. A closed case folder is complete and can be copied as-is.
  3. Focused tools. One tab performs one task and also works in a promotable scratch case.
  4. Orchestration. Specialized services stay external; selected results enter the case with provenance.
  5. Analyst control. Tools may suggest entities or links, but only an analyst action confirms them.
  6. Auditable output. Artifacts record how they were produced and label hints.
  7. Free core. Local computation and keyless services cover core workflows; user-supplied keys add optional providers.
  8. English interface.

Key constraints:

  • Legal-only imagery. Built-in providers are Esri, OSM, OpenTopoMap and Sentinel-2. Keyed providers need the user's own key. Unofficial key-less endpoints of keyed services (mt1.google.com) are never shipped. Custom XYZ templates stay supported.
  • Two-way delete/edit sync. An artifact and its sidebar entity are one thing; deleting either removes the other. One capture ⇄ one capture entity.

3. The case workspace

The workspace is ~/Azimut unless it was moved: AZIMUT_HOME wins, then a one-line pointer file at the platform's configuration location, then the default. A directory per investigation (~/Azimut/<case>/ by default):

README.txt     # which half of the folder is whose
azimut/        # everything Azimut owns; the rest of the folder is yours
  case.json    # small manifest: name, dates, storage format + schema
  notes.md     # free-form case notes (markdown)
  notes/       # note bodies, named after their title, filed as in the notebook
  sheets/      # case sheets as plain CSV; .meta/ holds the grid's own state
  media/       # source + captured + extracted media; .meta/ holds the sidecars
  proofs/      # exported PNGs; .meta/ holds the specs and pasted images
  exports/     # finished exports and yours to fill
  .data/       # case.db, the authoritative SQLite graph, and entity photos
  .drafts/     # post drafts
  .inspect/    # each file's Inspect work: its frames and their edits
  .collages/   # collage layouts and their previews; the picture one exports is media
  .compare/    # saved Compare session specs
  .horizon/    # saved Horizon views and their previews, searches, the work in progress
  .analysis/   # Detect areas, saved detections, runs and the frames behind their results
  .search/     # saved Grid Search state
  .layers/     # added map layers: spec + source as received + its icons; .cache/ is derived
  .mapplates/  # map plates: a page laid out round the case's maps, and its preview
  .trash/      # recoverable artifact payloads, in numbered slots

Tools use CaseRepository for structured state. Media, notes and proofs remain files. Legacy JSON graphs migrate to SQLite on open with a retained backup. One-shot work uses the same code path in a promotable scratch case. Exported case bundles live under the workspace's hidden .azimut/ directory. App-wide settings, scratch cases, caches and runtime tools also stay under .azimut/, so the visible workspace root contains only permanent cases.

4. Data model

The entity/link schema has existed since v1. Full vocabulary lives in ONTOLOGY.md.

  • Entity types (extensible) sit in one of eight families. Relations start from families and narrow endpoints where a verb is type-specific:

    Family Types
    actor person, organization
    asset vehicle, vessel, aircraft, structure
    class equipment-type
    identifier account, email, phone, domain, ip, network
    collected media, capture
    document proof, post, note, sheet, inspect-session, collage, compare-session, horizon-view, horizon-find, map-layer, map-plate, analysis-* (Detect), bookmark
    place place
    claim claim
  • Links: typed directed edges (owns, part-of, member-of, associated-with, posted, appears-in, sited-at, instance-of, in-network, located-at, depicts, same-image-as, about, at, cites, contradicts, …) plus free-typed labels.

  • Provenance on everything: which tool/action, source, when and review status (confirmed by analyst vs suggested by a tool).

  • Assessment stays separate: a Claim carries its confidence; a ratable ordinary relation may carry its own ordinal; a source carries Admiralty reliability A–E.

Tools suggest entities and links; the analyst reviews them. Relations, Mentions, Claims, lineage, the Board, the graph and configurable saved Timeline readings are shipped.


5. Done

v1 Proof Studio (shipped as GitHub v0.1.0+)

The first complete workflow: collect media → annotate the match → prepare the proof for publication.

Tool What it does
✅ Media Library & Inspect Imports or downloads case media with metadata, provenance and hashes, then reviews images and video closely.
✅ Satellite Saves places and attributed map captures from free or optional keyed imagery, including dated Sentinel-2 passes and usage controls.
✅ Geo Proof Composes annotated panels, files their coordinates as places and exports an editable PNG proof.
✅ Geo Report Prepares sourced proof threads and saved drafts without posting automatically.
✅ Case navigation Searches, groups and files case work through the sidebar, Saved views, folders, notes and synchronized deletion.
✅ Capture extension Files user-requested screenshots with their source details, saves map points and bookmarks pages.
✅ Distribution Ships the browser UI, hardened local launcher, locked cross-platform builds, ffmpeg and browser interaction tests.

v2 GEOINT suite (shipped as GitHub v0.2.0+)

Tool What it does
✅ Coordinates & sky Converts coordinates and reads sun, moon, twilight and local time for a saved point on charts or the map.
✅ Research helpers Prepares media for keyless reverse search and saves keyboard-reviewed AOI grids.
✅ Reports & templates Stores reusable proof and post structures, then prepares sourced Markdown for X or Bluesky.
✅ Case Notebook Edits linked Markdown notes with local media, Mermaid diagrams, PDF output and remembered export folders.
✅ Media at scale Downloads behind a login with a session named once, plus bounded search, searchable pickers, local metadata enrichment and GPS handoff to the map.
✅ Storage & recovery Uses per-case SQLite and durable jobs, with whole-case bundles, Trash and portable settings backups.
✅ Case utilities Opens case folders, reports scrubbed diagnostics, keeps filenames in sync and offers explicit Doctor repairs.
✅ Workspace portability Moves or adopts a workspace safely, recovers hand-added cases and prevents two live instances from sharing it silently.
✅ Updates & paste Reports available app, downloader and extension updates, then files supported clipboard content from the main case surfaces.
✅ Evidence on the map Places proofs and derived media through their evidence chain, with stated point uncertainty and footprints drawn under their pins.
✅ Map search Answers the search box while typing from saved work, a coordinate parse and a bundled gazetteer, and asks the geocoder only once typing stops.
✅ Ontology connections Keeps Relations, Mentions, Claim connectors and artifact lineage separate under one validated verb registry.
✅ Board & entities Provides the sortable Case Board, shared Details, typed creation, primary entity photos and a ticked selection deleted as one recoverable act.
✅ Case graph Draws registry-backed lenses with clustered nodes, readable edges, previews, a view budget and sources folded onto their edges.
✅ Working the graph Expands, folds, hides, searches and pins nodes per lens, with undo and no case mutation.
✅ Claim assessment Keeps statement confidence, relation confidence and source reliability separate, with explicit support and contradiction links.
✅ Structured findings Records associations, duplicate identifiers, asset condition, equipment models and statement totals without inventing missing values.
✅ Temporal Claims Dates a Claim with guided point, timestamp or interval input and files its subjects, places and evidence atomically.
✅ Case Timeline Aligns dated statements and media on a windowed axis read in UTC or a civil zone, with uncertainty, density, direct edits and Undated work.
✅ Timeline readings Builds coloured tracks from presets or Search+, then saves a changing Live view or a fixed Snapshot.
✅ Shared analysis views Shares one filter, saved-view family and fact-time window between Board and Graph, while Timeline keeps readings built for tracks and the Map only exchanges a window with them.
✅ Analysis view export Writes the Graph or the Timeline out as a vector plate carrying its lens, question, window, clock and legend, or copies it as an image.
✅ Case Sheet Opens and builds case CSVs in a plain grid: keyed rows, sorts, filters, row colour, clipboard both ways, bulk fill, undo and cells that point at case entities.
✅ Typed columns Types a column as a state, a list, a yes/no, a number, a point, a date or a picture, read by the sort, the filters, the map, the Timeline and the progress.
✅ A family of sheets Files a workbook one sheet per tab, forks a sheet, moves ticked rows under a column mapping, and confirms a reload or an overwrite when the file changed on disk.
✅ A sheet into the case, both ways Promotes a declared sheet into entities, places, vocabularies, row edges and dated Claims in one planned transaction, and builds a worklist back out of the case.
✅ Geolocation index Lays the case's proofs out one per row with their media, place and coordinates, and builds one proof per row back out of two address columns and a coordinate column, as a stoppable job.
✅ Imported proofs Turns a published post into a composed proof, every picture a panel and its text read for a position, with nothing filed before the preview is approved.
✅ Import origin States one origin for a whole import, offers it to a batch that landed without one, and corrects any file later from Details.
✅ Drawing on a proof Stamps a fixed set of marks, fills boxes and ellipses at a chosen opacity, keeps every shape tool in hand, and recolours, restyles, nudges, drags or deletes a picked family at once.
✅ Proof image transforms Turns or crops a panel or proof-owned overlay without changing its source, while keeping attached annotations on the same pixels.
✅ A proof of several points States every place a proof argues, each optionally named and moved on a map, files them under one title and carries them into the post and the exported picture.
✅ What a proof says about itself Carries an optional sentence, which is its notes and what a post is written from, and an optional date for its material, never pre-filled and shown on the Timeline.
✅ A date that reaches the footage A dated proof states that date for the original sources it rests on, as one cited statement restated on every save and never written over the file's own clock.

v3 GEOINT expansion (shipped as GitHub v0.3.0+)

Tool What it does
✅ Map navigation & captures Links map cameras, places case media and uncertainty footprints, and saves attributed captures with scale and north.
✅ Reference windows Fades a case picture or clip over the map, docked or pinned clear of its controls, in the app and the extension.
✅ Map layers Stacks infrastructure overlays, FIRMS fires, VIIRS night lights and OpenStreetMap borders, imports KML, KMZ, GeoJSON and GPX, and follows My Maps and GeoConfirmed.
✅ Personal layers Draws markers, lines and areas on any map from a blank layer, a file or a My Maps link, fed by the case's places, proofs and files, styled with the analyst's own icons, colours and a case key.
✅ Layers over time Dates every edit and reads a layer on any day with what changed ringed, on its time strip and on the Timeline.
✅ Layers everywhere Offers every layer in Compare, Detect and Horizon from one menu, reopens each case on its layers, and downloads a layer as KMZ, KML or GeoJSON or sends a day of it to My Maps.
✅ Map plates Lays a page out round the case's maps (legend, scale, north, inset, marks, tables, credits) from ten ready plates or a template, on vector, topographic, 3D or Sentinel-2 grounds, with looks, text styles and layer roles.
✅ Played plates Plays a plate by day and step, each with its annotations, framing, transitions and case videos, and exports a PNG, a print PDF, an MP4, a GIF or an evolution sheet while the analyst works on.
✅ Horizon Draws the terrain seen from a viewpoint in 3D with named summits and buildings from open sources, lays a photo over it matched by hand, and saves views that reopen as they were.
✅ Find (beta) Ranks the places of an area whose relief fits a photo's traced skyline, helped by marks on the trace, the camera, the sun and alignments, says how far to trust the best one, and keeps searches in the case.
✅ Globe 3D Draws Satellite's and a plate's 3D maps on the app's own globe over public relief, with the flat map's layers, places and measures, and files a tilted view as a credited capture.
✅ Measure Measures lines and areas with legs, bearings and angles, uses a line as range rings, a view cone, a shadow's height or a viewshed, and reads the ground and line of sight under it, flat and on the globe.
✅ Historical imagery & radar Browses Esri Wayback releases and dated Sentinel-1 passes, keeping acquisition dates separate from imagery releases.
✅ Satellite Compare Aligns and annotates dated imagery, echoes the pointer on the other side, highlights comparable changes, saves sessions and exports attributed PNGs, GIFs and evolution sheets.
✅ Detect Reviews Sentinel-2 and Sentinel-1 detections over shared areas, with pass coverage, cloud masks, custom analyzers and dated evidence; analyzers and areas travel as files.
✅ Copernicus layers & figures Writes composite, index and script layers offered in every map, reads one as a Detect rule, and lays several renderings of a pass out as a captioned figure.
✅ Capture extension Adds case map tools to third-party maps, hands media to publishing and reverse search sites, and supports extension updates.
✅ Home, guide & onboarding Opens recent work and task lists from Home, pictures every tool in the ? guide with three walked journeys, tours a newcomer and opens each version on its What's new.
✅ Inspect & Collage Autosaves work per file, captures the frame on screen with frames, marks and sound along the bar, arranges frames into collages straightened by a level line, and sends pictures to reverse search.
✅ Proof annotations & publishing Adds markers, blurs, tags, callouts, zoom insets and view cones, free or tied across panels at one line width, verifies proof points and carries proof dates into post templates.
✅ Dates & Timeline Shares date entry and clock selection, draws temporal precision explicitly and adds cited events from any tool.
✅ Subjects & case analysis Corrects and merges subjects, indexes their events, searches across scripts and reviews proposed account and site connections.
✅ Geolocation worklists Opens recent sheets, tracks imported files awaiting a proof and indexes every proof point with its date, source and coordinates.
✅ Files & navigation Files work into the active folder, offers contextual actions and filters, opens media in one full-screen viewer, and retraces tools and documents with guarded Back and Forward.
✅ Command palette Ctrl+K or ⌘K searches tools, cases and current-case documents, starts with recently added items and protects unsaved work.

6. Roadmap

Each version delivers one complete daily workflow. Firm ideas move here from §7. New tools become tabs or modes in an existing workspace (see UI.md). Releases ship as GitHub v0.x tags.

v3: GEOINT expansion

Tool What it does
One-click update (urgent, 0.3.4) The binary installs the next release in one press: it downloads beside itself, checks an Ed25519 signature made outside GitHub, starts the new binary once, swaps by renaming, restarts and keeps the old one to fall back on. Any failure leaves the installed version untouched and links to the release page; a pip install is told its command. Rehearsed on a pre-release before 0.3.5 relies on it.
Fires on the globe Draws active fires on the globe within their allowance.
Camera Resection (GCP) Marks matching points photo↔map, then solves camera position, viewing azimuth and rough FOV (OpenCV solvePnP) and saves the match as evidence. Its photo canvas and pixel↔angle camera frame are built for two callers: Sky Clock fills the same frame by hand.
Capture graticule The rest of what a plate states about itself: a latitude/longitude grid over app and extension captures, beside the scale bar and north arrow that already ship.
Image Compare Overlay two images with opacity, swipe and pixel diff. Assist satellite-to-screen alignment without presenting a verdict.
Georeferenced overlay Pins an image to the ground by three or four matching points: a commercial satellite shot from a post, a drone frame, an old plan. It draws under the map's own marks with an opacity slider, reprojects as the map pans, and is saved in the case with its control points so the fit can be checked.
Adopt a feature Turns a feature of an added layer into a place of the case, carrying the layer and the feature it came from as provenance.
Source directory Keeps the accounts, channels and pages worth following for this case, searchable by platform, area and topic, with notes and source reliability; monitoring remains a later opt-in workflow.
Metadata follow-up Explains which common image/video fields were stripped and proposes events from capture times.
Edit Provenance Reads a rendered video's own edit history: which source clips it was cut from, in what order, and the GPS, dates and cameras those clips still carry.
Sky sessions Saves a sun or moon lookup as a case artifact: the point, the date and the time, never the numbers they produce. It reopens where it was left, a proof can show its reading, and a statement can cite it.
Grid sessions in the graph Brings the saved AOI grids into the case as entities, adopting the specs already on disk. Grid Search is the last saved tool state living outside the graph, so today nothing can say "this sweep is how I found it".
Sky Clock Marks a shadow, the sun or the moon in an image or a video frame, with the horizon and north giving the angles, then renders the year as a day × hour heatmap of the slots that fit. A visible moon also carries phase and bright-limb angle, which usually cuts a year down to a few instants.
Case KMZ One self-contained file per case: a pin per place, carrying the notes and proof images it is linked to, opened in Google Earth. Frozen rather than live, because only the web Earth remains and it follows no network link.
Event layers The rest of what dates an event from the sky: archived weather and METAR, beside the fire detections that already ship.
OCR Reads signs and plates on import (tesseract, a native binary rather than a wheel), and detects script and language.
Audio Transcript Transcribe and translate speech offline; flag acoustic context such as bells, adhan, aircraft or language.
Ground Imagery Ground-level photos: Panoramax/Mapillary/KartaView key-less first; Street View easy link, optional keyed in-app view.
Panorama Stitch a video window / frame set. Auto-stitch already in Collage; still to do: sample a video window directly, seam blending.
Detached tool windows The rule the map already follows, applied to the rest: a read-and-work surface (Board, Graph, Timeline) opens as many tabs as wanted and the tab it left stays live; a document editor opens one window per document and is greyed out where it was. Cross-tool handoffs route to wherever the tool now lives.

Toward v3: GIF maker; curated tool links; full-text case search; clipboard image/URL capture with provenance; EXIF/GPS import suggestions for place and time; sun and moon times read against the terrain horizon the 3D map's DEM supplies, since a ridge ends the day well before the flat horizon does.

v4: investigation layer

Tool What it does
One sky frame Find's skyline, Camera Resection and Sky Clock read in one azimuth and elevation frame, so the sun and moon times the relief hides split the places a matching skyline leaves tied.
Evidence Locker Track SHA-256, timestamps, source and notes; archive with Wayback; export evidence.jsonl under a hash-chained manifest, so any later edit to an exported file is detectable.
Report Builder Assemble proofs/maps/timeline/entities/notes into PDF or one self-contained HTML file with its media embedded, readable offline.
Case Sync (Git) Push a case to a private or public Git remote, pull it back, and diff two revisions, so two analysts can work the same case.

Toward v4: archive-on-download and a Wayback CDX snapshot timeline with diff; web-page save extension; provenance stamp on exports (short hash, optionally visible) that re-identifies a shared PNG in its case; source location pattern-of-life map and timeline; cross-case handle/coordinate/face search; optional quota-aware X publishing.

v5: orchestration and advanced

Tool What it does
Search Orchestrator Run username/alias/email across services, analyst selects → entities. Integrations, not clones.
OSM Query (Overpass) Feature search from a form, and a described pattern ("filling station, roundabout, railway within 300 m") turned into candidates on the map; clicking a point looks it up in OSM, Wikidata and geolocated Commons photos. No Overpass QL.
Camera Track (video SfM) Solves a moving camera's path from a video: frames sampled from a window, position and viewing azimuth per keyframe, and a sparse point cloud. Reports insufficient parallax instead of guessing. Bundles a native SfM binary (COLMAP/GLOMAP), CPU-capable.
Vessel and Aircraft Tracks Historic ADS-B and AIS tracks on the map for a date, plus a watchlist that follows chosen callsigns or MMSIs.
Map Measures Measure on a resected photo's imagery, and a bearing layer that absorbs the v2 sun/moon arcs.
Déjà Vu Perceptual-hash index flags recycled footage (local first; community index later).
Manipulation Hints Add JPEG quantization, noise and AI-media hints alongside Inspect's ELA.
Channel Monitor Watch Telegram channels, auto-archive media, queue for geolocation (rate limits, ToS care).

Toward v5: real-world measurement from a resected photo or a solved camera track and its GCP camera pose; a gaussian-splat round trip for a solved camera track; satellite-pass search from public TLEs; 3D satellite capture; Google Photorealistic 3D Tiles on the user's own key; non-destructive identity resolution for duplicate entities returned by orchestrated searches.

7. Loose ideas

No version yet. Promote an idea when its workflow is clear; delete it when it stops making sense.

  • Media in the analyst's half: a button that looks for media beside azimut/ and offers to bring them into the case, rather than waiting for them to be moved into media/ by hand.
  • Count a statement's independence by origin, not by wrapper: three collages made from one video are three sources today, and are arguably one. The graph already answers this for a place; changing it for a statement changes a published number.
  • Free-form montage editor: consider only if it stays distinct from Geo Proof and the Collage tool.
  • In-app OSINT assistant: local chat and vision suggestions for analyst confirmation, with no cloud or API key by default.
  • Geographic playback: step through dated case items on the map instead of showing one fixed Timeline window.
  • More on the home page: the case's own notes beside the tiles, and panels the analyst arranges rather than a fixed grid. Each has to earn its place there rather than beside Board, Graph and Timeline, which already read the case.
  • Radar damage from a stack of passes: the pixel-wise t-test (PWTT) over a year of passes before and weeks after, which two passes cannot match.
  • Oil slicks by radar: dark patches on the sea near anchorages and lanes, which Sentinel-1 shows through cloud.
  • Map files out of the case: export pins, claims and Detect findings as KML or GeoJSON, with TimeStamp and TimeSpan so another viewer's time slider reads them.
  • Update ffmpeg from the app: download a static build into the workspace and prefer it at runtime, like the scraper update, if the bundled copy ever lags in a way users hit.
  • Vector text in plate PDFs: the PDF holds the page as one print-resolution picture; selectable text needs the plate's faces as TTF on the Python side.
  • Place names kept whole at a plate map's edge: the engine cuts a name the frame crosses; placing them away from the frame would need its own label pass.
  • A Sentinel-2 pass per day of a played plate: a plate's map holds one dated pass; following the play's days would spend the analyst's quota on every export.
  • Place names in their own script: the Arabic or Cyrillic name under the Latin one, for searching local sources. Needs the engine's right-to-left text plugin, bundled rather than fetched.
  • Free band formulas in Detect: a rule read on an expression the analyst writes. A normalised difference and a single band already work, including from a layer they wrote, so what is left is the general case — an arbitrary expression needs its own product family, a generated evalscript and thresholds calibrated on real scenes.
  • A deleted case waits before it is gone: artifacts, entities and bulk deletes are all recoverable, while removing a case is the one act with no way back and only a typed DELETE in front of it. Move the folder aside instead, and empty it later.
  • A fire detection to click: the points the app already draws close in, read back under the pointer for the detection's time, satellite, confidence and power.
  • A live public map: a layer published as GeoJSON at a public address (a Gist) that a uMap remote-data layer reads, so one press updates a map others follow.
  • Dated layers by side in Compare: a GeoConfirmed or other dated layer showing on each side only what was known by that side's date.
  • Find, narrower still: near a road or a track (OpenFreeMap's transportation layer, a line decoder and a tile cap per area), turns kept between searches of one area, a mirrored place shown flipped in Overlay, and the lens searched for a collage laid wholly by hand.
  • Sun and moon on the globe: the bodies in the 3D view's sky at the hour the Sun & moon panel is on, and the relief lit from where the sun stands then.
  • The sky over the area, not the tile: Detect's pass list and its newest pass judged by the cloud over the drawn area (one small SCL read per pass) rather than the 110 km tile's figure.
  • A mark of authorship on Proof and Plate exports: a faint pattern in the pixels, drawn from a key kept on the analyst's machine, that survives a screenshot or a light retouch and that only that key can find. A signed hash beside the file would say the export is untouched.

8. Explicit non-goals

  • No cloud, accounts, hosted service, or telemetry.
  • No automated geolocation verdict; Azimut files facts for the analyst.
  • No rebuilding specialized OSINT services; Azimut orchestrates them.
  • No block-evasion scraping. User session cookies are in scope; third-party downloader proxies are not because they re-encode media and expose targets.
  • No auto-posting by default. An optional, opt-in X/Twitter API key (Settings, with quota shown) may enable Geo Report publishing. Core features never require a paid API.

9. Architecture

  • Backend: Python 3.11+, FastAPI on localhost; current processing (ffmpeg, yt-dlp, gallery-dl, OpenCV) runs server-side.
  • Frontend: Svelte + Konva/canvas, served by the backend, opened in the default browser. The map is MapLibre GL behind lib/map's façade, so tools speak points, positions and view events and never the engine. Satellite's 3D view is a WebGL2 globe of the app's own (lib/globe) answering the same façade while it is on, and drawing the flat map's own layers by reading its style (lib/globe/mirror.js); a plate's 3D map stands on the same globe. Rail = workspaces in pipeline order, tools are tabs inside them (see UI.md).
  • Settings and secrets: in-app tabs group general preferences, publishing, imagery, templates, the capture extension, storage and system tools; keys stored locally and never bundled into a shared case, monthly usage counters, backup export/import, opt-out "new release is live" pop-up on load (per-version "don't show again"). Display preferences affect presentation only; artifacts keep decimal degrees + metres on disk.
  • Distribution: pip install azimut plus PyInstaller single-file binaries for Windows x86_64, Linux x86_64 and Apple Silicon macOS. Binaries bundle a static ffmpeg/ffprobe with its licence notice and texts (Settings → System → licence); pip installs still want ffmpeg on PATH. Intel macOS uses the Python package.
  • Dependencies: ranges in pyproject.toml, exact pins in uv.lock; yt-dlp
    • gallery-dl unbounded on purpose; scraper self-update keeps an old binary useful. gallery-dl (GPL-2.0-only) is never imported: it runs as its own process through its command line (engine/gallerydl.py), the binary starting itself as gallery-dl.
  • Storage: per-case SQLite case.db is the authoritative graph (files for media/notes/proofs); deleted artifacts wait in .trash/, and portable case bundles carry a cleaned database plus declared files under a SHA-256 manifest. Legacy case.json cases migrate on open; case open and lists use bounded, cursor-paged queries; thumbnails and background work run through a durable, recoverable per-case job queue drained by one worker. Details in STORAGE_AND_PERFORMANCE.md.
  • Security posture (single-user localhost): 127.0.0.1 bind + Host/Origin guard (DNS rebinding), which also refuses a foreign page's Sec-Fetch-Site on the API and the case files, since an image or a link sends no Origin on a GET, and lets no other site frame the app, where a hidden frame would make the analyst's clicks its own; 0600/0700 perms, hard 100 MP Pillow limit, content-hashed names for images pasted into a proof (no client-chosen path), token-gated ingest island for the extension. A case file is served nosniff, and under a sandbox policy unless its type only displays, so an SVG or a page that arrived in a bundle never runs script in the app's origin. The one route that reads a case file back out of that island — the attachments a composer hand-off carries — fences on the resolved path, so media/../case.json is refused where a prefix read off the request would have served it. Filling a composer and handing a picture to a reverse-image engine are the extension's only reach past localhost — eight hosts, declared, where it writes what the app gave it and reads nothing — and each switch that uses one is in the app (Settings → Publishing, Settings → General), where the analyst already decides how a thread is published and which engine gets the picture. The engine road carries the image itself rather than a path, since what Reverse Search prepares is a canvas frame that exists nowhere on disk, and it is the one hand-off whose page acts on what it is given: these engines search as soon as they hold a picture, which is what the button was pressed for. Seven of those hosts are the engine or the composer itself; the eighth is www.google.com, which is broader than the rest and is an accepted risk rather than an oversight: Lens redirects lens.google.com to the search home page and draws its uploader there, so the grant has to cover wherever that redirect lands. It buys nothing beyond that — the extension injects only into a tab it opened itself, at a URL the app handed it, and reads nothing back. Updating that extension writes the app's own bundled bytes into one fixed workspace path and takes nothing off the request — no path, no payload — so it sits on the settings router rather than in the ingest island, where the extension-origin CORS would have reached it; the message that then restarts the extension is only reachable from the page on the port the extension is paired with (any other localhost port is refused, told which address to set, and may only ask which copy is loaded; hand-offs open only the posting sites and image engines the app offers), names the install it means, and its worst outcome is an extension that restarts. The map tools widen that island by the read routes and two writes the worker's allowlist names, each trimmed to what a panel draws — one position's points without their thumbnails or link tallies, a sweep's own spec, a case's images and videos by name, a reference clip's frame rate and length — and the panel itself reaches them only through the worker's own allowlist, since a content script's fetch would carry the map site's origin and be refused. It is drawn in a closed shadow root and acts only on events the browser dispatched, so the map site can neither read the panel nor press it. Keeping those panels in step adds one more, and it is the narrowest of them: a read-only stream of what changed, never of what it says, so an event names a case and a file and the panel re-reads it through the routes it already had. The worker holds it and no panel is given it, which is the same fence as the rest — and it is deliberately not on the relay's allowlist, being one answer that never ends. The bytes of a picture come back over the hand-off's own route, behind the same fence: media and proofs, resolved, and nothing else in the case. A case id and an artifact name each address one directory entry, checked against POSIX and Windows path rules so the separator only one of them honours cannot walk out of the workspace. The workspace pointer is the one file written outside the workspace, 0600 and holding a path; deleting the copy a move set aside acts on this process's own memory, never on a path from the request. Accepted risks recorded here: cleartext keys over localhost, the hash-verified scraper updater, Intel macOS staying on cryptography 48 for want of later wheels (Azimut uses it for AES-GCM only, not the X.509 verifier its two open advisories concern), the release workflow's publish job running softprops/action-gh-release and pypa/gh-action-pypi-publish on mutable refs while it holds the PyPI OIDC identity (the branch ref is the form PyPA documents; every other action in the workflows is pinned by tag or by commit), the CLA workflow's write token on pull_request_target (it never checks out the pull request's code, and its one action is pinned by commit), tile/media URL fetches (SSRF only matters if the localhost assumption breaks), and a download that fails saying only that the content is unavailable being retried with the stored browser session, so a merely deleted post gets the analyst's cookies — kept because a hundred-row press cannot stop on a question and the first attempt is always cookie-less. A sheet's link check refuses a literal loopback, private or link-local address on the first hop and on every redirect; a hostname that resolves to one is not looked up to find out, and what such a hop could learn is "this port answered" and never a body. An imported workbook is bounded on its compressed bytes and on the size its own directory declares once unzipped. An added map layer is the second untrusted archive and the first untrusted XML: a KML is parsed by defusedxml, which refuses an external entity and an expansion bomb, under bounds on size, feature count and nesting depth, and a KMZ is a zip checked for an escaping member name, its uncompressed total and its compression ratio before a byte of it is read. The browser never sees any of it — it is handed the parsed GeoJSON, with every description stripped of markup at the boundary rather than rendered. A layer's own icons are the one thing it can ask a third-party host for, on an explicit tick at import and never afterwards, and the accepted risk is bounded on both ends: what goes out is a per-image GET under a count, a size and a total cap, and what comes back is decoded, tinted, resized and re-encoded here, so an SVG carrying a script, a file pretending to be a PNG and a thumbnail that unpacks into a gigabyte are one refusal rather than three checks. The browser only ever loads PNGs this process produced, from localhost, keyed by content hash. Following a public Google My Maps uses google.com/maps/d/kml?mid=…, the KMZ rather than the forcekml=1 conversion beside it: both carry the same placemarks, but the archive bundles the creator's actual icons as members of itself, while the conversion throws the pictograms away and points every style at one of three blank Google containers. It is undocumented, and is an accepted risk recorded here rather than one taken silently: SPEC §2 refuses the unofficial key-less endpoints of keyed services (the mt1.google.com case), and the distinction drawn is that this is the sharing mechanism the map's own creator switched on, not a way around a quota. It is fetched only when the analyst subscribes, presses Refresh, or switches the layer on for the first time in a session, when it asked to be re-read then. A layer received in a bundle is not re-read on switch-on, since its sender set that and chose the address; it waits for a Refresh pressed here. A case reopens on the layers it had on, drawn from their saved copy with no fetch, except one that stopped the last session while drawing, so a layer heavy enough to take the tab down does not take it down again on reload; a shape it stops answering in fails with a sentence rather than drawing nothing. A GeoConfirmed layer rides on those same three acts, plus one: its dialog reads the conflict list when the analyst opens it. Each read is GeoConfirmed's documented, key-less public API, through the backend and under a User-Agent naming the app, as it asks integrations to do; its robots.txt disallows /api/ for crawlers, which a read the analyst asked for is not. The icons arrive inside the export, so they cost no request. The map's search bar answers from a bundled gazetteer and never reaches out on a keystroke; its geocoder layer waits for a pause, and a request the one-per-second pace cannot take is dropped rather than queued. Two things reach out on mount and no others. The startup update check: opt-out, and read-only against GitHub's releases feed plus PyPI's JSON for the two downloaders, both governed by the same switch. And the home page's map of the case, which fetches basemap tiles for the points the case already holds — through the same proxy as every other map, from the keyless unmetered provider only, so it spends no allowance and asks for nothing a case with no saved point would. Release notes are rendered through the Notebook's DOMPurify-sanitized Markdown renderer rather than as raw HTML. The capture extension is compared locally, so it is answered with the switch off — except the Firefox copy, which Mozilla signs and the browser therefore updates itself: it polls the release's update manifest on its own schedule, past any switch the app has, and is recorded here as an accepted risk for the only permanent Firefox install that exists. Horizon's buildings reach their hosts only while their switch is on: OpenFreeMap, the Géoplateforme's WFS, source.coop (the 3D BAG), NRW's OGC API, NYC Open Data, Overture's catalog and tiles, figshare (3D-GloBFP) and Google's public bucket (2.5D heights). A 3D-GloBFP grid, Google's heights or Overture's footprints are read only after the analyst says yes to their size. They are third-party binaries parsed locally (a zip, a shapefile, a PMTiles archive, a GeoTIFF), an accepted risk bounded by fixed hosts and readers that refuse what they do not know: zip members are written by their stem only, never by their path. A plate's Sentinel-2 cloudless ground reaches EOX's tile server (tiles.maps.eox.at) only once the analyst picks it, through the same proxy as every basemap; the years it offers and their licences are answered by the app. Remote images embedded in a Notebook note contact their host whenever the preview opens; Notebook warns about that behavior and local Case media avoids it. Notebook diagrams are the one markup DOMPurify does not clear: Mermaid draws its SVG into the preview after sanitizing, under its own strict level, which escapes labels and drops click handlers. Three routes take a picture drawn in the browser back: the note PDF export, whose request, diagrams and decoded total are bounded before rendering, every diagram read as an image and the note's own text re-read from disk rather than trusted from the request; the analysis plate, bounded the same way and inspected before it is written, since a plate lands where documents are opened — it must start as an SVG and carry no script, event handler, embedded document or reference leaving the file; and saving a proof, which posts the composer's rendered export and the images pasted into it, bounded as a request and again as a decoded picture. A map plate's export is bounded as a request too; a played plate's pictures come first in bounded batches, are checked by their header (a PNG or a JPEG, bounded in pixels) and kept on disk as they came under a random token, so ffmpeg is what decodes them; the export, a Stop or 15 idle minutes lets them go. Every body the browser assembles whole — a table, a note, a picture — is refused by size before it is parsed, and the routes are not trusted to a list: tests/test_hardening.py walks them. Case imports extract only unique, non-symlink members declared by the manifest and matching its SHA-256. Password-protected bundles seal the complete ZIP with chunked AES-256-GCM and a scrypt-derived key; filenames stay encrypted and the password is never persisted in a job. Import temporarily stages a decrypted ZIP inside the incoming case directory. Imports validate declared and actual sizes, reserve filesystem headroom and warn above 10 GiB; downloads and generated files still have no app quota.

10. Open questions

  • Source reliability sits on the bookmark or the account cited. Reopen it the day a source is neither: a paper document, a testimony.
  • Déjà Vu community index: needs infrastructure and moderation; out of scope until v5.
  • Name/handle availability: GitHub org/repo azimut, x.com handle, domain.