Upload full text Space sources

.gitattributes

@@ -33,3 +33,54 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/example_image/T.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_building_building.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_building_castle.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_building_colorful_cottage.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_building_maya_pyramid.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_building_mushroom.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_building_space_station.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_dragon.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_elephant.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_furry.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_quadruped.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_robot_crab.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_robot_dinosour.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_creature_rock_monster.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_humanoid_block_robot.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_humanoid_dragonborn.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_humanoid_dwarf.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_humanoid_goblin.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_humanoid_mech.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_crate.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_fireplace.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_gate.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_lantern.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_magicbook.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_mailbox.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_monster_chest.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_paper_machine.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_phonograph.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_portal2.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_storage_chest.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_telephone.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_television.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_misc_workbench.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_biplane.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_bulldozer.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_cart.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_excavator.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_helicopter.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_locomotive.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/typical_vehicle_pirate_ship.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image/weatherworn_misc_paper_machine3.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image_edit/flower_rm.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image_edit/ice_cream_rm.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image_edit/pineapple_rm.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image_edit/typical_building_mushroom.png filter=lfs diff=lfs merge=lfs -text
+assets/example_image_edit/wooden_rm.png filter=lfs diff=lfs merge=lfs -text
+assets/teaser.png filter=lfs diff=lfs merge=lfs -text
+assets/teaser2.png filter=lfs diff=lfs merge=lfs -text
+example_results/T.glb filter=lfs diff=lfs merge=lfs -text
+trellis/representations/mesh/flexicubes/images/block_init.png filter=lfs diff=lfs merge=lfs -text
+trellis/representations/mesh/flexicubes/images/teaser_top.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,418 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
+
+# Python / Hugging Face Space artifacts
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.cache/
+tmp/
+ckpts/
+*.safetensors
+*.ckpt
+*.pt
+*.pth
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.tlog
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio 6 auto-generated project file (contains which files were open etc.)
+*.vbp
+
+# Visual Studio 6 workspace and project file (working project files containing files to include in project)
+*.dsw
+*.dsp
+
+# Visual Studio 6 technical files
+*.ncb
+*.aps
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# Visual Studio History (VSHistory) files
+.vshistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+# VS Code files for those working on multiple tools
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+# Windows Installer files from build outputs
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# JetBrains Rider
+*.sln.iml
+
+# Mac 
+.DS_Store
+.vscode/
+ckpts/
+tmp/

LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

NOTICE

@@ -0,0 +1,22 @@
+DVD: Discrete Voxel Diffusion for 3D Generation and Editing
+Copyright 2026 Zhengrui Xiang
+
+This project includes code and/or components adapted from the following projects:
+
+TRELLIS
+Copyright Microsoft Corporation and contributors.
+Licensed under the MIT License.
+Source: https://github.com/microsoft/TRELLIS
+
+DUO: The Diffusion Duality
+Subham Sekhar Sahoo, Justin Deschenaux, Aaron Gokaslan, Guanghan Wang, Justin Chiu, Volodymyr Kuleshov and contributors.
+
+Licensed under the Apache License, Version 2.0.
+Source: https://github.com/s-sahoo/duo
+
+Portions adapted from DUO were modified for discrete voxel diffusion training,
+sampling, evaluation, and related experiments.
+
+This project may also depend on third-party packages with separate license terms,
+including nvdiffrast and nvdiffrec. Please refer to the corresponding upstream repositories
+and license files for details.

THIRD_PARTY_LICENSES/LICENSE_DUO.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Subham Sekhar Sahoo
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

app.py

@@ -0,0 +1,53 @@
+import os
+
+
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+try:
+    import spaces
+except ImportError:
+    spaces = None
+
+import gradio as gr
+
+
+# Do not request a ZeroGPU worker during app startup. CUDA render extensions
+# are installed from prebuilt wheels in requirements.txt.
+APP_MODE = os.environ.get("DVD_SPACE_APP", "image").strip().lower()
+
+
+def _maybe_preload(module, label: str):
+    if os.environ.get("DVD_PRELOAD_DVD_GEN", "0").lower() in {"0", "false", "no"}:
+        return
+    module.log_event(f"preloading {label} DVD generation pipeline on cpu")
+    module.ensure_dvd_gen_pipeline("cpu")
+    module.log_event(f"{label} DVD generation pipeline preloaded on cpu")
+
+
+if APP_MODE in {"image", "img"}:
+    import app_dvd_image as app_module
+    _maybe_preload(app_module, "image")
+    demo = app_module.demo
+elif APP_MODE in {"text", "txt"}:
+    import app_dvd_text as app_module
+    _maybe_preload(app_module, "text")
+    demo = app_module.demo
+elif APP_MODE in {"both", "all", "full"}:
+    import app_dvd_image
+    import app_dvd_text
+    _maybe_preload(app_dvd_image, "image")
+    _maybe_preload(app_dvd_text, "text")
+    demo = gr.TabbedInterface(
+        [app_dvd_image.demo, app_dvd_text.demo],
+        ["Image", "Text"],
+        title="DVD + TRELLIS Voxel Generation and Editing",
+    )
+else:
+    raise ValueError("DVD_SPACE_APP must be 'image', 'text', or 'both'.")
+
+
+if __name__ == "__main__":
+    demo.queue().launch(show_api=False, show_error=True, ssr_mode=False)

app_dvd_image.py

