Default to CPU Eevee; retain optional GPU/Cycles and fix inherited task locks

README.md

@@ -13,17 +13,26 @@ license: mit
 
 # Blender Render Studio
 
-上传 `.blend`、纹理/缓存 ZIP 和 JSON 渲染配置，使用 Blender Cycles 生成图片、帧序列或 MP4 视频。提供中文 Gradio 界面、API、MCP，以及可连续提交批次、断点续渲、下载结果的 Python 客户端。
+上传 `.blend`、纹理/缓存 ZIP 和 JSON 渲染配置，默认使用 CPU + Eevee 生成图片、帧序列或 MP4 视频。提供中文 Gradio 界面、API、MCP，以及可连续提交批次、断点续渲、下载结果的 Python 客户端。
 
-**已在 Hugging Face `cpuai/blender-render-studio` 完成真实 ZeroGPU 渲染验证（2026-09-22）。** Blender 5.2.2 LTS 通过 CUDA 使用 NVIDIA RTX PRO 6000 Blackwell Server Edition 的 MIG 2g.48gb 分区，自检返回 `ok=true`、`gpu_verified=true`；工程 ZIP/JSON 上传、三帧 GPU 渲染、MP4 合成及结果下载也已通过。当前实测环境未发现 OptiX 设备，`AUTO` 正常选择 CUDA，也可显式设置 `device=CUDA`。其他硬件、版本和复杂工程仍应先运行自检；GPU 失败会报错，不会悄悄转为 CPU。[官方兼容性说明](https://huggingface.co/docs/hub/en/spaces-zerogpu)
+**1.1.0：默认 CPU + Eevee，不申请 ZeroGPU。** GPU 和 Cycles 保留为手动选项。Eevee 是图形渲染引擎：CPU 模式使用 Mesa llvmpipe 软件 OpenGL，并非 Blender 原生 CPU 路径；具体速度取决于场景与 CPU，不承诺比 Cycles 快。ZeroGPU 的 CUDA 已验证可运行 Cycles，但 Eevee GPU 还需要硬件 EGL/OpenGL 驱动，不能用 CUDA 可用来证明 Eevee 可用。
+
+| 配置 | 执行方式 |
+| --- | --- |
+| `engine=EEVEE, device=CPU`（默认） | CPU + Mesa 软件 OpenGL，无 GPU 租约 |
+| `engine=CYCLES, device=CPU` | Cycles CPU，无 GPU 租约 |
+| `engine=CYCLES, device=AUTO` | 可选 GPU；ZeroGPU 按批申请，优先 OptiX / CUDA |
+| `engine=EEVEE, device=AUTO` | 可选图形 GPU；没有硬件图形驱动时报错，不冒充 GPU 成功 |
+
+未指定 engine 的旧 JSON 采用新默认 Eevee；旧 CUDA / OPTIX 配置请显式增加 `engine=CYCLES`。已有任务的已保存配置不自动切换引擎，请重新创建任务，避免混合不同引擎的帧。
 
 ## 能做什么
 
 - 上传单个已打包资源的 `.blend`，或包含工程与外部资源的 ZIP。
 - JSON 设置场景、相机、视图层、分辨率、采样、降噪、透明背景、帧区间和 GPU 时间预算。
-- Cycles 的 AUTO / CUDA / OptiX 渲染；管理员可显式选择 CPU 测试模式。
+- Eevee / Cycles 与 CPU / GPU 可选；任务 JSON 的 `device=CPU` 始终直接在 CPU 执行。
 - PNG 8/16 位、OpenEXR 16/32 位帧输出；PNG 序列合成 H.264 MP4。
-- 按批申请 GPU，保存完成帧；取消、恢复、导出部分结果与日志。
+- CPU 直接渲染，GPU 才按批申请，保存完成帧；取消、恢复、导出部分结果与日志。
 - 使用同一套服务逻辑处理 UI、API 与 MCP 请求。
 
 这是渲染服务：它保留模型、材质、灯光、动画与受支持的已烘焙缓存，但不会替用户建立动画。自动脚本、OSL、合成器与视频序列编辑器被禁用，不安装用户插件。长动画需要多次租约，**不承诺免费、不承诺无限 GPU 时间，也不保证单帧超出平台时限的大场景能够完成**。
@@ -32,9 +41,9 @@ license: mit
 
 1. 新建 **Gradio SDK、Python 3.12** 的 Space，推荐设置为私有。
 2. 把本项目根目录全部文件上传到 Space 根目录，保留此 README 的 YAML 配置。
-3. 在 Space Settings 选择 **ZeroGPU** 硬件；是否可选取决于账号与平台当前资格。设置变量 `RENDER_BACKEND=zerogpu`。
+3. 在 Space Settings 选择 **ZeroGPU** 硬件；是否可选取决于账号与平台当前资格。保留 `RENDER_BACKEND=zerogpu` 即可提供可选 GPU；默认任务仍使用 CPU。也可在 CPU Space 上使用默认模式。
 4. 等待构建完成。`requirements.txt` 已包含 PyTorch；`packages.txt` 会安装 FFmpeg 与 Blender 的系统依赖。首次启动优先校验并安装 `vendor/` 中的 Blender **5.2.2**；未附带安装包时才从官方下载站下载。完整包已附带安装包，可避免下载站拒绝云平台访问的问题。
-5. 打开「环境自检」页，先查看环境，再运行真实 GPU 渲染自检。只有返回 `ok=true` 且 `gpu_verified=true` 才开始正式 GPU 任务。
+5. 打开「环境自检」页，先查看环境，先运行 CPU / Eevee 自检；使用 GPU 前再运行 GPU / Cycles 自检。只有返回 `ok=true` 且 `gpu_verified=true` 才开始正式 GPU 任务。
 
 若 ZeroGPU 自检失败，下载诊断日志；可以由你在 Space 设置中选择普通 NVIDIA GPU，并设置 `RENDER_BACKEND=gpu`。应用不会替你升级付费硬件。完整步骤、系统变量与问题排查见 [部署文档](docs/DEPLOY.zh-CN.md)。
 
@@ -53,7 +62,8 @@ license: mit
   "height": 360,
   "samples": 16,
   "frame": 1,
-  "device": "AUTO",
+  "engine": "EEVEE",
+  "device": "CPU",
   "batch_size": 1,
   "gpu_seconds": 120
 }
@@ -61,7 +71,7 @@ license: mit
 
 上传 JSON 文件后，它优先于编辑器内容。调整编辑器前请清空 JSON 文件上传框。若 ZIP 中有多个 `.blend`，设置 `"blend_file": "project/scene.blend"`，路径以 ZIP 解压根目录为准，使用 `/`。
 
-项目提供 [图片配置](examples/image.json)、[5 秒视频配置](examples/video.json)、[EXR 帧序列配置](examples/frames-exr.json)。实际耗时由场景决定，示例的 GPU 秒数只是请求预算。
+项目提供 [图片配置](examples/image.json)、[5 秒视频配置](examples/video.json)、[EXR 帧序列配置](examples/frames-exr.json)。实际耗时由场景决定，`gpu_seconds` 仅在 GPU 模式使用，CPU 任务使用 `cpu_timeout`。
 
 ## Agent 一条龙调用
 

SHA256SUMS.txt

@@ -1,38 +1,41 @@
 01ca9723815bf82ce4f5a5ea72b3ffca1e3f0861ca031f0611a9fbfb028352d8  .gitignore
 9859366fd6a1e412cde3018acec7a11746d71282e23a8e0b51f9ae83a153b02c  LICENSE
