Kesowa · Open Source
Kesowa builds ARU, a platform for flying drone missions and turning what comes back — video, telemetry, aerial imagery — into maps people can work with. This is everything we have opened up: the platform itself, the infrastructure that runs it, and the research that fed it.
The running system, split the way it is deployed: a browser client, an API, and the Rust workers that do the heavy processing behind them.
The operator's web front end, covering the whole life of a mission: planning it, watching live video and telemetry arrive, then viewing, annotating and digitising the imagery and maps that come out of it.
React, TypeScript and Vite. Mapping is deck.gl and Mapbox GL drawing Cloud-Optimised GeoTIFFs served through TiTiler; live video arrives over RTMP and HLS.
The API and real-time backend: authentication and multi-tenant authorization, mission planning and lifecycle, live telemetry and video stream coordination, and the pipeline that turns raw drone deliverables into map layers.
Node.js and TypeScript on Express, with MongoDB for data, Redis for caching, RabbitMQ for dispatching work to the processing workers, and MinIO or S3 for object storage.
Rust workers that consume jobs from a RabbitMQ queue, stream data in and out of S3-compatible storage, and publish a result back. Between them they cover archive decompression, GeoTIFF handling, video transcoding and ONNX model inference.
The design goal throughout is to stream rather than buffer — drone deliverables are large, so a worker should get through a multi-gigabyte archive or raster without holding it in memory.
Read the dev branch. The default branch is behind; active work happens ondev.
Turns uploaded drone video into streamable video-on-demand. It takes a job off the queue, pulls the source file from object storage, and writes back an HLS rendition, a subtitle track and a thumbnail. GStreamer does the transcoding.
How ARU gets deployed, at three different scales. These are published so the architecture can be read end to end, not as drop-in templates — they carry our cluster names and our assumptions.
The deployment monorepo — a Docker Compose stack that brings the whole system up together: web client, API server, database, object storage, raster tiles, live streaming and TLS, with the application code pulled in as git submodules.
The name is the repository's own joke: a monolith of ARU.
Kubernetes manifests for ARU on AWS EKS. Plain manifests applied with
kubectl — no Helm chart, no Kustomize overlays. Queue depth
drives worker autoscaling through KEDA.
secrets.example.yaml shows the shape to fill in.
Work that answered a question. Some of it became part of the platform and some of it stopped where it was; both are here as they stand.
Human-in-the-loop tree detection for aerial and drone imagery. It runs DeepForest over a GeoTIFF, shows you the predicted bounding boxes, lets you correct them by hand, then fine-tunes the model on your corrections — each round producing a new model version you can switch between.
A FastAPI service does the inference and training; a PyQt5 desktop application is the annotation surface.
The name is historical. It no longer uses MONAI Label; the repository kept the name it was created with.Computer-vision experiments built between 2021 and 2025, mostly aimed at pulling information out of drone and aerial imagery. Each top-level directory is an independent project with its own dependencies.
This is research code published for reference. It is not a library, there is no common interface, and the projects vary in completeness — some were prototypes that answered a question and stopped there.
Model weights are not MIT. Several derive from upstream models under their own terms, some of them research-only. The repository'sNOTICE lists which.
A prototype for identifying lending opportunities from hyperlocal map data: putting loan demand and supply on a map, so an opportunity can be assessed geographically rather than only from an application form.
Two independent pieces — an Expo and React Native client with Mapbox maps, and a Go backend on Gin with PostgreSQL and generated Swagger docs.
Our take-home assignment for back end candidates: build a Node.js REST API
that ingests geospatial imagery and extracts location information from it.
The test suite in __tests__/ defines the contract — the job is
to make it pass.
It is open so candidates can read the task before applying, and so anyone can judge whether the tests are fair. It is not a production service.
Everything here is MIT, with one exception: terraform is
MPL-2.0, inherited from the HashiCorp example it started from.
Model weights are a separate question from code. Where a repository ships
weights it did not train, its NOTICE file states the terms,
and some of those are research-only.
Each repository has a CONTRIBUTING.md covering how to get it
running locally and what we look for in a pull request. Issues and pull
requests are both welcome.
These repositories are published as they are used internally, so some default branches lag behind the branch where work actually happens. The README says which, where it matters.
Please do not open a public issue for a vulnerability. Every repository has a
SECURITY.md with the reporting address and what to expect
after you write.