Skip to content
Back to search

BlenderLore

BlenderLore: Learning 3D Coding from Internet Tutorial Videos.

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/freedomintelligence--blenderlore/badge.svg)](/listings/freedomintelligence--blenderlore)

HTML

<a href="/listings/freedomintelligence--blenderlore"><img src="/api/listings/freedomintelligence--blenderlore/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

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

1. Install prerequisites

Install Python 3.10+, Blender, and FFmpeg (including `ffprobe`), with Blender and FFmpeg on `PATH`. Commands below target macOS/Linux; on Windows, use Linux Python and Blender in WSL. Replace example paths with your own.

git clone https://github.com/FreedomIntelligence/BlenderLore.git
cd BlenderLore
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

For Codex, install and sign in to Codex CLI using the [official documentation](https://developers.openai.com/codex/cli/), and ensure the client can run `codex`.

2. Install Skills

Run from the repository root to install the Skill into the current user's Codex environment:

mkdir -p "$HOME/.agents/skills"
ln -s "$PWD/skills/blender-pipeline" "$HOME/.agents/skills/blender-pipeline"

3. Configure rendering

Cycles uses the CPU by default. Omit the Blender path setting if Blender is already on `PATH`.

export BLENDER_PIPELINE_BLENDER=/path/to/blender
export VIDEO2BLENDER_CYCLES_BACKEND=CPU

For GPU rendering, replace `CPU` with the appropriate backend: `OPTIX` or `CUDA` for NVIDIA, `METAL` for Apple Silicon, `HIP` for AMD, or `ONEAPI` for Intel.

4. Configure inputs and outputs

Keep input files on your computer. For API mode, enter their paths in the terminal launch command in step 5; for Codex, provide paths or links directly in the client's chat composer.

| Input | API argument | Provide in Codex | | --- | --- | --- | | Local video | `--video-file` | Absolute path to the video | | Video URL | `--video-url` | Full HTTPS video URL | | Markdown tutorial | `--tutorial` | Absolute path to the `.md` file |

Markdown tutorials need numbered operations and their referenced images. Text-only tutorials also require a final reference image.

Choose a new or empty output directory outside the repository: use `--output-dir` in API mode, or specify it in the Codex conversation. Output formats are fixed; main files appear as their corresponding stages complete:

run_001/
  tutorial.md             # Illustrated tutorial
  reproduce.py            # Blender Python code
  asset.blend             # Editable project
  render.png              # Rendered image
  six_views/              # Static multi-view renders, when applicable
  final_effect.mp4        # Animation or turntable video, when applicable
  pipeline_review.json    # Review results

5. Start with API / Codex

API

Open a terminal at the repository root and run this command for first-time setup:

python run_api.py --configure --config "$HOME/.config/blender-pipeline/pipeline.json"

At the terminal prompts, enter an HTTPS API endpoint ending in `/chat/completions` and your API key. The endpoint is saved in the `endpoint` field of `~/.config/blender-pipeline/pipeline.json`; the key is saved in `model_api_key` in the same directory. Edit these files to change the configuration later.

Launch from the same terminal, replacing the input path and output directory with your own. Use the corresponding argument from step 4 for other input types:

python run_api.py --config "$HOME/.config/blender-pipeline/pipeline.json" \
  --video-file /path/to/input/tutorial.mp4 --output-dir /path/to/data/run_api

For a tutorial with a starting project, append `--asset /path/to/starter.blend`; for a text-only tutorial, append `--target-image /path/to/target.png`.

Codex

Type `/blender-pipeline` in the chat composer:

/blender-pipeline
Input: /path/to/input/tutorial.mp4
Output: /path/to/data/run_skill

You can replace the input with a full video URL or a Markdown tutorial path. Include paths to any supporting project or reference images in the same message.

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.

README.md · README · 196 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. English | <a href="README_zh-CN.md">简体中文</a>
  2. <h2 align="center">BlenderLore: Learning 3D Coding from Internet Tutorial Videos</h2>
  3. <p align="center">
  4. <strong>If you like our project, please give us a star ⭐ on GitHub for the latest update.
  5. </strong>
  6. </p>
  7. <p align="center">
  8. <a href="https://blenderlore.github.io/"><img src="https://img.shields.io/badge/Project-Website-7b61ff" alt="Project Website"></a>
  9. <a href="https://github.com/FreedomIntelligence/BlenderLore"><img src="https://img.shields.io/badge/GitHub-Repository-111111.svg?logo=github" alt="GitHub Repository"></a>
  10. <a href="https://huggingface.co/datasets/FreedomIntelligence/BlenderLore"><img src="https://img.shields.io/badge/HuggingFace-Dataset-f6c344.svg?logo=huggingface" alt="Hugging Face Dataset"></a>
  11. <img src="https://img.shields.io/badge/Paper-Coming_Soon-8f7ad8" alt="Paper Coming Soon">
  12. </p>
  13. ## 🔭 Overview
  14. BlenderLore is a dataset and pipeline for acquiring and reusing procedural knowledge from internet tutorial videos for 3D coding. It converts video evidence into illustrated tutorials, reconstructs editable assets in Blender Python, and extracts reviewed methods for future creation tasks. The collection contains **about 22K project instances associated with over 3K tutorial videos** from YouTube and Bilibili.
  15. **Generalization is central to BlenderLore.** Executing code and inspecting geometry, appearance, and motion ground the inferred methods in concrete implementations. Agents can then retrieve, adapt, and combine methods from different tutorials for new goals. **BlenderLore Skill** packages the reconstruction workflow and procedural knowledge library for existing coding agents; knowledge accumulates externally without updating model parameters.
  16. ![A complete BlenderLore example: dynamic fur, from tutorial evidence to illustrated steps, Blender Python, and an animated asset](docs/assets/blenderlore_sample.png)
  17. *A complete example: dynamic fur. Illustrated steps connect the source video to executable reconstruction and reusable procedural knowledge.*
  18. ## 🧩 Method
  19. ![BlenderLore pipeline: tutorial videos, multimodal evidence, illustrated workflows and knowledge retrieval, a coding agent loop, and verified deliverables](docs/assets/blenderlore_method.png)
  20. 1. **Recover illustrated workflows.** Align video frames, narration, on-screen text, and interface changes into ordered steps, recording inputs, operations, parameters, and intermediate results.
  21. 2. **Ground methods in source assets.** Use creator-provided projects when available, repair missing components, and connect tutorial steps to concrete implementations.
  22. 3. **Reconstruct and inspect.** Retrieve relevant knowledge, generate Blender Python, execute and render the scene, and repair discrepancies in geometry, appearance, or motion.
  23. 4. **Review and retain knowledge.** Record each method's source, retrieval keywords, applicability, implementation excerpt, and checks for the intended result. Human experts review the resulting assets.
  24. 5. **Adapt and combine.** Reuse methods across tutorials to create new assets and expand the procedural knowledge library.
  25. ## Generalizing Beyond Tutorials
  26. ![Cross-tutorial composition: Duck GiGi modeling, transferred rigging and walking, and an iridescent material](docs/assets/blenderlore_composition.png)
  27. BlenderLore creates a walking iridescent Duck GiGi by combining three tutorials: a static character modeling workflow, a rigging and walking method transferred from a baby crocodile, and an iridescent material. The reusable unit is a construction method, allowing agents to adapt and combine knowledge beyond the demonstrated assets.
  28. ## 🎁 What You Get
  29. <table>
  30. <tr>
  31. <td width="33%" valign="top">
  32. ### 01 · An End-to-End Agent Pipeline
  33. Each run recreates a tutorial workflow and delivers an editable Blender project, a reproduction script, renders, and validation results.
  34. - Editable Asset — `asset.blend`
  35. - Reproduction Script — `reproduce.py`
  36. - Materials & Node Graphs
  37. - Final Render
  38. - Multi-View Renders
  39. - Animation
  40. - Agent Log
  41. </td>
  42. <td width="33%" valign="top">
  43. ### 02 · A High-Quality 3D Dataset
  44. About 22K project instances associated with over 3K tutorial videos, built through collection, repair, reconstruction, and cross-tutorial adaptation and composition. Human experts manually check every final asset file.
  45. </td>
  46. <td width="33%" valign="top">
  47. ### 03 · A Reusable Procedural Knowledge Library
  48. Reviewed entries record their source, applicability, implementation, and checks. BlenderLore Skill supplies this library and workflow guidance so coding agents can retrieve, adapt, and combine methods for new 3D tasks.
  49. </td>
  50. </tr>
  51. </table>
  52. ## 🚀 Quick Start
  53. ### 1. Install prerequisites
  54. Install Python 3.10+, Blender, and FFmpeg (including `ffprobe`), with Blender and FFmpeg on `PATH`. Commands below target macOS/Linux; on Windows, use Linux Python and Blender in WSL. Replace example paths with your own.
  55. ```bash
  56. git clone https://github.com/FreedomIntelligence/BlenderLore.git
  57. cd BlenderLore
  58. python3 -m venv .venv
  59. source .venv/bin/activate
  60. python -m pip install -r requirements.txt
  61. ```
  62. For Codex, install and sign in to Codex CLI using the [official documentation](https://developers.openai.com/codex/cli/), and ensure the client can run `codex`.
  63. ### 2. Install Skills
  64. Run from the repository root to install the Skill into the current user's Codex environment:
  65. ```bash
  66. mkdir -p "$HOME/.agents/skills"
  67. ln -s "$PWD/skills/blender-pipeline" "$HOME/.agents/skills/blender-pipeline"
  68. ```
  69. ### 3. Configure rendering
  70. Cycles uses the CPU by default. Omit the Blender path setting if Blender is already on `PATH`.
  71. ```bash
  72. export BLENDER_PIPELINE_BLENDER=/path/to/blender
  73. export VIDEO2BLENDER_CYCLES_BACKEND=CPU
  74. ```
  75. For GPU rendering, replace `CPU` with the appropriate backend: `OPTIX` or `CUDA` for NVIDIA, `METAL` for Apple Silicon, `HIP` for AMD, or `ONEAPI` for Intel.
  76. ### 4. Configure inputs and outputs
  77. Keep input files on your computer. For API mode, enter their paths in the terminal launch command in step 5; for Codex, provide paths or links directly in the client's chat composer.
  78. | Input | API argument | Provide in Codex |
  79. | --- | --- | --- |
  80. | Local video | `--video-file` | Absolute path to the video |
  81. | Video URL | `--video-url` | Full HTTPS video URL |
  82. | Markdown tutorial | `--tutorial` | Absolute path to the `.md` file |
  83. Markdown tutorials need numbered operations and their referenced images. Text-only tutorials also require a final reference image.
  84. Choose a new or empty output directory outside the repository: use `--output-dir` in API mode, or specify it in the Codex conversation. Output formats are fixed; main files appear as their corresponding stages complete:
  85. ```text
  86. run_001/
  87. tutorial.md # Illustrated tutorial
  88. reproduce.py # Blender Python code
  89. asset.blend # Editable project
  90. render.png # Rendered image
  91. six_views/ # Static multi-view renders, when applicable
  92. final_effect.mp4 # Animation or turntable video, when applicable
  93. pipeline_review.json # Review results
  94. ```
  95. ### 5. Start with API / Codex
  96. #### API
  97. Open a terminal at the repository root and run this command for first-time setup:
  98. ```bash
  99. python run_api.py --configure --config "$HOME/.config/blender-pipeline/pipeline.json"
  100. ```
  101. At the terminal prompts, enter an HTTPS API endpoint ending in `/chat/completions` and your API key. The endpoint is saved in the `endpoint` field of `~/.config/blender-pipeline/pipeline.json`; the key is saved in `model_api_key` in the same directory. Edit these files to change the configuration later.
  102. Launch from the same terminal, replacing the input path and output directory with your own. Use the corresponding argument from step 4 for other input types:
  103. ```bash
  104. python run_api.py --config "$HOME/.config/blender-pipeline/pipeline.json" \
  105. --video-file /path/to/input/tutorial.mp4 --output-dir /path/to/data/run_api
  106. ```
  107. For a tutorial with a starting project, append `--asset /path/to/starter.blend`; for a text-only tutorial, append `--target-image /path/to/target.png`.
  108. #### Codex
  109. Type `/blender-pipeline` in the chat composer:
  110. ```text
  111. /blender-pipeline
  112. Input: /path/to/input/tutorial.mp4
  113. Output: /path/to/data/run_skill
  114. ```
  115. You can replace the input with a full video URL or a Markdown tutorial path. Include paths to any supporting project or reference images in the same message.
  116. ## 📖 Citation
  117. ```bibtex
  118. @misc{blenderlore2026,
  119. title = {BlenderLore: Learning 3D Coding from Internet Tutorial Videos},
  120. author = {FreedomAI Team},
  121. year = {2026},
  122. publisher = {GitHub},
  123. journal = {GitHub repository},
  124. howpublished = {\url{https://github.com/FreedomIntelligence/BlenderLore}},
  125. }
  126. ```
  127. ## 🙏 Acknowledgements
  128. This project is built upon [Blender](https://www.blender.org/), the free and open-source 3D creation suite.
  129. ## 📄 License
  130. This project is released under the Apache 2.0 license.
  131. ## 📬 Contact
  132. For questions and feedback, please contact us at: <a href="mailto:minghaowu@link.cuhk.edu.cn">minghaowu@link.cuhk.edu.cn</a>

Ratings and comments

Sign in to rate this skill.

Sign in

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