@@ -0,0 +1,1160 @@
+import os
+
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+
+try:
+    import huggingface_hub
+
+    if not hasattr(huggingface_hub, "HfFolder"):
+        class HfFolder:
+            @staticmethod
+            def get_token():
+                return huggingface_hub.get_token()
+
+            @staticmethod
+            def save_token(token):
+                return huggingface_hub.login(token=token, add_to_git_credential=False)
+
+        huggingface_hub.HfFolder = HfFolder
+except Exception:
+    pass
+
+import gradio as gr
+import torch
+
+try:
+    import spaces
+except ImportError:
+    class _SpacesFallback:
+        @staticmethod
+        def GPU(duration=180):
+            return lambda fn: fn
+
+    spaces = _SpacesFallback()
+
+import argparse
+import gc
+import shutil
+import uuid
+from pathlib import Path
+
+import gradio_client.utils as gradio_client_utils
+import numpy as np
+from PIL import Image
+from starlette.templating import Jinja2Templates
+
+MAX_SEED = np.iinfo(np.int32).max
+RESOLUTION = 64
+ROOT_DIR = Path(__file__).resolve().parent
+TMP_DIR = ROOT_DIR / "tmp" / "dvd_app"
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+
+GEN_DVD_CONFIG = os.environ.get("DVD_GEN_CONFIG", "ckpts/dvd_img.json")
+GEN_DVD_CKPT = os.environ.get("DVD_GEN_CKPT", "ckpts/dvd_img.safetensors")
+EDIT_DVD_CONFIG = os.environ.get("DVD_EDIT_CONFIG", "ckpts/dvd_img_BSP_ft.json")
+EDIT_DVD_CKPT = os.environ.get("DVD_EDIT_CKPT", "ckpts/dvd_img_BSP_ft.safetensors")
+TRELLIS_IMAGE_MODEL = os.environ.get("TRELLIS_IMAGE_MODEL", "microsoft/TRELLIS-image-large")
+DVD_MODEL_REPO = os.environ.get("DVD_MODEL_REPO")
+DVD_MODEL_SUBFOLDER = os.environ.get("DVD_MODEL_SUBFOLDER") or None
+DVD_MODEL_REVISION = os.environ.get("DVD_MODEL_REVISION") or None
+DVD_MODEL_TOKEN = os.environ.get("DVD_MODEL_TOKEN") or os.environ.get("HF_TOKEN") or None
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
+
+
+def parse_camera_position(value: str) -> tuple[float, float, float]:
+    parts = [float(part.strip()) for part in value.split(",")]
+    if len(parts) != 3:
+        raise ValueError("DVD_VOXEL_CAMERA_POSITION must be three comma-separated numbers, e.g. -180,90,3")
+    return tuple(parts)
+
+
+VOXEL_CAMERA_POSITION = parse_camera_position(os.environ.get("DVD_VOXEL_CAMERA_POSITION", "-180,90,3"))
+
+
+dvd_gen_pipeline = None
+dvd_edit_pipeline = None
+trellis_pipeline = None
+
+DVDImageToVoxelPipeline = None
+TrellisImageTo3DPipeline = None
+as_voxel_output = None
+export_cubified_voxels = None
+run_image_stage2_from_dvd_voxels = None
+
+_postprocessing_utils = None
+
+
+def log_event(message: str):
+    print(f"[DVD Space] {message}", flush=True)
+
+
+def _download_file(url: str, dest: Path):
+    import urllib.request
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if dest.exists() and dest.stat().st_size > 0:
+        log_event(f"using cached {dest.name}")
+        return
+    tmp = dest.with_name(dest.name + ".tmp")
+    if tmp.exists():
+        tmp.unlink()
+    log_event(f"downloading {url} -> {dest}")
+    urllib.request.urlretrieve(url, tmp)
+    tmp.replace(dest)
+
+
+def prefetch_dvd_weights():
+    from huggingface_hub import hf_hub_download, snapshot_download
+
+    if DVD_MODEL_REPO:
+        filenames = (
+            "dvd_img.json",
+            "dvd_img.safetensors",
+            "dvd_img_BSP_ft.json",
+            "dvd_img_BSP_ft.safetensors",
+        )
+        for filename in filenames:
+            log_event(f"prefetching {DVD_MODEL_REPO}/{filename}")
+            hf_hub_download(
+                repo_id=DVD_MODEL_REPO,
+                filename=filename,
+                subfolder=DVD_MODEL_SUBFOLDER,
+                revision=DVD_MODEL_REVISION,
+                token=DVD_MODEL_TOKEN,
+            )
+
+    if os.environ.get("DVD_PREFETCH_TRELLIS", "0").lower() not in {"0", "false", "no", "off"}:
+        log_event(f"prefetching TRELLIS stage2 model {TRELLIS_IMAGE_MODEL}")
+        snapshot_download(repo_id=TRELLIS_IMAGE_MODEL)
+
+
+def prefetch_dinov2():
+    import shutil
+    import zipfile
+
+    hub_dir = Path(torch.hub.get_dir())
+    hub_dir.mkdir(parents=True, exist_ok=True)
+    repo_dir = hub_dir / "facebookresearch_dinov2_main"
+    if repo_dir.exists():
+        log_event(f"using cached DINOv2 repo {repo_dir}")
+    else:
+        zip_path = hub_dir / "main.zip"
+        _download_file("https://github.com/facebookresearch/dinov2/zipball/main", zip_path)
+        extract_tmp = hub_dir / "_dvd_dinov2_extract"
+        if extract_tmp.exists():
+            shutil.rmtree(extract_tmp)
+        extract_tmp.mkdir(parents=True, exist_ok=True)
+        log_event(f"extracting DINOv2 repo to {repo_dir}")
+        with zipfile.ZipFile(zip_path) as zf:
+            zf.extractall(extract_tmp)
+            top_level = zf.namelist()[0].split("/", 1)[0]
+        shutil.move(str(extract_tmp / top_level), str(repo_dir))
+        shutil.rmtree(extract_tmp, ignore_errors=True)
+
+    ckpt_dir = hub_dir / "checkpoints"
+    _download_file(
+        "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_reg4_pretrain.pth",
+        ckpt_dir / "dinov2_vitl14_reg4_pretrain.pth",
+    )
+
+
+def prefetch_assets():
+    if os.environ.get("DVD_PREFETCH_ASSETS", "1").lower() in {"0", "false", "no", "off"}:
+        log_event("asset prefetch disabled")
+        return
+    try:
+        log_event("asset prefetch start")
+        prefetch_dvd_weights()
+        prefetch_dinov2()
+        log_event("asset prefetch done")
+    except Exception as exc:
+        log_event(f"asset prefetch failed; continuing without prefetch: {exc}")
+
+
+def ensure_dvd_imports():
+    global DVDImageToVoxelPipeline
+    global TrellisImageTo3DPipeline
+    global as_voxel_output
+    global export_cubified_voxels
+    global run_image_stage2_from_dvd_voxels
+    if DVDImageToVoxelPipeline is not None:
+        return
+    log_event("importing DVD image/TRELLIS modules")
+    from dvd import (
+        DVDImageToVoxelPipeline as _DVDImageToVoxelPipeline,
+        TrellisImageTo3DPipeline as _TrellisImageTo3DPipeline,
+        as_voxel_output as _as_voxel_output,
+        export_cubified_voxels as _export_cubified_voxels,
+        run_image_stage2_from_dvd_voxels as _run_image_stage2_from_dvd_voxels,
+    )
+    DVDImageToVoxelPipeline = _DVDImageToVoxelPipeline
+    TrellisImageTo3DPipeline = _TrellisImageTo3DPipeline
+    as_voxel_output = _as_voxel_output
+    export_cubified_voxels = _export_cubified_voxels
+    run_image_stage2_from_dvd_voxels = _run_image_stage2_from_dvd_voxels
+
+
+def ensure_pipeline_device(pipeline, device: str, label: str):
+    target = torch.device(device)
+    current = pipeline.device
+    if current != target:
+        log_event(f"moving {label} pipeline from {current} to {target}")
+        pipeline.to(target)
+        log_event(f"{label} pipeline is on {target}")
+    return pipeline
+
+
+
+
+def ensure_zero_gpu_extensions():
+    """Verify TRELLIS CUDA render extensions installed by Space requirements."""
+    import importlib
+
+    missing = []
+    for module_name in ("nvdiffrast.torch", "diff_gaussian_rasterization"):
+        try:
+            importlib.import_module(module_name)
+        except ImportError as exc:
+            missing.append(f"{module_name}: {exc}")
+    if missing:
+        raise RuntimeError(
+            "Missing prebuilt CUDA render extensions. Rebuild/redeploy the Space wheels for: "
+            + "; ".join(missing)
+        )
+    log_event("CUDA render extensions ready")
+
+def get_postprocessing_utils():
+    global _postprocessing_utils
+    if _postprocessing_utils is not None:
+        return _postprocessing_utils
+    ensure_zero_gpu_extensions()
+    from trellis.utils import postprocessing_utils
+    _postprocessing_utils = postprocessing_utils
+    return _postprocessing_utils
+
+
+_original_json_schema_to_python_type = gradio_client_utils._json_schema_to_python_type
+
+
+def _safe_json_schema_to_python_type(schema, defs):
+    if isinstance(schema, bool):
+        return "Any"
+    if isinstance(schema, dict) and isinstance(schema.get("additionalProperties"), bool):
+        schema = dict(schema)
+        if schema["additionalProperties"]:
+            schema["additionalProperties"] = {}
+        else:
+            schema.pop("additionalProperties")
+    return _original_json_schema_to_python_type(schema, defs)
+
+
+gradio_client_utils._json_schema_to_python_type = _safe_json_schema_to_python_type
+
+
+_original_template_response = Jinja2Templates.TemplateResponse
+
+
+def _template_response_compat(self, *args, **kwargs):
+    if args and isinstance(args[0], str):
+        name = args[0]
+        context = args[1] if len(args) > 1 else kwargs.pop("context", None)
+        if isinstance(context, dict) and "request" in context:
+            return _original_template_response(self, context["request"], name, context, *args[2:], **kwargs)
+    return _original_template_response(self, *args, **kwargs)
+
+
+Jinja2Templates.TemplateResponse = _template_response_compat
+
+
+def list_asset_files(directory: str, suffixes: set[str]) -> list[Path]:
+    path = ROOT_DIR / directory
+    if not path.exists():
+        return []
+    return sorted(p for p in path.iterdir() if p.is_file() and p.suffix.lower() in suffixes)
+
+
+def asset_label(path: Path) -> str:
+    return path.stem.replace("_", " ")
+
+
+GENERATION_IMAGE_EXAMPLES = [
+    (asset_label(path), str(path)) for path in list_asset_files("assets/example_image", IMAGE_EXTENSIONS)
+]
+EDIT_IMAGE_EXAMPLES = [
+    (asset_label(path), str(path)) for path in list_asset_files("assets/example_image_edit", IMAGE_EXTENSIONS)
+]
+EDIT_VOXEL_EXAMPLES = [
+    (asset_label(path), str(path)) for path in list_asset_files("assets/example_voxel_edit", {".npy", ".npz", ".pt", ".pth"})
+]
+
+
+def voxel_viewer(label: str, exposure: float = 5.0, height: int = 300):
+    return gr.Model3D(
+        label=label,
+        height=height,
+        camera_position=VOXEL_CAMERA_POSITION,
+    )
+
+
+def get_device(device_arg: str) -> str:
+    if device_arg == "auto":
+        return "cuda" if torch.cuda.is_available() else "cpu"
+    return device_arg
+
+
+def default_server_port():
+    port = os.environ.get("GRADIO_SERVER_PORT")
+    return int(port) if port else None
+
+
+def load_dvd_pipeline_variant(device: str, variant: str):
+    ensure_dvd_imports()
+    if DVD_MODEL_REPO:
+        common_kwargs = {
+            "device": device,
+            "subfolder": DVD_MODEL_SUBFOLDER,
+            "revision": DVD_MODEL_REVISION,
+            "token": DVD_MODEL_TOKEN,
+        }
+        return DVDImageToVoxelPipeline.from_pretrained(DVD_MODEL_REPO, variant=variant, **common_kwargs)
+    if variant == "base":
+        return DVDImageToVoxelPipeline.from_files(GEN_DVD_CONFIG, GEN_DVD_CKPT, device=device)
+    if variant == "bsp":
+        return DVDImageToVoxelPipeline.from_files(EDIT_DVD_CONFIG, EDIT_DVD_CKPT, device=device)
+    raise ValueError(f"Unsupported DVD pipeline variant: {variant}")
+
+
+def load_dvd_pipelines(device: str):
+    return (
+        load_dvd_pipeline_variant(device, "base"),
+        load_dvd_pipeline_variant(device, "bsp"),
+    )
+
+
+def release_pipeline(name: str, label: str):
+    global dvd_gen_pipeline, dvd_edit_pipeline, trellis_pipeline
+    pipelines = {
+        "dvd_gen": dvd_gen_pipeline,
+        "dvd_edit": dvd_edit_pipeline,
+        "trellis": trellis_pipeline,
+    }
+    pipeline = pipelines[name]
+    if pipeline is None:
+        return
+    log_event(f"releasing {label} pipeline")
+    try:
+        pipeline.to("cpu")
+    except Exception as exc:
+        log_event(f"{label} pipeline CPU release warning: {exc}")
+    if name == "dvd_gen":
+        dvd_gen_pipeline = None
+    elif name == "dvd_edit":
+        dvd_edit_pipeline = None
+    elif name == "trellis":
+        trellis_pipeline = None
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    log_event(f"released {label} pipeline")
+
+
+def release_dvd_pipelines():
+    release_pipeline("dvd_gen", "DVD generation")
+    release_pipeline("dvd_edit", "DVD editing")
+
+
+def release_trellis_pipeline():
+    release_pipeline("trellis", "TRELLIS stage2")
+
+
+def ensure_dvd_gen_pipeline(device: str | None = None):
+    global dvd_gen_pipeline
+    device = device or os.environ.get("DVD_SPACE_DEVICE", "cuda")
+    release_trellis_pipeline()
+    if dvd_gen_pipeline is None:
+        log_event(f"loading DVD generation pipeline on {device}")
+        dvd_gen_pipeline = load_dvd_pipeline_variant(device, "base")
+        log_event("DVD generation pipeline ready")
+    else:
+        ensure_pipeline_device(dvd_gen_pipeline, device, "DVD generation")
+    return dvd_gen_pipeline
+
+
+def ensure_dvd_edit_pipeline(device: str | None = None):
+    global dvd_edit_pipeline
+    device = device or os.environ.get("DVD_SPACE_DEVICE", "cuda")
+    release_pipeline("dvd_gen", "DVD generation")
+    release_trellis_pipeline()
+    if dvd_edit_pipeline is None:
+        log_event(f"loading DVD editing pipeline on {device}")
+        dvd_edit_pipeline = load_dvd_pipeline_variant(device, "bsp")
+        log_event("DVD editing pipeline ready")
+    else:
+        ensure_pipeline_device(dvd_edit_pipeline, device, "DVD editing")
+    return dvd_edit_pipeline
+
+
+def ensure_trellis_pipeline(device: str | None = None):
+    ensure_dvd_imports()
+    global trellis_pipeline
+    device = device or os.environ.get("DVD_SPACE_DEVICE", "cuda")
+    release_dvd_pipelines()
+    if trellis_pipeline is None:
+        log_event(f"loading TRELLIS stage2 pipeline on {device}")
+        trellis_pipeline = TrellisImageTo3DPipeline.from_pretrained(TRELLIS_IMAGE_MODEL)
+        trellis_pipeline.to(device)
+        log_event("TRELLIS stage2 pipeline ready")
+    else:
+        ensure_pipeline_device(trellis_pipeline, device, "TRELLIS stage2")
+    return trellis_pipeline
+
+
+def preload_zero_gpu_models(device: str | None = None, preload: str | None = None):
+    device = device or os.environ.get("DVD_SPACE_DEVICE", "cuda")
+    preload = preload or os.environ.get("DVD_STARTUP_PRELOAD", "none")
+    requested = {
+        item.strip().lower()
+        for item in preload.replace(";", ",").split(",")
+        if item.strip()
+    }
+    if requested & {"0", "false", "no", "none", "off"}:
+        log_event("startup model preload disabled")
+        return
+
+    ensure_dvd_imports()
+    if requested & {"all", "gen", "generation", "dvd_gen", "image"}:
+        ensure_dvd_gen_pipeline(device)
+    if requested & {"all", "edit", "editing", "dvd_edit"}:
+        ensure_dvd_edit_pipeline(device)
+    if requested & {"all", "stage2", "trellis"}:
+        ensure_zero_gpu_extensions()
+        ensure_trellis_pipeline(device)
+
+
+def start_session(req: gr.Request):
+    user_dir = TMP_DIR / str(req.session_hash)
+    user_dir.mkdir(parents=True, exist_ok=True)
+
+
+def end_session(req: gr.Request):
+    user_dir = TMP_DIR / str(req.session_hash)
+    if user_dir.exists():
+        shutil.rmtree(user_dir)
+
+
+def session_path(req: gr.Request, name: str) -> str:
+    user_dir = TMP_DIR / str(req.session_hash)
+    user_dir.mkdir(parents=True, exist_ok=True)
+    return str(user_dir / name)
+
+
+def worker_path(name: str) -> str:
+    user_dir = TMP_DIR / f"worker-{uuid.uuid4().hex}"
+    user_dir.mkdir(parents=True, exist_ok=True)
+    return str(user_dir / name)
+
+
+def get_seed(randomize_seed: bool, seed: int) -> int:
+    return int(np.random.randint(0, MAX_SEED)) if randomize_seed else int(seed)
+
+
+def dvd_cfg_schedule(mode: str, constant: float, early: float, late: float, split: float):
+    if mode == "Default schedule":
+        return None
+    if mode == "Constant":
+        return float(constant)
+    split = float(split)
+    return lambda t: float(early) if t < split else float(late)
+
+
+def dvd_sampler_kwargs(
+    steps: int,
+    cfg_mode: str,
+    cfg_constant: float,
+    cfg_early: float,
+    cfg_late: float,
+    cfg_split: float,
+) -> dict:
+    kwargs = {"steps": int(steps)}
+    cfg_strength = dvd_cfg_schedule(cfg_mode, cfg_constant, cfg_early, cfg_late, cfg_split)
+    if cfg_strength is not None:
+        kwargs["cfg_strength"] = cfg_strength
+    return kwargs
+
+
+def slat_sampler_params(steps: int, cfg_strength: float) -> dict:
+    return {
+        "steps": int(steps),
+        "cfg_strength": float(cfg_strength),
+    }
+
+
+def voxel_output(voxels, resolution: int = RESOLUTION):
+    ensure_dvd_imports()
+    if isinstance(voxels, np.lib.npyio.NpzFile):
+        key = next((k for k in ("coords", "voxels", "samples") if k in voxels.files), voxels.files[0])
+        voxels = voxels[key]
+    if isinstance(voxels, np.ndarray):
+        voxels = torch.as_tensor(voxels)
+    elif isinstance(voxels, dict):
+        for key in ("coords", "voxels", "samples"):
+            if key in voxels:
+                voxels = voxels[key]
+                break
+        else:
+            raise gr.Error("Voxel dict must contain one of: coords, voxels, samples.")
+        return voxel_output(voxels, resolution=resolution)
+    elif isinstance(voxels, (list, tuple)):
+        voxels = torch.as_tensor(voxels)
+    output = as_voxel_output(voxels, resolution=resolution)
+    return as_voxel_output(output.samples.detach().cpu().long(), resolution=resolution)
+
+
+def voxel_state(voxels, resolution: int = RESOLUTION):
+    output = voxel_output(voxels, resolution=resolution)
+    return output.coords_without_batch.detach().cpu().numpy().astype(np.int32)
+
+
+def load_voxel_file(file, resolution: int = RESOLUTION):
+    if file is None:
+        raise gr.Error("Please upload a voxel coordinate file.")
+
+    path = None
+    if isinstance(file, (str, Path)):
+        path = str(file)
+    elif isinstance(file, dict):
+        path = file.get("path") or file.get("name") or file.get("orig_name")
+        if path is None:
+            return voxel_output(file, resolution=resolution)
+    elif hasattr(file, "path"):
+        path = file.path
+    elif hasattr(file, "name"):
+        path = file.name
+    else:
+        return voxel_output(file, resolution=resolution)
+
+    suffix = Path(path).suffix.lower()
+    if suffix == ".npy":
+        data = np.load(path, allow_pickle=False)
+    elif suffix == ".npz":
+        data = np.load(path, allow_pickle=False)
+    elif suffix in {".pt", ".pth"}:
+        data = torch.load(path, map_location="cpu")
+    else:
+        raise gr.Error(f"Unsupported voxel file type: {suffix}. Use .npy, .npz, .pt, or .pth.")
+    return voxel_output(data, resolution=resolution)
+
+def load_image_from_path(path: str):
+    if not path:
+        raise gr.Error("Please select an example image.")
+    return Image.open(path).convert("RGBA")
+
+
+def load_generation_example(image_path: str):
+    return load_image_from_path(image_path)
+
+
+def load_edit_image_example(image_path: str):
+    return load_image_from_path(image_path)
+
+
+@spaces.GPU(duration=60)
+def load_edit_voxel_example(voxel_path: str, req: gr.Request):
+    voxels = load_voxel_file(voxel_path)
+    mesh_path = voxel_to_mesh(voxels, session_path(req, "example_edit_voxels.glb"))
+    return voxel_state(voxels), mesh_path
+
+
+def save_voxel_coords(voxels, path: str) -> str:
+    ensure_dvd_imports()
+    output = as_voxel_output(voxels, resolution=RESOLUTION)
+    np.save(path, output.coords_without_batch.numpy())
+    return path
+
+
+def voxel_to_mesh(voxels, path: str) -> str:
+    ensure_dvd_imports()
+    return export_cubified_voxels(voxels, path, resolution=RESOLUTION)
+
+
+def rotate_voxels(voxels, axis: str, req: gr.Request):
+    if voxels is None:
+        raise gr.Error("No editing voxels available. Upload voxels or transfer generated voxels first.")
+
+    output = load_voxel_file(voxels)
+    samples = output.samples.clone()
+    axis_to_dims = {
+        "x": (2, 3),
+        "y": (1, 3),
+        "z": (1, 2),
+    }
+    samples = torch.rot90(samples, k=1, dims=axis_to_dims[axis])
+    rotated = as_voxel_output(samples, resolution=RESOLUTION)
+    mesh_path = voxel_to_mesh(rotated, session_path(req, f"edit_voxels_rot_{axis}.glb"))
+    return voxel_state(rotated), mesh_path
+
+
+@spaces.GPU(duration=60)
+def rotate_x(voxels, req: gr.Request):
+    return rotate_voxels(voxels, "x", req)
+
+
+@spaces.GPU(duration=60)
+def rotate_y(voxels, req: gr.Request):
+    return rotate_voxels(voxels, "y", req)
+
+
+@spaces.GPU(duration=60)
+def rotate_z(voxels, req: gr.Request):
+    return rotate_voxels(voxels, "z", req)
+
+
+def build_edit_mask(
+    use_1, x0_1, x1_1, y0_1, y1_1, z0_1, z1_1,
+    use_2, x0_2, x1_2, y0_2, y1_2, z0_2, z1_2,
+    use_3, x0_3, x1_3, y0_3, y1_3, z0_3, z1_3,
+    batch_size: int = 1,
+):
+    boxes = [
+        (use_1, x0_1, x1_1, y0_1, y1_1, z0_1, z1_1),
+        (use_2, x0_2, x1_2, y0_2, y1_2, z0_2, z1_2),
+        (use_3, x0_3, x1_3, y0_3, y1_3, z0_3, z1_3),
+    ]
+    edit_mask = torch.zeros((batch_size, RESOLUTION, RESOLUTION, RESOLUTION), dtype=torch.bool)
+    any_box = False
+    for use, x0, x1, y0, y1, z0, z1 in boxes:
+        if not use:
+            continue
+        ranges = [int(x0), int(x1), int(y0), int(y1), int(z0), int(z1)]
+        x0, x1, y0, y1, z0, z1 = [max(0, min(RESOLUTION, v)) for v in ranges]
+        if x0 >= x1 or y0 >= y1 or z0 >= z1:
+            continue
+        edit_mask[:, x0:x1, y0:y1, z0:z1] = True
+        any_box = True
+    if not any_box:
+        raise gr.Error("Enable at least one valid edit-mask box.")
+    return edit_mask
+
+
+def mask_inputs():
+    return [
+        box1_use, box1_x0, box1_x1, box1_y0, box1_y1, box1_z0, box1_z1,
+        box2_use, box2_x0, box2_x1, box2_y0, box2_y1, box2_z0, box2_z1,
+        box3_use, box3_x0, box3_x1, box3_y0, box3_y1, box3_z0, box3_z1,
+    ]
+
+
+@spaces.GPU(duration=600)
+def generate_voxels(
+    image: Image.Image,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    dvd_steps: int,
+    dvd_cfg_mode: str,
+    dvd_cfg_constant: float,
+    dvd_cfg_early: float,
+    dvd_cfg_late: float,
+    dvd_cfg_split: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.02, desc="Starting ZeroGPU callback")
+    log_event(f"generate_voxels start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if image is None:
+        log_event("generate_voxels missing image")
+        raise gr.Error("Please provide a generation image.")
+    seed = get_seed(randomize_seed, seed)
+    progress(0.08, desc="Loading DVD generation model")
+    pipeline = ensure_dvd_gen_pipeline("cuda")
+    progress(0.18, desc="Sampling voxels")
+    log_event(f"generate_voxels sampling seed={seed}")
+    voxels = pipeline.sample_voxels(
+        image,
+        seed=seed,
+        preprocess_image=preprocess_image,
+        **dvd_sampler_kwargs(dvd_steps, dvd_cfg_mode, dvd_cfg_constant, dvd_cfg_early, dvd_cfg_late, dvd_cfg_split),
+    )
+    progress(0.88, desc="Exporting voxel preview")
+    log_event("generate_voxels sampled; exporting voxel mesh")
+    mesh_path = voxel_to_mesh(voxels, worker_path("generated_voxels.glb"))
+    npy_path = save_voxel_coords(voxels, worker_path("generated_voxel64_coords.npy"))
+    torch.cuda.empty_cache()
+    log_event(f"generate_voxels done seed={seed} npy={npy_path}")
+    return voxel_state(voxels), mesh_path, npy_path, seed
+
+
+@spaces.GPU(duration=600)
+def generation_stage2(
+    image: Image.Image,
+    voxels,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    slat_steps: int,
+    slat_cfg_strength: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.02, desc="Starting ZeroGPU callback")
+    log_event(f"generation_stage2 start seed={seed} randomize={randomize_seed} steps={slat_steps}")
+    if image is None:
+        log_event("generation_stage2 missing image")
+        raise gr.Error("Please provide the same generation image for TRELLIS stage 2.")
+    if voxels is None:
+        raise gr.Error("Generate voxels before running TRELLIS stage 2.")
+    seed = get_seed(randomize_seed, seed)
+    log_event(f"generation_stage2 loading voxel state type={type(voxels).__name__}")
+    voxels = load_voxel_file(voxels)
+    log_event(f"generation_stage2 voxel state ready shape={tuple(voxels.samples.shape)}")
+    progress(0.08, desc="Checking CUDA render extensions")
+    ensure_dvd_imports()
+    ensure_zero_gpu_extensions()
+    log_event("generation_stage2 CUDA render extensions ready")
+    progress(0.16, desc="Loading TRELLIS stage 2")
+    log_event("generation_stage2 running TRELLIS")
+    pipeline = ensure_trellis_pipeline()
+    log_event("generation_stage2 TRELLIS pipeline ready")
+    outputs = run_image_stage2_from_dvd_voxels(
+        pipeline,
+        image,
+        voxels,
+        seed=seed,
+        formats=["gaussian", "mesh"],
+        preprocess_image=preprocess_image,
+        slat_sampler_params=slat_sampler_params(slat_steps, slat_cfg_strength),
+    )
+    glb = get_postprocessing_utils().to_glb(outputs["gaussian"][0], outputs["mesh"][0])
+    glb_path = worker_path("generated_stage2.glb")
+    glb.export(glb_path)
+    torch.cuda.empty_cache()
+    log_event(f"generation_stage2 done seed={seed} glb={glb_path}")
+    return glb_path, glb_path, seed
+
+
+def transfer_generation_to_editing(voxels, mesh_path):
+    if voxels is None:
+        raise gr.Error("No generated voxels to transfer.")
+    return voxels, mesh_path
+
+
+@spaces.GPU(duration=60)
+def load_edit_voxels(file, voxel_path: str, req: gr.Request):
+    voxel_source = file if file is not None else voxel_path
+    if voxel_source in (None, ""):
+        raise gr.Error("Upload a voxel file or select a preloaded edit voxel.")
+    voxels = load_voxel_file(voxel_source)
+    mesh_path = voxel_to_mesh(voxels, session_path(req, "loaded_edit_voxels.glb"))
+    return voxel_state(voxels), mesh_path
+
+
+@spaces.GPU(duration=60)
+def visualize_edit_mask(
+    voxels,
+    use_1, x0_1, x1_1, y0_1, y1_1, z0_1, z1_1,
+    use_2, x0_2, x1_2, y0_2, y1_2, z0_2, z1_2,
+    use_3, x0_3, x1_3, y0_3, y1_3, z0_3, z1_3,
+    req: gr.Request,
+):
+    if voxels is None:
+        raise gr.Error("No editing voxels available.")
+    output = load_voxel_file(voxels)
+    edit_mask = build_edit_mask(
+        use_1, x0_1, x1_1, y0_1, y1_1, z0_1, z1_1,
+        use_2, x0_2, x1_2, y0_2, y1_2, z0_2, z1_2,
+        use_3, x0_3, x1_3, y0_3, y1_3, z0_3, z1_3,
+        batch_size=output.samples.shape[0],
+    )
+    perturbed = output.samples.clone()
+    perturbed[edit_mask] = torch.randint(0, 2, perturbed[edit_mask].shape, dtype=perturbed.dtype)
+    mask_preview = as_voxel_output(perturbed, resolution=RESOLUTION)
+    mesh_path = voxel_to_mesh(mask_preview, session_path(req, "edit_mask_preview.glb"))
+    return mesh_path
+
+
+@spaces.GPU(duration=600)
+def run_editing(
+    target_image: Image.Image,
+    voxels,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    dvd_steps: int,
+    dvd_cfg_mode: str,
+    dvd_cfg_constant: float,
+    dvd_cfg_early: float,
+    dvd_cfg_late: float,
+    dvd_cfg_split: float,
+    use_1, x0_1, x1_1, y0_1, y1_1, z0_1, z1_1,
+    use_2, x0_2, x1_2, y0_2, y1_2, z0_2, z1_2,
+    use_3, x0_3, x1_3, y0_3, y1_3, z0_3, z1_3,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.02, desc="Starting ZeroGPU callback")
+    log_event(f"run_editing start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if target_image is None:
+        log_event("run_editing missing target image")
+        raise gr.Error("Please provide a target image for editing.")
+    if voxels is None:
+        raise gr.Error("Upload voxels or transfer generated voxels first.")
+
+    seed = get_seed(randomize_seed, seed)
+    output = load_voxel_file(voxels)
+    edit_mask = build_edit_mask(
+        use_1, x0_1, x1_1, y0_1, y1_1, z0_1, z1_1,
+        use_2, x0_2, x1_2, y0_2, y1_2, z0_2, z1_2,
+        use_3, x0_3, x1_3, y0_3, y1_3, z0_3, z1_3,
+        batch_size=output.samples.shape[0],
+    )
+    keep_mask = ~edit_mask
+    progress(0.08, desc="Loading DVD editing model")
+    pipeline = ensure_dvd_edit_pipeline("cuda")
+    progress(0.18, desc="Sampling edited voxels")
+    log_event("run_editing sampling")
+    edited = pipeline.edit_voxels(
+        target_image,
+        output,
+        keep_mask=keep_mask,
+        seed=seed,
+        preprocess_image=preprocess_image,
+        **dvd_sampler_kwargs(dvd_steps, dvd_cfg_mode, dvd_cfg_constant, dvd_cfg_early, dvd_cfg_late, dvd_cfg_split),
+    )
+    mesh_path = voxel_to_mesh(edited, worker_path("edited_voxels.glb"))
+    npy_path = save_voxel_coords(edited, worker_path("edited_voxel64_coords.npy"))
+    torch.cuda.empty_cache()
+    log_event(f"run_editing done seed={seed} npy={npy_path}")
+    return voxel_state(edited), mesh_path, npy_path, seed
+
+
+@spaces.GPU(duration=600)
+def editing_stage2(
+    target_image: Image.Image,
+    edited_voxels,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    slat_steps: int,
+    slat_cfg_strength: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.02, desc="Starting ZeroGPU callback")
+    log_event(f"editing_stage2 start seed={seed} randomize={randomize_seed} steps={slat_steps}")
+    if target_image is None:
+        log_event("editing_stage2 missing target image")
+        raise gr.Error("Please provide the target image for TRELLIS stage 2.")
+    if edited_voxels is None:
+        raise gr.Error("Run editing before TRELLIS stage 2.")
+    seed = get_seed(randomize_seed, seed)
+    log_event(f"editing_stage2 loading voxel state type={type(edited_voxels).__name__}")
+    edited_voxels = load_voxel_file(edited_voxels)
+    log_event(f"editing_stage2 voxel state ready shape={tuple(edited_voxels.samples.shape)}")
+    progress(0.08, desc="Checking CUDA render extensions")
+    ensure_dvd_imports()
+    ensure_zero_gpu_extensions()
+    log_event("editing_stage2 CUDA render extensions ready")
+    progress(0.16, desc="Loading TRELLIS stage 2")
+    pipeline = ensure_trellis_pipeline()
+    log_event("editing_stage2 TRELLIS pipeline ready")
+    outputs = run_image_stage2_from_dvd_voxels(
+        pipeline,
+        target_image,
+        edited_voxels,
+        seed=seed,
+        formats=["gaussian", "mesh"],
+        preprocess_image=preprocess_image,
+        slat_sampler_params=slat_sampler_params(slat_steps, slat_cfg_strength),
+    )
+    glb = get_postprocessing_utils().to_glb(outputs["gaussian"][0], outputs["mesh"][0])
+    glb_path = worker_path("edited_stage2.glb")
+    glb.export(glb_path)
+    torch.cuda.empty_cache()
+    return glb_path, glb_path, seed
+
+
+APP_CSS = """
+#editing-three-col {
+    align-items: flex-start;
+}
+#editing-three-col > div {
+    min-width: 220px !important;
+}
+"""
+
+
+with gr.Blocks(
+    delete_cache=(600, 600),
+    title="DVD + TRELLIS Voxel Generation and Editing",
+    css=APP_CSS,
+    fill_width=True,
+) as demo:
+    gr.Markdown(
+        """
+        ## DVD Voxel Generation and Editing
+        DVD generates or edits a 64^3 voxel structure first. TRELLIS stage 2 is run only when you click the stage-2 button.
+        """
+    )
+
+    generated_voxels_state = gr.State()
+    edit_voxels_state = gr.State()
+    edited_voxels_state = gr.State()
+
+    with gr.Tab("Generation"):
+        with gr.Row():
+            with gr.Column():
+                gen_example = gr.Dropdown(
+                    choices=GENERATION_IMAGE_EXAMPLES,
+                    label="Preloaded Generation Images",
+                    value=None,
+                    interactive=True,
+                )
+                gen_image = gr.Image(label="Condition Image", format="png", image_mode="RGBA", type="pil", height=300)
+                with gr.Accordion("Generation Settings", open=False):
+                    gen_seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                    gen_randomize = gr.Checkbox(value=True, label="Randomize seed")
+                    gen_preprocess = gr.Checkbox(value=False, label="DVD preprocess image")
+                    gen_dvd_steps = gr.Slider(1, 512, value=256, step=1, label="DVD voxel steps")
+                    gen_dvd_cfg_mode = gr.Radio(
+                        ["Default schedule", "Constant", "Two-stage"],
+                        value="Default schedule",
+                        label="DVD voxel CFG mode",
+                    )
+                    gen_dvd_cfg_constant = gr.Slider(
+                        0.0,
+                        5.0,
+                        value=0.7,
+                        step=0.05,
+                        label="DVD voxel constant CFG",
+                    )
+                    with gr.Row():
+                        gen_dvd_cfg_early = gr.Slider(0.0, 5.0, value=0.4, step=0.05, label="DVD CFG early t<0.5")
+                        gen_dvd_cfg_late = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="DVD CFG late")
+                    gen_dvd_cfg_split = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="DVD CFG switch time")
+                    gen_stage2_preprocess = gr.Checkbox(value=True, label="TRELLIS preprocess image for stage 2")
+                    gen_slat_steps = gr.Slider(1, 50, value=25, step=1, label="TRELLIS stage-2 steps")
+                    gen_slat_cfg = gr.Slider(0.0, 10.0, value=5.0, step=0.1, label="TRELLIS stage-2 CFG")
+                gen_btn = gr.Button("1. Generate DVD Voxels")
+                gen_stage2_btn = gr.Button("2. Run TRELLIS Stage 2", interactive=True)
+                transfer_btn = gr.Button("Move Generated Voxels To Editing")
+            with gr.Column():
+                gen_voxel_view = voxel_viewer("Generated / Cubified Voxels", exposure=5.0, height=320)
+                gen_npy_download = gr.DownloadButton(label="Download Voxel Coords (.npy)", interactive=False)
+                gen_stage2_view = gr.Model3D(label="TRELLIS Stage 2 GLB", height=320)
+                gen_glb_download = gr.DownloadButton(label="Download Stage 2 GLB", interactive=False)
+
+    with gr.Tab("Editing"):
+        with gr.Row(equal_height=False, elem_id="editing-three-col"):
+            with gr.Column(scale=1, min_width=220):
+                gr.Markdown("### 1. Source Voxels")
+                edit_image_example = gr.Dropdown(
+                    choices=EDIT_IMAGE_EXAMPLES,
+                    label="Preloaded Edit Target Images",
+                    value=None,
+                    interactive=True,
+                )
+                edit_target_image = gr.Image(label="Target Image", format="png", image_mode="RGBA", type="pil", height=260)
+                edit_voxel_example = gr.Dropdown(
+                    choices=EDIT_VOXEL_EXAMPLES,
+                    label="Preloaded Edit Voxels",
+                    value=None,
+                    interactive=True,
+                )
+                edit_file = gr.File(label="Upload Voxel Coords (.npy, .npz, .pt, .pth)")
+                load_edit_btn = gr.Button("Load Selected / Uploaded Voxels")
+                with gr.Row():
+                    rot_x_btn = gr.Button("Rotate X 90")
+                    rot_y_btn = gr.Button("Rotate Y 90")
+                    rot_z_btn = gr.Button("Rotate Z 90")
+                edit_voxel_view = voxel_viewer("Current Editing Voxels", exposure=10.0, height=300)
+
+            with gr.Column(scale=1, min_width=220):
+                gr.Markdown("### Edit Mask Boxes\nEach enabled box is an edit region. The union of enabled boxes is regenerated.")
+                with gr.Accordion("Box 1", open=True):
+                    box1_use = gr.Checkbox(value=True, label="Use box 1")
+                    with gr.Row():
+                        box1_x0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="x0")
+                        box1_x1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="x1")
+                    with gr.Row():
+                        box1_y0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="y0")
+                        box1_y1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="y1")
+                    with gr.Row():
+                        box1_z0 = gr.Slider(0, RESOLUTION, value=32, step=1, label="z0")
+                        box1_z1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="z1")
+                with gr.Accordion("Box 2", open=False):
+                    box2_use = gr.Checkbox(value=False, label="Use box 2")
+                    with gr.Row():
+                        box2_x0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="x0")
+                        box2_x1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="x1")
+                    with gr.Row():
+                        box2_y0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="y0")
+                        box2_y1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="y1")
+                    with gr.Row():
+                        box2_z0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="z0")
+                        box2_z1 = gr.Slider(0, RESOLUTION, value=16, step=1, label="z1")
+                with gr.Accordion("Box 3", open=False):
+                    box3_use = gr.Checkbox(value=False, label="Use box 3")
+                    with gr.Row():
+                        box3_x0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="x0")
+                        box3_x1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="x1")
+                    with gr.Row():
+                        box3_y0 = gr.Slider(0, RESOLUTION, value=0, step=1, label="y0")
+                        box3_y1 = gr.Slider(0, RESOLUTION, value=RESOLUTION, step=1, label="y1")
+                    with gr.Row():
+                        box3_z0 = gr.Slider(0, RESOLUTION, value=16, step=1, label="z0")
+                        box3_z1 = gr.Slider(0, RESOLUTION, value=32, step=1, label="z1")
+                preview_mask_btn = gr.Button("Preview Edit Region By Perturbing")
+                edit_mask_view = voxel_viewer("Edit Region Preview", exposure=5.0, height=300)
+
+            with gr.Column(scale=1, min_width=220):
+                gr.Markdown("### 3. Edited Result")
+                with gr.Accordion("Editing Settings", open=False):
+                    edit_seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                    edit_randomize = gr.Checkbox(value=True, label="Randomize seed")
+                    edit_preprocess = gr.Checkbox(value=True, label="DVD preprocess target image")
+                    edit_dvd_steps = gr.Slider(1, 512, value=128, step=1, label="DVD edit steps")
+                    edit_dvd_cfg_mode = gr.Radio(
+                        ["Default schedule", "Constant", "Two-stage"],
+                        value="Default schedule",
+                        label="DVD edit CFG mode",
+                    )
+                    edit_dvd_cfg_constant = gr.Slider(
+                        0.0,
+                        5.0,
+                        value=0.45,
+                        step=0.05,
+                        label="DVD edit constant CFG",
+                    )
+                    with gr.Row():
+                        edit_dvd_cfg_early = gr.Slider(0.0, 5.0, value=0.45, step=0.05, label="DVD CFG early t<0.5")
+                        edit_dvd_cfg_late = gr.Slider(0.0, 5.0, value=0.45, step=0.05, label="DVD CFG late")
+                    edit_dvd_cfg_split = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="DVD CFG switch time")
+                    edit_stage2_preprocess = gr.Checkbox(value=True, label="TRELLIS preprocess target image for stage 2")
+                    edit_slat_steps = gr.Slider(1, 50, value=25, step=1, label="TRELLIS stage-2 steps")
+                    edit_slat_cfg = gr.Slider(0.0, 10.0, value=5.0, step=0.1, label="TRELLIS stage-2 CFG")
+                edit_btn = gr.Button("Run DVD Editing")
+                edit_stage2_btn = gr.Button("Run TRELLIS Stage 2")
+                edited_voxel_view = voxel_viewer("Edited / Cubified Voxels", exposure=5.0, height=300)
+                edited_npy_download = gr.DownloadButton(label="Download Edited Voxel Coords (.npy)", interactive=False)
+                edit_stage2_view = gr.Model3D(label="Edited TRELLIS Stage 2 GLB", height=300)
+                edited_glb_download = gr.DownloadButton(label="Download Edited Stage 2 GLB", interactive=False)
+
+    demo.load(start_session)
+    demo.unload(end_session)
+
+
+    gen_example.change(load_generation_example, inputs=[gen_example], outputs=[gen_image])
+    edit_image_example.change(load_edit_image_example, inputs=[edit_image_example], outputs=[edit_target_image])
+    edit_voxel_example.change(
+        load_edit_voxel_example,
+        inputs=[edit_voxel_example],
+        outputs=[edit_voxels_state, edit_voxel_view],
+    )
+
+    gen_btn.click(
+        generate_voxels,
+        inputs=[
+            gen_image,
+            gen_seed,
+            gen_randomize,
+            gen_preprocess,
+            gen_dvd_steps,
+            gen_dvd_cfg_mode,
+            gen_dvd_cfg_constant,
+            gen_dvd_cfg_early,
+            gen_dvd_cfg_late,
+            gen_dvd_cfg_split,
+        ],
+        outputs=[generated_voxels_state, gen_voxel_view, gen_npy_download, gen_seed],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[gen_npy_download])
+
+    gen_stage2_btn.click(
+        generation_stage2,
+        inputs=[
+            gen_image,
+            generated_voxels_state,
+            gen_seed,
+            gen_randomize,
+            gen_stage2_preprocess,
+            gen_slat_steps,
+            gen_slat_cfg,
+        ],
+        outputs=[gen_stage2_view, gen_glb_download, gen_seed],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[gen_glb_download])
+
+    transfer_btn.click(
+        transfer_generation_to_editing,
+        inputs=[generated_voxels_state, gen_voxel_view],
+        outputs=[edit_voxels_state, edit_voxel_view],
+    )
+
+    load_edit_btn.click(
+        load_edit_voxels,
+        inputs=[edit_file, edit_voxel_example],
+        outputs=[edit_voxels_state, edit_voxel_view],
+    )
+    rot_x_btn.click(rotate_x, inputs=[edit_voxels_state], outputs=[edit_voxels_state, edit_voxel_view])
+    rot_y_btn.click(rotate_y, inputs=[edit_voxels_state], outputs=[edit_voxels_state, edit_voxel_view])
+    rot_z_btn.click(rotate_z, inputs=[edit_voxels_state], outputs=[edit_voxels_state, edit_voxel_view])
+
+    preview_mask_btn.click(
+        visualize_edit_mask,
+        inputs=[edit_voxels_state] + mask_inputs(),
+        outputs=[edit_mask_view],
+    )
+
+    edit_btn.click(
+        run_editing,
+        inputs=[
+            edit_target_image,
+            edit_voxels_state,
+            edit_seed,
+            edit_randomize,
+            edit_preprocess,
+            edit_dvd_steps,
+            edit_dvd_cfg_mode,
+            edit_dvd_cfg_constant,
+            edit_dvd_cfg_early,
+            edit_dvd_cfg_late,
+            edit_dvd_cfg_split,
+        ] + mask_inputs(),
+        outputs=[edited_voxels_state, edited_voxel_view, edited_npy_download, edit_seed],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[edited_npy_download])
+
+    edit_stage2_btn.click(
+        editing_stage2,
+        inputs=[
+            edit_target_image,
+            edited_voxels_state,
+            edit_seed,
+            edit_randomize,
+            edit_stage2_preprocess,
+            edit_slat_steps,
+            edit_slat_cfg,
+        ],
+        outputs=[edit_stage2_view, edited_glb_download, edit_seed],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[edited_glb_download])
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--device", default="auto", help="cuda, cpu, or auto")
+    parser.add_argument("--share", action="store_true")
+    parser.add_argument("--server-name", default=os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0"))
+    parser.add_argument("--server-port", type=int, default=default_server_port())
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Keep startup free of DVD/TRELLIS imports; only prefetch raw assets.
+    prefetch_assets()
+    preload_zero_gpu_models(os.environ.get("DVD_SPACE_DEVICE", "cuda"))
+    demo.queue().launch(
+        share=args.share,
+        server_name=args.server_name,
+        server_port=args.server_port,
+        show_api=False,
+        show_error=True,
+        ssr_mode=False,
+    )

app_dvd_image_gpu_lazy.py

@@ -0,0 +1,283 @@
+import os
+import random
+import uuid
+from pathlib import Path
+
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("SPARSE_ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+
+
+MAX_SEED = 2**31 - 1
+ROOT_DIR = Path(__file__).resolve().parent
+TMP_DIR = ROOT_DIR / "tmp" / "dvd_image_gpu_lazy"
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
+EXAMPLE_DIR = ROOT_DIR / "assets" / "example_image"
+EXAMPLES = [
+    str(path)
+    for path in sorted(EXAMPLE_DIR.iterdir())
+    if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+] if EXAMPLE_DIR.exists() else []
+
+_dvd_pipe = None
+_export_cubified_voxels = None
+
+
+def log_event(message: str):
+    print(f"[DVD GPULazy] {message}", flush=True)
+
+
+def _download_file(url: str, dest: Path):
+    import urllib.request
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if dest.exists() and dest.stat().st_size > 0:
+        log_event(f"using cached {dest.name}")
+        return
+    tmp = dest.with_name(dest.name + ".tmp")
+    if tmp.exists():
+        tmp.unlink()
+    log_event(f"downloading {url} -> {dest}")
+    urllib.request.urlretrieve(url, tmp)
+    tmp.replace(dest)
+
+
+def prefetch_dvd_weights():
+    from huggingface_hub import hf_hub_download
+
+    repo = os.environ.get("DVD_MODEL_REPO", "Zhengrui/dvd")
+    subfolder = os.environ.get("DVD_MODEL_SUBFOLDER") or None
+    revision = os.environ.get("DVD_MODEL_REVISION") or None
+    token = os.environ.get("DVD_MODEL_TOKEN") or os.environ.get("HF_TOKEN") or None
+    for filename in ("dvd_img.json", "dvd_img.safetensors"):
+        log_event(f"prefetching {repo}/{filename}")
+        hf_hub_download(
+            repo_id=repo,
+            filename=filename,
+            subfolder=subfolder,
+            revision=revision,
+            token=token,
+        )
+
+
+def prefetch_dinov2():
+    import shutil
+    import zipfile
+
+    hub_dir = Path(torch.hub.get_dir())
+    hub_dir.mkdir(parents=True, exist_ok=True)
+    repo_dir = hub_dir / "facebookresearch_dinov2_main"
+    if repo_dir.exists():
+        log_event(f"using cached DINOv2 repo {repo_dir}")
+    else:
+        zip_path = hub_dir / "main.zip"
+        _download_file("https://github.com/facebookresearch/dinov2/zipball/main", zip_path)
+        extract_tmp = hub_dir / "_dvd_dinov2_extract"
+        if extract_tmp.exists():
+            shutil.rmtree(extract_tmp)
+        extract_tmp.mkdir(parents=True, exist_ok=True)
+        log_event(f"extracting DINOv2 repo to {repo_dir}")
+        with zipfile.ZipFile(zip_path) as zf:
+            zf.extractall(extract_tmp)
+            top_level = zf.namelist()[0].split("/", 1)[0]
+        shutil.move(str(extract_tmp / top_level), str(repo_dir))
+        shutil.rmtree(extract_tmp, ignore_errors=True)
+
+    ckpt_dir = hub_dir / "checkpoints"
+    _download_file(
+        "https://dl.fbaipublicfiles.com/dinov2/dinov2_vitl14/dinov2_vitl14_reg4_pretrain.pth",
+        ckpt_dir / "dinov2_vitl14_reg4_pretrain.pth",
+    )
+
+
+def prefetch_assets():
+    if os.environ.get("DVD_PREFETCH_ASSETS", "1").lower() in {"0", "false", "no", "off"}:
+        log_event("asset prefetch disabled")
+        return
+    try:
+        log_event("asset prefetch start")
+        prefetch_dvd_weights()
+        prefetch_dinov2()
+        log_event("asset prefetch done")
+    except Exception as exc:
+        log_event(f"asset prefetch failed; continuing without prefetch: {exc}")
+
+
+prefetch_assets()
+
+
+def worker_path(name: str) -> str:
+    path = TMP_DIR / f"worker-{uuid.uuid4().hex}"
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path / name)
+
+
+def cfg_schedule(mode: str, constant: float, early: float, late: float, split: float):
+    if mode == "Constant":
+        return float(constant)
+    if mode == "Two-stage":
+        split = float(split)
+        early = float(early)
+        late = float(late)
+        return lambda t: early if t < split else late
+    return None
+
+
+def ensure_dvd_pipe():
+    global _dvd_pipe, _export_cubified_voxels
+    if _dvd_pipe is not None:
+        log_event("reusing cached DVD image pipeline")
+        return _dvd_pipe, _export_cubified_voxels
+
+    # Intentionally import DVD/TRELLIS only after @spaces.GPU has acquired a worker.
+    log_event("importing DVD inside GPU callback")
+    from dvd import DVDImageToVoxelPipeline, export_cubified_voxels
+
+    repo = os.environ.get("DVD_MODEL_REPO", "Zhengrui/dvd")
+    subfolder = os.environ.get("DVD_MODEL_SUBFOLDER") or None
+    revision = os.environ.get("DVD_MODEL_REVISION") or None
+    token = os.environ.get("DVD_MODEL_TOKEN") or os.environ.get("HF_TOKEN") or None
+
+    log_event(f"loading DVD image pipeline from {repo} on cuda")
+    _dvd_pipe = DVDImageToVoxelPipeline.from_pretrained(
+        repo,
+        variant="base",
+        device="cuda",
+        subfolder=subfolder,
+        revision=revision,
+        token=token,
+    )
+    _export_cubified_voxels = export_cubified_voxels
+    log_event("DVD image pipeline ready on cuda")
+    return _dvd_pipe, _export_cubified_voxels
+
+
+@spaces.GPU(duration=60)
+def zero_gpu_smoke_test():
+    log_event("zero_gpu_smoke_test start")
+    if not torch.cuda.is_available():
+        log_event("zero_gpu_smoke_test no cuda")
+        return "CUDA unavailable inside ZeroGPU worker"
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"zero_gpu_smoke_test done device={name} value={value}")
+    return f"OK: {name}, value={value}"
+
+
+@spaces.GPU(duration=600)
+def generate_voxels(
+    image,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    dvd_steps: int,
+    dvd_cfg_mode: str,
+    dvd_cfg_constant: float,
+    dvd_cfg_early: float,
+    dvd_cfg_late: float,
+    dvd_cfg_split: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.01, desc="Starting ZeroGPU callback")
+    log_event(f"generate_voxels start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if image is None:
+        raise gr.Error("Please provide an image.")
+
+    progress(0.04, desc="Loading DVD pipeline")
+    pipeline, export_cubified_voxels = ensure_dvd_pipe()
+
+    seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    sampler_kwargs = {"steps": int(dvd_steps)}
+    schedule = cfg_schedule(
+        dvd_cfg_mode,
+        dvd_cfg_constant,
+        dvd_cfg_early,
+        dvd_cfg_late,
+        dvd_cfg_split,
+    )
+    if schedule is not None:
+        sampler_kwargs["cfg_strength"] = schedule
+
+    progress(0.18, desc="Sampling DVD voxels")
+    log_event(f"sampling seed={seed} steps={dvd_steps}")
+    voxels = pipeline.sample_voxels(
+        image,
+        seed=seed,
+        preprocess_image=preprocess_image,
+        **sampler_kwargs,
+    )
+
+    progress(0.88, desc="Exporting voxel preview")
+    mesh_path = worker_path("generated_voxels.glb")
+    npy_path = worker_path("generated_voxel64_coords.npy")
+    export_cubified_voxels(voxels, mesh_path)
+    np.save(npy_path, voxels.coords_without_batch.detach().cpu().numpy().astype(np.int32))
+    torch.cuda.empty_cache()
+    log_event(f"generate_voxels done seed={seed} mesh={mesh_path} npy={npy_path}")
+    return mesh_path, npy_path, int(seed), f"Done. seed={seed}"
+
+
+with gr.Blocks(title="DVD Image", fill_width=True) as demo:
+    gr.Markdown("## DVD Image Voxel Generation")
+    with gr.Row():
+        smoke_btn = gr.Button("ZeroGPU Smoke Test")
+        smoke_out = gr.Textbox(label="ZeroGPU Status", interactive=False)
+    smoke_btn.click(zero_gpu_smoke_test, outputs=smoke_out)
+
+    with gr.Row(equal_height=False):
+        with gr.Column():
+            image = gr.Image(label="Input Image", format="png", image_mode="RGBA", type="pil", height=320)
+            if EXAMPLES:
+                gr.Examples(examples=EXAMPLES[:12], inputs=image, examples_per_page=6)
+            with gr.Accordion("DVD Settings", open=False):
+                seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+                preprocess_image = gr.Checkbox(value=True, label="DVD preprocess image")
+                dvd_steps = gr.Slider(1, 512, value=256, step=1, label="DVD steps")
+                dvd_cfg_mode = gr.Radio(
+                    ["Default schedule", "Constant", "Two-stage"],
+                    value="Default schedule",
+                    label="DVD CFG mode",
+                )
+                dvd_cfg_constant = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Constant CFG")
+                dvd_cfg_early = gr.Slider(0.0, 5.0, value=0.4, step=0.05, label="Early CFG")
+                dvd_cfg_late = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Late CFG")
+                dvd_cfg_split = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="CFG switch time")
+            gen_btn = gr.Button("Generate DVD Voxels", variant="primary")
+        with gr.Column():
+            voxel_view = gr.Model3D(
+                label="Generated / Cubified Voxels",
+                height=360,
+                camera_position=(-180, 90, 3),
+            )
+            npy_download = gr.DownloadButton(label="Download Voxel Coords (.npy)", interactive=False)
+            status = gr.Textbox(label="Status", interactive=False)
+
+    gen_btn.click(
+        generate_voxels,
+        inputs=[
+            image,
+            seed,
+            randomize_seed,
+            preprocess_image,
+            dvd_steps,
+            dvd_cfg_mode,
+            dvd_cfg_constant,
+            dvd_cfg_early,
+            dvd_cfg_late,
+            dvd_cfg_split,
+        ],
+        outputs=[voxel_view, npy_download, seed, status],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[npy_download])
+
+
+if __name__ == "__main__":
+    demo.queue().launch(show_api=False, show_error=True, ssr_mode=False)

