Skip to content
Back to search

banner-loop

MarketplaceWorks with Claude CodeGitHub

Hero-banner loop video pipeline for Claude Code

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/opskill--banner-loop/badge.svg)](/listings/opskill--banner-loop)

HTML

<a href="/listings/opskill--banner-loop"><img src="/api/listings/opskill--banner-loop/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/opskill/banner-loop && cd banner-loop
npm run assets                       # two CC0 textures from Poly Haven (cable trays, rack close-up)
export BLENDER_BIN=/Applications/Blender.app/Contents/MacOS/Blender

tools/loop.sh --scene concept_cable_trays --still 1 --spp 16    # one test frame
tools/loop.sh --scene concept_cable_trays --key 10_cable_trays  # full loop + 4K + QC

Results land in `out/concepts/video/` (gitignored).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 12 lines
  1. {
  2. "name": "banner-loop",
  3. "description": "Hero-banner loop video pipeline for Claude Code",
  4. "owner": { "name": "opskill" },
  5. "plugins": [
  6. {
  7. "name": "banner-loop",
  8. "source": "./",
  9. "description": "Render, AI-upscale and QC seamless 32:9 hero-banner loops from Blender scene scripts"
  10. }
  11. ]
  12. }
README.md · README · 137 lines
  1. <p align="center"><img src=".github/opskill-logo.svg" width="96" alt="opskill"></p>
  2. # banner-loop
  3. **English** · [한국어](README.ko.md)
  4. Seamless **32:9 hero-banner loop videos made entirely from code**: Blender scene scripts → Cycles at 1920×540 →
  5. Apple's on-device AI super-resolution (4×) → 3840×1080 MP4, with loop QC numbers for every render.
  6. Built for website hero banners: 5-second loops that never show a seam, keep the centre dark and calm for an HTML
  7. headline, move gently, and contain no text or logos.
  8. **[▶ Live demo](https://banner-loop-demo.vercel.app)** · [download the MP4s](https://github.com/opskill/banner-loop/releases/tag/v0.2.0)
  9. ![Cable trays loop](docs/examples/10_cable_trays.gif)
  10. | | |
  11. |---|---|
  12. | ![Cable trays](docs/examples/10_cable_trays.jpg) Cable trays | ![GPU macro](docs/examples/06_gpu_macro.jpg) GPU macro |
  13. | ![Cloud blocks](docs/examples/05_cloud_blocks.jpg) Cloud blocks | ![IX hub](docs/examples/01_ix_hub.jpg) IX hub |
  14. | ![CDN planet](docs/examples/03_cdn_planet.jpg) CDN planet | ![Fiber patch panel](docs/examples/02_fiber_macro.jpg) Fiber patch panel |
  15. | ![City data flow](docs/examples/04_city_dataflow.jpg) City data flow | ![Security lattice](docs/examples/07_security_lattice.jpg) Security lattice |
  16. | ![Domain grid](docs/examples/08_domain_grid.jpg) Domain grid | ![Rack close-up](docs/examples/09_rack_closeup.jpg) Rack close-up |
  17. | | |
  18. |---|---|
  19. | Scenes | 10 procedural concept loops (`scenes/concept_*.py`) — fibre patch panel, cable trays, GPU macro, IX hub, CDN planet, city data flow, cloud blocks, security lattice, domain grid, rack close-up |
  20. | Output | `<key>_5s_1920x540.mp4`, `<key>_5s_3840x1080_sr.mp4`, contact sheet, QC stats |
  21. | Speed (M2 Pro) | render 7–23 s/frame (17–57 min per loop), upscale ≈ 5 min 20 s per loop |
  22. | Why upscale | rendering 3840×1080 directly costs ~4× the GPU time; render → AI 4× is ~3–3.5× faster end to end |
  23. ## Requirements
  24. - macOS 26+ on Apple silicon (the upscaler uses `VTSuperResolutionScalerConfiguration`; the model downloads on first use)
  25. - [Blender](https://www.blender.org/download/) 5.x (tested 5.2 LTS), Node.js 20+, ffmpeg, Python 3 with `numpy` + `Pillow`
  26. - Xcode command line tools (`clang`) — `tools/loop.sh` builds the upscaler on first run
  27. Rendering works on any Blender platform; only the 4K upscale step is macOS-only (`--upscale none` elsewhere).
  28. ## Quick start
  29. ```bash
  30. git clone https://github.com/opskill/banner-loop && cd banner-loop
  31. npm run assets # two CC0 textures from Poly Haven (cable trays, rack close-up)
  32. export BLENDER_BIN=/Applications/Blender.app/Contents/MacOS/Blender
  33. tools/loop.sh --scene concept_cable_trays --still 1 --spp 16 # one test frame
  34. tools/loop.sh --scene concept_cable_trays --key 10_cable_trays # full loop + 4K + QC
  35. ```
  36. Results land in `out/concepts/video/` (gitignored).
  37. ## `tools/loop.sh` options
  38. | option | default | |
  39. |---|---|---|
  40. | `--scene NAME` | required | `scenes/NAME.py` |
  41. | `--key KEY` | required | output name, e.g. `10_cable_trays` |
  42. | `--frames A-B` | `1-150` | 5 s @ 30 fps. A partial range (e.g. `40-60`) re-renders only those frames, then encodes/upscales/QCs the whole sequence (frames 1..N must all exist); only a full range without `--resume` clears the frames folder |
  43. | `--spp N` | `64` | Cycles samples (96 for fine-detail macro scenes, 32 for drafts) |
  44. | `--chunk N` | `50` | frames per Blender run |
  45. | `--still F` | – | render a single frame and stop (on failure the end of the Blender log is printed) |
  46. | `--resume` | off | continue after a crash; keeps finished frames, re-renders empty placeholders |
  47. | `--upscale 4k\|none` | `4k` (`none` off macOS) | AI 4× → 3840×1080 (macOS 26+, `clang`), or 1920 only |
  48. | `--no-encode` / `--no-stats` | off | frames only / skip QC |
  49. | `--no-lock` | off | skip the shared GPU lock (see below) |
  50. | `--env K=V` | – | scene knobs read from the environment (e.g. `FIBER_CENTER_FILL=0.6`) |
  51. Scene scripts can also be run directly: `node bin/blender.mjs concept_ix_hub --engine cycles --spp 64 --start 1 --end 50 --out out/x`.
  52. ## How it works
  53. **Seamless loops.** Every scene is periodic in 150 frames: the camera travels exactly an integer number of repeating
  54. tiles (Array modifiers), pulses use integer periods, the Cycles seed is fixed. Animation uses **drivers** on `frame`
  55. rather than keyframes (Blender 5.2 keyframes ease even with linear defaults). QC checks that the seam diff (last → first
  56. frame) matches the normal frame-to-frame diff.
  57. **4× then half.** Apple's quality super-resolution scaler only supports 4× (input ≤ 1920×1080); the low-latency variant
  58. does 2× but only up to 960×960. So `tools/vtsr` upscales 1920×540 → 7680×2160 and down-samples to 3840×1080 with
  59. `VTPixelTransferSession`, which also averages away AI edge artefacts. It pre-rolls the last 8 frames so the temporal
  60. model is warmed up at frame 1 and the loop seam stays clean. The SR model shifts colour slightly (blue about −1.8 levels
  61. on cable trays), so each output frame gets a low-frequency colour fix back to the 1920 source (mean difference < 0.05
  62. levels; detail is kept). Both mp4s are tagged BT.709 (limited range).
  63. **Banner QC** (`tools/loopstats.py [--check] <frames_dir>`; `loop.sh` writes the 1920 and the "4K (SR)" numbers to
  64. `<key>_stats.txt`; `--check` exits 1 if the seam is > 1.5× adjacent diff + 0.5, pumping exceeds ±10 % or the centre
  65. p99.9 luma is > 160):
  66. | metric | target |
  67. |---|---|
  68. | seam diff vs adjacent diff | about equal |
  69. | mean adjacent diff (0–255) | ≲ 2–3 (gentle motion) |
  70. | frame-mean pumping | within ~±8 % |
  71. | centre 30 % max luma | ideally < ~120 (headline zone stays calm) |
  72. **Shared GPU lock.** Each Blender run takes `/tmp/blender_concept.lock` (`mkdir`/`rmdir`, holder pid in `pid`) and waits
  73. 25 s between chunks, so several agents or jobs can queue on one GPU without fighting. A waiting run prints who holds it.
  74. The lock is released on exit and Ctrl-C; if its holder died anyway, the next run takes it over. A lock without a pid
  75. (older tools) is never taken over: remove it once no Blender process is running.
  76. ## Install as a Claude Code plugin
  77. The repo is also a Claude Code plugin marketplace with one plugin (`banner-loop`) that ships the
  78. `banner-loop` skill: the pipeline, the banner rules, a review → fix loop and the asset license rules.
  79. ```bash
  80. claude plugin marketplace add opskill/banner-loop
  81. claude plugin install banner-loop@banner-loop
  82. ```
  83. or inside a session: `/plugin marketplace add opskill/banner-loop` then `/plugin install banner-loop@banner-loop`.
  84. Then ask in plain words ("render the cable trays loop in 4K", "make the CDN arcs calmer and re-render") or call
  85. `/banner-loop:banner-loop`. From a plugin install, outputs go to `./out` of the project you are in
  86. (`BANNER_LOOP_OUT`), not into the plugin cache.
  87. Other ways to get the skill:
  88. - **Clone and open** the repo in Claude Code — the skill is picked up from `.claude/skills/` automatically.
  89. - **Manual copy**: `cp -r skills/banner-loop ~/.claude/skills/` (the skill then expects a clone of this repo).
  90. - **One session only**: `claude --plugin-dir /path/to/banner-loop`.
  91. Update: `claude plugin marketplace update banner-loop`. Remove: `claude plugin uninstall banner-loop@banner-loop`.
  92. ## Writing a new scene
  93. Copy a scene (`concept_cable_trays.py` is the cleanest reference) and use the helpers in `scenes/lib.py`:
  94. `parse_args`, `reset_scene`, `setup_render`, `make_pbr`, `make_tiled_pbr`, `add_area_light`, `look_at`. Keep Blender-version differences inside `lib.py`.
  95. Rules: no text/logos, calm dark centre, integer periods over the loop, fixed seed.
  96. ## Assets and licenses
  97. - Code: MIT (see `LICENSE`).
  98. - Textures: [Poly Haven](https://polyhaven.com/license) **CC0**, downloaded by `npm run assets` from
  99. `assets/manifest.json`; not stored in the repo. Everything else in the scenes is procedural.
  100. - Rendered videos are yours. Blender's GPL covers the program, not its output.
  101. - If you add assets: use CC0 or licenses that allow commercial use, record source/license/author in `manifest.json`,
  102. credit CC-BY works where the video is published, and never use paid-marketplace, "personal use only", NC/ND,
  103. or unclear-provenance assets, or real company logos.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.