If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/hindupuravinash/the-gan-zoo shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 3y ago

• 17 active contributors
• MIT licensed
• ⚠ Stale — last commit 3y ago
• ⚠ Concentrated ownership — top contributor handles 63% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live hindupuravinash/the-gan-zoo repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/hindupuravinash/the-gan-zoo.

What it runs against: a local clone of hindupuravinash/the-gan-zoo — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in hindupuravinash/the-gan-zoo | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 973 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of hindupuravinash/the-gan-zoo. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/hindupuravinash/the-gan-zoo.git
#   cd the-gan-zoo
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of hindupuravinash/the-gan-zoo and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "hindupuravinash/the-gan-zoo(\\.git)?\\b" \\
  && ok "origin remote is hindupuravinash/the-gan-zoo" \\
  || miss "origin remote is not hindupuravinash/the-gan-zoo (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "gans.tsv" \\
  && ok "gans.tsv" \\
  || miss "missing critical file: gans.tsv"
test -f "update.py" \\
  && ok "update.py" \\
  || miss "missing critical file: update.py"
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "README.j2.md" \\
  && ok "README.j2.md" \\
  || miss "missing critical file: README.j2.md"
test -f "requirements.txt" \\
  && ok "requirements.txt" \\
  || miss "missing critical file: requirements.txt"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 973 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~943d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/hindupuravinash/the-gan-zoo"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

The GAN Zoo is a comprehensive, community-curated registry of named Generative Adversarial Network (GAN) architectures with paper links and GitHub repos. It solves the problem of tracking the explosive proliferation of GAN variants (3D-GAN, AC-GAN, StyleGAN, etc.) by maintaining a single authoritative TSV dataset (gans.tsv) that researchers can search, filter, and contribute to. The project auto-generates visualizations showing GAN growth over time and publishes the same data in markdown table format in README.md. Simple flat structure: gans.tsv is the authoritative source data (TSV with GAN name, paper URL, GitHub link); update.py is a Jinja2-driven script that reads gans.tsv and regenerates README.md and README.j2.md using the j2 template. cumulative_gans.jpg and The_GAN_Zoo.jpg are static visualizations. All contribution happens via PR edits to gans.tsv.

AI/ML researchers and practitioners who need a quick reference for GAN architecture names, paper citations, and implementations when reading papers or planning experiments. Also appeals to deep learning enthusiasts building surveys or tracking the GAN landscape evolution.

This is a lightweight, stable reference project rather than a software library. It has no automated tests, CI/CD, or version releases—it's a data curation repository maintained by a single author (hindupuravinash). Maturity is limited by the fact that updates depend entirely on manual PR reviews and TSV edits; there's no API, package distribution, or formal versioning. Best classified as 'actively maintained reference material' rather than production software.

Minimal technical risk since there is no running code to break; the risk is data quality and staleness. Single-maintainer dependency (no co-maintainers visible) means PR review latency could delay GAN additions. The requirements.txt contains 2018–2019 era pinned dependencies (Jinja2==2.10, matplotlib==2.2.3, requests==2.19.1) that are outdated but only used for build scripts, not runtime. No breaking change risk because there is no versioned API.

The repository is in maintenance mode—accepting PRs to add newly published GANs to gans.tsv. No major feature work is visible. The README hints at a Medium blogpost and a Deep Hunt newsletter integration, suggesting the project serves as promotional/educational content for the maintainer's broader AI community work.

git clone https://github.com/hindupuravinash/the-gan-zoo.git
cd the-gan-zoo
pip install -r requirements.txt
python update.py

This clones the repo, installs dependencies (Jinja2, BeautifulSoup, matplotlib for future visualization updates), and runs the update script to regenerate README.md from gans.tsv.

Daily commands: No 'running' in the traditional sense. To regenerate documentation after editing gans.tsv: python update.py. This will overwrite README.md and cumulative_gans.jpg based on the j2 template and TSV contents. No dev server or tests to start.

• gans.tsv — Core data source containing all GAN entries with metadata (name, paper link, year); every contributor must understand this TSV format to add new GANs
• update.py — Primary automation script that scrapes, processes, and generates the README and visualizations from gans.tsv; critical for understanding the data pipeline
• README.md — Generated output file displaying the curated list of GANs; reflects what users see and must match the gans.tsv source
• README.j2.md — Jinja2 template that defines how gans.tsv data is rendered into README.md; controls the output format and structure
• requirements.txt — Declares all Python dependencies (BeautifulSoup4, Jinja2, Pillow, matplotlib) needed to run update.py without breaking the pipeline

• gans.tsv (Plain text TSV) — Single source of truth for all GAN metadata; row format: name, paper title, arxiv URL, publication year; must be kept sorted and conflict-free
  • Failure mode: Malformed row (misaligned tabs, missing fields, invalid URL) breaks update.py parsing; breaks README generation
