| --- |
| 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). |
|
|
| [](https://subash-khanal.github.io/genesis) |
| [](https://arxiv.org/abs/2609.02683) |
| [](https://github.com/mvrl/genesis) |
|
|
|  |
|
|
| 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.* |
|
|
|  |
|
|
| ## 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). |
| |
