Video Family LoRA Hub
A multi-model video generation and identity LoRA workflow hub for a single 16GB GPU
A portfolio-ready Python CLI and demo app that unifies SVD, LTX-2, Wan, CogVideoX, and AnimateDiff SDXL through YAML manifests, ComfyUI workflow templates, adapters, mock-safe demo flows, screenshots, and a WebM walkthrough.
Verified Demo Recording 1
Copied by the portfolio quality pass from existing project demo media.
Media overview
Browse the project screenshots and recorded walkthroughs.
Project links and demo readiness
live
Live Demo
Open the verified live demo when available, or use the internal run guide for manual demo preparation.
github
View GitHub
Open the public repository when available, or review the source-access status captured by this case study.
video
Demo Recording
Open the demo recording when available, or use this section as the recording checklist for the project.
documentation
Read README
Open the project README when available, or use this case study as the documentation baseline.
Project overview
## Overview Video Family LoRA Hub is an AI video generation toolkit prepared as a portfolio demo. It keeps the real engineering structure: CLI, manifests, adapters, ComfyUI templates, trainer bridges, and reproducible artifacts, while adding a public mock-safe demo that an interviewer can inspect without a GPU or private model files. ## Demo Focus The first screen is a run composer and pipeline state board. Reviewers can switch between a family-film teaser, reference portrait i2v, continuity polish v2v, and identity LoRA training batch. Screenshots and the WebM walkthrough show manifest orchestration, artifact browsing, and architecture layers, while the README provides Mermaid diagrams and runnable validation commands. ## Architecture The core package is `video_generation_lab`: `cli.py` exposes the Typer interface, `pipeline.py` resolves YAML manifests, job chaining, and sharding, `adapters/` isolate model-family execution, `comfyui/api.py` handles workflow parameter binding and artifact download, and `outputs.py` standardizes metadata, config snapshots, previews, and run logs. ## Verifiability The public demo uses deterministic assets. Locally, `python scripts/run_demo_smoke.py` runs a complete mock-safe pipeline, and the project is validated with `pytest`, `ruff`, `mypy`, and `python -m build`. The result is not just a static portfolio page, but a rebuildable, testable, deployable showcase project.
My role
Solo developer: system architecture, CLI and adapter design, ComfyUI workflow integration, mock-safe demo, README diagrams, and GitHub Pages deployment
Problem
Video generation and LoRA training workflows are fragmented across model families, weight formats, ComfyUI nodes, and trainer projects. Running t2v, i2v, v2v, and identity LoRA workflows on one 16GB GPU needs a unified, reproducible operator surface that can also be shown publicly without private models.
Solution
The project uses a Typer CLI and Pydantic-validated YAML model catalog to coordinate a family registry, generation adapters, manifest runner, ComfyUI API templates, and trainer subprocess bridges. The public demo runs through deterministic dummy flows, so it is safe without GPU access, model weights, API keys, or external services.
Current outcome
The project is now portfolio-ready: the GitHub Pages demo opens directly on the product console, includes demo scenarios, pipeline state, artifact browser, screenshots, and a WebM walkthrough; locally it passes pytest, ruff, mypy, package build, demo smoke, and demo app build checks.
Highlights
- The first viewport is the actual product console, not a marketing-only page
- Mock-safe demo mode works without GPU, model weights, ComfyUI, or external APIs
- Typer CLI unifies t2v / i2v / v2v / pipeline runs with metadata and config snapshots
- YAML + Pydantic model registry covers SVD, LTX-2, Wan, CogVideoX, and AnimateDiff SDXL
- ComfyUI API workflow metadata is aligned with GUI exports for template validation
- README includes Mermaid architecture, data flow, deployment, module organization, and demo flow diagrams
Engineering challenges
- Full generation and LoRA training require large weights, GPU access, and ComfyUI custom nodes, so the public demo needs safe fallback behavior
- The original research repository included many experiment scripts, logs, outputs, local data, and model symlinks, requiring strict commit scoping
Target users
- Portfolio reviewers and interviewers
- Technical readers who need a quick view of purpose, stack, and maturity
Technical highlights
- Detected technical signals: Python, PyTorch, Diffusers, Hugging Face PEFT, Transformers, ComfyUI, Typer, Pydantic, PyYAML, GitHub Pages
- README evidence exists and can support a fuller reviewed case study
- A public GitHub repository is linked for source traceability
Architecture
This case study is generated from the portfolio catalog pipeline using README, Git metadata, package/build configuration, and media signals. The final architecture narrative still needs source-level review. Current detected technology signals include: Python, PyTorch, Diffusers, Hugging Face PEFT, Transformers, ComfyUI, Typer, Pydantic, PyYAML, GitHub Pages.
Data flow
A public data-flow narrative is not fully reviewed yet. If the project includes data processing, AI pipelines, or backend APIs, the next pass should document input, processing, storage, and UI/output flow end to end.
Project structure
video-family-lora-hub/ README.md # project documentation, when available source files # implementation reviewed by local audit package/build config # detected capability signals
Setup / Run guide
This project does not expose a verified runnable web command yet. Review the README/source tree and add exact install, run, test, and build commands before interview use. No verified build command was detected. Treat the current portfolio page as a case-study placeholder until build steps are reviewed.
Future improvements
- Complete the production-quality README, screenshots, and demo recording
- Add architecture diagrams, data-flow notes, and key technical decisions
- Verify build/test status and update the portfolio release report
Interview notes
- State the current maturity and demonstrable scope first
- Focus on verified stack, source structure, and completed behavior
- Do not claim unverified deployment, video, or test coverage as finished
Next steps
- Add a real GPU output gallery and evaluation dashboard
- Wrap the CLI core with a FastAPI or Gradio operator UI
- Add LoRA training experiment tracking and a formal artifact registry