Update app.py

app.py

@@ -8,9 +8,11 @@ from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 import json
 
-os.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))
+os.environ['HF_HOME'] = os.path.abspath(
+    os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download'))
+)
 
-# 영어/한국어 번역 딕셔너리
+# 단일 언어(영어)만 사용하기 위한 번역 딕셔너리
 translations = {
     "en": {
         "title": "FramePack - Image to Video Generation",
@@ -43,57 +45,16 @@ translations = {
         "model_error": "Failed to load model, possibly due to network issues or high server load. Please try again later.",
         "partial_video": "Processing error, but partial video has been generated",
         "processing_interrupt": "Processing was interrupted, but partial video has been generated"
-    },
-    "ko": {
-        "title": "FramePack - 이미지에서 동영상 생성",
-        "upload_image": "이미지 업로드",
-        "prompt": "프롬프트",
-        "quick_prompts": "빠른 프롬프트 목록",
-        "start_generation": "생성 시작",
-        "stop_generation": "생성 중지",
-        "use_teacache": "TeaCache 사용",
-        "teacache_info": "더 빠른 속도를 제공하지만 손가락이나 손 생성 품질이 약간 떨어질 수 있습니다.",
-        "negative_prompt": "부정 프롬프트",
-        "seed": "랜덤 시드",
-        "video_length": "동영상 길이 (최대 5초)",
-        "latent_window": "잠재 윈도우 크기",
-        "steps": "추론 스텝 수",
-        "steps_info": "이 값을 변경하는 것은 권장되지 않습니다.",
-        "cfg_scale": "CFG 스케일",
-        "distilled_cfg": "증류된 CFG 스케일",
-        "distilled_cfg_info": "이 값을 변경하는 것은 권장되지 않습니다.",
-        "cfg_rescale": "CFG 재스케일",
-        "gpu_memory": "GPU 메모리 보존 (GB) (값이 클수록 속도가 느려짐)",
-        "gpu_memory_info": "OOM 오류가 발생하면 이 값을 더 크게 설정하십시오. 값이 클수록 속도가 느려집니다.",
-        "next_latents": "다음 잠재 변수",
-        "generated_video": "생성된 동영상",
-        "sampling_note": "주의: 역순 샘플링 때문에, 종료 동작이 시작 동작보다 먼저 생성됩니다. 시작 동작이 동영상에 나타나지 않으면 기다려 주십시오. 나중에 생성됩니다.",
-        "error_message": "오류 메시지",
-        "processing_error": "처리 중 오류 발생",
-        "network_error": "네트워크 연결이 불안정하여 모델 다운로드가 시간 초과되었습니다. 나중에 다시 시도해 주십시오.",
-        "memory_error": "GPU 메모리가 부족합니다. GPU 메모리 보존 값을 늘리거나 동영상 길이를 줄여보세요.",
-        "model_error": "모델 로드에 실패했습니다. 네트워크 문제 또는 서버 부하가 높을 수 있습니다. 나중에 다시 시도해 주십시오.",
-        "partial_video": "처리 중 오류가 발생했지만 일부 동영상이 생성되었습니다.",
-        "processing_interrupt": "처리 중 중단되었지만 일부 동영상이 생성되었습니다."
     }
 }
 
-# 다국어 텍스트를 반환하는 함수
-def get_translation(key, lang="en"):
-    if lang in translations and key in translations[lang]:
-        return translations[lang][key]
-    # 기본값(영어) 반환
+# 영어만 사용할 것이므로 아래 함수는 사실상 항상 영어를 반환합니다.
+def get_translation(key):
     return translations["en"].get(key, key)
 
-# 디폴트 언어를 영어로 설정
+# 언어는 영어로 고정
 current_language = "en"
 
-# 언어 전환 함수
-def switch_language():
-    global current_language
-    current_language = "ko" if current_language == "en" else "en"
-    return current_language
-
 import gradio as gr
 import torch
 import traceback
@@ -102,148 +63,219 @@ import safetensors.torch as sf
 import numpy as np
 import math
 
-# Spaces 환경 체크
+# Hugging Face Space 환경 체크
 IN_HF_SPACE = os.environ.get('SPACE_ID') is not None
 
-# GPU 사용 여부 기록
+# GPU 사용 여부 전역 관리
 GPU_AVAILABLE = False
 GPU_INITIALIZED = False
 last_update_time = time.time()
 
-# Spaces 환경이라면, spaces 모듈 불러오기 시도
 if IN_HF_SPACE:
     try:
         import spaces
-        print("Hugging Face Space 환경에서 실행 중, spaces 모듈을 불러왔습니다.")
-        
-        # GPU 사용 가능 여부 확인
+        print("Running in Hugging Face Space environment.")
         try:
             GPU_AVAILABLE = torch.cuda.is_available()
             print(f"GPU available: {GPU_AVAILABLE}")
             if GPU_AVAILABLE:
-                print(f"GPU device name: {torch.cuda.get_device_name(0)}")
-                print(f"GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1e9} GB")
-                
-                # 작은 테스트 연산으로 실제 GPU 동작 확인
-                test_tensor = torch.zeros(1, device='cuda')
-                test_tensor = test_tensor + 1
+                test_tensor = torch.zeros(1, device='cuda') + 1
                 del test_tensor
-                print("GPU 테스트 연산 성공")
-            else:
-                print("경고: CUDA는 가능하다고 하나 실제 GPU 디바이스를 찾을 수 없습니다.")
+                print("GPU small test pass")
         except Exception as e:
             GPU_AVAILABLE = False
-            print(f"GPU 확인 중 오류 발생: {e}")
-            print("CPU 모드로 진행합니다.")
+            print(f"Error checking GPU: {e}")
     except ImportError:
-        print("spaces 모듈을 불러올 수 없습니다. Spaces 환경이 아닐 수 있습니다.")
         GPU_AVAILABLE = torch.cuda.is_available()
 
 from PIL import Image
 from diffusers import AutoencoderKLHunyuanVideo
-from transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer
-from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
-from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp
+from transformers import (
+    LlamaModel,
+    CLIPTextModel,
+    LlamaTokenizerFast,
+    CLIPTokenizer,
+    SiglipImageProcessor,
+    SiglipVisionModel
+)
+
+from diffusers_helper.hunyuan import (
+    encode_prompt_conds,
+    vae_decode,
+    vae_encode,
+    vae_decode_fake
+)
+
+from diffusers_helper.utils import (
+    save_bcthw_as_mp4,
+    crop_or_pad_yield_mask,
+    soft_append_bcthw,
+    resize_and_center_crop,
+    generate_timestamp
+)
+
+from diffusers_helper.bucket_tools import find_nearest_bucket
 from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
 from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
-from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete, IN_HF_SPACE as MEMORY_IN_HF_SPACE
+from diffusers_helper.memory import (
+    cpu,
+    gpu,
+    get_cuda_free_memory_gb,
+    move_model_to_device_with_memory_preservation,
+    offload_model_from_device_for_memory_preservation,
+    fake_diffusers_current_device,
+    DynamicSwapInstaller,
+    unload_complete_models,
+    load_model_as_complete
+)
+
 from diffusers_helper.thread_utils import AsyncStream, async_run
-from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
-from transformers import SiglipImageProcessor, SiglipVisionModel
 from diffusers_helper.clip_vision import hf_clip_vision_encode
-from diffusers_helper.bucket_tools import find_nearest_bucket
+from diffusers_helper.gradio.progress_bar import (
+    make_progress_bar_css,
+    make_progress_bar_html
+)
 
 outputs_folder = './outputs/'
 os.makedirs(outputs_folder, exist_ok=True)
 
-# Spaces 환경이 아닐 경우, VRAM 확인
+# GPU 메모리 확인
 if not IN_HF_SPACE:
     try:
         if torch.cuda.is_available():
             free_mem_gb = get_cuda_free_memory_gb(gpu)
-            print(f'남은 VRAM: {free_mem_gb} GB')
+            print(f'Free VRAM: {free_mem_gb} GB')
         else:
-            free_mem_gb = 6.0  # 기본값
-            print("CUDA를 사용할 수 없으므로 기본 메모리 설정을 사용합니다.")
+            free_mem_gb = 6.0
+            print("CUDA not available, default memory setting used.")
     except Exception as e:
         free_mem_gb = 6.0
-        print(f"CUDA 메모리 확인 중 오류 발생: {e} / 기본값 사용")
-        
+        print(f"Error getting GPU mem: {e}, using default=6GB")
     high_vram = free_mem_gb > 60
-    print(f'high_vram 모드: {high_vram}')
 else:
-    # Spaces 환경에서 기본값 설정
-    print("Spaces 환경에서 기본 메모리 설정 사용")
+    print("Using default memory setting in Spaces environment.")
     try:
         if GPU_AVAILABLE:
             free_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 * 0.9
-            high_vram = free_mem_gb > 10  # 조금 더 보수적으로 설정
+            high_vram = (free_mem_gb > 10)
         else:
             free_mem_gb = 6.0
             high_vram = False
     except Exception as e:
-        print(f"GPU 메모리 확인 중 오류: {e}")
         free_mem_gb = 6.0
         high_vram = False
-    
-    print(f'GPU 메모리: {free_mem_gb:.2f} GB, High-VRAM 모드: {high_vram}')
+    print(f'GPU memory: {free_mem_gb:.2f} GB, High-VRAM mode: {high_vram}')
 
-# 전역 모델 참조
 models = {}
-cpu_fallback_mode = not GPU_AVAILABLE  # GPU가 불가능하면 CPU 모드로
+cpu_fallback_mode = not GPU_AVAILABLE
 
 def load_models():
+    """
+    Load or initialize the global models
+    """
     global models, cpu_fallback_mode, GPU_INITIALIZED
     
     if GPU_INITIALIZED:
-        print("모델이 이미 로드되었습니다. 다시 로드하지 않습니다.")
+        print("Models are already loaded, skipping re-initialization.")
         return models
-    
-    print("모델 로드를 시작합니다...")
+
+    print("Start loading models...")
 
     try:
         device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
-        model_device = 'cpu'  # 우선 CPU에 로드
-
-        # 기본적으로 GPU면 float16, CPU면 float32
+        model_device = 'cpu'
+        
         dtype = torch.float16 if GPU_AVAILABLE else torch.float32
         transformer_dtype = torch.bfloat16 if GPU_AVAILABLE else torch.float32
-        
-        print(f"사용 디바이스: {device}, vae/text encoder dtype: {dtype}, transformer dtype: {transformer_dtype}")
-        
-        try:
-            text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to(model_device)
-            text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to(model_device)
-            tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
-            tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
-            vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to(model_device)
 
-            feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
-            image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to(model_device)
+        print(f"Device: {device}, VAE/Encoders dtype={dtype}, Transformer dtype={transformer_dtype}")
 
-            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('lllyasviel/FramePackI2V_HY', torch_dtype=transformer_dtype).to(model_device)
-            
-            print("모든 모델을 성공적으로 로드했습니다.")
+        try:
+            text_encoder = LlamaModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='text_encoder',
+                torch_dtype=dtype
+            ).to(model_device)
+            text_encoder_2 = CLIPTextModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='text_encoder_2',
+                torch_dtype=dtype
+            ).to(model_device)
+            tokenizer = LlamaTokenizerFast.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer'
+            )
+            tokenizer_2 = CLIPTokenizer.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer_2'
+            )
+            vae = AutoencoderKLHunyuanVideo.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='vae',
+                torch_dtype=dtype
+            ).to(model_device)
+
+            feature_extractor = SiglipImageProcessor.from_pretrained(
+                "lllyasviel/flux_redux_bfl", subfolder='feature_extractor'
+            )
+            image_encoder = SiglipVisionModel.from_pretrained(
+                "lllyasviel/flux_redux_bfl",
+                subfolder='image_encoder',
+                torch_dtype=dtype
+            ).to(model_device)
+
+            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
+                "lllyasviel/FramePackI2V_HY",
+                torch_dtype=transformer_dtype
+            ).to(model_device)
+
+            print("All models loaded successfully.")
         except Exception as e:
-            print(f"모델 로드 중 오류 발생: {e}")
-            print("정밀도를 낮춰 다시 로드합니다...")
-
+            print(f"Error loading models: {e}")
+            print("Retry with float32 on CPU...")
             dtype = torch.float32
             transformer_dtype = torch.float32
             cpu_fallback_mode = True
-            
-            text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to('cpu')
-            text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to('cpu')
-            tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
-            tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
-            vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to('cpu')
 
-            feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
-            image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to('cpu')
+            text_encoder = LlamaModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='text_encoder',
+                torch_dtype=dtype
+            ).to('cpu')
+            text_encoder_2 = CLIPTextModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='text_encoder_2',
+                torch_dtype=dtype
+            ).to('cpu')
+            tokenizer = LlamaTokenizerFast.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer'
+            )
+            tokenizer_2 = CLIPTokenizer.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer_2'
+            )
+            vae = AutoencoderKLHunyuanVideo.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='vae',
+                torch_dtype=dtype
+            ).to('cpu')
+
+            feature_extractor = SiglipImageProcessor.from_pretrained(
+                "lllyasviel/flux_redux_bfl", subfolder='feature_extractor'
+            )
+            image_encoder = SiglipVisionModel.from_pretrained(
+                "lllyasviel/flux_redux_bfl",
+                subfolder='image_encoder',
+                torch_dtype=dtype
+            ).to('cpu')
 
-            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('lllyasviel/FramePackI2V_HY', torch_dtype=transformer_dtype).to('cpu')
-            
-            print("CPU 모드로 모델 로드 성공")
+            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
+                "lllyasviel/FramePackI2V_HY",
+                torch_dtype=transformer_dtype
+            ).to('cpu')
+
+            print("Loaded in CPU-only fallback mode.")
 
         vae.eval()
         text_encoder.eval()
@@ -256,7 +288,7 @@ def load_models():
             vae.enable_tiling()
 
         transformer.high_quality_fp32_output_for_inference = True
-        print('transformer.high_quality_fp32_output_for_inference = True')
+        print("transformer.high_quality_fp32_output_for_inference = True")
 
         if not cpu_fallback_mode:
             transformer.to(dtype=transformer_dtype)
@@ -274,7 +306,6 @@ def load_models():
         if torch.cuda.is_available() and not cpu_fallback_mode:
             try:
                 if not high_vram:
-                    # 메모리 최적화
                     DynamicSwapInstaller.install_model(transformer, device=device)
                     DynamicSwapInstaller.install_model(text_encoder, device=device)
                 else:
@@ -283,10 +314,9 @@ def load_models():
                     image_encoder.to(device)
                     vae.to(device)
                     transformer.to(device)
-                print(f"모델을 {device}로 이동 완료")
+                print(f"Moved models to {device}")
             except Exception as e:
-                print(f"{device}로 모델 이동 중 오류 발생: {e}")
-                print("CPU 모드로 전환")
+                print(f"Error moving models to {device}: {e}, fallback to CPU")
                 cpu_fallback_mode = True
 
         models_local = {
@@ -299,116 +329,156 @@ def load_models():
             'image_encoder': image_encoder,
             'transformer': transformer
         }
-        
+
         GPU_INITIALIZED = True
         models.update(models_local)
-        print(f"모델 로드 완료. 현재 실행 모드: {'CPU' if cpu_fallback_mode else 'GPU'}")
+        print(f"Model load complete. Running mode: {'CPU' if cpu_fallback_mode else 'GPU'}")
         return models
     except Exception as e:
-        print(f"모델 로드 중 예상치 못한 오류가 발생: {e}")
+        print(f"Unexpected error in load_models(): {e}")
         traceback.print_exc()
-        
-        error_info = {
-            "error": str(e),
-            "traceback": traceback.format_exc(),
-            "cuda_available": torch.cuda.is_available(),
-            "device": "cpu" if cpu_fallback_mode else "cuda",
-        }
-        
-        try:
-            with open(os.path.join(outputs_folder, "error_log.txt"), "w") as f:
-                f.write(str(error_info))
-        except:
-            pass
-            
         cpu_fallback_mode = True
         return {}
 
+# GPU 데코레이터 사용 여부 (Spaces 전용)
 if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE:
     try:
         @spaces.GPU
         def initialize_models():
-            """@spaces.GPU 환경에서 모델을 초기화"""
             global GPU_INITIALIZED
             try:
                 result = load_models()
                 GPU_INITIALIZED = True
                 return result
             except Exception as e:
-                print(f"@spaces.GPU 모델 초기화 중 오류: {e}")
-                traceback.print_exc()
+                print(f"Error in @spaces.GPU model init: {e}")
                 global cpu_fallback_mode
                 cpu_fallback_mode = True
                 return load_models()
     except Exception as e:
-        print(f"spaces.GPU 데코레이터 생성 중 오류: {e}")
+        print(f"Error creating spaces.GPU decorator: {e}")
         def initialize_models():
             return load_models()
+else:
+    def initialize_models():
+        return load_models()
 
 def get_models():