app_dvd_image_trellis_style.py

@@ -0,0 +1,202 @@
+import os
+import random
+import uuid
+from pathlib import Path
+
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("SPARSE_ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+
+import spaces
+import gradio as gr
+import numpy as np
+import torch
+
+
+MAX_SEED = 2**31 - 1
+ROOT_DIR = Path(__file__).resolve().parent
+TMP_DIR = ROOT_DIR / "tmp" / "dvd_image_trellis_style"
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
+EXAMPLE_DIR = ROOT_DIR / "assets" / "example_image"
+EXAMPLES = [
+    str(path)
+    for path in sorted(EXAMPLE_DIR.iterdir())
+    if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+] if EXAMPLE_DIR.exists() else []
+
+
+def log_event(message: str):
+    print(f"[DVD TrellisStyle] {message}", flush=True)
+
+
+@spaces.GPU(duration=60)
+def first_gpu_setup():
+    log_event("first_gpu_setup start")
+    if not torch.cuda.is_available():
+        raise RuntimeError("CUDA unavailable during first_gpu_setup")
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"first_gpu_setup ok device={name} value={value}")
+
+
+# Match trellis-community: acquire a ZeroGPU worker once before importing TRELLIS.
+first_gpu_setup()
+
+from dvd import DVDImageToVoxelPipeline, export_cubified_voxels
+
+
+def worker_path(name: str) -> str:
+    path = TMP_DIR / f"worker-{uuid.uuid4().hex}"
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path / name)
+
+
+def cfg_schedule(mode: str, constant: float, early: float, late: float, split: float):
+    if mode == "Constant":
+        return float(constant)
+    if mode == "Two-stage":
+        split = float(split)
+        early = float(early)
+        late = float(late)
+        return lambda t: early if t < split else late
+    return None
+
+
+repo = os.environ.get("DVD_MODEL_REPO", "Zhengrui/dvd")
+subfolder = os.environ.get("DVD_MODEL_SUBFOLDER") or None
+revision = os.environ.get("DVD_MODEL_REVISION") or None
+token = os.environ.get("DVD_MODEL_TOKEN") or os.environ.get("HF_TOKEN") or None
+
+log_event(f"loading DVD image pipeline from {repo}")
+dvd_pipe = DVDImageToVoxelPipeline.from_pretrained(
+    repo,
+    variant="base",
+    subfolder=subfolder,
+    revision=revision,
+    token=token,
+)
+log_event("moving DVD image pipeline to cuda")
+dvd_pipe.to("cuda")
+log_event("DVD image pipeline ready on cuda")
+
+
+@spaces.GPU(duration=30)
+def zero_gpu_smoke_test():
+    log_event("zero_gpu_smoke_test start")
+    if not torch.cuda.is_available():
+        log_event("zero_gpu_smoke_test no cuda")
+        return "CUDA unavailable inside ZeroGPU worker"
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"zero_gpu_smoke_test done device={name} value={value}")
+    return f"OK: {name}, value={value}"
+
+
+@spaces.GPU(duration=240)
+def generate_voxels(
+    image,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    dvd_steps: int,
+    dvd_cfg_mode: str,
+    dvd_cfg_constant: float,
+    dvd_cfg_early: float,
+    dvd_cfg_late: float,
+    dvd_cfg_split: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.01, desc="Starting ZeroGPU callback")
+    log_event(f"generate_voxels start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if image is None:
+        raise gr.Error("Please provide an image.")
+
+    seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    sampler_kwargs = {"steps": int(dvd_steps)}
+    schedule = cfg_schedule(
+        dvd_cfg_mode,
+        dvd_cfg_constant,
+        dvd_cfg_early,
+        dvd_cfg_late,
+        dvd_cfg_split,
+    )
+    if schedule is not None:
+        sampler_kwargs["cfg_strength"] = schedule
+
+    progress(0.08, desc="Sampling DVD voxels")
+    voxels = dvd_pipe.sample_voxels(
+        image,
+        seed=seed,
+        preprocess_image=preprocess_image,
+        **sampler_kwargs,
+    )
+
+    progress(0.88, desc="Exporting voxel preview")
+    mesh_path = worker_path("generated_voxels.glb")
+    npy_path = worker_path("generated_voxel64_coords.npy")
+    export_cubified_voxels(voxels, mesh_path)
+    np.save(npy_path, voxels.coords_without_batch.detach().cpu().numpy().astype(np.int32))
+    torch.cuda.empty_cache()
+    log_event(f"generate_voxels done seed={seed} mesh={mesh_path} npy={npy_path}")
+    return mesh_path, npy_path, int(seed), f"Done. seed={seed}"
+
+
+with gr.Blocks(title="DVD Image", fill_width=True) as demo:
+    gr.Markdown("## DVD Image Voxel Generation")
+    with gr.Row():
+        smoke_btn = gr.Button("ZeroGPU Smoke Test")
+        smoke_out = gr.Textbox(label="ZeroGPU Status", interactive=False)
+    smoke_btn.click(zero_gpu_smoke_test, outputs=smoke_out)
+
+    with gr.Row(equal_height=False):
+        with gr.Column():
+            image = gr.Image(label="Input Image", format="png", image_mode="RGBA", type="pil", height=320)
+            if EXAMPLES:
+                gr.Examples(examples=EXAMPLES[:12], inputs=image, examples_per_page=6)
+            with gr.Accordion("DVD Settings", open=False):
+                seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+                preprocess_image = gr.Checkbox(value=True, label="DVD preprocess image")
+                dvd_steps = gr.Slider(1, 512, value=256, step=1, label="DVD steps")
+                dvd_cfg_mode = gr.Radio(
+                    ["Default schedule", "Constant", "Two-stage"],
+                    value="Default schedule",
+                    label="DVD CFG mode",
+                )
+                dvd_cfg_constant = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Constant CFG")
+                dvd_cfg_early = gr.Slider(0.0, 5.0, value=0.4, step=0.05, label="Early CFG")
+                dvd_cfg_late = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Late CFG")
+                dvd_cfg_split = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="CFG switch time")
+            gen_btn = gr.Button("Generate DVD Voxels", variant="primary")
+        with gr.Column():
+            voxel_view = gr.Model3D(
+                label="Generated / Cubified Voxels",
+                height=360,
+                camera_position=(-180, 90, 3),
+            )
+            npy_download = gr.DownloadButton(label="Download Voxel Coords (.npy)", interactive=False)
+            status = gr.Textbox(label="Status", interactive=False)
+
+    gen_btn.click(
+        generate_voxels,
+        inputs=[
+            image,
+            seed,
+            randomize_seed,
+            preprocess_image,
+            dvd_steps,
+            dvd_cfg_mode,
+            dvd_cfg_constant,
+            dvd_cfg_early,
+            dvd_cfg_late,
+            dvd_cfg_split,
+        ],
+        outputs=[voxel_view, npy_download, seed, status],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[npy_download])
+
+
+if __name__ == "__main__":
+    demo.launch(show_api=False, show_error=True, ssr_mode=False)

