README.md

---
license: mit
library_name: pytorch
pipeline_tag: image-to-image
tags:
  - satellite-imagery
  - remote-sensing
  - super-resolution
  - image-outpainting
  - flow-matching
  - generative-model
---

# Genesis

**A Generative Engine for Hierarchical Satellite Image Synthesis** — ACM SIGSPATIAL 2026 (Oral).

[![Project Page](https://img.shields.io/badge/Project-Page-2ea44f)](https://subash-khanal.github.io/genesis)
[![arXiv](https://img.shields.io/badge/arXiv-2609.02683-b31b1b)](https://arxiv.org/abs/2609.02683)
[![Code](https://img.shields.io/badge/GitHub-Code-181717?logo=github)](https://github.com/mvrl/genesis)

![Genesis: sparse seed tiles → full multi-scale quadtree](assets/task.png)

Genesis completes a sparse set of seed satellite tiles into a full, zoomable Web-Mercator
**quadtree** — filling every scale and location. Two flow-matching *JiT* operators do the work: a
**parent-conditional super-resolution** model (one 256×256 parent tile → the 512×512 mosaic of its
four children, one zoom level down) and a **mask-based outpainting** model (256×256 completion
under quadrant masks). Composed into a pyramid engine, they bring the seeds to a common working
level, greedily outpaint to complete that level, super-resolve down to the leaf tiles, and fill the
coarser levels by downsampling — yielding a pyramid that is consistent across scales and honors
every seed. Models are trained on the Git-10M global tile corpus.

*Subash Khanal, Yangzhi Cui, Daniel Cher, Eric Xing, Brian Wei, Srikumar Sastry, Nathan Jacobs —
Washington University in St. Louis.*

![The Genesis pyramid-completion pipeline](assets/pipeline.png)

## Checkpoints

All models sample with **50 flow-matching steps, cfg = 1.0** (the paper eval setting) and load
**EMA** weights. Main runs are trained to 800k steps. The main SR models are DINOv3-conditioned
(+LPIPS); the main outpainting models are no-DINO.

| Path | Model / arch | Size | Train steps | What it's for |
|---|---|---:|---:|---|
| `main/superresolution/main_B16/sr-full-tile-stage3-step0800000.ckpt` | SR · JiT-B/16 | 3.3 GB | 800k | **Main SR** (DINOv3 + LPIPS), 256→512 |
| `main/superresolution/main_H16/sr-full-tile-stage3-step0800000.ckpt` | SR · JiT-H/16 | 23 GB | 800k | **Main SR**, largest model (quick-start default) |
| `main/outpainting/main_B16/op-new-stage3-step0800000.ckpt` | OP · JiT-B/16 | 3.6 GB | 800k | **Main outpainting** (no-DINO, quadrant masks) |
| `main/outpainting/main_H16/op-new-stage3-step0800000.ckpt` | OP · JiT-H/16 | 26 GB | 800k | **Main outpainting**, largest model (quick-start default) |
| `shared/git10m_quad_meta.json` | metadata | 1.7 GB | — | Git-10M split metadata (paper eval) |
| `shared/hierarchy_index_quad.pkl` | metadata | 0.6 GB | — | Parent↔child quadtree index (paper eval) |
| `dinov3_vitl16_pretrain_sat493m-eadcf0ff.pth` | DINOv3 ViT-L/16 (SAT-493M) | 1.2 GB | — | Frozen conditioning encoder for SR |

The `ablations/` folder holds additional checkpoints used only to reproduce the paper's ablation
table (see the [code repo](https://github.com/mvrl/genesis)'s `docs/EVALUATION.md`).

## Quick start

Install the code repo (checkpoints download from this HF repo automatically):

```bash
git clone https://github.com/mvrl/genesis && cd genesis
uv sync && source .venv/bin/activate    # Python 3.13, torch 2.8 cu128
```

Then run one SR ×2 pass and one quadrant-outpainting pass on a **live Esri World Imagery tile**
(a Bavarian village amid fields and forest, at zoom 16, serves as the dummy input — the script
fetches it over the network). The JiT-H/16 checkpoints total ~49 GB on first download; swap `H16`→`B16`
in the two checkpoint paths for a lighter 7 GB variant:

```python
import os, sys
sys.path.insert(0, "src"); sys.path.insert(0, "demos")

from huggingface_hub import hf_hub_download
from PIL import Image
from utils.genesis_common import (fetch_tile_at_zoom, inference_device,
                                  load_sr_denoiser, load_op_denoiser,
                                  outpaint_context_white_holes_preview,
                                  run_superresolution, run_outpainting)

device = inference_device()                       # cuda if available, else cpu
out = "logs/example_sr_op"; os.makedirs(out, exist_ok=True)

sr_ckpt = hf_hub_download("MVRL/genesis", "main/superresolution/main_H16/sr-full-tile-stage3-step0800000.ckpt")
op_ckpt = hf_hub_download("MVRL/genesis", "main/outpainting/main_H16/op-new-stage3-step0800000.ckpt")
dino    = hf_hub_download("MVRL/genesis", "dinov3_vitl16_pretrain_sat493m-eadcf0ff.pth")

tile = fetch_tile_at_zoom(lon=12.9062, lat=48.6529, zoom=16)   # a real 256×256 tile (Bavarian village)
tile.save(f"{out}/01_original_tile.png")

# SR: z16 parent → 512×512 mosaic of its four z17 children.
# Showcase config = the paper's pyramid-engine SR settings (cfg 2.5 + bicubic
# warm start); the engine reads `cfg_scale`, so set the attribute (not args.cfg).
tile.save(f"{out}/02_sr_input.png")
tile.resize((512, 512), Image.BICUBIC).save(f"{out}/03_sr_bicubic_512.png")  # baseline SR starts from
sr_model, _ = load_sr_denoiser(sr_ckpt, "JiT-H/16", dino_weights=dino, device=device)
sr_model.cfg_scale = 2.5
sr_model.args.bicubic_init = True
sr_model.args.bicubic_init_t_start = 0.4
run_superresolution(sr_model, tile, device, target_zoom=17).save(f"{out}/04_sr_output.png")

# OP: keep the upper-left quadrant real, outpaint the other three (white = hole)
mask = Image.new("L", (256, 256), 255); mask.paste(0, (0, 0, 128, 128))
op_model, _ = load_op_denoiser(op_ckpt, "JiT-H/16", dino_weights="", device=device)
outpaint_context_white_holes_preview(tile, mask).save(f"{out}/05_op_masked_input.png")
run_outpainting(op_model, tile, mask, device, tile_zoom=16).save(f"{out}/06_op_output.png")
```

Every input and output lands in `logs/example_sr_op/`, numbered in pipeline order — original
tile, SR input / bicubic baseline / SR output, masked OP input, outpainted OP output. The SR
pass technically starts from the bicubic upsample (the warm start anchors on it), so comparing
`03_sr_bicubic_512.png` against `04_sr_output.png` shows exactly what the model adds beyond
plain interpolation.

Or as a one-liner, using the copy shipped in the code repo —
[`demos/example_sr_op.py`](https://github.com/mvrl/genesis/blob/main/demos/example_sr_op.py):

```bash
python demos/example_sr_op.py
```

> Live imagery: Esri World Imagery — Source: Esri, Maxar, Earthstar Geographics, and the GIS User
> Community.

## Demos

Interactive Gradio apps live in the code repo — see
[`demos/README.md`](https://github.com/mvrl/genesis/blob/main/demos/README.md).
The main one is the **full-pyramid builder** (`demos/app_pyramid_unified.py`): click a satellite
map to drop sparse seed tiles and watch Genesis complete an entire 4-level quadtree live,
tile-by-tile, with a stitched-PNG download. Companion apps cover single-tile 256→512 SR, quadrant
outpainting, a large lateral-outpainting grid, a deep 6-level pyramid, and no-model interpolation
baselines.

## Reproduce the paper

One command per paper table — see
[`docs/EVALUATION.md`](https://github.com/mvrl/genesis/blob/main/docs/EVALUATION.md)
in the code repo:
`bash src/eval/run_all_sr.sh` · `run_all_op.sh` · `run_all_ablation.sh` · `run_all_dense500.sh`,
each with the paper-exact defaults baked in.

## Citation

```bibtex
@inproceedings{khanal2026genesis,
  author = {Khanal, Subash and Cui, Yangzhi and Cher, Daniel and Xing, Eric and Wei, Brian and Sastry, Srikumar and Jacobs, Nathan},
  booktitle = {ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems (ACM SIGSPATIAL)},
  title = {Genesis: A Generative Engine for Hierarchical Satellite Image Synthesis},
  doi = {10.1145/3841645.3843313},
  month = nov,
  year = {2026},
  pdf = {https://arxiv.org/pdf/2609.02683},
  archiveprefix = {arXiv},
  primaryclass = {cs.CV},
  eprint = {2609.02683},
  code = {https://github.com/mvrl/genesis},
  project = {https://subash-khanal.github.io/genesis/},
  huggingface = {https://huggingface.co/MVRL/genesis}
}
```

## License & acknowledgments

The Genesis code and checkpoints are released under the **MIT License** (see the
[code repo](https://github.com/mvrl/genesis)). Both Genesis operators build on
[JiT](https://github.com/LTH14/JiT) — we thank the authors for releasing their codebase.

`dinov3_vitl16_pretrain_sat493m-eadcf0ff.pth` is the satellite-pretrained (SAT-493M) ViT-L/16
encoder from Meta AI's [DINOv3](https://github.com/facebookresearch/dinov3) release, redistributed
here unmodified for convenience; it remains governed by Meta's DINOv3 license, not MIT. At
inference the SR model loads it via `torch.hub.load('facebookresearch/dinov3', 'dinov3_vitl16',
weights=...)`.

Training data comes from the [Git-10M](https://huggingface.co/datasets/lcybuaa/Git-10M) global
satellite-tile corpus. Demo/example imagery is fetched live from Esri World Imagery (attribution
above).