-76a3daaeb2dc63ba93f69fc0196255a96c1821c15712303dc72791fdb5dbd9c9  README.md
-c9c3c0a625432125e2d67e4ec41cab2da24d4a2a82ea90bb4c2cb4b4f373a1ce  app.py
-be89bb68c01e6c897ed2c6d2d9adf4b9198069cee154c78d79c2e9595b68551c  blender_runtime.py
-cfd98db7174045fc2bbd52e3aeab40e73ff055fab14d910f3ae51c20b4100c89  docs/API.zh-CN.md
-b0bbcff7f95847cd795389f006a59d57d356ea7f3366bc0ffea5fdf77ad4869e  docs/ARCHITECTURE.zh-CN.md
-4416e578fd7f74b38ce5b3bef561bde67d3d9e73c3bb5bb2b7aeb0dd356686d2  docs/DEPLOY.zh-CN.md
+d890598d803cdf4eb8d0cfedb65e8f24d0e57a9d30ee5ddf50caa9ac36a1258f  README.md
+6a1b5671dc8cbb821c53d59ec87bdef44cf27043c29f4d12abd02f4d4600949c  app.py
+8a66bdfd18fc776fd8e3796321c55d74c5a653ab9b8ad6db5c72d5d1e46e4f14  blender_runtime.py
+cc802ca4d81169e26cbb8e3a5f99f85f27cadbe42878ecf75065fe8d4a7d2dad  docs/API.zh-CN.md
+8055fec30c5327cc6473cc2dd72d8f76ff63d4fdddf726a2a03d048fc732bb1e  docs/ARCHITECTURE.zh-CN.md
+4d7f45c20a39dc86820ddc379f2137efeb9017ada58e33387d288d9fc1a1406c  docs/DEPLOY.zh-CN.md
+e9fc2087b746d6f86cf5b7f6f279203cc9297379c590e948f660109809f7d21a  docs/TEST_REPORT-1.1.0.zh-CN.md
 ca04fb9e7d16e031c7b10ff1dd962839a70118762f086da82722b674bafa8c34  docs/TEST_REPORT.zh-CN.md
 15c1033cf2053ed563dda8f8d550bb4c654fa42498c0b18e3f9dd56ea1ed81c8  examples/client_render.py
+666283a6b6eec04a781fdb3da2440fca82d21c2a051b82e5022c08158684db59  examples/cycles-gpu.json
 5526526b59e34340d00fd0f50c9eb154b6cbc2a20966e978676016c76246b299  examples/demo.blend
-bf20fe326c04e0da1fb73ca274bdeb1aab3f376b6a58436fb61f36b8ef92b4d1  examples/frames-exr.json
-adb035c8df07ca5ae548246ae06cf4e4d1d950e5979c654dd2a6d026bebb2bf6  examples/image.json
+30eb328bebb04efac0e992a459b008d04c1d55d3a6c1c1f8636880fcf3fbfec7  examples/frames-exr.json
+638f0ac4677a145ba396748dedebdc164d7b39bcb7ffa67790700722ef5e3e0e  examples/image.json
 9c31eed31fe6dbf766c61a8d2a496e10e7217dd6484ea8110664df9876285078  examples/mcp-client.json
-315f3e2a287d0432731ac338226adda7f2a0417f89d16def6f5a19b1814ea851  examples/video.json
-e4559cf2075458310e2d45adfa6a194abe3c5f0c190281761d82baa0882a0920  packages.txt
-eac6acad35c1807caefed69ff8a24241a5b282aa78d07eff2dc7466ef190aa6b  render.schema.json
-9fddaee1f11cdea4e873da26372cf89660d2226b04c5c441c2d8f028872e005d  render_config.py
-192dbfb9677d30f47de762c670ccaf4614fc9d3dbe60e5e4710155be79b8bb66  render_worker.py
+e4dd8b9a4848b80580955a99ffbae6457eb6c1c30552ac0a6ab20a5995c36e75  examples/video.json
+14e5fded3a6736acc30d48afc3c7c69cce7358ec9790ff393c69b451f0d679d7  packages.txt
+4e40dd38f6ea857f170064059fdff1092f54152eaed02d115c0c9d9cc7ed1e7d  render.schema.json
+11b88858aa4caa6b7ab3d0028964c3350a578ae15b6e46664510f6959f8ef2e3  render_config.py
+f84bddf01a48007804a9ebb92e2ac55131a73ba169985c1a202dd500d4f958c9  render_worker.py
 5e80794bcc6d2549958645e311fe2e150307ca42d1a05b154959c044697327ad  requirements-dev.txt
 87a9e0631bcf876ec66709de42468e22aad8d55ec7eacfcecc6cb4042b0b9685  requirements.txt
 65e361844de06033efda047b4a4092f6d073f03e5bfef61af95cf0af66a1c9a0  scripts/create_demo.py
-0011be2a80cf0b9c33343060c9686673c49dbbb38959eeaedd981de4e1920771  scripts/smoke_test.py
-f53672630ccacee5d9f0d6dd255f1e60e5d72b31111500e722b5479faf950703  service.py
-5b460e5eb194c451fe914693222c182a084f4e4d49029248c4f37de7e6ffb442  test-artifacts/api-smoke-report.json
+8745e606faf94fe48dd46d887262f7a7319798a5672d03fdc1aaf14beb6faf9f  scripts/smoke_test.py
+a81ee88e76013334db37af6e2b2488623d4c0366f0ae524f40055517c1c2aaa8  service.py
+b7917759d8864af2578fbae948404f9343c0c89a0282284bc251db9322165298  test-artifacts/api-smoke-report.json
 37c0bcbd782040c859387845cb02eefc787628b70da1c591fbcbf3866926d06f  test-artifacts/cpu-animation-preview.mp4
-106a45a39d7d4bfc3c42b2366ccff21261afa6b4d62b4757396f6bf7b086dea6  test-artifacts/cpu-render-preview.png
+fde62827730295cf0435bc847b9908787c1df36e78ed85394d78afd3ffc6cc0e  test-artifacts/cpu-render-preview.png
 c36a41702e9d6fa2c080926aaeb1a54028fe845fd987ceee01b15dec44c9c1e3  test-artifacts/exr-smoke-report.json
 f780ddecea166cabf5b6ee4ce8abe1d94f9ff24abdf9c2c7b27d3b04722be6aa  test-artifacts/video-smoke-report.json
 055a91885259120961a179671ef1b66b8ccc3da372796211e88fbdeb103dfb79  test-artifacts/zerogpu-animation-preview.mp4
 7e10fac1dbc5b431996c178b76f34e09d96b0991a255a333b7b1b288a18256d7  test-artifacts/zerogpu-render-preview.png
 2c0b188931be19ea4d449b4b6dc0a8d6410b5035b1a0a7761b3cea1c9dd13f67  test-artifacts/zerogpu-smoke-report.json
 6ec47b34933b82755ad54217aa0fd2a9ac9d9636c2f1c87a42d3d735ea2d6cfa  tests/test_config_uploads.py
+ea4ab35f50549f0bd55dafa7a0b4d8945288c2262e5d2697f669600012b8a8b3  tests/test_render_modes.py
 b4311978dd179edbc7a92bc442b83b736edf2c746ebccbc34ce81e862909b4d8  tests/test_runtime.py