• update.py (Python, Jinja2, Pillow, matplotlib, BeautifulSoup4) — Orchestrates the entire build pipeline: reads TSV, validates/sorts data, renders Jinja2, calls matplotlib, writes outputs; idempotent on repeated runs
  • Failure mode: Exception (e.g., invalid TSV row, missing template, matplotlib error) halts build; outputs become stale
• README.j2.md (Jinja2 templating syntax) — Jinja2 template defining the structure and formatting of the final README; controls how GAN list is presented to users
  • Failure mode: Syntax error in template or undefined variables causes render failure; makes README unreadable or misleading
• README.md (generated) (Markdown) — Final output document consumed by GitHub; renders as the repo's homepage; must pass basic markdown syntax validation
  • Failure mode: Invalid markdown (e.g., broken links, unclosed code blocks) degraded GitHub rendering; user experience hampered
• cumulative_gans.jpg (PNG/JPEG image generated by matplotlib) — Time-series visualization showing growth of GAN count by year; provides at-a-glance trend insight
  • Failure mode: Image generation fails (missing data, matplotlib error) or becomes blank/corrupted; visual proof of growth is lost

• GitHub Repository → gans.tsv — Contributors submit pull requests adding or updating GAN rows; curator merges changes
• gans.tsv → update.py — Script reads TSV file, parses tab-delimited rows, extracts name, title, URL, year
• update.py → README.j2.md — undefined

Add a New GAN to the Zoo

1. Open gans.tsv and append a new row with format: GAN_NAME\tPaper_Title\tarxiv_URL\tYear (e.g., 'NewGAN\tMy Novel Architecture\thttps://arxiv.org/abs/XXXX.XXXXX\t2023') (gans.tsv)
2. Run python update.py from the repo root to regenerate README.md, cumulative_gans.jpg, and any other artifacts from the updated gans.tsv (update.py)
3. Verify the changes in README.md appear correctly and the image chart is updated with the new entry's year (README.md)
4. Commit gans.tsv, README.md, and cumulative_gans.jpg together to preserve consistency across the repo

Modify the README Layout or Styling

1. Edit README.j2.md to change how GANs are formatted (e.g., add columns, change sorting, adjust markdown structure) using Jinja2 syntax (for loops, filters, conditionals) (README.j2.md)
2. Run python update.py to render the template with current gans.tsv data and regenerate README.md (update.py)
3. Review the generated README.md to ensure layout, links, and formatting match your intended changes (README.md)

Update Dependencies or Add New Visualization

1. If adding a new Python library (e.g., for different chart types), add it to requirements.txt with a pinned version (e.g., 'seaborn==0.11.0') (requirements.txt)
2. Update update.py to import and use the new library (e.g., new matplotlib code paths for cumulative_gans.jpg generation) (update.py)
3. Test by running python update.py locally and verify all outputs (README.md, images) are generated without errors

• Python + update.py script — Lightweight orchestrator for data transformation; no need for a full web framework since this is a static, curator-driven project
• Jinja2 templating — Separates data (gans.tsv) from presentation (README.j2.md), enabling easy reformatting and experimentation without touching raw data
• TSV (Tab-Separated Values) for gans.tsv — Human-readable, version-control-friendly format that works seamlessly with pull requests; simple to parse in Python
• Matplotlib for cumulative_gans.jpg — Generates time-series visualization showing GAN growth trend; built-in to scientific Python ecosystem
• BeautifulSoup4 (implied by dependencies) — Likely used in update.py to scrape or validate arxiv URLs and metadata during periodic updates

• All data in a single gans.tsv file rather than a database

  • Why: Minimizes infrastructure; keeps data portable and mergeable for collaborative GitHub workflows
  • Consequence: Scales linearly; at 5000+ GANs, file size remains small (~200KB), but O(n) parsing for every update.py run; no indexing or querying ability

• README generated from template on each run rather than hand-edited

  • Why: Ensures README always reflects gans.tsv truth; no risk of manual drift; automation reduces contributor friction
  • Consequence: Contributors must never edit README.md directly—must modify gans.tsv or README.j2.md; requires discipline and documentation

• Static image (cumulative_gans.jpg) regenerated each run instead of dynamic charting

  • Why: Simple storage, fast rendering, no runtime dependencies for viewers; easy to track in git history
  • Consequence: Chart must be regenerated and committed to repo; cannot dynamically filter or zoom viewer-side; image size and format fixed

• No authentication, access control, or submission workflow; contributions via pull requests only

  • Why: Relies on GitHub's native PR review process; no custom backend required
  • Consequence: Curator must manually review every PR; no spam filtering or automated validation; doesn't scale to thousands of concurrent submissions

• Does not serve a live-updating web interface or API endpoint for GAN metadata
• Does not provide search/filtering beyond browser Ctrl+F on the generated README
• Does not automatically scrape arxiv or validate paper links at runtime
• Does not handle user accounts, authentication, or permissioned submissions
• Does not generate peer-reviewed assessments or citations; is a curation list only
• Does not support non-English content or multi-language translations