app_dvd_image_wrapper.py

@@ -0,0 +1,187 @@
+import os
+import random
+import uuid
+from pathlib import Path
+
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+
+import spaces
+import gradio as gr
+import numpy as np
+import torch
+
+from dvd import DVDImageToVoxelPipeline, export_cubified_voxels
+
+
+MAX_SEED = 2**31 - 1
+ROOT_DIR = Path(__file__).resolve().parent
+TMP_DIR = ROOT_DIR / "tmp" / "dvd_image_wrapper"
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
+EXAMPLE_DIR = ROOT_DIR / "assets" / "example_image"
+EXAMPLES = [
+    str(path)
+    for path in sorted(EXAMPLE_DIR.iterdir())
+    if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+] if EXAMPLE_DIR.exists() else []
+
+
+def log_event(message: str):
+    print(f"[DVD Wrapper] {message}", flush=True)
+
+
+def worker_path(name: str) -> str:
+    path = TMP_DIR / f"worker-{uuid.uuid4().hex}"
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path / name)
+
+
+def cfg_schedule(mode: str, constant: float, early: float, late: float, split: float):
+    if mode == "Constant":
+        return float(constant)
+    if mode == "Two-stage":
+        split = float(split)
+        early = float(early)
+        late = float(late)
+        return lambda t: early if t < split else late
+    return None
+
+
+repo = os.environ.get("DVD_MODEL_REPO", "Zhengrui/dvd")
+subfolder = os.environ.get("DVD_MODEL_SUBFOLDER") or None
+revision = os.environ.get("DVD_MODEL_REVISION") or None
+token = os.environ.get("DVD_MODEL_TOKEN") or os.environ.get("HF_TOKEN") or None
+
+log_event(f"loading DVD image pipeline from {repo}")
+dvd_pipe = DVDImageToVoxelPipeline.from_pretrained(
+    repo,
+    variant="base",
+    subfolder=subfolder,
+    revision=revision,
+    token=token,
+)
+log_event("moving DVD image pipeline to cuda")
+dvd_pipe.to("cuda")
+log_event("DVD image pipeline ready on cuda")
+
+
+@spaces.GPU(duration=30)
+def zero_gpu_smoke_test():
+    log_event("zero_gpu_smoke_test start")
+    if not torch.cuda.is_available():
+        log_event("zero_gpu_smoke_test no cuda")
+        return "CUDA unavailable inside ZeroGPU worker"
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"zero_gpu_smoke_test done device={name} value={value}")
+    return f"OK: {name}, value={value}"
+
+
+@spaces.GPU(duration=180)
+def generate_voxels(
+    image,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    dvd_steps: int,
+    dvd_cfg_mode: str,
+    dvd_cfg_constant: float,
+    dvd_cfg_early: float,
+    dvd_cfg_late: float,
+    dvd_cfg_split: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.01, desc="Starting ZeroGPU callback")
+    log_event(f"generate_voxels start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if image is None:
+        raise gr.Error("Please provide an image.")
+
+    seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    sampler_kwargs = {"steps": int(dvd_steps)}
+    schedule = cfg_schedule(
+        dvd_cfg_mode,
+        dvd_cfg_constant,
+        dvd_cfg_early,
+        dvd_cfg_late,
+        dvd_cfg_split,
+    )
+    if schedule is not None:
+        sampler_kwargs["cfg_strength"] = schedule
+
+    progress(0.08, desc="Sampling DVD voxels")
+    voxels = dvd_pipe.sample_voxels(
+        image,
+        seed=seed,
+        preprocess_image=preprocess_image,
+        **sampler_kwargs,
+    )
+
+    progress(0.88, desc="Exporting voxel preview")
+    mesh_path = worker_path("generated_voxels.glb")
+    npy_path = worker_path("generated_voxel64_coords.npy")
+    export_cubified_voxels(voxels, mesh_path)
+    np.save(npy_path, voxels.coords_without_batch.detach().cpu().numpy().astype(np.int32))
+    torch.cuda.empty_cache()
+    log_event(f"generate_voxels done seed={seed} mesh={mesh_path} npy={npy_path}")
+    return mesh_path, npy_path, int(seed), f"Done. seed={seed}"
+
+
+with gr.Blocks(title="DVD Image", fill_width=True) as demo:
+    gr.Markdown("## DVD Image Voxel Generation")
+    with gr.Row():
+        smoke_btn = gr.Button("ZeroGPU Smoke Test")
+        smoke_out = gr.Textbox(label="ZeroGPU Status", interactive=False)
+    smoke_btn.click(zero_gpu_smoke_test, outputs=smoke_out)
+
+    with gr.Row(equal_height=False):
+        with gr.Column():
+            image = gr.Image(label="Input Image", format="png", image_mode="RGBA", type="pil", height=320)
+            if EXAMPLES:
+                gr.Examples(examples=EXAMPLES[:12], inputs=image, examples_per_page=6)
+            with gr.Accordion("DVD Settings", open=False):
+                seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+                preprocess_image = gr.Checkbox(value=True, label="DVD preprocess image")
+                dvd_steps = gr.Slider(1, 512, value=256, step=1, label="DVD steps")
+                dvd_cfg_mode = gr.Radio(
+                    ["Default schedule", "Constant", "Two-stage"],
+                    value="Default schedule",
+                    label="DVD CFG mode",
+                )
+                dvd_cfg_constant = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Constant CFG")
+                dvd_cfg_early = gr.Slider(0.0, 5.0, value=0.4, step=0.05, label="Early CFG")
+                dvd_cfg_late = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Late CFG")
+                dvd_cfg_split = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="CFG switch time")
+            gen_btn = gr.Button("Generate DVD Voxels", variant="primary")
+        with gr.Column():
+            voxel_view = gr.Model3D(
+                label="Generated / Cubified Voxels",
+                height=360,
+                camera_position=(-180, 90, 3),
+            )
+            npy_download = gr.DownloadButton(label="Download Voxel Coords (.npy)", interactive=False)
+            status = gr.Textbox(label="Status", interactive=False)
+
+    gen_btn.click(
+        generate_voxels,
+        inputs=[
+            image,
+            seed,
+            randomize_seed,
+            preprocess_image,
+            dvd_steps,
+            dvd_cfg_mode,
+            dvd_cfg_constant,
+            dvd_cfg_early,
+            dvd_cfg_late,
+            dvd_cfg_split,
+        ],
+        outputs=[voxel_view, npy_download, seed, status],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[npy_download])
+
+
+if __name__ == "__main__":
+    demo.launch(show_api=False, show_error=True, ssr_mode=False)