-711e0f562fc6d0bfdc9e4007475f99ceda6a343185d106c016546c5b6dbe3a27  tests/test_service.py
+1ad4758353682535e826f429f39a9990f87e3afc180a5cae93fb1273c5a5d370  tests/test_service.py
 4fb5d2d55725d9adb5f8c58be6192cde4d825f2f31c1b698458eb39f8add3a37  uploads.py
 988e0c9b9146513f69c01f70dd55fac73a2fd0e749c66ba440de7fdc07a32f6b  vendor/README.md
 84098912789dc450e95697c4184fb8a90acbe5111c2ba4aede3fecb57806a168  vendor/blender-5.2.2-linux-x64.tar.xz

app.py

@@ -15,7 +15,7 @@ import gradio as gr
 
 import service
 from blender_runtime import ensure_blender
-from render_config import RenderConfig
+from render_config import RenderConfig, parse_config
 
 
 LOGGER = logging.getLogger(__name__)
@@ -51,7 +51,8 @@ HERO = """
   <p>上传 Blender 工程与资源，用 JSON 驱动图片或动画渲染。<br>
   按批次保存帧，通过 API 与 MCP 接入你的创作 Agent。</p>
   <div class="pills">
-    <span class="pill">Cycles 渲染</span>
+    <span class="pill">默认 CPU + Eevee</span>
+    <span class="pill">GPU / Cycles 可选</span>
     <span class="pill">逐批续渲</span>
     <span class="pill">图片 / 视频</span>
     <span class="pill">API + MCP</span>
@@ -140,7 +141,7 @@ def render_chunk(job_id: str) -> dict[str, Any]:
 
 
 def _render_remaining(job_id: str) -> Iterator[dict[str, Any]]:
-    """界面专用连续模式：每批正常申请 GPU，错误或取消后立即结束。"""
+    """界面专用连续模式：按所选后端逐批渲染，错误或取消后立即结束。"""
     job_id = _job_id(job_id)
     current = _invoke(service.job_status, job_id)
     yield current
@@ -227,6 +228,11 @@ def finalize_job(
     return _invoke(service.finalize_job, _job_id(job_id))
 
 
+def cpu_self_test() -> tuple[dict[str, Any], list[str], str | None]:
+    """Verify default CPU Eevee rendering without allocating a GPU."""
+    return _invoke(service.cpu_self_test)
+
+
 def gpu_self_test() -> tuple[dict[str, Any], list[str], str | None]:
     """Test actual Blender GPU rendering with a small built-in scene.
 
@@ -244,15 +250,21 @@ def _preset(mode: str) -> str:
     return json.dumps(data, indent=2, ensure_ascii=False)
 
 
+def _render_options(config_json: str, engine: str, device: str) -> str:
+    # Update only render choices; retain camera, animation and quality settings.
+    data = json.loads(config_json or "{}")
+    data.update(engine=engine, device=device)
+    return parse_config(json.dumps(data)).model_dump_json(indent=2)
+
+
 def build_app() -> gr.Blocks:
     """构建界面；导入本模块不会下载 Blender，也不会申请 GPU。"""
     with gr.Blocks(title="Blender Render Space", delete_cache=(3600, 86400)) as demo:
         gr.HTML(HERO)
         gr.Markdown(
-            "**ZeroGPU + Blender 为实验性组合。** 首次使用请运行「环境自检」："
-            "必须确认 Blender 子进程能在当前 Space 的 GPU 租约内实际渲染。"
-            "GPU 失败会明确报错；不会静默转为 CPU。"
-            "长动画由多个有时限的批次完成，单帧仍需在单次租约内完成。",
+            "**默认 CPU + Eevee**，不申请 ZeroGPU。Eevee 在 CPU 上通过软件图形驱动渲染。"
+            "需要光线追踪时可选 Cycles；GPU 为手动选项。"
+            "ZeroGPU 的 GPU 选项推荐搭配 Cycles，Eevee GPU 需要可用的硬件图形驱动。",
             elem_classes="workflow-note",
         )
 
@@ -295,6 +307,11 @@ def build_app() -> gr.Blocks:
                             "`batch_size` 控制每次提交的帧数；建议先用低分辨率、"
                             "少量采样验证，再提高画质。"
                         )
+                        with gr.Row():
+                            engine_choice = gr.Dropdown([("Eevee（默认）", "EEVEE"), ("Cycles", "CYCLES")], value="EEVEE", label="渲染引擎")
+                            device_choice = gr.Dropdown([("CPU（默认）", "CPU"), ("GPU（自动选择）", "AUTO")], value="CPU", label="计算设备")
+                        apply_options = gr.Button("将引擎与设备应用到 JSON", size="sm")
+                        gr.Markdown("选择后点击应用；创建任务以 JSON 为准。上传 JSON 文件时，请直接修改文件中的 engine / device。")
                         prepare = gr.Button("准备渲染任务", variant="primary", size="lg")
 
                     with gr.Column(scale=6, min_width=320):
@@ -321,7 +338,7 @@ def build_app() -> gr.Blocks:
                         gr.Markdown(
                             "每次点击「渲染下一批」处理一个批次；剩余帧可继续提交。"
                             "「连续渲染剩余帧」会逐批提交，遇到错误或配额不足立即结束，"
-                            "不会自动重试。**连续模式可能耗尽 GPU 配额，可随时点击「停止任务」。**"
+                            "不会自动重试。**仅选择 GPU 时消耗 GPU 配额；可随时点击「停止任务」。**"
                             "API / Agent 也可按状态自动循环。"
                             "停止后保留已完成帧；点击「恢复任务」后再提交渲染。"
                         )
@@ -351,11 +368,12 @@ def build_app() -> gr.Blocks:
                     "自检失败时，请下载日志检查原因，或选择常驻 GPU Space。\n\n"
                     "后端由 Space 环境变量 `RENDER_BACKEND` 选择："
                     "`auto`、`zerogpu`、`gpu` 或 `cpu`。"
-                    "CPU 模式用于功能验证；GPU 模式不进行静默 CPU 回退。"
+                    "CPU + Eevee 是默认工作模式。任务 JSON 的 device=CPU 始终绕过 GPU 租约；GPU 不进行静默 CPU 回退。"
                 )
                 with gr.Row():
                     env_button = gr.Button("读取环境")
-                    probe_button = gr.Button("运行 GPU 自检", variant="primary")
+                    cpu_probe_button = gr.Button("运行 CPU / Eevee 自检", variant="primary")
+                    probe_button = gr.Button("运行 GPU / Cycles 自检")
                 env_output = gr.JSON(label="环境信息")
                 with gr.Row():
                     with gr.Column():
@@ -375,6 +393,7 @@ def build_app() -> gr.Blocks:
                     "| API | 用途 |\n| --- | --- |\n"
                     "| `environment_info` | 检查后端与安装信息 |\n"
                     "| `config_schema` | 获取完整 JSON Schema |\n"
+                    "| `cpu_self_test` | 验证默认 CPU Eevee 渲染 |\n"
                     "| `gpu_self_test` | 验证 Blender 实际 GPU 渲染 |\n"
                     "| `prepare_job` | 上传工程和配置，创建任务 |\n"
                     "| `inspect_job` | 检查场景、相机与资源 |\n"
@@ -427,6 +446,10 @@ def build_app() -> gr.Blocks:
         )
         env_button.click(environment_info, None, env_output, api_name="environment_info", queue=False)
         schema_button.click(config_schema, None, schema_output, api_name="config_schema", queue=False)