No environment variables, no external services required, no config files to set up. Gotchas: (1) gans.tsv is tab-separated, not comma-separated—copy-paste errors break the parser. (2) update.py must be run manually after TSV edits; there's no git hook or CI to enforce this, so the README can fall out of sync if someone merges a gans.tsv change without running update.py. (3) Links in gans.tsv must be absolute URLs or the markdown output will malform.

• Generative Adversarial Network (GAN) — The core concept this repo indexes; understanding the generator-discriminator adversarial training loop is essential to parsing GAN variant names and papers.
• GAN taxonomy / naming conventions — This repo reveals patterns in GAN naming (prefixes like AC-, 3D-, Conditional-, Spectral-) that hint at architectural innovations; learning to decode names like 'StyleGAN' or 'Progressive GAN' helps researchers track the design space.
• Jinja2 templating — update.py uses Jinja2 to transform data (gans.tsv) into presentation (README.md); understanding template syntax is required to modify the output format or add new report types.
• Tab-Separated Values (TSV) format — gans.tsv is the data backbone; contributors must respect TSV structure (no unescaped tabs in cells, proper line endings) or the parser breaks.
• Conditional GANs — A major GAN subclass (cGAN, AC-GAN, CGAN) that appears repeatedly in the zoo; understanding how conditioning (class labels, text prompts) steers generation is key to the variance in architecture names.
• Matplotlib chart generation — cumulative_gans.jpg is auto-generated by update.py using matplotlib; modifying this visualization requires understanding how the script reads gans.tsv and plots GAN counts over publication year.

• eriklindernoren/Keras-GAN — Companion repo providing working Keras/TensorFlow implementations of major GANs listed in the zoo; allows researchers to jump from the-gan-zoo reference to runnable code.
• hwalsukdar/awesome-deep-learning — Broader awesome-style curated list of deep learning resources; the-gan-zoo is a specialized successor focused only on GANs.
• bioinformatics-centre/seqan — Not directly related but exemplifies the awesome-list / reference repo pattern used in the-gan-zoo for tracking a rapidly growing sub-field.
• openai/gpt-3 — Represents the transformer/generative model ecosystem that GANs coexist with; researchers comparing GANs to diffusion models or language models often reference both.
• NVlabs/stylegan — Major landmark GAN repo (StyleGAN); exemplifies the kind of GitHub implementation links curated in gans.tsv.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add data validation and schema tests for gans.tsv

The gans.tsv file is the core data asset, but there's no automated validation. Contributors could introduce invalid data (missing fields, malformed URLs, incorrect dates). A test suite would ensure data integrity and catch issues in PRs before merge.

• [ ] Create tests/test_gans_data.py to validate gans.tsv structure (required columns, URL format, year range)
• [ ] Add assertions for consistency (e.g., paper titles match URL content, no duplicate entries)
• [ ] Integrate test execution into a GitHub Actions workflow (.github/workflows/validate-data.yml)
• [ ] Reference test output in README.md to guide contributors on data format requirements

Refactor and document update.py with input validation and error handling

update.py is the script contributors use to generate README.md from the template and data, but it lacks error handling, logging, and documentation. Adding these would make the maintenance workflow more robust and contributor-friendly.

• [ ] Add comprehensive docstrings and inline comments to update.py explaining the Jinja2 templating flow
• [ ] Implement try-catch blocks for file I/O operations (missing gans.tsv, README.j2.md, permission errors)
• [ ] Add logging output (e.g., 'Processing X GANs', 'Generated README.md successfully')
• [ ] Create CONTRIBUTING.md documenting how to run update.py and what to do if it fails

Add GitHub Actions workflow to auto-validate and preview README changes

When contributors modify gans.tsv or README.j2.md, there's no automated check that the generated README.md is correct or that the visualization scripts (cumulative_gans.jpg) would still work. A CI workflow would catch issues early.

• [ ] Create .github/workflows/validate-readme.yml to run update.py on PR changes and verify README.md is regenerated correctly
• [ ] Add a step to validate gans.tsv TSV formatting and required fields using Python's csv module
• [ ] Generate and compare cumulative_gans.jpg output to detect regressions in the visualization logic
• [ ] Post workflow results as a PR comment showing validation status and GAN count statistics

• Add a CSV export alongside gans.tsv so users can load GAN data into spreadsheets or Python pandas DataFrames without manual parsing.
• Create a GitHub Actions workflow (e.g., in .github/workflows/) to automatically run update.py on every PR merge to gans.tsv, eliminating the manual script-running step and keeping README.md always in sync.
• Write a Python script to validate gans.tsv on upload (check for malformed rows, invalid URLs, duplicate GAN names) and surface errors in PR checks, reducing maintainer review burden.

Failed to generate security analysis.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.