app_image_min.py

@@ -0,0 +1,116 @@
+import gradio as gr
+import torch
+import spaces
+
+import json
+import os
+import random
+import subprocess
+import sys
+import uuid
+from pathlib import Path
+
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+
+MAX_SEED = 2**31 - 1
+TMP_DIR = Path(__file__).resolve().parent / "tmp" / "dvd_image_min"
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def log_event(message: str):
+    print(f"[DVD Image Min] {message}", flush=True)
+
+
+def worker_path(name: str) -> str:
+    path = TMP_DIR / f"worker-{uuid.uuid4().hex}"
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path / name)
+
+
+@spaces.GPU(duration=30)
+def zero_gpu_smoke_test():
+    log_event("zero_gpu_smoke_test start")
+    if not torch.cuda.is_available():
+        log_event("cuda unavailable")
+        return "CUDA unavailable"
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"zero_gpu_smoke_test done device={name} value={value}")
+    return f"OK: {name}, value={value}"
+
+
+@spaces.GPU(duration=120)
+def generate_voxels(image, seed, randomize_seed, preprocess_image, dvd_steps, progress=gr.Progress(track_tqdm=True)):
+    progress(0.01, desc="Starting ZeroGPU callback")
+    log_event(f"generate_voxels start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if image is None:
+        raise gr.Error("Please provide an image.")
+    seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    image_path = worker_path("input.png")
+    mesh_path = worker_path("generated_voxels.glb")
+    npy_path = worker_path("generated_voxel64_coords.npy")
+    config_path = worker_path("generate_config.json")
+    image.save(image_path)
+    with open(config_path, "w") as f:
+        json.dump(
+            {
+                "image_path": image_path,
+                "mesh_path": mesh_path,
+                "npy_path": npy_path,
+                "seed": int(seed),
+                "preprocess_image": bool(preprocess_image),
+                "dvd_steps": int(dvd_steps),
+                "dvd_cfg_mode": "Default schedule",
+                "dvd_cfg_constant": 0.7,
+                "dvd_cfg_early": 0.4,
+                "dvd_cfg_late": 0.7,
+                "dvd_cfg_split": 0.5,
+            },
+            f,
+        )
+    progress(0.08, desc="Running isolated DVD worker")
+    env = os.environ.copy()
+    env.setdefault("PYTHONUNBUFFERED", "1")
+    cmd = [sys.executable, str(Path(__file__).resolve().parent / "space_image_worker.py"), "generate", config_path]
+    proc = subprocess.run(cmd, env=env, text=True, capture_output=True)
+    if proc.stdout:
+        print(proc.stdout, flush=True)
+    if proc.stderr:
+        print(proc.stderr, flush=True)
+    if proc.returncode != 0:
+        raise gr.Error(f"DVD worker failed with exit code {proc.returncode}. Check Space logs.")
+    log_event(f"generate_voxels done seed={seed}")
+    return mesh_path, npy_path, int(seed), f"Done. seed={seed}"
+
+
+with gr.Blocks(title="DVD Image", fill_width=True) as demo:
+    with gr.Row():
+        smoke_btn = gr.Button("ZeroGPU Smoke Test")
+        smoke_out = gr.Textbox(label="ZeroGPU Status", interactive=False)
+    smoke_btn.click(zero_gpu_smoke_test, outputs=smoke_out)
+
+    with gr.Row(equal_height=False):
+        with gr.Column():
+            image = gr.Image(label="Input Image", format="png", image_mode="RGBA", type="pil", height=320)
+            seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+            randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+            preprocess_image = gr.Checkbox(value=True, label="Preprocess image")
+            dvd_steps = gr.Slider(1, 512, value=256, step=1, label="DVD steps")
+            gen_btn = gr.Button("Generate DVD Voxels", variant="primary")
+        with gr.Column():
+            voxel_view = gr.Model3D(label="Generated / Cubified Voxels", height=360, camera_position=(-180, 90, 3))
+            npy_download = gr.DownloadButton(label="Download Voxel Coords (.npy)", interactive=False)
+            status = gr.Textbox(label="Status", interactive=False)
+
+    gen_btn.click(
+        generate_voxels,
+        inputs=[image, seed, randomize_seed, preprocess_image, dvd_steps],
+        outputs=[voxel_view, npy_download, seed, status],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[npy_download])
+
+
+if __name__ == "__main__":
+    demo.queue().launch(show_api=False, show_error=True, ssr_mode=False)

app_smoke.py

@@ -0,0 +1,29 @@
+import gradio as gr
+import torch
+import spaces
+
+
+def log_event(message: str):
+    print(f"[DVD Smoke] {message}", flush=True)
+
+
+@spaces.GPU(duration=30)
+def zero_gpu_smoke_test():
+    log_event("zero_gpu_smoke_test start")
+    if not torch.cuda.is_available():
+        log_event("cuda unavailable")
+        return "CUDA unavailable"
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"zero_gpu_smoke_test done device={name} value={value}")
+    return f"OK: {name}, value={value}"
+
+
+with gr.Blocks(title="ZeroGPU Smoke Test") as demo:
+    out = gr.Textbox(label="Status")
+    btn = gr.Button("ZeroGPU Smoke Test")
+    btn.click(zero_gpu_smoke_test, outputs=out)
+
+
+if __name__ == "__main__":
+    demo.queue().launch(show_api=False, show_error=True, ssr_mode=False)