+        apply_options.click(_render_options, [config_editor, engine_choice, device_choice], config_editor,
+                            queue=False, api_visibility="private")
+        cpu_probe_button.click(cpu_self_test, None, [probe_output, probe_files, probe_image],
+                               api_name="cpu_self_test", **blender_queue)
         probe_button.click(
             gpu_self_test,
             None,

blender_runtime.py

@@ -213,7 +213,7 @@ def ensure_blender() -> Path:
     return binary
 
 
-def _worker_environment() -> dict[str, str]:
+def _worker_environment(config: dict | None = None) -> dict[str, str]:
     """移除应用服务凭据，保留 CUDA、NVIDIA 和动态库搜索路径。"""
     forbidden_prefixes = (
         "HF_", "HUGGINGFACE_", "HUGGING_FACE_", "AWS_", "AZURE_", "GOOGLE_",
@@ -231,6 +231,18 @@ def _worker_environment() -> dict[str, str]:
     environment["OPENBLAS_NUM_THREADS"] = str(threads)
     environment["MKL_NUM_THREADS"] = str(threads)
     environment["PYTHONNOUSERSITE"] = "1"
+    config = config or {}
+    if config.get("engine", "EEVEE") == "EEVEE":
+        # Use Mesa's software OpenGL only for explicitly selected CPU jobs.
+        for name in ("LIBGL_ALWAYS_SOFTWARE", "GALLIUM_DRIVER", "MESA_LOADER_DRIVER_OVERRIDE",
+                     "__EGL_VENDOR_LIBRARY_FILENAMES", "EGL_PLATFORM"):
+            environment.pop(name, None)
+        if config.get("device", "CPU") == "CPU":
+            environment.update(LIBGL_ALWAYS_SOFTWARE="true", GALLIUM_DRIVER="llvmpipe",
+                               EGL_PLATFORM="surfaceless", LP_NUM_THREADS=str(threads))
+            mesa = Path("/usr/share/glvnd/egl_vendor.d/50_mesa.json")
+            if mesa.is_file():
+                environment["__EGL_VENDOR_LIBRARY_FILENAMES"] = str(mesa)
     return environment
 
 
@@ -313,6 +325,7 @@ def run_task(
         command = [
             str(binary), "--background", "--factory-startup", "--disable-autoexec",
             "--threads", str(_thread_count()), "--python-exit-code", "1",
+            "--gpu-backend", "opengl",
             "--python", str(_WORKER), "--", task_filename,
         ]
         with log_path.open("wb") as log:
@@ -322,7 +335,7 @@ def run_task(
                 stdout=log,
                 stderr=subprocess.STDOUT,
                 cwd=log_path.parent,
-                env=_worker_environment(),
+                env=_worker_environment(task.get("config", {})),
                 start_new_session=os.name == "posix",
                 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0,
             )

docs/API.zh-CN.md

@@ -141,7 +141,8 @@ job_id, status = client.predict(
 | `scene` / `camera` / `view_layer` | 名称或 null | 指定 Blender 数据块；默认沿用场景设置 |
 | `width` / `height` | 16–8192 | 基础分辨率，受像素总量上限限制 |
 | `resolution_percentage` | 1–100 | 实际输出缩放比例 |
-| `samples` | 1–4096 | Cycles 最大采样数 |
+| `engine` | `EEVEE` / `CYCLES` | 默认 Eevee |
+| `samples` | 1–4096 | Eevee 渲染采样数或 Cycles 最大采样数 |
 | `denoise` | true / false | 降噪 |
 | `adaptive_threshold` | 0.0–1.0 | 自适应采样阈值 |
 | `frame` | 正整数 | 单图帧号 |
@@ -150,7 +151,7 @@ job_id, status = client.predict(
 | `format` | `PNG` / `OPEN_EXR` | 视频模式只接受 PNG |
 | `color_depth` | 8 / 16 / 32 | PNG：8/16；EXR：16/32 |
 | `transparent` | true / false | 透明背景；MP4 不支持 |
-| `device` | `AUTO` / `CUDA` / `OPTIX` / `CPU` | CPU 必须同时由管理员启用 CPU 后端 |
+| `device` | `AUTO` / `CUDA` / `OPTIX` / `CPU` | 默认 CPU；无需管理员切换。AUTO 为显式 GPU，CUDA/OPTIX 仅适用 Cycles |
 | `batch_size` | 1–64 | 每次请求最多渲染帧数 |
 | `gpu_seconds` | 10–600 | ZeroGPU 请求预算；平台可能另有限制，不是时长保证 |
 | `cpu_timeout` | 10–7200 | 普通 GPU/CPU 子进程与编码超时 |
@@ -190,3 +191,7 @@ HF 也提供 Hub MCP 集成；是否能直接添加某个私有 Space、如何
 ## 推荐 Agent 策略
 
 先读取 `environment_info` 与 `config_schema`；首次部署调用 `gpu_self_test`。准备后立刻保存 ID，检查场景相机和缺失资产，再串行调用 `render_chunk`，每次都判断错误和完成帧增量。全部完成后 `finalize_job` 并核验输出。出现配额、超时或兼容性失败时停止自动重试、取回部分输出和日志，明确报告原因；修复后用相同 ID 恢复，若修改工程或配置则新建任务。
+
+## 1.1.0 默认模式
+
+空配置 `{}` 选择 `engine=EEVEE, device=CPU`，使用 Mesa llvmpipe 软件 OpenGL，不申请 GPU。`cpu_self_test` 无参数，返回真实 CPU Eevee 自检结果、日志与图片；`gpu_self_test` 明确测试 Cycles GPU。ZeroGPU 不保证提供 Eevee 所需硬件 EGL/OpenGL；Eevee GPU 检测到软件驱动会报错。已有旧任务按 Cycles 续渲，新任务使用新默认。

docs/ARCHITECTURE.zh-CN.md

@@ -1,10 +1,10 @@
 # 架构与实施规划
 
-版本：1.0.0。目标是用相同的工程文件与 JSON 参数，把 Blender 渲染任务交给 HF Space，允许人操作界面，也允许 agent 全程使用 API/MCP。交付为可部署代码，不包含已经创建的 Space，也不包含 HF 上真实 ZeroGPU 渲染成功的声明。
+版本：1.1.0。目标是用相同的工程文件与 JSON 参数，把 Blender 渲染任务交给 HF Space，允许人操作界面，也允许 agent 全程使用 API/MCP。交付为可部署代码，不包含已经创建的 Space，也不包含 HF 上真实 ZeroGPU 渲染成功的声明。
 
 ## 可行性结论与技术选择
 
-ZeroGPU 通过 `spaces.GPU` 为函数申请有时间限制的 GPU；官方重点支持 Gradio/PyTorch。Blender Cycles 是外部原生程序，因此平台兼容性是必须实测的前提，而不是装饰器能自动保证的事情。当前采取「租约内启动 Blender 子进程 → 检测 Cycles 设备 → 实际渲染 → 读取报告」路径。平台如果禁止或不支持这条路径，就明确失败并保留日志。普通 NVIDIA GPU Space 作为显式备选，CPU 作为显式开发测试模式。[ZeroGPU 文档](https://huggingface.co/docs/hub/en/spaces-zerogpu)
+ZeroGPU 通过 `spaces.GPU` 为函数申请有时间限制的 GPU；官方重点支持 Gradio/PyTorch。Blender Cycles 是外部原生程序，因此平台兼容性是必须实测的前提，而不是装饰器能自动保证的事情。当前采取「租约内启动 Blender 子进程 → 检测 Cycles 设备 → 实际渲染 → 读取报告」路径。平台如果禁止或不支持这条路径，就明确失败并保留日志。普通 NVIDIA GPU Space 作为显式备选，CPU + Eevee 为默认正式工作模式，使用 Mesa 软件 OpenGL，绕过 GPU 租约。[ZeroGPU 文档](https://huggingface.co/docs/hub/en/spaces-zerogpu)
 
 采用官方 Blender Linux x64 分发包而不是在 Python 中嵌入 `bpy`：保持 Blender 自己的 Python、Cycles 与打包库版本一致，同时便于超时后结束进程树。服务端 Python 3.12、Gradio 6.28.0、spaces 0.51.3；PyTorch 固定为官方支持的 2.8.0，用于 ZeroGPU 平台运行时，真正的图像生成仍由 Blender 完成。[spaces 发布记录](https://pypi.org/project/spaces/0.51.3/)、[Gradio 发布记录](https://pypi.org/project/gradio/6.28.0/)
 
@@ -32,7 +32,7 @@ flowchart TD
     B --> C["场景、相机与资源检查"]
     C --> D{"执行后端"}
     D --> E["ZeroGPU 租约"]
-    D --> F["普通 GPU / 显式 CPU"]
+    D --> F["普通 GPU / 默认 CPU"]
     E --> G["Blender 渲染当前批次"]
     F --> G
     G --> H["原子保存完成帧"]
@@ -92,3 +92,7 @@ GPU 配额由 HF 账号、排队和平台规则决定；应用不绕过配额，
 自动化可检查 JSON/ZIP 拒绝路径、任务状态、断点、API 参数、CPU 小场景和 FFmpeg 输出。实际 HF ZeroGPU 的租约、GPU 子进程可见性、驱动/OptiX 兼容性、账号配额、真实场景显存、长时间稳定性必须在目标 Space 验证。自检通过只证明该次小场景成功；不能推出所有工程和无限长度视频都能成功。
 
 建议部署验收顺序：真实自检 → 低分辨率单帧 → 3 帧连续动画 → 一次中断/恢复 → 下载并核对结果 → 正式任务。只做针对剩余风险的验证，不以重复 CPU 测试代替 GPU 实测。
+
+## 1.1.0 更新
+
+任务引擎与计算设备独立选择；新配置默认 Eevee / CPU。CPU 路径直接启动 Blender；GPU 路径才进入 spaces.GPU。旧任务缺少 engine 时按 Cycles 续渲，防止混帧。任务文件锁在退出时显式 LOCK_UN，避免 GPU fork 子进程继承文件描述符后继续持锁。

docs/DEPLOY.zh-CN.md

@@ -31,7 +31,7 @@
 | 超时 | 场景加载与首帧总耗时 | 降低采样/分辨率；单帧不能完成时使用普通 GPU |
 | 配额用尽或排队拒绝 | HF 调用账号当前配额 | 等待配额恢复；不要无休止自动重试 |
 
-普通 GPU 备选需要你手动选择硬件，并将 `RENDER_BACKEND=gpu`。这可能产生费用；代码不会操作 HF 硬件设置。`gpu_self_test` 在显式 CPU 模式下会测试 CPU 渲染，但返回 `gpu_verified=false`，不能当作 GPU 成功证据。
+普通 GPU 备选需要你手动选择硬件，并将 `RENDER_BACKEND=gpu`。这可能产生费用；代码不会操作 HF 硬件设置。`cpu_self_test` 测试默认 Eevee CPU；`gpu_self_test` 始终显式测试 Cycles GPU。
 
 ## 工程准备
 
@@ -63,7 +63,7 @@ ZIP 可包含如下路径：
 
 | 变量 | 默认值 | 作用 |
 | --- | --- | --- |
-| `RENDER_BACKEND` | `auto` | `auto` 检测 ZeroGPU，否则普通 GPU；可显式 `zerogpu` / `gpu` / `cpu` |
+| `RENDER_BACKEND` | `auto` | 仅决定 GPU 任务路由；默认任务 device=CPU 绕过租约。auto/cpu 在显式 GPU 任务中检测 ZeroGPU，否则普通 GPU |
 | `BLENDER_VERSION` | `5.2.2` | 自动下载的官方 Blender 三段版本号 |
 | `BLENDER_BIN` | 未设置 | 已安装 Blender 可执行文件绝对路径；优先于自动下载 |
 | `BLENDER_CACHE` | 用户缓存目录内的 `blender-render-space` | Blender 下载和安装缓存 |
@@ -115,3 +115,9 @@ python app.py
 若你已配置持久化挂载，可将 `RENDER_DATA_DIR` 指向该挂载的可写目录；本应用不会自动购买或创建持久存储。持久化数据还应自行备份。[HF 存储文档](https://huggingface.co/docs/hub/en/spaces-storage)
 
 推荐私有 Space、受信任工程、不存放与渲染无关的敏感凭据。随机 job ID 是任务访问凭据，获得 ID 的调用者可以访问任务状态和输出。现有路径控制和禁脚本不是强隔离沙箱，复杂恶意 `.blend` 仍可能触发 Blender 原生漏洞。
+
+## 1.1.0 CPU + Eevee
+
+默认 engine=EEVEE、device=CPU，CPU 通过 Mesa llvmpipe 软件 OpenGL 运行 Eevee。packages.txt 安装 libegl-mesa0、libgl1-mesa-dri、libglx-mesa0；只在 CPU Eevee 子进程设置 LIBGL_ALWAYS_SOFTWARE、GALLIUM_DRIVER 与 Mesa EGL，不污染 GPU 子进程。保留 ZeroGPU 硬件可让用户按任务选择 GPU，默认 CPU 不申请 GPU 租约。
+
+Eevee 在 CPU 上的软件绘制速度取决于工程，不保证快于 Cycles。GPU Eevee 需要硬件图形驱动；ZeroGPU 的 CUDA 可用不等于 EGL/OpenGL 可用。

docs/TEST_REPORT-1.1.0.zh-CN.md

@@ -0,0 +1,9 @@
+# 1.1.0 测试记录
+
+- 单元及回归测试：105 项通过。
+- 验证 CPU 任务在 ZeroGPU 配置下绕过 GPU 租约。
+- 验证 GPU 显式选择、CUDA / OptiX 仅供 Cycles、旧任务保持 Cycles。
+- 验证 fork 子进程仍持有文件描述符时，父进程正确释放任务锁。
+- Blender 5.2.2 LTS 实际 CPU Eevee 渲染成功：Mesa llvmpipe (LLVM 20.1.2, 256 bits)。
+- 本机 Gradio API：上传工程 ZIP 与 JSON、640×360 PNG 渲染、结果 ZIP 下载及完整性检查通过。
+- 线上验证将在部署后追加。Eevee CPU 使用软件 OpenGL，不保证所有场景都快于 Cycles。

examples/cycles-gpu.json

@@ -0,0 +1,9 @@
+{
+  "engine": "CYCLES",
+  "device": "AUTO",
+  "mode": "image",
+  "width": 640,
+  "height": 360,
+  "samples": 32,
+  "gpu_seconds": 120
+}

examples/frames-exr.json

@@ -12,10 +12,11 @@
   "format": "OPEN_EXR",
   "color_depth": 16,
   "transparent": true,
-  "device": "AUTO",
+  "device": "CPU",
   "strict_assets": true,
-  "batch_size": 1,
+  "batch_size": 16,
   "gpu_seconds": 120,
   "cpu_timeout": 600,
-  "seed": 0
+  "seed": 0,
+  "engine": "EEVEE"
 }

examples/image.json

@@ -11,10 +11,11 @@
   "format": "PNG",
   "color_depth": 8,
   "transparent": false,
-  "device": "AUTO",
+  "device": "CPU",
   "strict_assets": true,
   "batch_size": 1,
   "gpu_seconds": 120,
   "cpu_timeout": 600,
-  "seed": 0
+  "seed": 0,
+  "engine": "EEVEE"
 }

examples/video.json

@@ -15,12 +15,13 @@
   "format": "PNG",
   "color_depth": 8,
   "transparent": false,
-  "device": "AUTO",
+  "device": "CPU",
   "strict_assets": true,
-  "batch_size": 1,
+  "batch_size": 16,
   "gpu_seconds": 120,
   "cpu_timeout": 600,
   "video_crf": 18,
   "video_preset": "medium",
-  "seed": 0
+  "seed": 0,
+  "engine": "EEVEE"
 }

packages.txt

@@ -13,3 +13,6 @@ libxxf86vm1
 libxrandr2
 libxcursor1
 libwayland-client0
+libegl-mesa0
+libgl1-mesa-dri
+libglx-mesa0

render.schema.json

@@ -165,8 +165,17 @@
       "title": "Color Depth",
       "type": "integer"
     },
+    "engine": {
+      "default": "EEVEE",
+      "enum": [
+        "EEVEE",
+        "CYCLES"
+      ],
+      "title": "Engine",
+      "type": "string"
+    },
     "device": {
-      "default": "AUTO",
+      "default": "CPU",
       "enum": [
         "AUTO",
         "CUDA",

render_config.py

@@ -67,7 +67,8 @@ class RenderConfig(BaseModel):
     fps: Annotated[int, Field(ge=1, le=120)] = 24
     format: Literal["PNG", "OPEN_EXR"] = "PNG"
     color_depth: Literal[8, 16, 32] = 8
-    device: Literal["AUTO", "CUDA", "OPTIX", "CPU"] = "AUTO"
+    engine: Literal["EEVEE", "CYCLES"] = "EEVEE"
+    device: Literal["AUTO", "CUDA", "OPTIX", "CPU"] = "CPU"
     seed: Annotated[int, Field(ge=0, le=2_147_483_647)] = 0
     motion_blur: bool = False
     strict_assets: bool = True
@@ -105,6 +106,8 @@ class RenderConfig(BaseModel):
 
     @model_validator(mode="after")
     def validate_render_constraints(self) -> "RenderConfig":
+        if self.engine == "EEVEE" and self.device in {"CUDA", "OPTIX"}:
+            raise ValueError("CUDA / OPTIX 仅用于 Cycles；Eevee 请使用 CPU 或 AUTO。")
         if self.frame_end < self.frame_start:
             raise ValueError("frame_end 不能小于 frame_start。")
         if self.format == "PNG" and self.color_depth not in (8, 16):

render_worker.py

@@ -315,8 +315,13 @@ def inspect_scene(assets):
             "missing_assets": [a for a in assets if a["status"] in {"missing", "blocked"}]}
 
 
-def configure_cycles(scene, config):
-    scene.render.engine = "CYCLES"
+def configure_render(scene, config):
+    engine = config.get("engine", "EEVEE")
+    if engine == "CYCLES":
+        scene.render.engine = "CYCLES"
+    else:
+        engines = scene.render.bl_rna.properties["engine"].enum_items.keys()
+        scene.render.engine = "BLENDER_EEVEE_NEXT" if "BLENDER_EEVEE_NEXT" in engines else "BLENDER_EEVEE"
     for key, default in (("resolution_x", 960), ("resolution_y", 540)):
         source = "width" if key == "resolution_x" else "height"
         setattr(scene.render, key, int(config.get(source, default)))
@@ -330,12 +335,15 @@ def configure_cycles(scene, config):
     scene.render.image_settings.file_format = config.get("format", "PNG")
     scene.render.image_settings.color_mode = "RGBA"
     scene.render.image_settings.color_depth = str(config.get("color_depth", 8))
-    scene.cycles.samples = int(config.get("samples", 64))
-    scene.cycles.use_denoising = bool(config.get("denoise", True))
-    scene.cycles.use_adaptive_sampling = True
-    scene.cycles.adaptive_threshold = float(config.get("adaptive_threshold", 0.01))
-    scene.cycles.seed = int(config.get("seed", 0))
-    scene.cycles.shading_system = False
+    if engine == "CYCLES":
+        scene.cycles.samples = int(config.get("samples", 64))
+        scene.cycles.use_denoising = bool(config.get("denoise", True))
+        scene.cycles.use_adaptive_sampling = True
+        scene.cycles.adaptive_threshold = float(config.get("adaptive_threshold", 0.01))
+        scene.cycles.seed = int(config.get("seed", 0))
+        scene.cycles.shading_system = False
+    else:
+        scene.eevee.taa_render_samples = int(config.get("samples", 64))
     if hasattr(scene.render, "use_motion_blur"):
         scene.render.use_motion_blur = bool(config.get("motion_blur", False))
     elif hasattr(scene.cycles, "use_motion_blur"):
@@ -350,7 +358,9 @@ def configure_cycles(scene, config):
         raise ValueError("场景没有活动相机，请在 JSON 中指定 camera 或先在 Blender 中添加相机。")
 
 
-def device_candidates(requested):
+def device_candidates(requested, engine="CYCLES"):
+    if engine == "EEVEE":
+        return ("CPU" if requested == "CPU" else "EEVEE_GPU",)
     if requested == "AUTO":
         return ("OPTIX", "CUDA")
     if requested not in {"OPTIX", "CUDA", "CPU"}:
@@ -359,6 +369,18 @@ def device_candidates(requested):
 
 
 def use_device(scene, backend):
+    if scene.render.engine != "CYCLES":
+        import gpu
+        if hasattr(gpu, "init"):
+            gpu.init()
+        renderer = gpu.platform.renderer_get()
+        vendor = gpu.platform.vendor_get()
+        software = any(tag in renderer.lower() for tag in ("llvmpipe", "softpipe", "swrast", "software", "lavapipe"))
+        if backend != "CPU" and software:
+            raise RuntimeError("Eevee 未找到硬件图形驱动；当前是软件 OpenGL。请使用 CPU + Eevee，或 GPU + Cycles。")
+        if backend == "CPU" and not software:
+            raise RuntimeError("CPU Eevee 未确认 Mesa 软件渲染器；拒绝误用硬件 GPU。")
+        return [{"name": renderer, "vendor": vendor, "type": "CPU" if software else "GPU", "use": True}]
     addon = bpy.context.preferences.addons.get("cycles")
     if addon is None:
         raise RuntimeError("此 Blender 安装不包含 Cycles。")
@@ -441,7 +463,7 @@ def main():
     output_dir.mkdir(parents=True, exist_ok=True)
     config = task.get("config", {})
     result = {"ok": False, "action": task["action"], "blender_version": bpy.app.version_string,
-              "warnings": [], "devices": [], "backend": None, "frames": [], "timings": {}}
+              "engine": config.get("engine", "EEVEE"), "warnings": [], "devices": [], "backend": None, "frames": [], "timings": {}}
     start = time.monotonic()
     try:
         action = task["action"]
@@ -450,9 +472,9 @@ def main():
             probe_config = {**config, "width": 32, "height": 32, "resolution_percentage": 100,
                             "samples": 1, "denoise": False, "format": "PNG", "color_depth": "8"}
             harden_scenes(result["warnings"])
-            configure_cycles(scene, probe_config)
+            configure_render(scene, probe_config)
             failures = []
-            for backend in device_candidates(config.get("device", "AUTO")):
+            for backend in device_candidates(config.get("device", "CPU"), config.get("engine", "EEVEE")):
                 try:
                     result["devices"] = use_device(scene, backend)
                     result["backend"] = backend
@@ -462,7 +484,7 @@ def main():
                 except Exception as exc:
                     failures.append(f"{backend}: {exc}")
             else:
-                raise RuntimeError("实际 Cycles 探针渲染失败；检测到 CUDA 不代表 ZeroGPU 可以运行 Blender。" + " | ".join(failures))
+                raise RuntimeError("实际渲染探针失败。" + " | ".join(failures))
             result["warnings"].extend(failures)
         elif action in {"inspect", "render"}:
             root = Path(task["project_root"]).resolve(strict=True)
@@ -480,14 +502,14 @@ def main():
                     missing = ", ".join(a["name"] for a in result["missing_assets"][:8])
                     raise ValueError(f"存在缺失或越界资源：{missing}。请上传完整资源，或将 strict_assets 设为 false 后接受缺失效果。")
                 scene = select_scene(config)
-                configure_cycles(scene, config)
+                configure_render(scene, config)
                 frames = task.get("frames") or [int(config.get("frame", config.get("frame_start", scene.frame_current)))]
                 for frame in frames:
                     if not isinstance(frame, int) or isinstance(frame, bool) or abs(frame) > 1_048_574:
                         raise ValueError("帧编号必须是 Blender 支持范围内的整数。")
                 # AUTO 必须通过实际首帧验证；OPTIX 初始化成功也可能在加载内核时失败。
                 failures = []
-                for backend in device_candidates(config.get("device", "AUTO")):
+                for backend in device_candidates(config.get("device", "CPU"), config.get("engine", "EEVEE")):
                     try:
                         result["devices"] = use_device(scene, backend)
                         result["backend"] = backend

scripts/smoke_test.py

@@ -47,7 +47,7 @@ def main():
             client = Client(url, verbose=False, download_files=str(temp / 'downloads'),
                             httpx_kwargs={'trust_env':False})
             environment = client.predict(api_name='/environment_info')
-            probe, _, _ = client.predict(api_name='/gpu_self_test')
+            probe, _, _ = client.predict(api_name='/cpu_self_test')
             assert probe['ok'] and probe['backend'] == 'CPU' and not probe['gpu_verified']
             job_id, prepared = client.predict([handle_file(str(project))], '{}', handle_file(str(config)),
                                               api_name='/prepare_job')

service.py

@@ -61,36 +61,50 @@ def _lock(path: Path):
     if not lock.acquire(blocking=False):
         raise ValueError('该任务正在执行，请等待或取消当前批次。')
     handle = None
+    acquired = False
     try:
         handle = (path / '.lock').open('a+')
         # Linux 文件锁使重入和多进程请求也不能同时更改同一任务。
         import fcntl
         try:
             fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            acquired = True
         except BlockingIOError:
             raise ValueError('该任务正在另一个进程执行。') from None
         yield
     finally:
         if handle is not None:
-            handle.close()
+            # ZeroGPU forks can inherit this descriptor. Closing the parent copy
+            # alone leaves the lock held until all forked copies disappear.
+            try:
+                if acquired:
+                    fcntl.flock(handle, fcntl.LOCK_UN)
+            finally:
+                handle.close()
         lock.release()
 
 
-def _backend() -> str:
+def _backend(cfg: RenderConfig | None = None) -> str:
+    # Each job explicitly chooses CPU or GPU. Deployment hardware stays available.
+    if cfg is None or cfg.device == 'CPU':
+        return 'cpu'
     choice = os.environ.get('RENDER_BACKEND', 'auto').lower()
-    if choice not in {'auto', 'zerogpu', 'gpu', 'cpu'}:
-        raise ValueError('RENDER_BACKEND 必须为 auto / zerogpu / gpu / cpu。')
     from spaces.config import Config
     zero = bool(Config.zero_gpu)
-    if choice == 'auto':
+    if choice in {'auto', 'cpu'}:
         return 'zerogpu' if zero else 'gpu'
     if choice == 'zerogpu' and not zero:
-        raise ValueError('当前不是 ZeroGPU 运行环境。请在 Space 设置选择 ZeroGPU；本地测试请设置 RENDER_BACKEND=cpu 或 gpu。')
+        raise ValueError('当前不是 ZeroGPU 运行环境；请选择 CPU 或配置可用 GPU。')
+    if choice not in {'zerogpu', 'gpu'}:
+        raise ValueError('RENDER_BACKEND 必须为 auto、zerogpu、gpu 或 cpu。')
     return choice
 
 
 def _config(meta: dict) -> RenderConfig:
-    return parse_config(json.dumps(meta['config']))
+    saved = dict(meta['config'])
+    # Pre-1.1 jobs were always Cycles. Never mix Eevee into a resumed sequence.
+    saved.setdefault('engine', 'CYCLES')
+    return parse_config(json.dumps(saved))
 
 
 def _frame_path(path: Path, frame: int, config: RenderConfig) -> Path:
@@ -180,12 +194,16 @@ def environment_info() -> dict:
         except importlib.metadata.PackageNotFoundError:
             versions[name] = None
     return {
-        'app_version': '1.0.0', 'versions': versions,
+        'app_version': '1.1.0', 'versions': versions,
         'zerogpu_environment': bool(Config.zero_gpu),
-        'configured_backend': os.environ.get('RENDER_BACKEND', 'auto'),
+        'configured_backend': 'cpu',
+        'gpu_backend_preference': os.environ.get('RENDER_BACKEND', 'auto'),
+        'default_engine': 'EEVEE', 'default_device': 'CPU',
+        'default_allocates_gpu': False,
+        'supported_engines': ['EEVEE', 'CYCLES'],
         'ffmpeg_available': bool(shutil.which('ffmpeg')),
         'gpu_verified': False,
-        'message': '本接口不分配 GPU。请运行真实渲染自检；ZeroGPU 对 Blender 的兼容性尚需部署验证。',
+        'message': '默认 CPU + Eevee（Mesa 软件 OpenGL），不申请 GPU。可显式选择 GPU；ZeroGPU 推荐 Cycles + AUTO。',
         'mcp_path': '/gradio_api/mcp/',
         'job_ttl_hours': int(os.environ.get('JOB_TTL_HOURS', '24')),
     }
@@ -210,11 +228,7 @@ def prepare_job(files: list[str], config_json: str, config_file: str | None = No
             raise ValueError('配置文件不得超过 64 KiB。')
         config_json = p.read_text(encoding='utf-8-sig')
     cfg = parse_config(config_json)
-    backend = _backend()
-    if backend != 'cpu' and cfg.device == 'CPU':
-        raise ValueError('CPU 渲染必须由管理员设置 RENDER_BACKEND=cpu，GPU 模式不允许静默回退。')
-    if backend == 'cpu':
-        cfg = cfg.model_copy(update={'device': 'CPU'})
+    backend = _backend(cfg)
     _cleanup()
     # 预留任务目录与数量检查是一个原子步骤，避免并行 API 越过任务上限。
     import fcntl
@@ -456,14 +470,22 @@ def finalize_job(job_id: str) -> tuple[dict, list[str], str | None, str | None]:
         return summary, files, image, video
 
 
+def cpu_self_test() -> tuple[dict, list[str], str | None]:
+    """Render a real Eevee frame on the CPU without requesting a GPU lease."""
+    return _self_test(RenderConfig(engine='EEVEE', device='CPU'))
+
+
 def gpu_self_test() -> tuple[dict, list[str], str | None]:
-    """Run a real tiny Cycles render on the selected backend and return diagnostics."""
-    backend = _backend()
+    """Explicitly test Cycles GPU; never invoked by CPU jobs."""
+    return _self_test(RenderConfig(engine='CYCLES', device='AUTO'))
+
+
+def _self_test(cfg: RenderConfig) -> tuple[dict, list[str], str | None]:
+    backend = _backend(cfg)
     ensure_blender()
     token = secrets.token_hex(24)
     path = JOB_ROOT / ('probe-' + token)
     path.mkdir()
-    cfg = RenderConfig(device='CPU' if backend == 'cpu' else 'AUTO')
     task = {'action': 'probe', 'project_root': str(path), 'output_dir': str(path / 'frames'),
             'result_path': str(path / 'probe-result.json'), 'config': cfg.model_dump(), 'frames': [1]}
     try:
@@ -472,7 +494,7 @@ def gpu_self_test() -> tuple[dict, list[str], str | None]:
         result['gpu_verified'] = bool(result.get('ok')) and backend != 'cpu'
     except Exception as exc:
         result = {'ok': False, 'gpu_verified': False, 'deployment_backend': backend,
-                  'error': str(exc), 'message': '该环境尚未通过 Blender GPU 渲染验证；请查看日志或改用普通 GPU Space。'}
+                  'error': str(exc), 'message': '渲染自检失败，请查看日志。'}
     result = _public_report(result)
     _atomic_json(path / 'probe-result.json', result)
     files = [_export(path, path / 'probe-result.json')]

test-artifacts/api-smoke-report.json

@@ -12,7 +12,7 @@
   "api_download_zip_verified": true,
   "zero_gpu_tested": false,
   "environment": {
-    "app_version": "1.0.0",
+    "app_version": "1.1.0",
     "versions": {
       "gradio": "6.28.0",
       "spaces": "0.51.3",
@@ -20,9 +20,17 @@
     },
     "zerogpu_environment": false,
     "configured_backend": "cpu",
+    "gpu_backend_preference": "cpu",
+    "default_engine": "EEVEE",
+    "default_device": "CPU",
+    "default_allocates_gpu": false,
+    "supported_engines": [
+      "EEVEE",
+      "CYCLES"
+    ],
     "ffmpeg_available": true,
     "gpu_verified": false,
-    "message": "本接口不分配 GPU。请运行真实渲染自检；ZeroGPU 对 Blender 的兼容性尚需部署验证。",
+    "message": "默认 CPU + Eevee（Mesa 软件 OpenGL），不申请 GPU。可显式选择 GPU；ZeroGPU 推荐 Cycles + AUTO。",
     "mcp_path": "/gradio_api/mcp/",
     "job_ttl_hours": 24
   }

tests/test_render_modes.py

@@ -0,0 +1,74 @@
+import importlib
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from render_config import RenderConfig, parse_config
+from blender_runtime import _worker_environment
+
+
+def test_default_cpu_bypasses_zerogpu_even_when_deployment_is_zerogpu(monkeypatch):
+    import service
+    monkeypatch.setenv('RENDER_BACKEND', 'zerogpu')
+    cfg = parse_config('{}')
+    assert (cfg.engine, cfg.device) == ('EEVEE', 'CPU')
+    assert service._backend(cfg) == 'cpu'
+    calls = []
+    monkeypatch.setattr(service, 'run_task', lambda *args: calls.append('cpu') or {'ok': True})
+    monkeypatch.setattr(service, '_zero_render', lambda *args: pytest.fail('CPU must not allocate a GPU'))
+    service._execute({}, Path('/tmp'), service._backend(cfg), cfg, Path('/tmp/mode-test.log'))
+    assert calls == ['cpu']
+
+
+def test_gpu_is_opt_in_and_cycles_only_devices_are_validated(monkeypatch):
+    import service
+    from spaces.config import Config
+    monkeypatch.setenv('RENDER_BACKEND', 'auto')
+    monkeypatch.setattr(Config, 'zero_gpu', True)
+    assert service._backend(RenderConfig(engine='CYCLES', device='AUTO')) == 'zerogpu'
+    assert service._backend(RenderConfig(engine='CYCLES', device='CPU')) == 'cpu'
+    with pytest.raises(ValueError, match='CUDA / OPTIX'):
+        RenderConfig(engine='EEVEE', device='CUDA')
+
+
+def test_software_gl_environment_does_not_leak_into_gpu_jobs(monkeypatch):
+    monkeypatch.setenv('LIBGL_ALWAYS_SOFTWARE', 'true')
+    monkeypatch.setenv('GALLIUM_DRIVER', 'llvmpipe')
+    cpu = _worker_environment({'engine': 'EEVEE', 'device': 'CPU'})
+    gpu = _worker_environment({'engine': 'EEVEE', 'device': 'AUTO'})
+    assert cpu['LIBGL_ALWAYS_SOFTWARE'] == 'true'
+    assert cpu['GALLIUM_DRIVER'] == 'llvmpipe'
+    assert 'LIBGL_ALWAYS_SOFTWARE' not in gpu
+    assert 'GALLIUM_DRIVER' not in gpu
+
+
+@pytest.mark.skipif(not hasattr(os, 'fork'), reason='Linux fork regression')
+def test_lock_released_while_forked_worker_still_holds_descriptor(tmp_path):
+    import service
+    r, w = os.pipe()
+    child = None
+    try:
+        with service._lock(tmp_path):
+            child = os.fork()
+            if child == 0:
+                os.close(w)
+                os.read(r, 1)
+                os._exit(0)
+        # Child still owns an inherited descriptor, but must not own the lock.
+        with service._lock(tmp_path):
+            pass
+    finally:
+        if child:
+            os.write(w, b'x')
+            os.waitpid(child, 0)
+        os.close(r)
+        os.close(w)
+
+
+def test_legacy_jobs_resume_with_cycles():
+    import service
+    assert service._config({'config': {'device': 'AUTO'}}).engine == 'CYCLES'
+    assert service._config({'config': {'engine': 'EEVEE', 'device': 'CPU'}}).engine == 'EEVEE'

tests/test_service.py

@@ -34,7 +34,7 @@ def service(monkeypatch, tmp_path):
         monkeypatch.setattr(module, attribute, value)
     monkeypatch.setattr(module, "_LOCKS", {})
     monkeypatch.setattr(module, "ensure_blender", lambda: Path("/test/fake-blender"))
-    monkeypatch.setattr(module, "_backend", lambda: "cpu")
+    monkeypatch.setattr(module, "_backend", lambda cfg=None: "cpu")
     return module