-    """모델을 불러오거나 이미 불러왔다면 반환"""
-    global models, GPU_INITIALIZED
-    
+    """
+    Retrieve or load models if not loaded yet.
+    """
+    global models
     model_loading_key = "__model_loading__"
-    
+
     if not models:
         if model_loading_key in globals():
-            print("모델 로딩 중입니다. 대기 중...")
+            print("Models are loading, please wait...")
             import time
             start_wait = time.time()
-            while not models and model_loading_key in globals():
+            while (not models) and (model_loading_key in globals()):
                 time.sleep(0.5)
                 if time.time() - start_wait > 60:
-                    print("모델 로딩 대기 시간 초과")
+                    print("Timed out waiting for model load.")
                     break
-            
             if models:
                 return models
-            
         try:
             globals()[model_loading_key] = True
-            
             if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE and not cpu_fallback_mode:
                 try:
-                    print("GPU 데코레이터(@spaces.GPU)로 모델 로딩 시도")
+                    print("Loading models via @spaces.GPU decorator.")
                     models_local = initialize_models()
                     models.update(models_local)
                 except Exception as e:
-                    print(f"GPU 데코레이터 로딩 실패: {e} / 직접 로딩 시도")
+                    print(f"Error with GPU decorator: {e}, direct load fallback.")
                     models_local = load_models()
                     models.update(models_local)
             else:
-                print("모델 직접 로딩 시도")
                 models_local = load_models()
                 models.update(models_local)
         except Exception as e:
-            print(f"모델 로드 중 오류: {e}")
-            traceback.print_exc()
+            print(f"Unexpected error while loading models: {e}")
             models.clear()
         finally:
             if model_loading_key in globals():
                 del globals()[model_loading_key]
-    
     return models
 
 stream = AsyncStream()
 
+# 오류 메시지 HTML 생성 함수(영어만)
+def create_error_html(error_msg, is_timeout=False):
+    """
+    Create a user-friendly error message in English only
+    """
+    if is_timeout:
+        if "partial" in error_msg:
+            en_msg = "Processing timed out, but partial video has been generated."
+        else:
+            en_msg = f"Processing timed out: {error_msg}"
+    elif "model load" in error_msg.lower():
+        en_msg = "Failed to load models. Possibly heavy traffic or GPU issues."
+    elif "gpu" in error_msg.lower() or "cuda" in error_msg.lower() or "memory" in error_msg.lower():
+        en_msg = "GPU memory insufficient or error. Please try increasing GPU memory or reduce video length."
+    elif "sampling" in error_msg.lower():
+        if "partial" in error_msg.lower():
+            en_msg = "Error during sampling process, but partial video has been generated."
+        else:
+            en_msg = "Error during sampling process. Unable to generate video."
+    elif "timeout" in error_msg.lower():
+        en_msg = "Network or model download timed out. Please try again later."
+    else:
+        en_msg = f"Processing error: {error_msg}"
+
+    return f"""
+    <div class="error-message" id="custom-error-container">
+        <div>
+            <span class="error-icon">⚠️</span> {en_msg}
+        </div>
+    </div>
+    <script>
+        // Hide default Gradio error UI
+        (function() {{
+            const defaultErrorElements = document.querySelectorAll('.error');
+            defaultErrorElements.forEach(el => {{
+                el.style.display = 'none';
+            }});
+        }})();
+    </script>
+    """
+
 @torch.no_grad()
-def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+def worker(
+    input_image,
+    prompt,
+    n_prompt,
+    seed,
+    total_second_length,
+    latent_window_size,
+    steps,
+    cfg,
+    gs,
+    rs,
+    gpu_memory_preservation,
+    use_teacache
+):
+    """
+    Actual generation logic in background thread.
+    """
     global last_update_time
     last_update_time = time.time()
-    
+
     total_second_length = min(total_second_length, 5.0)
-    
+
     try:
         models_local = get_models()
         if not models_local:
-            error_msg = "모델 로드에 실패했습니다. 로그를 확인하세요."
+            error_msg = "Model load failed. Check logs for details."
             print(error_msg)
             stream.output_queue.push(('error', error_msg))
             stream.output_queue.push(('end', None))
             return
-        
+
         text_encoder = models_local['text_encoder']
         text_encoder_2 = models_local['text_encoder_2']
         tokenizer = models_local['tokenizer']
@@ -418,22 +488,22 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
         image_encoder = models_local['image_encoder']
         transformer = models_local['transformer']
     except Exception as e:
-        error_msg = f"모델 가져오기 실패: {e}"
-        print(error_msg)
+        err = f"Error retrieving models: {e}"
+        print(err)
         traceback.print_exc()
-        stream.output_queue.push(('error', error_msg))
+        stream.output_queue.push(('error', err))
         stream.output_queue.push(('end', None))
         return
-    
-    device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
-    print(f"추론 디바이스: {device}")
+
+    device = 'cuda' if (GPU_AVAILABLE and not cpu_fallback_mode) else 'cpu'
+    print(f"Inference device: {device}")
 
     if cpu_fallback_mode:
-        print("CPU 모드에서 일부 파라미터를 축소합니다.")
+        print("CPU fallback mode: reducing some parameters for performance.")
         latent_window_size = min(latent_window_size, 5)
         steps = min(steps, 15)
         total_second_length = min(total_second_length, 2.0)
-    
+
     total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)
     total_latent_sections = int(max(round(total_latent_sections), 1))
 
@@ -443,6 +513,8 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
     history_latents = None
     total_generated_latent_frames = 0
 
+    from diffusers_helper.memory import unload_complete_models
+
     stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
 
     try:
@@ -452,95 +524,102 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
                     text_encoder, text_encoder_2, image_encoder, vae, transformer
                 )
             except Exception as e:
-                print(f"모델 언로드 중 오류: {e}")
-        
-        # 텍스트 인코딩
+                print(f"Error unloading models: {e}")
+
+        # Text Encode
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding...'))))
 
         try:
             if not high_vram and not cpu_fallback_mode:
                 fake_diffusers_current_device(text_encoder, device)
                 load_model_as_complete(text_encoder_2, target_device=device)
 
-            llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+            llama_vec, clip_l_pooler = encode_prompt_conds(
+                prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2
+            )
 
             if cfg == 1:
-                llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
+                llama_vec_n, clip_l_pooler_n = (
+                    torch.zeros_like(llama_vec),
+                    torch.zeros_like(clip_l_pooler),
+                )
             else:
-                llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+                llama_vec_n, clip_l_pooler_n = encode_prompt_conds(
+                    n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2
+                )
 
             llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
             llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
         except Exception as e:
-            error_msg = f"텍스트 인코딩 오류: {e}"
-            print(error_msg)
+            err = f"Text encoding error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # 입력 이미지 처리
+        # Image processing
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing...'))))
 
         try:
             H, W, C = input_image.shape
             height, width = find_nearest_bucket(H, W, resolution=640)
-            
+
             if cpu_fallback_mode:
                 height = min(height, 320)
                 width = min(width, 320)
-                
+
             input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)
             Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
 
             input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
             input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
         except Exception as e:
-            error_msg = f"이미지 전처리 오류: {e}"
-            print(error_msg)
+            err = f"Image preprocess error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # VAE 인코딩
+        # VAE encoding
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding...'))))
 
         try:
             if not high_vram and not cpu_fallback_mode:
                 load_model_as_complete(vae, target_device=device)
-
             start_latent = vae_encode(input_image_pt, vae)
         except Exception as e:
-            error_msg = f"VAE 인코딩 오류: {e}"
-            print(error_msg)
+            err = f"VAE encode error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # CLIP Vision 인코딩
+        # CLIP Vision
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encode...'))))
 
         try:
             if not high_vram and not cpu_fallback_mode:
                 load_model_as_complete(image_encoder, target_device=device)
-
-            image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
+            image_encoder_output = hf_clip_vision_encode(
+                input_image_np, feature_extractor, image_encoder
+            )
             image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
         except Exception as e:
-            error_msg = f"CLIP Vision 인코딩 오류: {e}"
-            print(error_msg)
+            err = f"CLIP Vision encode error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # dtype 변환
+        # Convert dtype
         try:
             llama_vec = llama_vec.to(transformer.dtype)
             llama_vec_n = llama_vec_n.to(transformer.dtype)
@@ -548,67 +627,81 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
             image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
         except Exception as e:
-            error_msg = f"dtype 변환 오류: {e}"
-            print(error_msg)
+            err = f"Data type conversion error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # 샘플링 진행
+        # Sampling
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling...'))))
 
         rnd = torch.Generator("cpu").manual_seed(seed)
         num_frames = latent_window_size * 4 - 3
 
         try:
-            history_latents = torch.zeros(size=(1, 16, 1 + 2 + 16, height // 8, width // 8), dtype=torch.float32).cpu()
+            history_latents = torch.zeros(
+                size=(1, 16, 1 + 2 + 16, height // 8, width // 8),
+                dtype=torch.float32
+            ).cpu()
             history_pixels = None
             total_generated_latent_frames = 0
         except Exception as e:
-            error_msg = f"히스토리 상태 초기화 오류: {e}"
-            print(error_msg)
+            err = f"Init history state error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        latent_paddings = reversed(range(total_latent_sections))
+        latent_paddings = list(reversed(range(total_latent_sections)))
         if total_latent_sections > 4:
+            # Some heuristic to flatten out large steps
             latent_paddings = [3] + [2]*(total_latent_sections - 3) + [1, 0]
 
         for latent_padding in latent_paddings:
             last_update_time = time.time()
-            is_last_section = latent_padding == 0
+            is_last_section = (latent_padding == 0)
             latent_padding_size = latent_padding * latent_window_size
 
             if stream.input_queue.top() == 'end':
-                # 중단 신호 수신 시 부분 결과 반환
+                # If user requests end, save partial video if possible
                 if history_pixels is not None and total_generated_latent_frames > 0:
                     try:
-                        output_filename = os.path.join(outputs_folder, f'{job_id}_final_{total_generated_latent_frames}.mp4')
-                        save_bcthw_as_mp4(history_pixels, output_filename, fps=30)
-                        stream.output_queue.push(('file', output_filename))
+                        outname = os.path.join(
+                            outputs_folder, f'{job_id}_final_{total_generated_latent_frames}.mp4'
+                        )
+                        save_bcthw_as_mp4(history_pixels, outname, fps=30)
+                        stream.output_queue.push(('file', outname))
                     except Exception as e:
-                        print(f"마지막 비디오 저장 오류: {e}")
-                
+                        print(f"Error saving final partial video: {e}")
                 stream.output_queue.push(('end', None))
                 return
 
-            print(f'latent_padding_size = {latent_padding_size}, is_last_section = {is_last_section}')
+            print(f"latent_padding_size={latent_padding_size}, last_section={is_last_section}")
 
             try:
-                indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
-                clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
+                indices = torch.arange(
+                    0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])
+                ).unsqueeze(0)
+                (
+                    clean_latent_indices_pre,
+                    blank_indices,
+                    latent_indices,
+                    clean_latent_indices_post,
+                    clean_latent_2x_indices,
+                    clean_latent_4x_indices
+                ) = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
                 clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
 
                 clean_latents_pre = start_latent.to(history_latents)
-                clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16, :, :].split([1, 2, 16], dim=2)
+                clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16].split([1, 2, 16], dim=2)
                 clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)
             except Exception as e:
-                error_msg = f"샘플링 데이터 준비 오류: {e}"
-                print(error_msg)
+                err = f"Sampling data prep error: {e}"
+                print(err)
                 traceback.print_exc()
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
@@ -617,15 +710,17 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             if not high_vram and not cpu_fallback_mode:
                 try:
                     unload_complete_models()
-                    move_model_to_device_with_memory_preservation(transformer, target_device=device, preserved_memory_gb=gpu_memory_preservation)
+                    move_model_to_device_with_memory_preservation(
+                        transformer, target_device=device, preserved_memory_gb=gpu_memory_preservation
+                    )
                 except Exception as e:
-                    print(f"transformer GPU 이동 오류: {e}")
+                    print(f"Error moving transformer to GPU: {e}")
 
             if use_teacache and not cpu_fallback_mode:
                 try:
                     transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
                 except Exception as e:
-                    print(f"teacache 초기화 오류: {e}")
+                    print(f"Error init teacache: {e}")
                     transformer.initialize_teacache(enable_teacache=False)
             else:
                 transformer.initialize_teacache(enable_teacache=False)
@@ -633,33 +728,31 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             def callback(d):
                 global last_update_time
                 last_update_time = time.time()
-                
                 try:
                     if stream.input_queue.top() == 'end':
                         stream.output_queue.push(('end', None))
-                        raise KeyboardInterrupt('사용자 중단 요청')
-
+                        raise KeyboardInterrupt('User requested stop.')
                     preview = d['denoised']
                     preview = vae_decode_fake(preview)
-
-                    preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)
+                    preview = (preview * 255.0).cpu().numpy().clip(0,255).astype(np.uint8)
                     preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')
 
-                    current_step = d['i'] + 1
-                    percentage = int(100.0 * current_step / steps)
-                    hint = f'Sampling {current_step}/{steps}'
-                    desc = f'Total generated frames: {int(max(0, total_generated_latent_frames * 4 - 3))}, Video length: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} seconds (FPS-30).'
-                    stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
+                    curr_step = d['i'] + 1
+                    percentage = int(100.0 * curr_step / steps)
+                    hint = f'Sampling {curr_step}/{steps}'
+                    desc = f'Total frames so far: {int(max(0, total_generated_latent_frames * 4 - 3))}'
+                    barhtml = make_progress_bar_html(percentage, hint)
+                    stream.output_queue.push(('progress', (preview, desc, barhtml)))
                 except KeyboardInterrupt:
                     raise
                 except Exception as e:
-                    print(f"콜백 중 오류: {e}")
+                    print(f"Callback error: {e}")
                 return
 
             try:
-                sampling_start_time = time.time()
-                print(f"샘플링 시작, device: {device}, dtype: {transformer.dtype}, TeaCache: {use_teacache and not cpu_fallback_mode}")
-                
+                print(f"Sampling with device={device}, dtype={transformer.dtype}, teacache={use_teacache}")
+                from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
+
                 try:
                     generated_latents = sample_hunyuan(
                         transformer=transformer,
@@ -688,144 +781,134 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
                         clean_latent_2x_indices=clean_latent_2x_indices,
                         clean_latents_4x=clean_latents_4x,
                         clean_latent_4x_indices=clean_latent_4x_indices,
-                        callback=callback,
+                        callback=callback
                     )
-                    
-                    print(f"샘플링 완료. 소요 시간: {time.time() - sampling_start_time:.2f} 초")
                 except KeyboardInterrupt as e:
-                    print(f"사용자 중단: {e}")
+                    print(f"User interrupt: {e}")
                     if last_output_filename:
                         stream.output_queue.push(('file', last_output_filename))
-                        error_msg = "사용자에 의해 중단되었지만, 일부 비디오가 생성되었습니다."
+                        err = "User stopped generation, partial video returned."
                     else:
-                        error_msg = "사용자에 의해 중단되었습니다. 비디오가 생성되지 않았습니다."
-                    
-                    stream.output_queue.push(('error', error_msg))
+                        err = "User stopped generation, no video produced."
+                    stream.output_queue.push(('error', err))
                     stream.output_queue.push(('end', None))
                     return
             except Exception as e:
-                print(f"샘플링 중 오류: {e}")
+                print(f"Sampling error: {e}")
                 traceback.print_exc()
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
-                    error_msg = f"샘플링 중 오류(일부 비디오 생성됨): {e}"
-                    stream.output_queue.push(('error', error_msg))
+                    err = f"Error during sampling, partial video returned: {e}"
+                    stream.output_queue.push(('error', err))
                 else:
-                    error_msg = f"샘플링 중 오류: {e}"
-                    stream.output_queue.push(('error', error_msg))
+                    err = f"Error during sampling, no video produced: {e}"
+                    stream.output_queue.push(('error', err))
                 stream.output_queue.push(('end', None))
                 return
 
             try:
                 if is_last_section:
                     generated_latents = torch.cat([start_latent.to(generated_latents), generated_latents], dim=2)
-
                 total_generated_latent_frames += int(generated_latents.shape[2])
                 history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2)
             except Exception as e:
-                error_msg = f"생성된 잠재 변수 처리 오류: {e}"
-                print(error_msg)
+                err = f"Post-latent processing error: {e}"
+                print(err)
                 traceback.print_exc()
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
-                stream.output_queue.push(('error', error_msg))
+                stream.output_queue.push(('error', err))
                 stream.output_queue.push(('end', None))
                 return
 
             if not high_vram and not cpu_fallback_mode:
                 try:
-                    offload_model_from_device_for_memory_preservation(transformer, target_device=device, preserved_memory_gb=8)
+                    offload_model_from_device_for_memory_preservation(
+                        transformer, target_device=device, preserved_memory_gb=8
+                    )
                     load_model_as_complete(vae, target_device=device)
                 except Exception as e:
-                    print(f"모델 메모리 관리 오류: {e}")
+                    print(f"Model memory manage error: {e}")
 
             try:
-                real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]
+                real_history_latents = history_latents[:, :, :total_generated_latent_frames]
             except Exception as e:
-                error_msg = f"히스토리 잠재 변수 처리 오류: {e}"
-                print(error_msg)
+                err = f"History latents slice error: {e}"
+                print(err)
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
                 continue
 
             try:
-                vae_start_time = time.time()
-                print(f"VAE 디코딩 시작, 잠재 변수 크기: {real_history_latents.shape}")
-
+                # VAE decode
                 if history_pixels is None:
                     history_pixels = vae_decode(real_history_latents, vae).cpu()
                 else:
-                    section_latent_frames = (latent_window_size * 2 + 1) if is_last_section else (latent_window_size * 2)
+                    # Overlap logic
+                    section_latent_frames = (
+                        (latent_window_size * 2 + 1) if is_last_section else (latent_window_size * 2)
+                    )
                     overlapped_frames = latent_window_size * 4 - 3
-
                     current_pixels = vae_decode(real_history_latents[:, :, :section_latent_frames], vae).cpu()
                     history_pixels = soft_append_bcthw(current_pixels, history_pixels, overlapped_frames)
-
-                print(f"VAE 디코딩 완료, 소요 시간: {time.time() - vae_start_time:.2f} 초")
-
-                if not high_vram and not cpu_fallback_mode:
-                    try:
-                        unload_complete_models()
-                    except Exception as e:
-                        print(f"모델 언로드 중 오류: {e}")
-
-                output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
-
-                save_start_time = time.time()
+                
+                output_filename = os.path.join(
+                    outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4'
+                )
                 save_bcthw_as_mp4(history_pixels, output_filename, fps=30)
-                print(f"비디오 저장 완료, 소요 시간: {time.time() - save_start_time:.2f} 초")
-
-                print(f'디코딩 완료. 현재 latent 크기: {real_history_latents.shape}, pixel 크기: {history_pixels.shape}')
-
                 last_output_filename = output_filename
                 stream.output_queue.push(('file', output_filename))
             except Exception as e:
-                print(f"비디오 디코딩/저장 중 오류: {e}")
+                print(f"Video decode/save error: {e}")
                 traceback.print_exc()
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
-                error_msg = f"비디오 디코딩/저장 오류: {e}"
-                stream.output_queue.push(('error', error_msg))
+                err = f"Video decode/save error: {e}"
+                stream.output_queue.push(('error', err))
                 continue
 
             if is_last_section:
                 break
     except Exception as e:
-        print(f"처리 중 오류 발생: {e} (type: {type(e)})")
+        print(f"Outer error: {e}, type={type(e)}")
         traceback.print_exc()
-        
-        if isinstance(e, KeyboardInterrupt):
-            print("KeyboardInterrupt 발생")
-
         if not high_vram and not cpu_fallback_mode:
             try:
                 unload_complete_models(
                     text_encoder, text_encoder_2, image_encoder, vae, transformer
                 )
-            except Exception as unload_error:
-                print(f"언로드 오류: {unload_error}")
-        
+            except Exception as ue:
+                print(f"Unload error: {ue}")
+
         if last_output_filename:
             stream.output_queue.push(('file', last_output_filename))
-        
-        error_msg = f"처리 중 오류: {e}"
-        stream.output_queue.push(('error', error_msg))
+        err = f"Error in worker: {e}"
+        stream.output_queue.push(('error', err))
 
-    print("worker 함수 종료, 'end' 신호 전송")
+    print("Worker finished, pushing 'end'.")
     stream.output_queue.push(('end', None))
-    return
 
+# 최종 처리 함수 (Spaces GPU decorator or normal)
 if IN_HF_SPACE and 'spaces' in globals():
     @spaces.GPU
-    def process_with_gpu(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+    def process_with_gpu(
+        input_image, prompt, n_prompt, seed,
+        total_second_length, latent_window_size, steps,
+        cfg, gs, rs, gpu_memory_preservation, use_teacache
+    ):
         global stream
-        assert input_image is not None, 'No input image!'
-
-        yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
+        assert input_image is not None, "No input image given."
 
+        # Initialize UI state
+        yield None, None, "", "", gr.update(interactive=False), gr.update(interactive=True)
         try:
             stream = AsyncStream()
-            async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)
+            async_run(
+                worker,
+                input_image, prompt, n_prompt, seed,
+                total_second_length, latent_window_size, steps, cfg, gs, rs,
+                gpu_memory_preservation, use_teacache
+            )
 
             output_filename = None
             prev_output_filename = None
@@ -834,61 +917,73 @@ if IN_HF_SPACE and 'spaces' in globals():
             while True:
                 try:
                     flag, data = stream.output_queue.next()
-
                     if flag == 'file':
                         output_filename = data
                         prev_output_filename = output_filename
                         yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)
-
-                    if flag == 'progress':
+                    elif flag == 'progress':
                         preview, desc, html = data
                         yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
-                    
-                    if flag == 'error':
+                    elif flag == 'error':
                         error_message = data
-                        print(f"오류 메시지 수신: {error_message}")
-
-                    if flag == 'end':
-                        if output_filename is None and prev_output_filename is not None:
+                        print(f"Got error: {error_message}")
+                    elif flag == 'end':
+                        if output_filename is None and prev_output_filename:
                             output_filename = prev_output_filename
-                        
                         if error_message:
-                            error_html = create_error_html(error_message)
-                            yield output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+                            err_html = create_error_html(error_message)
+                            yield (
+                                output_filename, gr.update(visible=False), gr.update(),
+                                err_html, gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         else:
-                            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
+                            yield (
+                                output_filename, gr.update(visible=False), gr.update(),
+                                '', gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         break
                 except Exception as e:
-                    print(f"출력 처리 중 오류: {e}")
-                    current_time = time.time()
-                    if current_time - last_update_time > 60:
-                        print(f"처리가 {current_time - last_update_time:.1f}초 동안 정지됨. 타임��웃으로 간주.")
+                    print(f"Loop error: {e}")
+                    if (time.time() - last_update_time) > 60:
+                        print("No updates for 60 seconds, possible hang or timeout.")
                         if prev_output_filename:
-                            error_html = create_error_html("처리 시간이 초과되었지만 일부 동영상이 생성되었습니다.", is_timeout=True)
-                            yield prev_output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+                            err_html = create_error_html("partial video has been generated", is_timeout=True)
+                            yield (
+                                prev_output_filename, gr.update(visible=False), gr.update(),
+                                err_html, gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         else:
-                            error_html = create_error_html(f"처리 시간 초과: {e}", is_timeout=True)
-                            yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+                            err_html = create_error_html(f"Processing timed out: {e}", is_timeout=True)
+                            yield (
+                                None, gr.update(visible=False), gr.update(),
+                                err_html, gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         break
         except Exception as e:
-            print(f"프로세스 시작 오류: {e}")
+            print(f"Start process error: {e}")
             traceback.print_exc()
-            error_msg = str(e)
-            
-            error_html = create_error_html(error_msg)
-            yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
-    
+            err_html = create_error_html(str(e))
+            yield None, gr.update(visible=False), gr.update(), err_html, gr.update(interactive=True), gr.update(interactive=False)
+
     process = process_with_gpu
 else:
-    def process(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+    def process(
+        input_image, prompt, n_prompt, seed,
+        total_second_length, latent_window_size, steps,
+        cfg, gs, rs, gpu_memory_preservation, use_teacache
+    ):
         global stream
-        assert input_image is not None, 'No input image!'
-
-        yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
+        assert input_image is not None, "No input image given."
 
+        yield None, None, "", "", gr.update(interactive=False), gr.update(interactive=True)
         try:
             stream = AsyncStream()
-            async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)
+            async_run(
+                worker,
+                input_image, prompt, n_prompt, seed,
+                total_second_length, latent_window_size, steps, cfg, gs, rs,
+                gpu_memory_preservation, use_teacache
+            )
 
             output_filename = None
             prev_output_filename = None
@@ -897,561 +992,314 @@ else:
             while True:
                 try:
                     flag, data = stream.output_queue.next()
-
                     if flag == 'file':
                         output_filename = data
                         prev_output_filename = output_filename
                         yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)
-
-                    if flag == 'progress':
+                    elif flag == 'progress':
                         preview, desc, html = data
                         yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
-                    
-                    if flag == 'error':
+                    elif flag == 'error':
                         error_message = data
-                        print(f"오류 메시지 수신: {error_message}")
-
-                    if flag == 'end':
-                        if output_filename is None and prev_output_filename is not None:
+                        print(f"Got error: {error_message}")
+                    elif flag == 'end':
+                        if output_filename is None and prev_output_filename:
                             output_filename = prev_output_filename
-                        
                         if error_message:
-                            error_html = create_error_html(error_message)
-                            yield output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+                            err_html = create_error_html(error_message)
+                            yield (
+                                output_filename, gr.update(visible=False), gr.update(),
+                                err_html, gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         else:
-                            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
+                            yield (
+                                output_filename, gr.update(visible=False), gr.update(),
+                                '', gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         break
                 except Exception as e:
-                    print(f"출력 처리 중 오류: {e}")
-                    current_time = time.time()
-                    if current_time - last_update_time > 60:
-                        print(f"{current_time - last_update_time:.1f}초 동안 진행이 없어 타임아웃으로 간주합니다.")
+                    print(f"Loop error: {e}")
+                    if (time.time() - last_update_time) > 60:
+                        print("No update for 60 seconds, possible hang or timeout.")
                         if prev_output_filename:
-                            error_html = create_error_html("처리 시간이 초과되었지만 일부 동영상이 생성되었습니다.", is_timeout=True)
-                            yield prev_output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+                            err_html = create_error_html("partial video has been generated", is_timeout=True)
+                            yield (
+                                prev_output_filename, gr.update(visible=False), gr.update(),
+                                err_html, gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         else:
-                            error_html = create_error_html(f"처리 시간 초과: {e}", is_timeout=True)
-                            yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+                            err_html = create_error_html(f"Processing timed out: {e}", is_timeout=True)
+                            yield (
+                                None, gr.update(visible=False), gr.update(),
+                                err_html, gr.update(interactive=True), gr.update(interactive=False)
+                            )
                         break
         except Exception as e:
-            print(f"프로세스 시작 오류: {e}")
+            print(f"Start process error: {e}")
             traceback.print_exc()
-            error_msg = str(e)
-            
-            error_html = create_error_html(error_msg)
-            yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+            err_html = create_error_html(str(e))
+            yield None, gr.update(visible=False), gr.update(), err_html, gr.update(interactive=True), gr.update(interactive=False)
 
 def end_process():
-    print("사용자가 중지 버튼을 눌렀습니다. 종료 신호를 보냅니다...")
+    """
+    Stop generation by pushing 'end' to the worker queue
+    """
+    print("User clicked stop, sending 'end' signal...")
+    global stream
     if 'stream' in globals() and stream is not None:
         try:
-            current_top = stream.input_queue.top()
-            print(f"현재 입력 큐 top: {current_top}")
+            top_signal = stream.input_queue.top()
+            print(f"Queue top signal = {top_signal}")
         except Exception as e:
-            print(f"입력 큐 확인 오류: {e}")
+            print(f"Error checking queue top: {e}")
         try:
             stream.input_queue.push('end')
-            print("end 신호 전송 완료")
-            try:
-                current_top_after = stream.input_queue.top()
-                print(f"신호 전송 후 입력 큐 top: {current_top_after}")
-            except Exception as e:
-                print(f"신호 전송 후 큐 상태 확인 오류: {e}")
+            print("Pushed 'end' successfully.")
         except Exception as e:
-            print(f"end 신호 전송 오류: {e}")
+            print(f"Error pushing 'end': {e}")
     else:
-        print("stream이 초기화되지 않아 종료 신호를 보낼 수 없습니다.")
+        print("Warning: Stream not initialized, cannot stop.")
     return None
 
+# 예시 빠른 프롬프트
 quick_prompts = [
-    'The girl dances gracefully, with clear movements, full of charm.',
-    'A character doing some simple body movements.',
+    ["The girl dances gracefully, with clear movements, full of charm."],
+    ["A character doing some simple body movements."]
 ]
-quick_prompts = [[x] for x in quick_prompts]
 
+# CSS
 def make_custom_css():
-    progress_bar_css = make_progress_bar_css()
-    
-    responsive_css = """
-    /* progress_bar_css로부터 불러온 기본 설정 + 추가 */
-    
+    base_progress_css = make_progress_bar_css()
+    enhanced_css = """
+    /* Visual & layout improvement */
+    body {
+        background: #f9fafb !important; 
+        font-family: "Noto Sans", sans-serif;
+    }
     #app-container {
-        max-width: 100%;
+        max-width: 1200px;
         margin: 0 auto;
+        padding: 1rem;
+        position: relative;
     }
-    
-    #language-toggle {
-        position: fixed;
-        top: 10px;
-        right: 10px;
-        z-index: 1000;
-        background-color: rgba(0, 0, 0, 0.7);
-        color: white;
-        border: none;
-        border-radius: 4px;
-        padding: 5px 10px;
-        cursor: pointer;
-        font-size: 14px;
+    #app-container h1 {
+        color: #2d3748;
+        margin-bottom: 1.2rem;
+        font-weight: 700;
     }
-    
-    h1 {
-        font-size: 2rem;
-        text-align: center;
-        margin-bottom: 1rem;
+    .gr-panel {
+        background: #fff;
+        border: 1px solid #cbd5e0;
+        border-radius: 8px;
+        padding: 1rem;
+        box-shadow: 0 1px 2px rgba(0,0,0,0.1);
     }
-    
-    .start-btn, .stop-btn {
+    .button-container button {
         min-height: 45px;
         font-size: 1rem;
+        font-weight: 600;
     }
-    
-    @media (max-width: 768px) {
-        h1 {
-            font-size: 1.5rem;
-            margin-bottom: 0.5rem;
-        }
-        
-        .mobile-full-width {
-            flex-direction: column !important;
-        }
-        
-        .mobile-full-width > .gr-block {
-            min-width: 100% !important;
-            flex-grow: 1;
-        }
-        
-        .video-container {
-            height: auto !important;
-        }
-        
-        .button-container button {
-            min-height: 50px;
-            font-size: 1rem;
-            touch-action: manipulation;
-        }
-        
-        .slider-container input[type="range"] {
-            height: 30px;
-        }
+    .button-container button#start-button {
+        background-color: #3182ce !important;
+        color: #fff !important;
     }
-    
-    @media (min-width: 769px) and (max-width: 1024px) {
-        .tablet-adjust {
-            width: 48% !important;
-        }
+    .button-container button#stop-button {
+        background-color: #e53e3e !important;
+        color: #fff !important;
     }
-    
-    @media (prefers-color-scheme: dark) {
-        .dark-mode-text {
-            color: #f0f0f0;
-        }
-        .dark-mode-bg {
-            background-color: #2a2a2a;
-        }
-    }
-    
-    button, input, select, textarea {
-        font-size: 16px;
-    }
-    
-    button, .interactive-element {
-        min-height: 44px;
-        min-width: 44px;
+    .button-container button:hover {
+        filter: brightness(0.95);
     }
-    
-    .high-contrast {
-        color: #fff;
-        background-color: #000;
+    .preview-container, .video-container {
+        border: 1px solid #cbd5e0;
+        border-radius: 8px;
+        overflow: hidden;
     }
-    
     .progress-container {
-        margin-top: 10px;
-        margin-bottom: 10px;
+        margin-top: 15px;
+        margin-bottom: 15px;
     }
-    
-    #error-message {
-        color: #ff4444;
-        font-weight: bold;
-        padding: 10px;
-        border-radius: 4px;
-        margin-top: 10px;
-    }
-    
     .error-message {
-        background-color: rgba(255, 0, 0, 0.1);
+        background-color: #fff5f5;
+        border: 1px solid #fed7d7;
+        color: #e53e3e;
         padding: 10px;
         border-radius: 4px;
         margin-top: 10px;
-        border: 1px solid #ffcccc;
     }
-    
-    .error-msg-en, .error-msg-ko {
-        font-weight: bold;
-    }
-    
     .error-icon {
-        color: #ff4444;
-        font-size: 18px;
+        color: #e53e3e;
         margin-right: 8px;
     }
-    
-    #error-message:empty {
-        background-color: transparent;
-        border: none;
-        padding: 0;
-        margin: 0;
+    #error-message {
+        color: #ff4444;
+        font-weight: bold;
+        padding: 10px;
+        border-radius: 4px;
+        margin-top: 10px;
     }
-    
-    .error {
-        display: none !important;
+    @media (max-width: 768px) {
+        #app-container {
+            padding: 0.5rem;
+        }
+        .mobile-full-width {
+            flex-direction: column !important;
+        }
+        .mobile-full-width > .gr-block {
+            width: 100% !important;
+        }
     }
     """
-    
-    return progress_bar_css + responsive_css
+    return base_progress_css + enhanced_css
 
 css = make_custom_css()
+
+# Gradio UI
 block = gr.Blocks(css=css).queue()
 with block:
-    gr.HTML("""
-        <div id="app-container">
-            <button id="language-toggle" onclick="toggleLanguage()">한국어 / English</button>
-        </div>
-        <script>
-            window.currentLang = "en";
-            function toggleLanguage() {
-                window.currentLang = (window.currentLang === "en") ? "ko" : "en";
-                
-                const elements = document.querySelectorAll('[data-i18n]');
-                elements.forEach(el => {
-                    const key = el.getAttribute('data-i18n');
-                    const translations = {
-                        "en": {
-                            "title": "FramePack - Image to Video Generation",
-                            "upload_image": "Upload Image",
-                            "prompt": "Prompt",
-                            "quick_prompts": "Quick Prompts",
-                            "start_generation": "Generate",
-                            "stop_generation": "Stop",
-                            "use_teacache": "Use TeaCache",
-                            "teacache_info": "Faster speed, but may result in slightly worse finger and hand generation.",
-                            "negative_prompt": "Negative Prompt",
-                            "seed": "Seed",
-                            "video_length": "Video Length (max 5 seconds)",
-                            "latent_window": "Latent Window Size",
-                            "steps": "Inference Steps",
-                            "steps_info": "Changing this value is not recommended.",
-                            "cfg_scale": "CFG Scale",
-                            "distilled_cfg": "Distilled CFG Scale",
-                            "distilled_cfg_info": "Changing this value is not recommended.",
-                            "cfg_rescale": "CFG Rescale",
-                            "gpu_memory": "GPU Memory Preservation (GB) (larger means slower)",
-                            "gpu_memory_info": "Set this to a larger value if you encounter OOM errors. Larger values cause slower speed.",
-                            "next_latents": "Next Latents",
-                            "generated_video": "Generated Video",
-                            "sampling_note": "Note: Due to reversed sampling, ending actions will be generated before starting actions. If the starting action is not in the video, please wait, it will be generated later.",
-                            "error_message": "Error"
-                        },
-                        "ko": {
-                            "title": "FramePack - 이미지에서 동영상 생성",
-                            "upload_image": "이미지 업로드",
-                            "prompt": "프롬프트",
-                            "quick_prompts": "빠른 프롬프트 목록",
-                            "start_generation": "생성 시작",
-                            "stop_generation": "생성 중지",
-                            "use_teacache": "TeaCache 사용",
-                            "teacache_info": "더 빠른 속도를 제공하지만 손가락이나 손 생성 품질이 약간 떨어질 수 있습니다.",
-                            "negative_prompt": "부정 프롬프트",
-                            "seed": "랜덤 시드",
-                            "video_length": "동영상 길이 (최대 5초)",
-                            "latent_window": "잠재 윈도우 크기",
-                            "steps": "추론 스텝 수",
-                            "steps_info": "이 값을 변경하는 것은 권장되지 않습니다.",
-                            "cfg_scale": "CFG 스케일",
-                            "distilled_cfg": "증류된 CFG 스케일",
-                            "distilled_cfg_info": "이 값을 변경하는 것은 권장되지 않습니다.",
-                            "cfg_rescale": "CFG 재스케일",
-                            "gpu_memory": "GPU 메모리 보존 (GB) (값이 클수록 속도가 느려짐)",
-                            "gpu_memory_info": "OOM 오류가 발생하면 이 값을 더 크게 설정하십시오. 값이 클수록 속도가 느려집니다.",
-                            "next_latents": "다음 잠재 변수",
-                            "generated_video": "생성된 동영상",
-                            "sampling_note": "주의: 역순 샘플링 때문에, 종료 동작이 시작 동작보다 먼저 생성됩니다. 시작 동작이 나타나지 않으면 기다려 주십시오.",
-                            "error_message": "오류 메시지"
-                        }
-                    };
-                    
-                    if (translations[window.currentLang] && translations[window.currentLang][key]) {
-                        if (el.tagName === 'BUTTON') {
-                            el.textContent = translations[window.currentLang][key];
-                        } else if (el.tagName === 'LABEL') {
-                            el.textContent = translations[window.currentLang][key];
-                        } else {
-                            el.innerHTML = translations[window.currentLang][key];
-                        }
-                    }
-                });
-                
-                // bilingual-label 처리
-                document.querySelectorAll('.bilingual-label').forEach(el => {
-                    const enText = el.getAttribute('data-en');
-                    const koText = el.getAttribute('data-ko');
-                    el.textContent = (window.currentLang === 'en') ? enText : koText;
-                });
-                
-                // data-lang 처리
-                document.querySelectorAll('[data-lang]').forEach(el => {
-                    el.style.display = (el.getAttribute('data-lang') === window.currentLang) ? 'block' : 'none';
-                });
-            }
-            
-            document.addEventListener('DOMContentLoaded', function() {
-                setTimeout(() => {
-                    // 매핑
-                    const labelMap = {
-                        "Upload Image": "upload_image",
-                        "이미지 업로드": "upload_image",
-                        "Prompt": "prompt",
-                        "프롬프트": "prompt",
-                        "Quick Prompts": "quick_prompts",
-                        "빠른 프롬프트 목록": "quick_prompts",
-                        "Generate": "start_generation",
-                        "생성 시작": "start_generation",
-                        "Stop": "stop_generation",
-                        "생성 중지": "stop_generation"
-                    };
-                    
-                    document.querySelectorAll('label, span, button').forEach(el => {
-                        const text = el.textContent.trim();
-                        if (labelMap[text]) {
-                            el.setAttribute('data-i18n', labelMap[text]);
-                        }
-                    });
-                    
-                    const titleEl = document.querySelector('h1');
-                    if (titleEl) titleEl.setAttribute('data-i18n', 'title');
-                    
-                    toggleLanguage();
-                }, 1000);
-            });
-        </script>
-    """)
-
-    gr.HTML("<h1 data-i18n='title'>FramePack - Image to Video Generation</h1>")
-    
+    # 상단 제목
+    gr.HTML("<div id='app-container'><h1>FramePack - Image to Video Generation</h1></div>")
+
     with gr.Row(elem_classes="mobile-full-width"):
-        with gr.Column(scale=1, elem_classes="mobile-full-width"):
+        with gr.Column(scale=1, elem_classes="gr-panel"):
             input_image = gr.Image(
-                sources='upload', 
-                type="numpy", 
-                label="Upload Image", 
+                label="Upload Image",
+                sources='upload',
+                type="numpy",
                 elem_id="input-image",
                 height=320
             )
-            
-            prompt = gr.Textbox(
-                label="Prompt", 
-                value='',
-                elem_id="prompt-input"
-            )
-            
+            prompt = gr.Textbox(label="Prompt", value='', elem_id="prompt-input")
+
             example_quick_prompts = gr.Dataset(
-                samples=quick_prompts, 
-                label='Quick Prompts', 
-                samples_per_page=1000, 
+                samples=quick_prompts,
+                label="Quick Prompts",
+                samples_per_page=1000,
                 components=[prompt]
             )
             example_quick_prompts.click(
-                lambda x: x[0], 
-                inputs=[example_quick_prompts], 
-                outputs=prompt, 
-                show_progress=False, 
+                fn=lambda x: x[0],
+                inputs=[example_quick_prompts],
+                outputs=prompt,
+                show_progress=False,
                 queue=False
             )
-
+        with gr.Column(scale=1, elem_classes="gr-panel"):
             with gr.Row(elem_classes="button-container"):
                 start_button = gr.Button(
-                    value="Generate", 
-                    elem_classes="start-btn", 
+                    value="Generate",
                     elem_id="start-button",
                     variant="primary"
                 )
-                
                 end_button = gr.Button(
-                    value="Stop", 
-                    elem_classes="stop-btn", 
+                    value="Stop",
                     elem_id="stop-button",
                     interactive=False
                 )
-
-            with gr.Group():
-                use_teacache = gr.Checkbox(
-                    label='Use TeaCache', 
-                    value=True, 
-                    info='Faster speed, but may result in slightly worse finger and hand generation.'
-                )
-
-                n_prompt = gr.Textbox(label="Negative Prompt", value="", visible=False)
-                
-                seed = gr.Number(
-                    label="Seed", 
-                    value=31337, 
-                    precision=0
-                )
-                
-                with gr.Group(elem_classes="slider-container"):
-                    total_second_length = gr.Slider(
-                        label="Video Length (max 5 seconds)", 
-                        minimum=1, 
-                        maximum=5, 
-                        value=5, 
-                        step=0.1
-                    )
-                    
-                    latent_window_size = gr.Slider(
-                        label="Latent Window Size", 
-                        minimum=1, 
-                        maximum=33, 
-                        value=9, 
-                        step=1, 
-                        visible=False
-                    )
-                    
-                    steps = gr.Slider(
-                        label="Inference Steps", 
-                        minimum=1, 
-                        maximum=100, 
-                        value=25, 
-                        step=1, 
-                        info='Changing this value is not recommended.'
-                    )
-
-                    cfg = gr.Slider(
-                        label="CFG Scale", 
-                        minimum=1.0, 
-                        maximum=32.0, 
-                        value=1.0, 
-                        step=0.01, 
-                        visible=False
-                    )
-                    
-                    gs = gr.Slider(
-                        label="Distilled CFG Scale", 
-                        minimum=1.0, 
-                        maximum=32.0, 
-                        value=10.0, 
-                        step=0.01, 
-                        info='Changing this value is not recommended.'
-                    )
-                    
-                    rs = gr.Slider(
-                        label="CFG Rescale", 
-                        minimum=0.0, 
-                        maximum=1.0, 
-                        value=0.0, 
-                        step=0.01, 
-                        visible=False
-                    )
-
-                    gpu_memory_preservation = gr.Slider(
-                        label="GPU Memory (GB)", 
-                        minimum=6, 
-                        maximum=128, 
-                        value=6, 
-                        step=0.1, 
-                        info="Set this to a larger value if you encounter OOM errors. Larger values cause slower speed."
-                    )
-
-        with gr.Column(scale=1, elem_classes="mobile-full-width"):
-            preview_image = gr.Image(
-                label="Preview", 
-                height=200, 
-                visible=False,
-                elem_classes="preview-container"
-            )
             
             result_video = gr.Video(
-                label="Generated Video", 
-                autoplay=True, 
-                show_share_button=True,
-                height=512, 
+                label="Generated Video",
+                autoplay=True,
                 loop=True,
+                height=320,
                 elem_classes="video-container",
                 elem_id="result-video"
             )
-            
-            gr.HTML("<div data-i18n='sampling_note'>Note: Due to reversed sampling, ending actions will be generated before starting actions.</div>")
+            preview_image = gr.Image(
+                label="Preview",
+                visible=False,
+                height=150,
+                elem_classes="preview-container"
+            )
+
+            gr.Markdown(get_translation("sampling_note"))
             
             with gr.Group(elem_classes="progress-container"):
-                progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
-                progress_bar = gr.HTML('', elem_classes='no-generating-animation')
+                progress_desc = gr.Markdown('')
+                progress_bar = gr.HTML('')
             
             error_message = gr.HTML('', elem_id='error-message', visible=True)
-    
-    ips = [input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache]
 
-    start_button.click(fn=process, inputs=ips, outputs=[
-        result_video, preview_image, progress_desc, progress_bar, start_button, end_button
-    ])
+    # 고급 파라미터 Accordion
+    with gr.Accordion("Advanced Settings", open=False, elem_classes="gr-panel"):
+        use_teacache = gr.Checkbox(
+            label=get_translation("use_teacache"),
+            value=True,
+            info=get_translation("teacache_info")
+        )
+        n_prompt = gr.Textbox(label=get_translation("negative_prompt"), value="", visible=False)
+        seed = gr.Number(
+            label=get_translation("seed"),
+            value=31337,
+            precision=0
+        )
+        total_second_length = gr.Slider(
+            label=get_translation("video_length"),
+            minimum=1,
+            maximum=5,
+            value=5,
+            step=0.1
+        )
+        latent_window_size = gr.Slider(
+            label=get_translation("latent_window"),
+            minimum=1,
+            maximum=33,
+            value=9,
+            step=1,
+            visible=False
+        )
+        steps = gr.Slider(
+            label=get_translation("steps"),
+            minimum=1,
+            maximum=100,
+            value=25,
+            step=1,
+            info=get_translation("steps_info")
+        )
+        cfg = gr.Slider(
+            label=get_translation("cfg_scale"),
+            minimum=1.0,
+            maximum=32.0,
+            value=1.0,
+            step=0.01,
+            visible=False
+        )
+        gs = gr.Slider(
+            label=get_translation("distilled_cfg"),
+            minimum=1.0,
+            maximum=32.0,
+            value=10.0,
+            step=0.01,
+            info=get_translation("distilled_cfg_info")
+        )
+        rs = gr.Slider(
+            label=get_translation("cfg_rescale"),
+            minimum=0.0,
+            maximum=1.0,
+            value=0.0,
+            step=0.01,
+            visible=False
+        )
+        gpu_memory_preservation = gr.Slider(
+            label=get_translation("gpu_memory"),
+            minimum=6,
+            maximum=128,
+            value=6,
+            step=0.1,
+            info=get_translation("gpu_memory_info")
+        )
+
+    # 처리 함수 연결
+    ips = [
+        input_image, prompt, n_prompt, seed,
+        total_second_length, latent_window_size, steps,
+        cfg, gs, rs, gpu_memory_preservation, use_teacache
+    ]
+    start_button.click(
+        fn=process,
+        inputs=ips,
+        outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button]
+    )
     end_button.click(fn=end_process)
 
 block.launch()
-
-def create_error_html(error_msg, is_timeout=False):
-    en_msg = ""
-    ko_msg = ""
-    
-    if is_timeout:
-        if "부분" in error_msg or "partial" in error_msg:
-            en_msg = "Processing timed out, but partial video has been generated."
-            ko_msg = "처리 시간이 초과되었지만 일부 동영상이 생성되었습니다."
-        else:
-            en_msg = f"Processing timed out: {error_msg}"
-            ko_msg = f"처리 시간 초과: {error_msg}"
-    elif "모델 로드" in error_msg:
-        en_msg = "Failed to load models. Possibly heavy traffic or GPU problem."
-        ko_msg = "모델 로드에 실패했습니다. 과도한 트래픽 또는 GPU 문제일 수 있습니다."
-    elif "GPU" in error_msg or "CUDA" in error_msg or "memory" in error_msg or "메모리" in error_msg:
-        en_msg = "GPU memory insufficient or error. Increase GPU memory preservation or reduce video length."
-        ko_msg = "GPU 메모리가 부족하거나 오류가 발생했습니다. GPU 메모리 보존 값을 늘리거나 동영상 길이를 줄여보세요."
-    elif "샘플링 중 오류" in error_msg or "sampling process" in error_msg:
-        if "부분" in error_msg or "partial" in error_msg:
-            en_msg = "Error during sampling, but partial video has been generated."
-            ko_msg = "샘플링 중 오류가 발생했지만 일부 동영상이 생성되었습니다."
-        else:
-            en_msg = "Error during sampling. Unable to generate video."
-            ko_msg = "샘플링 중 오류가 발생했습니다. 비디오 생성에 실패했습니다."
-    elif "네트워크" in error_msg or "Network" in error_msg or "ConnectionError" in error_msg or "ReadTimeoutError" in error_msg:
-        en_msg = "Network is unstable, model download timed out. Please try again later."
-        ko_msg = "네트워크가 불안정하여 모델 다운로드가 시간 초과되었습니다. 잠시 후 다시 시도해 주세요."
-    elif "VAE" in error_msg or "디코딩" in error_msg or "decode" in error_msg:
-        en_msg = "Error during video decoding or saving process. Try a different seed."
-        ko_msg = "비디오 디코딩/저장 중 오류가 발생했습니다. 다른 시드를 시도해보세요."
-    else:
-        en_msg = f"Processing error: {error_msg}"
-        ko_msg = f"처리 중 오류가 발생했습니다: {error_msg}"
-    
-    return f"""
-    <div class="error-message" id="custom-error-container">
-        <div class="error-msg-en" data-lang="en">
-            <span class="error-icon">⚠️</span> {en_msg}
-        </div>
-        <div class="error-msg-ko" data-lang="ko">
-            <span class="error-icon">⚠️</span> {ko_msg}
-        </div>
-    </div>
-    <script>
-        (function() {{
-            const errorContainer = document.getElementById('custom-error-container');
-            if (errorContainer) {{
-                const currentLang = window.currentLang || 'en';
-                const errMsgs = errorContainer.querySelectorAll('[data-lang]');
-                errMsgs.forEach(msg => {{
-                    msg.style.display = (msg.getAttribute('data-lang') === currentLang) ? 'block' : 'none';
-                }});
-                const defaultErrorElements = document.querySelectorAll('.error');
-                defaultErrorElements.forEach(el => {{
-                    el.style.display = 'none';
-                }});
-            }}
-        }})();
-    </script>
-    """