app_space_image.py

@@ -0,0 +1,188 @@
+import gradio as gr
+import torch
+import spaces
+
+import json
+import os
+import subprocess
+import sys
+import uuid
+from pathlib import Path
+
+import numpy as np
+
+os.environ.setdefault("SPCONV_ALGO", "native")
+os.environ.setdefault("ATTN_BACKEND", "flash_attn")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("DVD_MODEL_REPO", "Zhengrui/dvd")
+
+
+MAX_SEED = np.iinfo(np.int32).max
+TMP_DIR = Path(__file__).resolve().parent / "tmp" / "dvd_space_image"
+TMP_DIR.mkdir(parents=True, exist_ok=True)
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
+EXAMPLE_DIR = Path(__file__).resolve().parent / "assets" / "example_image"
+GENERATION_IMAGE_EXAMPLES = [
+    str(path) for path in sorted(EXAMPLE_DIR.iterdir())
+    if path.is_file() and path.suffix.lower() in IMAGE_EXTENSIONS
+]
+
+
+
+def log_event(message: str):
+    print(f"[DVD Space Lean] {message}", flush=True)
+
+
+def worker_path(name: str) -> str:
+    path = TMP_DIR / f"worker-{uuid.uuid4().hex}"
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path / name)
+
+
+def cfg_schedule(mode: str, constant: float, early: float, late: float, split: float):
+    if mode == "Constant":
+        return float(constant)
+    if mode == "Two-stage":
+        split = float(split)
+        early = float(early)
+        late = float(late)
+        return lambda t: early if t < split else late
+    return None
+
+
+def save_voxel_coords(voxels, path: str) -> str:
+    coords = voxels.coords.detach().cpu().numpy().astype(np.int32)
+    np.save(path, coords)
+    return path
+
+
+
+def get_seed(randomize_seed: bool, seed: int) -> int:
+    return int(np.random.randint(0, MAX_SEED)) if randomize_seed else int(seed)
+
+
+
+@spaces.GPU(duration=30)
+def zero_gpu_smoke_test():
+    log_event("zero_gpu_smoke_test start")
+    if not torch.cuda.is_available():
+        log_event("zero_gpu_smoke_test no cuda")
+        return "CUDA unavailable inside ZeroGPU worker"
+    value = torch.ones((1,), device="cuda").sum().item()
+    name = torch.cuda.get_device_name(0)
+    log_event(f"zero_gpu_smoke_test done device={name} value={value}")
+    return f"OK: {name}, value={value}"
+
+
+@spaces.GPU(duration=300)
+def generate_voxels(
+    image,
+    seed: int,
+    randomize_seed: bool,
+    preprocess_image: bool,
+    dvd_steps: int,
+    dvd_cfg_mode: str,
+    dvd_cfg_constant: float,
+    dvd_cfg_early: float,
+    dvd_cfg_late: float,
+    dvd_cfg_split: float,
+    progress=gr.Progress(track_tqdm=True),
+):
+    progress(0.01, desc="Starting ZeroGPU callback")
+    log_event(f"generate_voxels start seed={seed} randomize={randomize_seed} steps={dvd_steps}")
+    if image is None:
+        raise gr.Error("Please provide an image.")
+
+    seed = get_seed(randomize_seed, seed)
+    image_path = worker_path("input.png")
+    mesh_path = worker_path("generated_voxels.glb")
+    npy_path = worker_path("generated_voxel64_coords.npy")
+    config_path = worker_path("generate_config.json")
+    image.save(image_path)
+    with open(config_path, "w") as f:
+        json.dump(
+            {
+                "image_path": image_path,
+                "mesh_path": mesh_path,
+                "npy_path": npy_path,
+                "seed": int(seed),
+                "preprocess_image": bool(preprocess_image),
+                "dvd_steps": int(dvd_steps),
+                "dvd_cfg_mode": dvd_cfg_mode,
+                "dvd_cfg_constant": float(dvd_cfg_constant),
+                "dvd_cfg_early": float(dvd_cfg_early),
+                "dvd_cfg_late": float(dvd_cfg_late),
+                "dvd_cfg_split": float(dvd_cfg_split),
+            },
+            f,
+        )
+
+    progress(0.08, desc="Running isolated DVD worker")
+    env = os.environ.copy()
+    env.setdefault("PYTHONUNBUFFERED", "1")
+    cmd = [sys.executable, str(Path(__file__).resolve().parent / "space_image_worker.py"), "generate", config_path]
+    log_event("starting isolated DVD worker")
+    proc = subprocess.run(cmd, env=env, text=True, capture_output=True)
+    if proc.stdout:
+        print(proc.stdout, flush=True)
+    if proc.stderr:
+        print(proc.stderr, flush=True)
+    if proc.returncode != 0:
+        raise gr.Error(f"DVD worker failed with exit code {proc.returncode}. Check Space logs.")
+
+    progress(0.98, desc="Done")
+    log_event(f"generate_voxels done seed={seed} npy={npy_path}")
+    return mesh_path, npy_path, seed, f"Done. seed={seed}"
+
+
+with gr.Blocks(title="DVD Image Generation", fill_width=True) as demo:
+    gr.Markdown("## DVD Image Voxel Generation")
+    with gr.Row():
+        smoke_btn = gr.Button("ZeroGPU Smoke Test")
+        smoke_out = gr.Textbox(label="ZeroGPU Status", interactive=False)
+    smoke_btn.click(zero_gpu_smoke_test, outputs=smoke_out)
+
+    with gr.Row(equal_height=False):
+        with gr.Column(scale=1):
+            image = gr.Image(label="Input Image", format="png", image_mode="RGBA", type="pil", height=320)
+            gr.Examples(
+                examples=GENERATION_IMAGE_EXAMPLES[:12],
+                inputs=image,
+                examples_per_page=6,
+            )
+            with gr.Accordion("DVD Settings", open=False):
+                seed = gr.Slider(0, MAX_SEED, value=0, step=1, label="Seed")
+                randomize_seed = gr.Checkbox(value=True, label="Randomize seed")
+                preprocess_image = gr.Checkbox(value=True, label="DVD preprocess image")
+                dvd_steps = gr.Slider(1, 512, value=128, step=1, label="DVD steps")
+                dvd_cfg_mode = gr.Radio(["Default schedule", "Constant", "Two-stage"], value="Default schedule", label="DVD CFG mode")
+                dvd_cfg_constant = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Constant CFG")
+                dvd_cfg_early = gr.Slider(0.0, 5.0, value=0.4, step=0.05, label="Early CFG")
+                dvd_cfg_late = gr.Slider(0.0, 5.0, value=0.7, step=0.05, label="Late CFG")
+                dvd_cfg_split = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="CFG switch time")
+            gen_btn = gr.Button("Generate DVD Voxels", variant="primary")
+        with gr.Column(scale=1):
+            voxel_view = gr.Model3D(label="Generated / Cubified Voxels", height=360, camera_position=(-180, 90, 3))
+            npy_download = gr.DownloadButton(label="Download Voxel Coords (.npy)", interactive=False)
+            status = gr.Textbox(label="Status", interactive=False)
+
+    gen_btn.click(
+        generate_voxels,
+        inputs=[
+            image,
+            seed,
+            randomize_seed,
+            preprocess_image,
+            dvd_steps,
+            dvd_cfg_mode,
+            dvd_cfg_constant,
+            dvd_cfg_early,
+            dvd_cfg_late,
+            dvd_cfg_split,
+        ],
+        outputs=[voxel_view, npy_download, seed, status],
+    ).then(lambda: gr.DownloadButton(interactive=True), outputs=[npy_download])
+
+
+if __name__ == "__main__":
+    demo.queue().launch(show_api=False, show_error=True, ssr_mode=False)