Add files using upload-large-folder tool

runtime-data/references/.gitkeep

@@ -0,0 +1 @@
+

runtime/experimental/__init__.py

@@ -0,0 +1 @@
+"""Experimental code kept separate from the pinned Fish Speech baseline."""

runtime/experimental/codec.py

@@ -0,0 +1,336 @@
+"""Project-local inference memory optimizations for the S2-Pro DAC codec.
+
+The pinned Fish Speech source remains unchanged. This module builds the same
+codec and loads the same checkpoint, then removes buffers that are unnecessary
+for the window-limited inference path before the model is moved to CUDA.
+"""
+
+from __future__ import annotations
+
+import gc
+import io
+import math
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+import torch
+
+os.environ.setdefault("TEMPORARILY_DISABLE_PROTOBUF_VERSION_CHECK", "true")
+
+from fish_speech.models.dac.modded_dac import DAC
+
+
+def load_reference_audio_soundfile(
+    reference_audio: bytes | str | Path,
+    sample_rate: int,
+):
+    """Decode API reference audio without TorchCodec.
+
+    Torch 2.11 routes ``torchaudio.load`` through optional TorchCodec. The
+    pinned container already includes SoundFile, which supports the WAV/FLAC
+    inputs accepted by this service, so no environment package mutation is
+    needed.
+    """
+
+    import numpy as np
+    import soundfile as sf
+    import torchaudio
+
+    source = (
+        io.BytesIO(reference_audio)
+        if isinstance(reference_audio, bytes)
+        else reference_audio
+    )
+    audio, original_rate = sf.read(source, dtype="float32", always_2d=True)
+    mono = np.asarray(audio.mean(axis=1), dtype=np.float32)
+    if original_rate != sample_rate:
+        mono = (
+            torchaudio.functional.resample(
+                torch.from_numpy(mono),
+                original_rate,
+                sample_rate,
+            )
+            .contiguous()
+            .numpy()
+        )
+    return mono
+
+
+@torch.inference_mode()
+def warm_reference_encoder(
+    codec: torch.nn.Module,
+    device: str | torch.device,
+    seconds: float = 1.0,
+) -> dict[str, Any]:
+    """Prime lazy codec state before the first user reference is cached.
+
+    The staged BF16 encoder produces a different discrete code sequence on its
+    first CUDA pass. A discarded silence pass makes subsequent encodes bit
+    stable, preventing the first uploaded voice from being conditioned on an
+    avoidable cold-start code path.
+    """
+
+    if seconds <= 0:
+        raise ValueError("Reference warmup duration must be positive")
+    target = torch.device(device)
+    sample_rate = int(codec.sample_rate)
+    samples = int(round(sample_rate * seconds))
+    audio = torch.zeros((1, samples), dtype=torch.float32)
+    lengths = torch.tensor([samples], device=target, dtype=torch.long)
+    started = time.perf_counter()
+    codes = codec.encode(audio, lengths)[0][0].cpu()
+    return {
+        "input": "digital_silence",
+        "seconds": seconds,
+        "samples": samples,
+        "code_frames": int(codes.shape[-1]),
+        "elapsed_seconds": time.perf_counter() - started,
+    }
+
+
+class StagedReferenceCodec(DAC):
+    """DAC with decode modules resident and reference-only modules staged."""
+
+    @property
+    def device(self) -> torch.device:
+        return self._decode_device
+
+    def configure_reference_staging(
+        self,
+        decode_device: str | torch.device,
+        offload_device: str | torch.device = "cpu",
+    ) -> None:
+        self._decode_device = torch.device(decode_device)
+        self._reference_offload_device = torch.device(offload_device)
+        self._reference_lock = threading.Lock()
+
+        # These modules are used by ``from_indices`` and remain resident.
+        self.quantizer.semantic_quantizer.to(self._decode_device)
+        self.quantizer.quantizer.to(self._decode_device)
+        self.quantizer.post_module.to(self._decode_device)
+        self.quantizer.upsample.to(self._decode_device)
+        self.decoder.to(self._decode_device)
+
+        # These modules are required only while a new reference is encoded.
+        self.encoder.to(self._reference_offload_device)
+        self.quantizer.downsample.to(self._reference_offload_device)
+        self.quantizer.pre_module.to(self._reference_offload_device)
+
+    @torch.inference_mode()
+    def encode(
+        self,
+        audio_data: torch.Tensor,
+        audio_lengths: torch.Tensor | None = None,
+        n_quantizers: int | None = None,
+        **kwargs,
+    ):
+        """Encode reference codes, staging only the required modules on CUDA."""
+
+        if not hasattr(self, "_reference_lock"):
+            return super().encode(
+                audio_data,
+                audio_lengths=audio_lengths,
+                n_quantizers=n_quantizers,
+                **kwargs,
+            )
+
+        with self._reference_lock:
+            reference_modules = (
+                self.encoder,
+                self.quantizer.downsample,
+                self.quantizer.pre_module,
+            )
+            for module in reference_modules:
+                module.to(self._decode_device)
+
+            try:
+                dtype = next(self.encoder.parameters()).dtype
+                audio_data = audio_data.to(device=self._decode_device, dtype=dtype)
+                if audio_data.ndim == 2:
+                    audio_data = audio_data.unsqueeze(1)
+                length = audio_data.shape[-1]
+                right_pad = (
+                    math.ceil(length / self.frame_length) * self.frame_length - length
+                )
+                audio_data = torch.nn.functional.pad(audio_data, (0, right_pad))
+                if audio_lengths is None:
+                    audio_lengths = torch.tensor(
+                        [length + right_pad],
+                        device=self._decode_device,
+                        dtype=torch.long,
+                    )
+                else:
+                    audio_lengths = audio_lengths.to(self._decode_device)
+
+                z = self.encoder(audio_data)
+                z = self.quantizer.downsample(z)
+                z = self.quantizer.pre_module(z)
+                semantic_z, semantic_codes, *_ = self.quantizer.semantic_quantizer(z)
+                residual_z = z - semantic_z
+                _, residual_codes, *_ = self.quantizer.quantizer(
+                    residual_z,
+                    n_quantizers=n_quantizers,
+                )
+                indices = torch.cat([semantic_codes, residual_codes], dim=1)
+                indices_lens = torch.ceil(audio_lengths / self.frame_length).long()
+            finally:
+                if self._decode_device.type == "cuda":
+                    torch.cuda.synchronize(self._decode_device)
+                for module in reference_modules:
+                    module.to(self._reference_offload_device)
+                if self._decode_device.type == "cuda":
+                    torch.cuda.empty_cache()
+
+            return indices, indices_lens
+
+
+def _tensor_bytes(tensor: torch.Tensor | None) -> int:
+    if tensor is None:
+        return 0
+    return tensor.numel() * tensor.element_size()
+
+
+@torch.inference_mode()
+def compact_codec_inference_buffers(codec: torch.nn.Module) -> dict[str, Any]:
+    """Remove dead causal masks and bound RoPE tables to configured limits.
+
+    ``WindowLimitedTransformer.forward`` always constructs an exact mask for
+    the current input and passes it to its parent implementation. Therefore the
+    inherited 32768-square causal mask is not read on this path. Its RoPE table
+    is used, but the configured block size is the model's supported inference
+    limit and is far smaller than the inherited 327680-frame table.
+    """
+
+    from fish_speech.models.dac.modded_dac import WindowLimitedTransformer
+
+    records: list[dict[str, Any]] = []
+    saved_bytes = 0
+    for name, module in codec.named_modules():
+        if not isinstance(module, WindowLimitedTransformer):
+            continue
+
+        causal_mask = module.causal_mask
+        freqs_cis = module.freqs_cis
+        if freqs_cis is None:
+            raise RuntimeError(f"Codec transformer {name} has no RoPE table")
+
+        frame_limit = int(module.config.block_size)
+        if frame_limit <= 0 or frame_limit > freqs_cis.shape[0]:
+            raise RuntimeError(
+                f"Invalid codec RoPE limit for {name}: {frame_limit} "
+                f"of {freqs_cis.shape[0]}"
+            )
+
+        before_mask_bytes = _tensor_bytes(causal_mask)
+        before_rope_bytes = _tensor_bytes(freqs_cis)
+        device = freqs_cis.device
+        module.causal_mask = torch.empty(0, dtype=torch.bool, device=device)
+        module.freqs_cis = freqs_cis[:frame_limit].clone()
+        after_rope_bytes = _tensor_bytes(module.freqs_cis)
+        module._compact_inference_frame_limit = frame_limit
+
+        records.append(
+            {
+                "module": name,
+                "frame_limit": frame_limit,
+                "removed_causal_mask_bytes": before_mask_bytes,
+                "rope_bytes_before": before_rope_bytes,
+                "rope_bytes_after": after_rope_bytes,
+            }
+        )
+        saved_bytes += before_mask_bytes + before_rope_bytes - after_rope_bytes
+
+    if len(records) != 3:
+        raise RuntimeError(
+            f"Expected three window-limited codec transformers, found {len(records)}"
+        )
+
+    report = {
+        "policy": "compact_windowed_inference_buffers",
+        "windowed_transformers": len(records),
+        "theoretical_saved_bytes": saved_bytes,
+        "records": records,
+    }
+    codec._compact_inference_buffers_report = report
+    return report
+
+
+@torch.inference_mode()
+def load_compact_codec_model(
+    config_name: str,
+    checkpoint_path: str | Path,
+    device: str | torch.device = "cuda:0",
+    precision: torch.dtype = torch.bfloat16,
+    offload_reference: bool = False,
+) -> torch.nn.Module:
+    """Load the pinned codec with compact buffers before CUDA placement."""
+
+    from hydra.utils import instantiate
+    from omegaconf import OmegaConf
+
+    from fish_speech.models.dac import modded_dac as modded_dac_module
+
+    config_path = (
+        Path(modded_dac_module.__file__).resolve().parents[2]
+        / "configs"
+        / f"{config_name}.yaml"
+    )
+    cfg = OmegaConf.load(config_path)
+    if offload_reference:
+        cfg._target_ = "experimental.codec.StagedReferenceCodec"
+
+    codec = instantiate(cfg)
+    state_dict = torch.load(
+        checkpoint_path,
+        map_location="cpu",
+        mmap=True,
+        weights_only=True,
+    )
+    if "state_dict" in state_dict:
+        state_dict = state_dict["state_dict"]
+    if any("generator" in key for key in state_dict):
+        state_dict = {
+            key.replace("generator.", ""): value
+            for key, value in state_dict.items()
+            if "generator." in key
+        }
+
+    load_result = codec.load_state_dict(state_dict, strict=False, assign=True)
+    unexpected = [
+        key
+        for key in load_result.unexpected_keys
+        if not key.endswith(("causal_mask", "freqs_cis"))
+    ]
+    if load_result.missing_keys or unexpected:
+        raise RuntimeError(
+            "Unexpected compact codec checkpoint mismatch: "
+            f"missing={load_result.missing_keys[:5]}, unexpected={unexpected[:5]}"
+        )
+
+    report = compact_codec_inference_buffers(codec)
+    codec.eval()
+    codec.to(dtype=precision)
+    if offload_reference:
+        codec.configure_reference_staging(device)
+        report["reference_path"] = "staged_from_cpu_to_decode_device"
+    else:
+        codec.to(device=device)
+        report["reference_path"] = "resident_on_decode_device"
+    codec._compact_inference_buffers_report = report
+    del state_dict
+    gc.collect()
+    if torch.cuda.is_available() and torch.device(device).type == "cuda":
+        torch.cuda.empty_cache()
+    return codec
+
+
+__all__ = [
+    "StagedReferenceCodec",
+    "compact_codec_inference_buffers",
+    "load_compact_codec_model",
+    "load_reference_audio_soundfile",
+    "warm_reference_encoder",
+]

runtime/native/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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 Support. 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 (c) 2025 Comfy Org. All rights reserved.
+
+   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.

runtime/native/direct_w4a4_m1/direct_w4a4_m1.cpp

@@ -0,0 +1,104 @@
+#include "direct_w4a4_m1.h"
+
+#include <torch/extension.h>
+
+#include <optional>
+
+namespace {
+
+torch::Tensor direct_w4a4_m1_linear(
+    const torch::Tensor& activation_qdata,
+    const torch::Tensor& activation_block_scales,
+    const torch::Tensor& activation_tensor_scale,
+    const torch::Tensor& weight_qdata,
+    const torch::Tensor& weight_block_scales,
+    const torch::Tensor& weight_tensor_scale,
+    const std::optional<torch::Tensor>& bias) {
+  TORCH_CHECK(
+      activation_qdata.is_cuda() &&
+          activation_qdata.scalar_type() == at::kByte &&
+          activation_qdata.dim() == 2 && activation_qdata.is_contiguous(),
+      "activation qdata must be contiguous CUDA uint8 [padded_M,K/2]");
+  TORCH_CHECK(
+      activation_qdata.size(0) >= 1,
+      "direct W4A4 M=1 requires at least one packed activation row");
+  TORCH_CHECK(
+      activation_block_scales.is_cuda() &&
+          activation_block_scales.dim() == 2 &&
+          activation_block_scales.is_contiguous() &&
+          activation_block_scales.element_size() == 1,
+      "activation block scales must be contiguous CUDA byte-sized [padded_M,padded_K/16]");
+  TORCH_CHECK(
+      activation_tensor_scale.is_cuda() &&
+          activation_tensor_scale.scalar_type() == at::kFloat &&
+          activation_tensor_scale.numel() == 1 &&
+          activation_tensor_scale.is_contiguous(),
+      "activation tensor scale must be one contiguous CUDA float32 value");
+  TORCH_CHECK(
+      weight_qdata.is_cuda() && weight_qdata.scalar_type() == at::kByte &&
+          weight_qdata.dim() == 2 && weight_qdata.is_contiguous(),
+      "weight qdata must be contiguous CUDA uint8 [N,K/2]");
+  TORCH_CHECK(
+      weight_block_scales.is_cuda() && weight_block_scales.dim() == 2 &&
+          weight_block_scales.is_contiguous() &&
+          weight_block_scales.element_size() == 1,
+      "weight block scales must be contiguous CUDA byte-sized [padded_N,padded_K/16]");
+  TORCH_CHECK(
+      weight_tensor_scale.is_cuda() &&
+          weight_tensor_scale.scalar_type() == at::kFloat &&
+          weight_tensor_scale.numel() == 1 &&
+          weight_tensor_scale.is_contiguous(),
+      "weight tensor scale must be one contiguous CUDA float32 value");
+  TORCH_CHECK(
+      activation_qdata.device() == activation_block_scales.device() &&
+          activation_qdata.device() == activation_tensor_scale.device() &&
+          activation_qdata.device() == weight_qdata.device() &&
+          activation_qdata.device() == weight_block_scales.device() &&
+          activation_qdata.device() == weight_tensor_scale.device(),
+      "all direct W4A4 tensors must use the same CUDA device");
+
+  const int64_t in_features = activation_qdata.size(1) * 2;
+  const int64_t out_features = weight_qdata.size(0);
+  TORCH_CHECK(
+      in_features > 0 && in_features % 32 == 0,
+      "direct W4A4 M=1 requires K divisible by 32");
+  TORCH_CHECK(
+      weight_qdata.size(1) == activation_qdata.size(1),
+      "activation and weight packed K dimensions differ");
+  TORCH_CHECK(out_features > 0, "direct W4A4 M=1 requires positive N");
+  TORCH_CHECK(
+      activation_block_scales.size(0) >= 1 &&
+          activation_block_scales.size(1) >= in_features / 16,
+      "activation block-scale tensor is too small");
+  TORCH_CHECK(
+      weight_block_scales.size(0) >= out_features &&
+          weight_block_scales.size(1) >= in_features / 16,
+      "weight block-scale tensor is too small");
+
+  if (bias.has_value()) {
+    const auto& value = *bias;
+    TORCH_CHECK(
+        value.is_cuda() && value.scalar_type() == at::kBFloat16 &&
+            value.dim() == 1 && value.is_contiguous() &&
+            value.numel() == out_features &&
+            value.device() == activation_qdata.device(),
+        "bias must be contiguous CUDA bfloat16 [N]");
+  }
+  return direct_w4a4_m1_linear_cuda(
+      activation_qdata,
+      activation_block_scales,
+      activation_tensor_scale,
+      weight_qdata,
+      weight_block_scales,
+      weight_tensor_scale,
+      bias);
+}
+
+}  // namespace
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) {
+  module.def(
+      "linear",
+      &direct_w4a4_m1_linear,
+      "Direct packed-NVFP4 activation x packed-NVFP4 weight M=1 linear");
+}

runtime/native/rmsnorm_nvfp4_m1/rmsnorm_nvfp4_m1.cpp

@@ -0,0 +1,38 @@
+#include "rmsnorm_nvfp4_m1.h"
+
+#include <torch/extension.h>
+
+#include <vector>
+
+namespace {
+
+std::vector<torch::Tensor> rmsnorm_nvfp4_m1(
+    const torch::Tensor& input,
+    const torch::Tensor& weight,
+    double epsilon) {
+  TORCH_CHECK(
+      input.is_cuda() && input.scalar_type() == at::kBFloat16 &&
+          input.dim() == 2 && input.size(0) == 1 && input.is_contiguous(),
+      "RMSNorm input must be contiguous CUDA bfloat16 [1,K]");
+  TORCH_CHECK(
+      weight.is_cuda() && weight.scalar_type() == at::kBFloat16 &&
+          weight.dim() == 1 && weight.is_contiguous(),
+      "RMSNorm weight must be contiguous CUDA bfloat16 [K]");
+  TORCH_CHECK(
+      weight.device() == input.device() && weight.numel() == input.size(1),
+      "RMSNorm input and weight dimensions/devices differ");
+  TORCH_CHECK(
+      input.size(1) > 0 && input.size(1) % 32 == 0,
+      "fused RMSNorm-to-NVFP4 requires K divisible by 32");
+  TORCH_CHECK(epsilon > 0.0, "RMSNorm epsilon must be positive");
+  return rmsnorm_nvfp4_m1_cuda(input, weight, epsilon);
+}
+
+}  // namespace
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) {
+  module.def(
+      "quantize",
+      &rmsnorm_nvfp4_m1,
+      "Fused Qwen RMSNorm to packed NVFP4 at logical M=1");
+}

runtime/native/rmsnorm_nvfp4_m1/rmsnorm_nvfp4_m1.cu

@@ -0,0 +1,160 @@
+#include "rmsnorm_nvfp4_m1.h"
+
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include <cuda_bf16.h>
+#include <cuda_fp4.h>
+#include <cuda_fp8.h>
+#include <cuda_runtime.h>
+
+#include <cstdint>
+#include <vector>
+
+namespace {
+
+constexpr int kThreads = 256;
+constexpr int kFp4BlockElements = 16;
+constexpr int kScaleTileOuter = 128;
+constexpr float kFp4Max = 6.0f;
+constexpr float kFp8Max = 448.0f;
+constexpr float kCombinedMax = kFp4Max * kFp8Max;
+
+__device__ __forceinline__ size_t scale_offset(
+    int outer,
+    int inner_scale,
+    int scale_inner_dim) {
+  const int outer_tile = outer / kScaleTileOuter;
+  const int local_outer = outer % kScaleTileOuter;
+  const int local_inner = inner_scale & 3;
+  const int inner_tile_start = inner_scale - local_inner;
+  const size_t tile_base =
+      static_cast<size_t>(inner_tile_start + outer_tile * scale_inner_dim) *
+      kScaleTileOuter;
+  return tile_base + static_cast<size_t>(local_outer & 31) * 16 +
+      static_cast<size_t>(local_outer >> 5) * 4 + local_inner;
+}
+
+__device__ __forceinline__ float e4m3_to_float(uint8_t raw) {
+  const __half_raw half_raw = __nv_cvt_fp8_to_halfraw(raw, __NV_E4M3);
+  return __half2float(static_cast<__half>(half_raw));
+}
+
+__device__ __forceinline__ float qwen_rmsnorm_value(
+    const __nv_bfloat16* input,
+    const __nv_bfloat16* weight,
+    int index,
+    float inverse_rms) {
+  const float normalized = __bfloat162float(input[index]) * inverse_rms;
+  const __nv_bfloat16 normalized_bf16 = __float2bfloat16_rn(normalized);
+  return __bfloat162float(__float2bfloat16_rn(
+      __bfloat162float(normalized_bf16) * __bfloat162float(weight[index])));
+}
+
+__global__ void rmsnorm_nvfp4_m1_kernel(
+    const __nv_bfloat16* __restrict__ input,
+    const __nv_bfloat16* __restrict__ weight,
+    uint8_t* __restrict__ qdata,
+    uint8_t* __restrict__ block_scales,
+    float* __restrict__ tensor_scale,
+    int k,
+    int scale_inner_dim,
+    float epsilon) {
+  __shared__ float reduction[kThreads];
+  const int tid = threadIdx.x;
+  float sum_square = 0.0f;
+  for (int index = tid; index < k; index += kThreads) {
+    const float value = __bfloat162float(input[index]);
+    sum_square = fmaf(value, value, sum_square);
+  }
+  reduction[tid] = sum_square;
+  __syncthreads();
+  for (int offset = kThreads / 2; offset > 0; offset >>= 1) {
+    if (tid < offset) {
+      reduction[tid] += reduction[tid + offset];
+    }
+    __syncthreads();
+  }
+  const float inverse_rms = rsqrtf(reduction[0] / static_cast<float>(k) + epsilon);
+
+  float local_max = 0.0f;
+  for (int index = tid; index < k; index += kThreads) {
+    local_max = fmaxf(
+        local_max,
+        fabsf(qwen_rmsnorm_value(input, weight, index, inverse_rms)));
+  }
+  reduction[tid] = local_max;
+  __syncthreads();
+  for (int offset = kThreads / 2; offset > 0; offset >>= 1) {
+    if (tid < offset) {
+      reduction[tid] = fmaxf(reduction[tid], reduction[tid + offset]);
+    }
+    __syncthreads();
+  }
+  // TensorCoreNVFP4Layout computes the default scale from a BF16 amax, so
+  // the division result is rounded to BF16 before Params converts it to F32.
+  const float global_scale = __bfloat162float(__float2bfloat16_rn(
+      __fdiv_rn(reduction[0], kCombinedMax)));
+  if (tid == 0) {
+    tensor_scale[0] = global_scale;
+  }
+  __syncthreads();
+
+  const int block_count = k / kFp4BlockElements;
+  for (int block = tid; block < block_count; block += kThreads) {
+    const int base = block * kFp4BlockElements;
+    float values[kFp4BlockElements];
+    float block_max = 0.0f;
+#pragma unroll
+    for (int element = 0; element < kFp4BlockElements; ++element) {
+      values[element] = qwen_rmsnorm_value(
+          input, weight, base + element, inverse_rms);
+      block_max = fmaxf(block_max, fabsf(values[element]));
+    }
+    float scaled_block_scale = (block_max / kFp4Max) / global_scale;
+    scaled_block_scale = fminf(scaled_block_scale, kFp8Max);
+    const uint8_t raw_block_scale = static_cast<uint8_t>(
+        __nv_cvt_float_to_fp8(
+            scaled_block_scale, __NV_SATFINITE, __NV_E4M3));
+    block_scales[scale_offset(0, block, scale_inner_dim)] = raw_block_scale;
+    const float total_scale = global_scale * e4m3_to_float(raw_block_scale);
+#pragma unroll
+    for (int pair = 0; pair < kFp4BlockElements / 2; ++pair) {
+      const float even = values[pair * 2] / total_scale;
+      const float odd = values[pair * 2 + 1] / total_scale;
+      const float2 arguments = make_float2(odd, even);
+      qdata[base / 2 + pair] = static_cast<uint8_t>(
+          __nv_cvt_float2_to_fp4x2(arguments, __NV_E2M1, cudaRoundNearest));
+    }
+  }
+}
+
+}  // namespace
+
+std::vector<torch::Tensor> rmsnorm_nvfp4_m1_cuda(
+    const torch::Tensor& input,
+    const torch::Tensor& weight,
+    double epsilon) {
+  const auto device = input.device();
+  c10::cuda::CUDAGuard guard(device);
+  const int64_t k = input.size(1);
+  const int64_t scale_cols = (k / 16 + 3) / 4 * 4;
+  torch::Tensor qdata = torch::zeros(
+      {16, k / 2}, input.options().dtype(at::kByte));
+  torch::Tensor block_scales = torch::zeros(
+      {128, scale_cols},
+      input.options().dtype(at::ScalarType::Float8_e4m3fn));
+  torch::Tensor tensor_scale = torch::empty(
+      {}, input.options().dtype(at::kFloat));
+  const auto stream = at::cuda::getCurrentCUDAStream(device.index()).stream();
+  rmsnorm_nvfp4_m1_kernel<<<1, kThreads, 0, stream>>>(
+      reinterpret_cast<const __nv_bfloat16*>(input.data_ptr()),
+      reinterpret_cast<const __nv_bfloat16*>(weight.data_ptr()),
+      reinterpret_cast<uint8_t*>(qdata.data_ptr()),
+      reinterpret_cast<uint8_t*>(block_scales.data_ptr()),
+      reinterpret_cast<float*>(tensor_scale.data_ptr()),
+      static_cast<int>(k),
+      static_cast<int>(scale_cols),
+      static_cast<float>(epsilon));
+  C10_CUDA_KERNEL_LAUNCH_CHECK();
+  return {qdata, block_scales, tensor_scale};
+}

runtime/native/rmsnorm_nvfp4_m1/rmsnorm_nvfp4_m1.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <torch/extension.h>
+
+#include <vector>
+
+std::vector<torch::Tensor> rmsnorm_nvfp4_m1_cuda(
+    const torch::Tensor& input,
+    const torch::Tensor& weight,
+    double epsilon);

runtime/native/smallm_gemv/smallm_gemv.cpp

@@ -0,0 +1,86 @@
+#include "smallm_gemv.h"
+
+#include <torch/extension.h>
+
+#include <optional>
+
+namespace {
+
+torch::Tensor smallm_nvfp4_linear(
+    const torch::Tensor& input,
+    const torch::Tensor& packed_weight,
+    const torch::Tensor& weight_block_scales,
+    const torch::Tensor& weight_tensor_scale,
+    const std::optional<torch::Tensor>& bias) {
+  TORCH_CHECK(input.is_cuda(), "small-M GEMV requires a CUDA input");
+  TORCH_CHECK(
+      input.scalar_type() == at::kBFloat16,
+      "small-M GEMV input must be bfloat16");
+  TORCH_CHECK(
+      input.dim() >= 1 && input.is_contiguous(),
+      "small-M GEMV input must be contiguous");
+  TORCH_CHECK(
+      packed_weight.is_cuda() && packed_weight.scalar_type() == at::kByte &&
+          packed_weight.dim() == 2 && packed_weight.is_contiguous(),
+      "packed weight must be contiguous CUDA uint8 [N,K/2]");
+  TORCH_CHECK(
+      weight_block_scales.is_cuda() && weight_block_scales.dim() == 2 &&
+          weight_block_scales.is_contiguous() &&
+          weight_block_scales.element_size() == 1,
+      "weight block scales must be contiguous CUDA byte-sized [padded_N,padded_K/16]");
+  TORCH_CHECK(
+      weight_tensor_scale.is_cuda() &&
+          weight_tensor_scale.scalar_type() == at::kFloat &&
+          weight_tensor_scale.numel() == 1 &&
+          weight_tensor_scale.is_contiguous(),
+      "weight tensor scale must be one contiguous CUDA float32 value");
+  TORCH_CHECK(
+      input.device() == packed_weight.device() &&
+          input.device() == weight_block_scales.device() &&
+          input.device() == weight_tensor_scale.device(),
+      "all small-M GEMV tensors must use the same CUDA device");
+
+  const int64_t out_features = packed_weight.size(0);
+  const int64_t in_features = packed_weight.size(1) * 2;
+  TORCH_CHECK(
+      input.size(-1) == in_features,
+      "small-M GEMV expected input width ",
+      in_features,
+      " but got ",
+      input.size(-1));
+  TORCH_CHECK(
+      in_features > 0 && in_features % 32 == 0,
+      "small-M GEMV requires K divisible by 32");
+  TORCH_CHECK(
+      out_features > 0,
+      "small-M GEMV requires positive N");
+  TORCH_CHECK(
+      weight_block_scales.size(0) >= out_features &&
+          weight_block_scales.size(1) >= in_features / 16,
+      "weight block scale tensor is too small");
+
+  if (bias.has_value()) {
+    const auto& value = *bias;
+    TORCH_CHECK(
+        value.is_cuda() && value.scalar_type() == at::kBFloat16 &&
+            value.dim() == 1 && value.is_contiguous() &&
+            value.numel() == out_features &&
+            value.device() == input.device(),
+        "bias must be contiguous CUDA bfloat16 [N]");
+  }
+  return smallm_nvfp4_linear_cuda(
+      input,
+      packed_weight,
+      weight_block_scales,
+      weight_tensor_scale,
+      bias);
+}
+
+}  // namespace
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, module) {
+  module.def(
+      "linear",
+      &smallm_nvfp4_linear,
+      "Fused BF16-activation x packed-NVFP4-weight small-M GEMV");
+}

runtime/native/smallm_gemv/smallm_gemv.cu

@@ -0,0 +1,171 @@
+#include "smallm_gemv.h"
+
+#include <ATen/cuda/CUDAContext.h>
+#include <c10/cuda/CUDAGuard.h>
+#include <cuda_bf16.h>
+#include <cuda_fp8.h>
+#include <cuda_runtime.h>
+
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <vector>
+
+namespace {
+
+constexpr int kWarpSize = 32;
+constexpr int kWarpsPerBlock = 8;
+constexpr int kThreads = kWarpSize * kWarpsPerBlock;
+constexpr int kFp4BlockElements = 16;
+constexpr int kScaleTileOuter = 128;
+
+__device__ __forceinline__ size_t scale_offset(
+    int outer,
+    int inner_scale,
+    int scale_inner_dim) {
+  const int outer_tile = outer / kScaleTileOuter;
+  const int local_outer = outer % kScaleTileOuter;
+  const int local_inner = inner_scale & 3;
+  const int inner_tile_start = inner_scale - local_inner;
+  const size_t tile_base =
+      static_cast<size_t>(
+          inner_tile_start + outer_tile * scale_inner_dim) *
+      kScaleTileOuter;
+  return tile_base + static_cast<size_t>(local_outer & 31) * 16 +
+      static_cast<size_t>(local_outer >> 5) * 4 + local_inner;
+}
+
+__device__ __forceinline__ float e4m3_to_float(uint8_t raw) {
+  const __half_raw half_raw = __nv_cvt_fp8_to_halfraw(raw, __NV_E4M3);
+  return __half2float(static_cast<__half>(half_raw));
+}
+
+__device__ __forceinline__ float2 e2m1x2_to_float2(uint8_t packed) {
+  const __half2_raw raw =
+      __nv_cvt_fp4x2_to_halfraw2(packed, __NV_E2M1);
+  const __half2 converted(raw);
+  return __half22float2(converted);
+}
+
+__global__ void smallm_nvfp4_gemv_kernel(
+    const __nv_bfloat16* __restrict__ input,
+    const uint8_t* __restrict__ packed_weight,
+    const uint8_t* __restrict__ weight_block_scales,
+    const float* __restrict__ weight_tensor_scale,
+    const __nv_bfloat16* __restrict__ bias,
+    __nv_bfloat16* __restrict__ output,
+    int m,
+    int n,
+    int k,
+    int scale_inner_dim) {
+  const int lane = threadIdx.x & (kWarpSize - 1);
+  const int warp_in_block = threadIdx.x / kWarpSize;
+  const int64_t output_linear =
+      static_cast<int64_t>(blockIdx.x) * kWarpsPerBlock + warp_in_block;
+  const int64_t output_count = static_cast<int64_t>(m) * n;
+  if (output_linear >= output_count) {
+    return;
+  }
+
+  const int row_m = static_cast<int>(output_linear / n);
+  const int row_n = static_cast<int>(
+      output_linear - static_cast<int64_t>(row_m) * n);
+  const int packed_k = k / 2;
+  const __nv_bfloat16* input_row =
+      input + static_cast<int64_t>(row_m) * k;
+  const uint8_t* weight_row =
+      packed_weight + static_cast<int64_t>(row_n) * packed_k;
+  float accumulator = 0.0f;
+
+  for (int pair = lane; pair < packed_k; pair += kWarpSize) {
+    const uint8_t packed = weight_row[pair];
+    const int scale_block = pair / (kFp4BlockElements / 2);
+    const uint8_t scale_raw = weight_block_scales[
+        scale_offset(row_n, scale_block, scale_inner_dim)];
+    const float scale =
+        e4m3_to_float(scale_raw) * weight_tensor_scale[0];
+    const float2 weights = e2m1x2_to_float2(packed);
+    const int input_index = pair * 2;
+    accumulator = fmaf(
+        __bfloat162float(input_row[input_index]),
+        weights.y * scale,
+        accumulator);
+    accumulator = fmaf(
+        __bfloat162float(input_row[input_index + 1]),
+        weights.x * scale,
+        accumulator);
+  }
+
+#pragma unroll
+  for (int offset = 16; offset > 0; offset >>= 1) {
+    accumulator += __shfl_down_sync(0xFFFFFFFF, accumulator, offset);
+  }
+  if (lane == 0) {
+    if (bias != nullptr) {
+      accumulator += __bfloat162float(bias[row_n]);
+    }
+    output[output_linear] = __float2bfloat16_rn(accumulator);
+  }
+}
+
+}  // namespace
+
+torch::Tensor smallm_nvfp4_linear_cuda(
+    const torch::Tensor& input,
+    const torch::Tensor& packed_weight,
+    const torch::Tensor& weight_block_scales,
+    const torch::Tensor& weight_tensor_scale,
+    const std::optional<torch::Tensor>& bias) {
+  const auto device = input.device();
+  c10::cuda::CUDAGuard guard(device);
+  const int64_t out_features64 = packed_weight.size(0);
+  const int64_t in_features64 = packed_weight.size(1) * 2;
+  const int64_t logical_m64 = input.numel() / in_features64;
+  TORCH_CHECK(
+      logical_m64 > 0 &&
+          logical_m64 <= static_cast<int64_t>(std::numeric_limits<int>::max()),
+      "small-M GEMV M is out of range");
+  TORCH_CHECK(
+      out_features64 <= static_cast<int64_t>(std::numeric_limits<int>::max()) &&
+          in_features64 <= static_cast<int64_t>(std::numeric_limits<int>::max()),
+      "small-M GEMV N or K is out of range");
+  const int m = static_cast<int>(logical_m64);
+  const int n = static_cast<int>(out_features64);
+  const int k = static_cast<int>(in_features64);
+
+  std::vector<int64_t> output_shape = input.sizes().vec();
+  output_shape.back() = out_features64;
+  torch::Tensor output = torch::empty(
+      output_shape,
+      input.options().dtype(at::kBFloat16));
+  const int64_t output_count = logical_m64 * out_features64;
+  const int64_t block_count64 =
+      (output_count + kWarpsPerBlock - 1) / kWarpsPerBlock;
+  TORCH_CHECK(
+      block_count64 <= static_cast<int64_t>(std::numeric_limits<int>::max()),
+      "small-M GEMV grid is too large");
+
+  const auto stream =
+      at::cuda::getCurrentCUDAStream(device.index()).stream();
+  const __nv_bfloat16* bias_pointer =
+      bias.has_value()
+      ? reinterpret_cast<const __nv_bfloat16*>(bias->data_ptr())
+      : nullptr;
+  smallm_nvfp4_gemv_kernel<<<
+      static_cast<int>(block_count64),
+      kThreads,
+      0,
+      stream>>>(
+      reinterpret_cast<const __nv_bfloat16*>(input.data_ptr()),
+      reinterpret_cast<const uint8_t*>(packed_weight.data_ptr()),
+      reinterpret_cast<const uint8_t*>(weight_block_scales.data_ptr()),
+      reinterpret_cast<const float*>(weight_tensor_scale.data_ptr()),
+      bias_pointer,
+      reinterpret_cast<__nv_bfloat16*>(output.data_ptr()),
+      m,
+      n,
+      k,
+      static_cast<int>(weight_block_scales.size(1)));
+  C10_CUDA_KERNEL_LAUNCH_CHECK();
+  return output;
+}

runtime/native/smallm_gemv/smallm_gemv.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <torch/extension.h>
+
+#include <optional>
+
+torch::Tensor smallm_nvfp4_linear_cuda(
+    const torch::Tensor& input,
+    const torch::Tensor& packed_weight,
+    const torch::Tensor& weight_block_scales,
+    const torch::Tensor& weight_tensor_scale,
+    const std::optional<torch::Tensor>& bias);

runtime/web/index.html

@@ -0,0 +1,234 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>S2-Pro Quantized TTS</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        font-family: Inter, ui-sans-serif, system-ui, sans-serif;
+        background: #0b1014;
+        color: #edf3f6;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        background:
+          radial-gradient(circle at 15% 10%, #18384a 0, transparent 34rem),
+          linear-gradient(145deg, #080c10, #111b21);
+      }
+      main { width: min(920px, calc(100% - 32px)); margin: 0 auto; padding: 48px 0 72px; }
+      header { margin-bottom: 28px; }
+      .eyebrow { color: #68d6c0; font-size: 0.78rem; font-weight: 800; letter-spacing: 0.15em; text-transform: uppercase; }
+      h1 { margin: 8px 0; font-size: clamp(2rem, 6vw, 4rem); line-height: 1; letter-spacing: -0.05em; }
+      header p { max-width: 700px; color: #aab9c2; line-height: 1.65; }
+      .card { background: rgba(18, 28, 34, 0.9); border: 1px solid #2b3d47; border-radius: 18px; padding: 24px; box-shadow: 0 22px 70px #0008; }
+      .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }
+      .full { grid-column: 1 / -1; }
+      label { display: block; margin-bottom: 8px; color: #c9d5da; font-size: 0.88rem; font-weight: 700; }
+      textarea, input, select {
+        width: 100%; border: 1px solid #354b56; border-radius: 11px; padding: 12px 13px;
+        background: #0a1217; color: #f4fafc; font: inherit; outline: none;
+      }
+      textarea { min-height: 108px; resize: vertical; line-height: 1.5; }
+      textarea:focus, input:focus, select:focus { border-color: #68d6c0; box-shadow: 0 0 0 3px #68d6c022; }
+      .hint { margin: 7px 0 0; color: #82939d; font-size: 0.79rem; line-height: 1.45; }
+      .actions { display: flex; align-items: center; gap: 14px; margin-top: 22px; flex-wrap: wrap; }
+      button {
+        appearance: none; border: 0; border-radius: 999px; padding: 12px 22px;
+        color: #06100e; background: #68d6c0; font: inherit; font-weight: 850; cursor: pointer;
+      }
+      button:hover { background: #8be6d4; }
+      button:disabled { opacity: 0.45; cursor: wait; }
+      #status { color: #9fb0b9; font-size: 0.88rem; }
+      #status.error { color: #ff9f9f; }
+      .result { display: none; margin-top: 22px; padding-top: 20px; border-top: 1px solid #2b3d47; }
+      audio { width: 100%; }
+      .download { display: inline-block; margin-top: 12px; color: #68d6c0; font-weight: 700; }
+      .badge { display: inline-flex; align-items: center; gap: 7px; padding: 6px 10px; border: 1px solid #2b3d47; border-radius: 999px; color: #aab9c2; font-size: 0.76rem; }
+      .dot { width: 8px; height: 8px; border-radius: 50%; background: #e2b34a; }
+      .dot.ok { background: #68d6c0; box-shadow: 0 0 12px #68d6c0; }
+      footer { margin-top: 22px; color: #6f8089; font-size: 0.76rem; line-height: 1.5; }
+      @media (max-width: 680px) { .grid { grid-template-columns: 1fr; } .full { grid-column: auto; } main { padding-top: 28px; } }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <div class="eyebrow">V1 · English balanced release</div>
+        <h1 id="model-title">Fish Audio S2-Pro NVFP4 Balanced</h1>
+        <p id="model-description">Loading the active checkpoint information…</p>
+        <div class="badge"><span id="health-dot" class="dot"></span><span id="health-text">Checking service…</span></div>
+      </header>
+
+      <section class="card">
+        <form id="tts-form">
+          <div class="grid">
+            <div class="full">
+              <label for="text">Text to speak</label>
+              <textarea id="text" required>A clear voice can make even a short message feel personal and memorable.</textarea>
+              <p class="hint">The base S2-Pro model can sound flatter than highly expressive TTS systems. Inline instructions may help some prompts, but V1 does not claim to solve that inherited limitation.</p>
+            </div>
+            <div>
+              <label for="reference-audio">Zero-shot reference audio</label>
+              <input id="reference-audio" type="file" accept="audio/*" required>
+              <p class="hint">Use a clean, consented 10–30 second sample with one speaker and little background noise.</p>
+            </div>
+            <div>
+              <label for="reference-text">Exact reference transcript</label>
+              <textarea id="reference-text" required placeholder="Transcribe the reference audio verbatim."></textarea>
+              <p class="hint">The transcript is required for reliable zero-shot conditioning.</p>
+            </div>
+            <div>
+              <label for="seed">Seed (optional)</label>
+              <input id="seed" type="number" placeholder="Random when blank">
+            </div>
+            <div>
+              <label for="sampling-preset">Voice-clone sampling</label>
+              <select id="sampling-preset">
+                <option value="natural" selected>Natural (recommended)</option>
+                <option value="api">Original API default</option>
+                <option value="stable">Stable identity</option>
+                <option value="expressive">Higher randomness (not an emotion tag)</option>
+              </select>
+              <p class="hint">Use the same seed to A/B sampling. For emotional delivery, put explicit [tag] instructions in the text.</p>
+            </div>
+            <div>
+              <label for="temperature">Temperature</label>
+              <input id="temperature" type="number" min="0.1" max="1" step="0.05" value="0.9">
+            </div>
+            <div>
+              <label for="top-p">Top-p</label>
+              <input id="top-p" type="number" min="0.1" max="1" step="0.05" value="0.9">
+            </div>
+          </div>
+          <div class="actions">
+            <button id="generate" type="submit">Generate speech</button>
+            <span id="status">Ready.</span>
+          </div>
+        </form>
+        <div id="result" class="result">
+          <audio id="player" controls></audio>
+          <a id="download" class="download" download="s2-pro-tts.wav">Download WAV</a>
+        </div>
+      </section>
+      <footer><strong>Built with Fish Audio.</strong> Use only voices you have permission to clone. This derivative is under the Fish Audio Research License; commercial use requires a separate written license from Fish Audio.</footer>
+    </main>
+
+    <script>
+      const form = document.querySelector('#tts-form');
+      const button = document.querySelector('#generate');
+      const status = document.querySelector('#status');
+      const result = document.querySelector('#result');
+      const player = document.querySelector('#player');
+      const download = document.querySelector('#download');
+      const samplingPreset = document.querySelector('#sampling-preset');
+      const temperature = document.querySelector('#temperature');
+      const topP = document.querySelector('#top-p');
+      let currentUrl = null;
+
+      const samplingProfiles = {
+        natural: { temperature: 0.9, topP: 0.9 },
+        api: { temperature: 0.8, topP: 0.8 },
+        stable: { temperature: 0.7, topP: 0.7 },
+        expressive: { temperature: 0.95, topP: 0.95 }
+      };
+
+      samplingPreset.addEventListener('change', () => {
+        const profile = samplingProfiles[samplingPreset.value];
+        temperature.value = profile.temperature;
+        topP.value = profile.topP;
+      });
+
+      function toBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        const chunkSize = 32768;
+        let binary = '';
+        for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+          binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+        }
+        return btoa(binary);
+      }
+
+      function setStatus(message, isError = false) {
+        status.textContent = message;
+        status.classList.toggle('error', isError);
+      }
+
+      async function checkHealth() {
+        try {
+          const response = await fetch('/v1/health');
+          if (!response.ok) throw new Error(`HTTP ${response.status}`);
+          const modelResponse = await fetch('/v1/model');
+          if (!modelResponse.ok) throw new Error(`Model HTTP ${modelResponse.status}`);
+          const model = await modelResponse.json();
+          const isNvfp4 = model.policy === 'w4a16_gate_up_middle30_mxfp8_rest';
+          const isBf16 = model.policy === 'bf16_control';
+          document.querySelector('#model-title').textContent = model.model;
+          document.querySelector('#model-description').textContent = `${model.quantization}. Checkpoint: ${model.checkpoint}`;
+          document.querySelector('#health-dot').classList.add('ok');
+          document.querySelector('#health-text').textContent = isNvfp4 ? 'Checkpointed NVFP4 service online' : (isBf16 ? 'Untouched BF16 base online' : 'MXFP8 service online');
+          if (isNvfp4) {
+            samplingProfiles.natural = { temperature: 1.0, topP: 0.85 };
+            temperature.value = 1.0;
+            topP.value = 0.85;
+          }
+        } catch (error) {
+          document.querySelector('#health-text').textContent = 'Service unavailable';
+        }
+      }
+
+      form.addEventListener('submit', async (event) => {
+        event.preventDefault();
+        const audio = document.querySelector('#reference-audio').files[0];
+        const referenceText = document.querySelector('#reference-text').value.trim();
+        if (!audio || !referenceText) {
+          setStatus('Reference audio and its exact transcript are required.', true);
+          return;
+        }
+        button.disabled = true;
+        result.style.display = 'none';
+        setStatus('Encoding reference and generating… first use may take longer.');
+        try {
+          const seedValue = document.querySelector('#seed').value;
+          const payload = {
+            text: document.querySelector('#text').value,
+            references: [{ audio: toBase64(await audio.arrayBuffer()), text: referenceText }],
+            reference_id: null,
+            format: 'wav',
+            streaming: false,
+            normalize: false,
+            max_new_tokens: 2048,
+            chunk_length: 1000,
+            top_p: Number(topP.value),
+            repetition_penalty: 1.05,
+            temperature: Number(temperature.value),
+            seed: seedValue === '' ? null : Number(seedValue),
+            // The pinned server caches transcript text by audio hash alone.
+            // A fresh load prevents a prior transcript for the same WAV from
+            // silently conditioning this request.
+            use_memory_cache: 'off'
+          };
+          const headers = { 'Content-Type': 'application/json', 'Accept': 'audio/wav' };
+          const response = await fetch('/v1/tts', { method: 'POST', headers, body: JSON.stringify(payload) });
+          if (!response.ok) throw new Error((await response.text()) || `HTTP ${response.status}`);
+          const blob = await response.blob();
+          if (currentUrl) URL.revokeObjectURL(currentUrl);
+          currentUrl = URL.createObjectURL(blob);
+          player.src = currentUrl;
+          download.href = currentUrl;
+          result.style.display = 'block';
+          setStatus(`Complete — ${(blob.size / 1024).toFixed(0)} KiB WAV.`);
+        } catch (error) {
+          setStatus(`Generation failed: ${error.message}`, true);
+        } finally {
+          button.disabled = false;
+        }
+      });
+
+      checkHealth();
+    </script>
+  </body>
+</html>

vendor/fish-speech/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,63 @@
+name: "🕷️ Bug report"
+description: |
+  Please follow this template carefully to ensure we can address your issue quickly.
+  Make sure to provide as much detail as possible, including logs and screenshots.
+labels:
+  - bug
+body:
+  - type: checkboxes
+    attributes:
+      label: Self Checks
+      description: "To ensure timely help, please confirm the following:"
+      options:
+        - label: This template is only for bug reports. For questions, please visit [Discussions](https://github.com/fishaudio/fish-speech/discussions).
+          required: true
+        - label: I have thoroughly reviewed the project documentation (installation, training, inference) but couldn't find information to solve my problem. [English](https://speech.fish.audio/) [中文](https://speech.fish.audio/zh/) [日本語](https://speech.fish.audio/ja/) [Portuguese (Brazil)](https://speech.fish.audio/pt/)
+          required: true
+        - label: I have searched for existing issues, including closed ones. [Search issues](https://github.com/fishaudio/fish-speech/issues)
+          required: true
+        - label: I confirm that I am using English to submit this report (我已阅读并同意 [Language Policy](https://github.com/fishaudio/fish-speech/issues/515)).
+          required: true
+        - label: "[FOR CHINESE USERS] 请务必使用英文提交 Issue，否则会被关闭。谢谢！:）"
+          required: true
+        - label: "Please do not modify this template and fill in all required fields."
+          required: true
+  - type: dropdown
+    attributes:
+      label: Cloud or Self Hosted
+      multiple: true
+      options:
+        - Cloud
+        - Self Hosted (Docker)
+        - Self Hosted (Source)
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Environment Details
+      description: "Provide details such as OS, Python version, and any relevant software or dependencies."
+      placeholder: e.g., macOS 13.5, Python 3.10, torch==2.4.1, Gradio 4.44.0
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps to Reproduce
+      description: |
+        Include detailed steps, screenshots, and logs. Use the correct markdown syntax for code blocks.
+      placeholder: |
+        1. Run the command `python -m tools.api_client -t "xxxxx"`
+        2. Observe the console output error: `ModuleNotFoundError: No module named 'pyaudio'` (with screenshots or logs will be better)
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: ✔️ Expected Behavior
+      placeholder: Describe what you expected to happen.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: ❌ Actual Behavior
+      placeholder: Describe what actually happened.
+    validations:
+      required: false

vendor/fish-speech/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: "\U0001F4E7 Discussions"
+    url: https://github.com/fishaudio/fish-speech/discussions
+    about: General discussions and request help from the community

vendor/fish-speech/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,64 @@
+name: "⭐ Feature or enhancement request"
+description: Propose something new.
+labels:
+  - enhancement
+body:
+  - type: checkboxes
+    attributes:
+      label: Self Checks
+      description: "To make sure we get to you in time, please check the following :)"
+      options:
+        - label: I have thoroughly reviewed the project documentation (installation, training, inference) but couldn't find any relevant information that meets my needs. [English](https://speech.fish.audio/) [中文](https://speech.fish.audio/zh/) [日本語](https://speech.fish.audio/ja/) [Portuguese (Brazil)](https://speech.fish.audio/pt/)
+          required: true
+        - label: I have searched for existing issues [search for existing issues]([https://github.com/langgenius/dify/issues](https://github.com/fishaudio/fish-speech/issues)), including closed ones.
+          required: true
+        - label: I confirm that I am using English to submit this report (我已阅读并同意 [Language Policy](https://github.com/fishaudio/fish-speech/issues/515)).
+          required: true
+        - label: "[FOR CHINESE USERS] 请务必使用英文提交 Issue，否则会被关闭。谢谢！:）"
+          required: true
+        - label: "Please do not modify this template :) and fill in all the required fields."
+          required: true
+
+  - type: textarea
+    attributes:
+      label: 1. Is this request related to a challenge you're experiencing? Tell us your story.
+      description: |
+        Describe the specific problem or scenario you’re facing in detail. For example:
+        *"I was trying to use [feature] for [specific task], but encountered [issue]. This was frustrating because...."*
+      placeholder: Please describe the situation in as much detail as possible.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: 2. What is your suggested solution?
+      description: |
+        Provide a clear description of the feature or enhancement you'd like to propose. 
+        How would this feature solve your issue or improve the project?
+      placeholder: Describe your idea or proposed solution here.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: 3. Additional context or comments
+      description: |
+        Any other relevant information, links, documents, or screenshots that provide clarity. 
+        Use this section for anything not covered above.
+      placeholder: Add any extra details here.
+    validations:
+      required: false
+
+  - type: checkboxes
+    attributes:
+      label: 4. Can you help us with this feature?
+      description: |
+        Let us know if you're interested in contributing. This is not a commitment but a way to express interest in collaboration.
+      options:
+        - label: I am interested in contributing to this feature.
+          required: false
+
+  - type: markdown
+    attributes:
+      value: |
+        **Note:** Please submit only one request per issue to keep discussions focused and manageable.

vendor/fish-speech/.github/workflows/build-docker-image.yml

@@ -0,0 +1,78 @@
+name: Build Docker Images
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest-16c64g
+    strategy:
+      matrix:
+        target: [webui, server]
+        backend: [cuda, cpu]
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      
+      - name: Get Version
+        run: |
+          if [[ $GITHUB_REF == refs/tags/v* ]]; then
+            version=$(basename ${GITHUB_REF})
+          else
+            version=nightly
+          fi
+          echo "version=${version}" >> $GITHUB_ENV
+          echo "Current version: ${version}"
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_PAT }}
+
+      - name: Set platform for CPU builds
+        id: platform
+        run: |
+          if [ "${{ matrix.backend }}" = "cpu" ]; then
+            echo "platforms=linux/amd64,linux/arm64" >> $GITHUB_OUTPUT
+          else
+            echo "platforms=linux/amd64" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Build and Push ${{ matrix.target }}-${{ matrix.backend }} Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ steps.platform.outputs.platforms }}
+          push: true
+          target: ${{ matrix.target }}
+          build-args: |
+            BACKEND=${{ matrix.backend }}
+            UV_EXTRA=${{ matrix.backend == 'cuda' && 'cu126' || 'cpu' }}
+          tags: |
+            fishaudio/fish-speech:${{ matrix.target }}-${{ matrix.backend }}-${{ env.version }}
+            fishaudio/fish-speech:${{ matrix.target }}-${{ matrix.backend }}
+            ${{ (matrix.target == 'webui' && matrix.backend == 'cuda') && format('fishaudio/fish-speech:{0}', env.version) || '' }}
+            ${{ (matrix.target == 'webui' && matrix.backend == 'cuda') && 'fishaudio/fish-speech:latest' || '' }}
+          outputs: type=image,oci-mediatypes=true,compression=zstd,compression-level=3,force-compression=true
+          cache-from: type=registry,ref=fishaudio/fish-speech:${{ matrix.target }}-${{ matrix.backend }}
+          cache-to: type=inline
+
+  update-readme:
+    runs-on: ubuntu-latest
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - name: Push README to Dockerhub
+        uses: peter-evans/dockerhub-description@v4
+        with:
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_PAT }}
+          repository: fishaudio/fish-speech

vendor/fish-speech/.github/workflows/docs.yml

@@ -0,0 +1,33 @@
+name: docs
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure Git Credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.x
+      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV 
+      - uses: actions/cache@v4
+        with:
+          key: mkdocs-material-${{ env.cache_id }}
+          path: .cache
+          restore-keys: |
+            mkdocs-material-
+      - run: pip install -r docs/requirements.txt
+      - run: mkdocs gh-deploy --force

vendor/fish-speech/.github/workflows/stale.yml

@@ -0,0 +1,25 @@
+name: Close inactive issues
+on:
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  close-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/stale@v9
+        with:
+          days-before-issue-stale: 30
+          days-before-issue-close: 14
+          stale-issue-label: "stale"
+          stale-issue-message: "This issue is stale because it has been open for 30 days with no activity."
+          close-issue-message: "This issue was closed because it has been inactive for 14 days since being marked as stale."
+          days-before-pr-stale: 30
+          days-before-pr-close: 30
+          stale-pr-label: "stale"
+          stale-pr-message: "This PR is stale because it has been open for 30 days with no activity."
+          close-pr-message: "This PR was closed because it has been inactive for 30 days since being marked as stale."
+          repo-token: ${{ secrets.GITHUB_TOKEN }}

vendor/fish-speech/awesome_webui/src/App.tsx

@@ -0,0 +1,1185 @@
+import { useEffect, useRef, useState } from 'react'
+import {
+  AudioLines,
+  ChevronDown,
+  CircleAlert,
+  Copy,
+  Download,
+  FileText,
+  Info,
+  LoaderCircle,
+  Plus,
+  Settings2,
+  Upload,
+} from 'lucide-react'
+
+import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from '@/components/ui/card'
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from '@/components/ui/collapsible'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Label } from '@/components/ui/label'
+import { ScrollArea } from '@/components/ui/scroll-area'
+import { Separator } from '@/components/ui/separator'
+import { Slider } from '@/components/ui/slider'
+import { Switch } from '@/components/ui/switch'
+import { Textarea } from '@/components/ui/textarea'
+import { ToggleGroup, ToggleGroupItem } from '@/components/ui/toggle-group'
+
+type AudioFormat = 'mp3' | 'wav' | 'pcm' | 'opus'
+type LatencyMode = 'normal' | 'balanced'
+
+const defaultInputText = `[excited, joyful tone] We're going to DISNEY WORLD! [squeal of delight] I've been saving for [emphasis] three years [breathless] and finally, FINALLY we can go! The look on your face right now is worth every extra shift I worked!
+[angry] After everything we've been through [break] I can't believe you would [emphasize] betray me like this. I gave you EVERYTHING! And now I'm left with nothing but memories and broken promises!`
+
+
+type ControlsState = {
+  chunkLength: number
+  maxNewTokens: number
+  temperature: number
+  topP: number
+  repetitionPenalty: number
+  normalize: boolean
+  format: AudioFormat
+  latency: LatencyMode
+}
+
+type Metrics = {
+  textLength: number
+  ttftMs: number
+  receivedKb: number
+}
+
+type StatusState = {
+  tone: 'error' | 'info'
+  message: string
+}
+
+type ReferenceItem = {
+  id: number
+  name: string
+  audio: ArrayBuffer
+  text: string
+  previewUrl: string
+}
+
+type SpeakerGroup = {
+  id: number
+  references: ReferenceItem[]
+}
+
+type PendingReference = {
+  mode: 'create' | 'edit'
+  speakerId: number
+  referenceId?: number
+  name: string
+  audio?: ArrayBuffer
+  text: string
+}
+
+const initialControls: ControlsState = {
+  chunkLength: 1000,
+  maxNewTokens: 2048,
+  temperature: 0.9,
+  topP: 0.9,
+  repetitionPenalty: 1.05,
+  normalize: false,
+  format: 'mp3',
+  latency: 'normal',
+}
+
+const formatMimeMap: Record<AudioFormat, string> = {
+  mp3: 'audio/mpeg',
+  wav: 'audio/wav',
+  pcm: 'audio/pcm',
+  opus: 'audio/opus',
+}
+
+function createId() {
+  return Date.now() + Math.floor(Math.random() * 100000)
+}
+
+function arrayBufferToBase64(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer)
+  let binary = ''
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i])
+  }
+  return btoa(binary)
+}
+
+function createSpeakerGroup(): SpeakerGroup {
+  return {
+    id: createId(),
+    references: [],
+  }
+}
+
+const initialSpeakerGroup = createSpeakerGroup()
+
+function buildReferencesPayload(
+  speakerGroups: SpeakerGroup[],
+  includeBinaryAudio: boolean,
+) {
+  return speakerGroups.flatMap((speakerGroup) =>
+    speakerGroup.references.map((reference) => ({
+      text: reference.text,
+      audio: includeBinaryAudio
+        ? arrayBufferToBase64(reference.audio)
+        : '<audio binary data>',
+    })),
+  )
+}
+
+function buildPreviewPayload(
+  inputText: string,
+  controls: ControlsState,
+  speakerGroups: SpeakerGroup[],
+) {
+  return {
+    text: inputText,
+    chunk_length: controls.chunkLength,
+    max_new_tokens: controls.maxNewTokens,
+    format: controls.format,
+    latency: controls.latency,
+    normalize: controls.normalize,
+    references: buildReferencesPayload(speakerGroups, false),
+    temperature: controls.temperature,
+    top_p: controls.topP,
+    repetition_penalty: controls.repetitionPenalty,
+  }
+}
+
+function buildRequestPayload(
+  inputText: string,
+  controls: ControlsState,
+  speakerGroups: SpeakerGroup[],
+) {
+  return {
+    text: inputText,
+    chunk_length: controls.chunkLength,
+    max_new_tokens: controls.maxNewTokens,
+    format: controls.format,
+    latency: controls.latency,
+    normalize: controls.normalize,
+    references: buildReferencesPayload(speakerGroups, true),
+    temperature: controls.temperature,
+    top_p: controls.topP,
+    repetition_penalty: controls.repetitionPenalty,
+  }
+}
+
+function createFileName(inputText: string) {
+  const safePrefix = inputText.trim().replace(/\s+/g, '-').slice(0, 24) || 'tts'
+  return safePrefix
+}
+
+function getErrorMessage(error: unknown) {
+  return error instanceof Error ? error.message : 'Unknown error'
+}
+
+function waitForSourceBuffer(sourceBuffer: SourceBuffer) {
+  if (!sourceBuffer.updating) {
+    return Promise.resolve()
+  }
+
+  return new Promise<void>((resolve) => {
+    const handleUpdateEnd = () => {
+      sourceBuffer.removeEventListener('updateend', handleUpdateEnd)
+      resolve()
+    }
+
+    sourceBuffer.addEventListener('updateend', handleUpdateEnd)
+  })
+}
+
+function canUseStreamingPlayback(format: AudioFormat) {
+  const mime = formatMimeMap[format]
+  return typeof window.MediaSource !== 'undefined' && MediaSource.isTypeSupported(mime)
+}
+
+type SettingSliderProps = {
+  label: string
+  value: number
+  min: number
+  max: number
+  step?: number
+  onValueChange: (value: number) => void
+  formatValue?: (value: number) => string
+}
+
+function SettingSlider({
+  label,
+  value,
+  min,
+  max,
+  step = 1,
+  onValueChange,
+  formatValue,
+}: SettingSliderProps) {
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-between gap-4">
+        <Label>{label}</Label>
+        <span className="text-sm text-muted-foreground">
+          {formatValue ? formatValue(value) : value}
+        </span>
+      </div>
+      <Slider
+        value={[value]}
+        min={min}
+        max={max}
+        step={step}
+        onValueChange={(nextValue) => {
+          const current = nextValue[0]
+          if (typeof current === 'number') {
+            onValueChange(current)
+          }
+        }}
+      />
+    </div>
+  )
+}
+
+function App() {
+  const [inputText, setInputText] = useState(defaultInputText)
+  const [controls, setControls] = useState(initialControls)
+  const [speakerGroups, setSpeakerGroups] = useState<SpeakerGroup[]>([initialSpeakerGroup])
+  const [pendingReference, setPendingReference] = useState<PendingReference | null>(null)
+  const [openSpeakerIds, setOpenSpeakerIds] = useState<number[]>([initialSpeakerGroup.id])
+  const [metrics, setMetrics] = useState<Metrics | null>(null)
+  const [isGenerating, setIsGenerating] = useState(false)
+  const [copyLabel, setCopyLabel] = useState('Copy')
+  const [isRequestPreviewOpen, setIsRequestPreviewOpen] = useState(false)
+  const [statusMessage, setStatusMessage] = useState<StatusState | null>(null)
+  const [downloadUrl, setDownloadUrl] = useState<string | null>(null)
+  const [downloadName, setDownloadName] = useState('generated-audio.mp3')
+
+  const audioRef = useRef<HTMLAudioElement | null>(null)
+  const fileInputRef = useRef<HTMLInputElement | null>(null)
+  const speakerGroupsRef = useRef<SpeakerGroup[]>([])
+  const uploadTargetSpeakerIdRef = useRef<number | null>(null)
+  const downloadUrlRef = useRef<string | null>(null)
+  const mediaSourceUrlRef = useRef<string | null>(null)
+
+  speakerGroupsRef.current = speakerGroups
+
+  useEffect(() => {
+    return () => {
+      speakerGroupsRef.current.forEach((speakerGroup) => {
+        speakerGroup.references.forEach((reference) => {
+          URL.revokeObjectURL(reference.previewUrl)
+        })
+      })
+
+      if (downloadUrlRef.current) {
+        URL.revokeObjectURL(downloadUrlRef.current)
+      }
+
+      if (mediaSourceUrlRef.current) {
+        URL.revokeObjectURL(mediaSourceUrlRef.current)
+      }
+    }
+  }, [])
+
+  function addSpeaker() {
+    const nextSpeaker = createSpeakerGroup()
+    setSpeakerGroups((current) => [...current, nextSpeaker])
+    setOpenSpeakerIds((current) => [...current, nextSpeaker.id])
+  }
+
+  function removeSpeaker(speakerId: number) {
+    setSpeakerGroups((current) => {
+      const targetSpeaker = current.find((speakerGroup) => speakerGroup.id === speakerId)
+      if (targetSpeaker) {
+        targetSpeaker.references.forEach((reference) => {
+          URL.revokeObjectURL(reference.previewUrl)
+        })
+      }
+
+      const next = current.filter((speakerGroup) => speakerGroup.id !== speakerId)
+      return next.length > 0 ? next : [createSpeakerGroup()]
+    })
+    setOpenSpeakerIds((current) => current.filter((currentSpeakerId) => currentSpeakerId !== speakerId))
+
+    if (pendingReference?.speakerId === speakerId) {
+      setPendingReference(null)
+    }
+  }
+
+  function addReference(speakerId: number, name: string, audio: ArrayBuffer, text: string) {
+    const previewUrl = URL.createObjectURL(new Blob([audio], { type: formatMimeMap.mp3 }))
+
+    setSpeakerGroups((current) =>
+      current.map((speakerGroup) =>
+        speakerGroup.id === speakerId
+          ? {
+              ...speakerGroup,
+              references: [
+                ...speakerGroup.references,
+                {
+                  id: createId(),
+                  name,
+                  audio,
+                  text,
+                  previewUrl,
+                },
+              ],
+            }
+          : speakerGroup,
+      ),
+    )
+  }
+
+  function removeReference(speakerId: number, referenceId: number) {
+    setSpeakerGroups((current) =>
+      current.map((speakerGroup) => {
+        if (speakerGroup.id !== speakerId) {
+          return speakerGroup
+        }
+
+        return {
+          ...speakerGroup,
+          references: speakerGroup.references.filter((reference) => {
+            if (reference.id === referenceId) {
+              URL.revokeObjectURL(reference.previewUrl)
+              return false
+            }
+
+            return true
+          }),
+        }
+      }),
+    )
+  }
+
+  function updateReferenceText(speakerId: number, referenceId: number, text: string) {
+    setSpeakerGroups((current) =>
+      current.map((speakerGroup) =>
+        speakerGroup.id === speakerId
+          ? {
+              ...speakerGroup,
+              references: speakerGroup.references.map((reference) =>
+                reference.id === referenceId ? { ...reference, text } : reference,
+              ),
+            }
+          : speakerGroup,
+      ),
+    )
+  }
+
+  function clearDownloadUrl() {
+    if (downloadUrlRef.current) {
+      URL.revokeObjectURL(downloadUrlRef.current)
+      downloadUrlRef.current = null
+    }
+
+    setDownloadUrl(null)
+  }
+
+  function clearMediaSourceUrl() {
+    if (mediaSourceUrlRef.current) {
+      URL.revokeObjectURL(mediaSourceUrlRef.current)
+      mediaSourceUrlRef.current = null
+    }
+  }
+
+  async function handleReferenceUpload(event: React.ChangeEvent<HTMLInputElement>) {
+    const file = event.target.files?.[0]
+    const speakerId = uploadTargetSpeakerIdRef.current
+    event.target.value = ''
+    uploadTargetSpeakerIdRef.current = null
+
+    if (!file || typeof speakerId !== 'number') {
+      return
+    }
+
+    const audio = await file.arrayBuffer()
+    setPendingReference({
+      mode: 'create',
+      speakerId,
+      name: file.name,
+      audio,
+      text: '',
+    })
+  }
+
+  function savePendingReference() {
+    if (!pendingReference) {
+      return
+    }
+
+    if (pendingReference.mode === 'create' && pendingReference.audio) {
+      addReference(
+        pendingReference.speakerId,
+        pendingReference.name,
+        pendingReference.audio,
+        pendingReference.text,
+      )
+    }
+
+    if (pendingReference.mode === 'edit' && typeof pendingReference.referenceId === 'number') {
+      updateReferenceText(
+        pendingReference.speakerId,
+        pendingReference.referenceId,
+        pendingReference.text,
+      )
+    }
+
+    setPendingReference(null)
+    setStatusMessage(null)
+  }
+
+  async function copyRequestPreview() {
+    const requestPreview = JSON.stringify(
+      buildPreviewPayload(inputText, controls, speakerGroups),
+      null,
+      2,
+    )
+
+    try {
+      await navigator.clipboard.writeText(requestPreview)
+      setCopyLabel('Copied')
+      window.setTimeout(() => setCopyLabel('Copy'), 2000)
+    } catch (error) {
+      setStatusMessage({
+        tone: 'error',
+        message: `Failed to copy request preview: ${getErrorMessage(error)}`,
+      })
+    }
+  }
+
+  async function handleGenerateAudio() {
+    const audioElement = audioRef.current
+    if (!audioElement) {
+      return
+    }
+
+    const mime = formatMimeMap[controls.format]
+    const useStreamingPlayback = canUseStreamingPlayback(controls.format)
+
+    clearDownloadUrl()
+    clearMediaSourceUrl()
+    setMetrics(null)
+    setStatusMessage(null)
+    setIsGenerating(true)
+
+    try {
+      const response = await fetch('/v1/tts', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(buildRequestPayload(inputText, controls, speakerGroups)),
+      })
+
+      if (!response.ok || !response.body) {
+        throw new Error('Failed to generate audio')
+      }
+
+      const reader = response.body.getReader()
+      let mediaSource: MediaSource | null = null
+
+      if (useStreamingPlayback) {
+        mediaSource = new MediaSource()
+        const streamUrl = URL.createObjectURL(mediaSource)
+        mediaSourceUrlRef.current = streamUrl
+        audioElement.src = streamUrl
+      } else {
+        audioElement.removeAttribute('src')
+        audioElement.load()
+      }
+
+      const allChunks: ArrayBuffer[] = []
+      const playQueue: ArrayBuffer[] = []
+      let sourceBuffer: SourceBuffer | null = null
+      let readingDone = false
+      let receivedLength = 0
+      let ttftMs = -1
+      const startTime = performance.now()
+
+      if (mediaSource) {
+        const sourceReady = new Promise<void>((resolve, reject) => {
+          mediaSource.addEventListener(
+            'sourceopen',
+            () => {
+              try {
+                sourceBuffer = mediaSource.addSourceBuffer(mime)
+
+                const processQueue = async () => {
+                  if (!sourceBuffer || !mediaSource) {
+                    return
+                  }
+
+                  while (true) {
+                    if (readingDone && playQueue.length === 0) {
+                      await waitForSourceBuffer(sourceBuffer)
+                      if (mediaSource.readyState === 'open') {
+                        mediaSource.endOfStream()
+                      }
+                      break
+                    }
+
+                    const chunk = playQueue.shift()
+                    if (!chunk) {
+                      await new Promise<void>((resolveSleep) => {
+                        window.setTimeout(resolveSleep, 50)
+                      })
+                      continue
+                    }
+
+                    await waitForSourceBuffer(sourceBuffer)
+                    sourceBuffer.appendBuffer(chunk)
+                    await waitForSourceBuffer(sourceBuffer)
+                  }
+                }
+
+                void processQueue()
+                resolve()
+              } catch (error) {
+                reject(error)
+              }
+            },
+            { once: true },
+          )
+        })
+
+        await sourceReady
+      }
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) {
+          readingDone = true
+          break
+        }
+
+        receivedLength += value.byteLength
+
+        if (ttftMs < 0) {
+          ttftMs = performance.now() - startTime
+        }
+
+        setMetrics({
+          textLength: inputText.length,
+          ttftMs,
+          receivedKb: Math.round(receivedLength / 1024),
+        })
+
+        const chunk = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength)
+        playQueue.push(chunk)
+        allChunks.push(chunk)
+
+        if (useStreamingPlayback && audioElement.paused) {
+          void audioElement.play().catch(() => undefined)
+        }
+      }
+
+      const audioBlob = new Blob(allChunks, { type: mime })
+      const nextDownloadUrl = URL.createObjectURL(audioBlob)
+      downloadUrlRef.current = nextDownloadUrl
+      setDownloadUrl(nextDownloadUrl)
+      setDownloadName(`${createFileName(inputText)}.${controls.format}`)
+
+      if (!useStreamingPlayback) {
+        audioElement.src = nextDownloadUrl
+        audioElement.load()
+        setStatusMessage({
+          tone: 'info',
+          message: `Format "${controls.format}" is not supported for in-browser playback. The file is ready to download after generation completes.`,
+        })
+      }
+    } catch (error) {
+      setStatusMessage({
+        tone: 'error',
+        message: `Audio generation failed: ${getErrorMessage(error)}`,
+      })
+    } finally {
+      setIsGenerating(false)
+    }
+  }
+
+  const requestPreview = JSON.stringify(
+    buildPreviewPayload(inputText, controls, speakerGroups),
+    null,
+    2,
+  )
+
+  const totalReferenceCount = speakerGroups.reduce(
+    (count, speakerGroup) => count + speakerGroup.references.length,
+    0,
+  )
+
+  return (
+    <main className="min-h-screen bg-zinc-50">
+      <div className="mx-auto max-w-[1600px] px-3 py-3 sm:px-4 lg:px-5">
+        <div className="grid gap-4 xl:h-[calc(100vh-1.5rem)] xl:grid-cols-[minmax(0,1fr)_460px]">
+          <section className="grid gap-4 xl:min-h-0 xl:grid-rows-[minmax(0,1fr)_auto]">
+            <Card className="rounded-xl border-zinc-200 bg-white shadow-none xl:min-h-0 xl:flex xl:flex-col">
+              <CardHeader className="space-y-1 border-b border-zinc-100 px-4 py-4">
+                <div className="flex items-center gap-2 text-zinc-700">
+                  <FileText className="size-4" />
+                  <CardTitle>Input</CardTitle>
+                </div>
+                <CardDescription>
+                  Enter the text to synthesize and inspect the outgoing request payload.
+                </CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-4 px-4 pt-4 xl:min-h-0 xl:flex-1 xl:overflow-y-auto">
+                <div className="space-y-2">
+                  <Label htmlFor="inputText">Input Text</Label>
+                  <Textarea
+                    id="inputText"
+                    value={inputText}
+                    onChange={(event) => setInputText(event.target.value)}
+                    placeholder="Enter text to synthesize"
+                    className="min-h-[220px] resize-y rounded-xl border-zinc-200 bg-white p-3 text-sm shadow-none focus-visible:ring-zinc-300 xl:min-h-[260px]"
+                  />
+                </div>
+
+                <Collapsible open={isRequestPreviewOpen} onOpenChange={setIsRequestPreviewOpen}>
+                  <div className="rounded-xl border border-zinc-200 bg-zinc-50">
+                    <div className="flex flex-col gap-2 p-3 sm:flex-row sm:items-center sm:justify-between">
+                      <div>
+                        <div className="text-sm font-medium text-zinc-900">Request Preview</div>
+                        <div className="text-xs text-zinc-500">
+                          Live snapshot of the payload sent to the backend.
+                        </div>
+                      </div>
+                      <div className="flex items-center gap-2">
+                        <Button
+                          type="button"
+                          variant="ghost"
+                          size="sm"
+                          className="border border-zinc-200 bg-white text-zinc-700 hover:bg-zinc-100"
+                          onClick={copyRequestPreview}
+                        >
+                          <Copy className="size-3.5" />
+                          {copyLabel}
+                        </Button>
+                        <CollapsibleTrigger asChild>
+                          <Button
+                            type="button"
+                            variant="ghost"
+                            size="sm"
+                            className="border border-zinc-200 bg-white text-zinc-700 hover:bg-zinc-100"
+                          >
+                            {isRequestPreviewOpen ? 'Collapse' : 'Expand'}
+                            <ChevronDown
+                              className={`size-4 transition-transform ${
+                                isRequestPreviewOpen ? 'rotate-180' : ''
+                              }`}
+                            />
+                          </Button>
+                        </CollapsibleTrigger>
+                      </div>
+                    </div>
+                    <CollapsibleContent>
+                      <Separator className="bg-zinc-200" />
+                      <div className="p-3 pt-3">
+                        <ScrollArea className="h-56 min-w-0 rounded-lg border border-zinc-200 bg-white">
+                          <pre className="max-w-full whitespace-pre-wrap break-all p-3 text-xs leading-5 text-zinc-700">
+                            {requestPreview}
+                          </pre>
+                        </ScrollArea>
+                      </div>
+                    </CollapsibleContent>
+                  </div>
+                </Collapsible>
+
+                <div className="space-y-4">
+                  <Button
+                    type="button"
+                    size="lg"
+                    className="h-11 rounded-lg bg-zinc-900 text-white hover:bg-zinc-800"
+                    onClick={handleGenerateAudio}
+                    disabled={isGenerating}
+                  >
+                    {isGenerating ? (
+                      <LoaderCircle className="size-4 animate-spin" />
+                    ) : (
+                      <AudioLines className="size-4" />
+                    )}
+                    {isGenerating ? 'Generating Audio...' : 'Generate Audio'}
+                  </Button>
+
+                  {statusMessage ? (
+                    <Alert
+                      variant={statusMessage.tone === 'error' ? 'destructive' : 'warning'}
+                      className="rounded-lg"
+                    >
+                      <div className="flex items-start gap-3">
+                        {statusMessage.tone === 'error' ? (
+                          <CircleAlert className="mt-0.5 size-4 shrink-0" />
+                        ) : (
+                          <Info className="mt-0.5 size-4 shrink-0" />
+                        )}
+                        <div>
+                          <AlertTitle>
+                            {statusMessage.tone === 'error' ? 'Error' : 'Notice'}
+                          </AlertTitle>
+                          <AlertDescription>{statusMessage.message}</AlertDescription>
+                        </div>
+                      </div>
+                    </Alert>
+                  ) : null}
+                </div>
+              </CardContent>
+            </Card>
+
+            <Card className="rounded-xl border-zinc-200 bg-white shadow-none">
+              <CardHeader className="space-y-1 border-b border-zinc-100 px-4 py-4">
+                <div className="flex items-center gap-2 text-zinc-700">
+                  <AudioLines className="size-4" />
+                  <CardTitle>Output</CardTitle>
+                </div>
+                <CardDescription>
+                  Stream the result when supported, then preview or download the final file.
+                </CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-3 px-4 pt-4">
+                <audio
+                  ref={audioRef}
+                  controls
+                  className="w-full rounded-lg border border-zinc-200 bg-white"
+                />
+
+                <div className="flex flex-wrap gap-2">
+                  {metrics ? (
+                    <>
+                      <Badge variant="outline" className="border-zinc-200 bg-white text-zinc-700">
+                        Text length: {metrics.textLength}
+                      </Badge>
+                      <Badge variant="outline" className="border-zinc-200 bg-white text-zinc-700">
+                        TTFT: {metrics.ttftMs.toFixed(2)} ms
+                      </Badge>
+                      <Badge variant="outline" className="border-zinc-200 bg-white text-zinc-700">
+                        Received: {metrics.receivedKb} KB
+                      </Badge>
+                    </>
+                  ) : (
+                    <Badge variant="outline" className="border-zinc-200 bg-white text-zinc-500">
+                      No output yet
+                    </Badge>
+                  )}
+                </div>
+
+                <div className="flex justify-end">
+                  {downloadUrl ? (
+                    <Button
+                      asChild
+                      variant="outline"
+                      className="border-zinc-200 bg-white text-zinc-800 hover:bg-zinc-100"
+                    >
+                      <a href={downloadUrl} download={downloadName}>
+                        <Download className="size-4" />
+                        Download
+                      </a>
+                    </Button>
+                  ) : null}
+                </div>
+              </CardContent>
+            </Card>
+          </section>
+
+          <aside className="grid gap-4 xl:min-h-0 xl:grid-rows-[minmax(0,1fr)_auto]">
+            <Card className="rounded-xl border-zinc-200 bg-white shadow-none xl:min-h-0 xl:flex xl:flex-col">
+              <CardHeader className="space-y-1 border-b border-zinc-100 px-4 py-4">
+                <div className="flex items-center gap-2 text-zinc-700">
+                  <Upload className="size-4" />
+                  <CardTitle>Reference Audio</CardTitle>
+                </div>
+                <CardDescription>
+                  Build one or more speaker groups. Each speaker can have multiple reference clips.
+                </CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-3 px-4 pt-4 xl:min-h-0 xl:flex xl:flex-1 xl:flex-col">
+                <div className="flex flex-wrap items-center justify-between gap-2">
+                  <div className="flex items-center text-sm text-zinc-500">
+                    {speakerGroups.length} speaker{speakerGroups.length === 1 ? '' : 's'} /{' '}
+                    {totalReferenceCount} reference{totalReferenceCount === 1 ? '' : 's'}
+                  </div>
+                  <Button
+                    type="button"
+                    variant="outline"
+                    className="border-zinc-200 bg-white hover:bg-zinc-100"
+                    onClick={addSpeaker}
+                  >
+                    <Plus className="size-4" />
+                    Add Speaker
+                  </Button>
+                  <input
+                    ref={fileInputRef}
+                    type="file"
+                    accept="audio/*"
+                    className="hidden"
+                    onChange={handleReferenceUpload}
+                  />
+                </div>
+
+                <ScrollArea className="min-h-0 rounded-md xl:h-full xl:flex-1">
+                  <div className="space-y-2">
+                    {speakerGroups.length > 0 ? (
+                      speakerGroups.map((speakerGroup, speakerIndex) => (
+                        <Collapsible
+                          key={speakerGroup.id}
+                          open={openSpeakerIds.includes(speakerGroup.id)}
+                          onOpenChange={(open) => {
+                            setOpenSpeakerIds((current) =>
+                              open
+                                ? [...current, speakerGroup.id]
+                                : current.filter(
+                                    (currentSpeakerId) => currentSpeakerId !== speakerGroup.id,
+                                  ),
+                            )
+                          }}
+                        >
+                          <div className="rounded-lg border border-zinc-200 bg-white">
+                            <div className="flex flex-col gap-2 px-3 py-3 sm:flex-row sm:items-center sm:justify-between">
+                              <div className="min-w-0">
+                                <div className="text-sm font-medium text-zinc-900">
+                                  Speaker {speakerIndex}
+                                </div>
+                                <div className="text-xs text-zinc-500">
+                                  {speakerGroup.references.length} reference
+                                  {speakerGroup.references.length === 1 ? '' : 's'}
+                                </div>
+                              </div>
+                              <div className="flex flex-wrap gap-2">
+                                <Button
+                                  type="button"
+                                  variant="outline"
+                                  size="sm"
+                                  className="h-8 border-zinc-200 bg-white px-2.5 hover:bg-zinc-100"
+                                  onClick={() => {
+                                    uploadTargetSpeakerIdRef.current = speakerGroup.id
+                                    fileInputRef.current?.click()
+                                  }}
+                                >
+                                  <Upload className="size-4" />
+                                  Upload
+                                </Button>
+                                {speakerGroups.length > 1 ? (
+                                  <Button
+                                    type="button"
+                                    variant="ghost"
+                                    size="sm"
+                                    className="h-8 px-2.5 text-zinc-500 hover:bg-zinc-100 hover:text-zinc-900"
+                                    onClick={() => removeSpeaker(speakerGroup.id)}
+                                  >
+                                    Remove
+                                  </Button>
+                                ) : null}
+                                <CollapsibleTrigger asChild>
+                                  <Button
+                                    type="button"
+                                    variant="ghost"
+                                    size="sm"
+                                    className="h-8 px-2 text-zinc-500 hover:bg-zinc-100 hover:text-zinc-900"
+                                  >
+                                    <ChevronDown
+                                      className={`size-4 transition-transform ${
+                                        openSpeakerIds.includes(speakerGroup.id) ? 'rotate-180' : ''
+                                      }`}
+                                    />
+                                  </Button>
+                                </CollapsibleTrigger>
+                              </div>
+                            </div>
+
+                            <CollapsibleContent>
+                              <Separator className="bg-zinc-200" />
+                              <div className="space-y-2 px-3 py-2.5">
+                                {speakerGroup.references.length > 0 ? (
+                                  speakerGroup.references.map((reference) => (
+                                    <div
+                                      key={reference.id}
+                                      className="flex flex-col gap-2 rounded-md border border-zinc-200 bg-zinc-50 p-2 sm:flex-row sm:items-center"
+                                    >
+                                      <audio
+                                        controls
+                                        src={reference.previewUrl}
+                                        className="h-9 w-full min-w-0 rounded-md border border-zinc-200 bg-white sm:flex-1"
+                                      />
+                                      <div className="flex gap-2 sm:shrink-0">
+                                        <Button
+                                          type="button"
+                                          variant="ghost"
+                                          size="sm"
+                                          className="h-8 border border-zinc-200 bg-white px-2.5 text-zinc-600 hover:bg-zinc-100 hover:text-zinc-900"
+                                          onClick={() =>
+                                            setPendingReference({
+                                              mode: 'edit',
+                                              speakerId: speakerGroup.id,
+                                              referenceId: reference.id,
+                                              name: reference.name,
+                                              text: reference.text,
+                                            })
+                                          }
+                                        >
+                                          Edit Text
+                                        </Button>
+                                        <Button
+                                          type="button"
+                                          variant="ghost"
+                                          size="sm"
+                                          className="h-8 border border-zinc-200 bg-white px-2.5 text-zinc-500 hover:bg-zinc-100 hover:text-zinc-900"
+                                          onClick={() =>
+                                            removeReference(speakerGroup.id, reference.id)
+                                          }
+                                        >
+                                          Remove
+                                        </Button>
+                                      </div>
+                                    </div>
+                                  ))
+                                ) : (
+                                  <div className="px-1 py-3 text-sm text-zinc-500">
+                                    No references yet.
+                                  </div>
+                                )}
+                              </div>
+                            </CollapsibleContent>
+                          </div>
+                        </Collapsible>
+                      ))
+                    ) : (
+                      <div className="rounded-lg border border-dashed border-zinc-300 bg-white p-4 text-sm text-zinc-500">
+                        No speaker groups configured yet.
+                      </div>
+                    )}
+                  </div>
+                </ScrollArea>
+              </CardContent>
+            </Card>
+
+            <Card className="rounded-xl border-zinc-200 bg-white shadow-none">
+              <CardHeader className="space-y-1 border-b border-zinc-100 px-4 py-4">
+                <div className="flex items-center gap-2 text-zinc-700">
+                  <Settings2 className="size-4" />
+                  <CardTitle>Generation Settings</CardTitle>
+                </div>
+                <CardDescription>Adjust sampling and output parameters.</CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-4 px-4 pt-4">
+                <div className="space-y-2">
+                  <Label>Latency Mode</Label>
+                  <ToggleGroup
+                    type="single"
+                    value={controls.latency}
+                    className="grid grid-cols-2 gap-2"
+                    onValueChange={(value) => {
+                      if (value) {
+                        setControls((current) => ({
+                          ...current,
+                          latency: value as LatencyMode,
+                        }))
+                      }
+                    }}
+                  >
+                    <ToggleGroupItem value="balanced" className="w-full">
+                      balanced
+                    </ToggleGroupItem>
+                    <ToggleGroupItem value="normal" className="w-full">
+                      normal
+                    </ToggleGroupItem>
+                  </ToggleGroup>
+                  <p className="text-xs text-zinc-500">
+                    Low uses incremental local decode for faster first audio. Normal waits for the
+                    full LLM result, then decodes once.
+                  </p>
+                </div>
+
+                <div className="space-y-2">
+                  <Label>Format</Label>
+                  <ToggleGroup
+                    type="single"
+                    value={controls.format}
+                    className="grid grid-cols-4 gap-2"
+                    onValueChange={(value) => {
+                      if (value) {
+                        setControls((current) => ({
+                          ...current,
+                          format: value as AudioFormat,
+                        }))
+                      }
+                    }}
+                  >
+                    <ToggleGroupItem value="mp3" className="w-full">
+                      mp3
+                    </ToggleGroupItem>
+                    <ToggleGroupItem value="wav" className="w-full">
+                      wav
+                    </ToggleGroupItem>
+                    <ToggleGroupItem value="pcm" className="w-full">
+                      pcm
+                    </ToggleGroupItem>
+                    <ToggleGroupItem value="opus" className="w-full">
+                      opus
+                    </ToggleGroupItem>
+                  </ToggleGroup>
+                </div>
+
+                <div className="flex items-center justify-between rounded-lg border border-zinc-200 bg-zinc-50 px-3 py-2.5">
+                  <div className="space-y-1">
+                    <Label htmlFor="normalize">Normalize</Label>
+                    <p className="text-xs text-zinc-500">
+                      Normalize text before synthesis to keep input formatting consistent.
+                    </p>
+                  </div>
+                  <Switch
+                    id="normalize"
+                    checked={controls.normalize}
+                    onCheckedChange={(checked) =>
+                      setControls((current) => ({
+                        ...current,
+                        normalize: checked,
+                      }))
+                    }
+                  />
+                </div>
+
+                <Separator className="bg-zinc-200" />
+
+                <SettingSlider
+                  label="Chunk Length"
+                  value={controls.chunkLength}
+                  min={100}
+                  max={1000}
+                  onValueChange={(value) =>
+                    setControls((current) => ({
+                      ...current,
+                      chunkLength: value,
+                    }))
+                  }
+                />
+                <SettingSlider
+                  label="Max New Tokens"
+                  value={controls.maxNewTokens}
+                  min={256}
+                  max={2048}
+                  onValueChange={(value) =>
+                    setControls((current) => ({
+                      ...current,
+                      maxNewTokens: value,
+                    }))
+                  }
+                />
+                <SettingSlider
+                  label="Temperature"
+                  value={controls.temperature}
+                  min={0.8}
+                  max={1}
+                  step={0.01}
+                  formatValue={(value) => value.toFixed(2)}
+                  onValueChange={(value) =>
+                    setControls((current) => ({
+                      ...current,
+                      temperature: value,
+                    }))
+                  }
+                />
+                <SettingSlider
+                  label="Top P"
+                  value={controls.topP}
+                  min={0.8}
+                  max={1}
+                  step={0.01}
+                  formatValue={(value) => value.toFixed(2)}
+                  onValueChange={(value) =>
+                    setControls((current) => ({
+                      ...current,
+                      topP: value,
+                    }))
+                  }
+                />
+                <SettingSlider
+                  label="Repetition Penalty"
+                  value={controls.repetitionPenalty}
+                  min={1}
+                  max={1.2}
+                  step={0.01}
+                  formatValue={(value) => value.toFixed(2)}
+                  onValueChange={(value) =>
+                    setControls((current) => ({
+                      ...current,
+                      repetitionPenalty: value,
+                    }))
+                  }
+                />
+              </CardContent>
+            </Card>
+          </aside>
+        </div>
+      </div>
+
+      <Dialog open={pendingReference !== null} onOpenChange={(open) => !open && setPendingReference(null)}>
+        <DialogContent className="border-zinc-200 bg-white">
+          <DialogHeader>
+            <DialogTitle>
+              {pendingReference?.mode === 'create' ? 'Save Reference Text' : 'Edit Reference Text'}
+            </DialogTitle>
+            <DialogDescription>
+              {pendingReference
+                ? `Speaker ${speakerGroups.findIndex(
+                    (speakerGroup) => speakerGroup.id === pendingReference.speakerId,
+                  )}`
+                : ''}
+            </DialogDescription>
+          </DialogHeader>
+          <div className="space-y-3">
+            <div className="text-sm font-medium text-zinc-900">{pendingReference?.name}</div>
+            <Textarea
+              value={pendingReference?.text ?? ''}
+              onChange={(event) =>
+                setPendingReference((current) =>
+                  current
+                    ? {
+                        ...current,
+                        text: event.target.value,
+                      }
+                    : current,
+                )
+              }
+              placeholder="Enter reference text"
+              className="min-h-40 rounded-lg border-zinc-200 bg-white shadow-none focus-visible:ring-zinc-300"
+            />
+          </div>
+          <DialogFooter>
+            <Button type="button" variant="ghost" onClick={() => setPendingReference(null)}>
+              Cancel
+            </Button>
+            <Button
+              type="button"
+              variant="outline"
+              className="border-zinc-200 bg-white hover:bg-zinc-100"
+              onClick={savePendingReference}
+            >
+              Save
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </main>
+  )
+}
+
+export default App

vendor/fish-speech/awesome_webui/src/components/ui/alert.tsx

@@ -0,0 +1,35 @@
+import * as React from 'react'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const alertVariants = cva('relative w-full rounded-lg border px-4 py-3 text-sm', {
+  variants: {
+    variant: {
+      default: 'bg-card text-card-foreground',
+      destructive: 'border-destructive/20 bg-destructive/5 text-destructive',
+      warning: 'border-amber-200 bg-amber-50 text-amber-900',
+    },
+  },
+  defaultVariants: {
+    variant: 'default',
+  },
+})
+
+function Alert({
+  className,
+  variant,
+  ...props
+}: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>) {
+  return <div role="alert" className={cn(alertVariants({ variant }), className)} {...props} />
+}
+
+function AlertTitle({ className, ...props }: React.ComponentProps<'h5'>) {
+  return <h5 className={cn('mb-1 font-medium leading-none tracking-tight', className)} {...props} />
+}
+
+function AlertDescription({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('text-sm [&_p]:leading-relaxed', className)} {...props} />
+}
+
+export { Alert, AlertDescription, AlertTitle }

vendor/fish-speech/awesome_webui/src/components/ui/badge.tsx

@@ -0,0 +1,31 @@
+/* eslint-disable react-refresh/only-export-components */
+import * as React from 'react'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const badgeVariants = cva(
+  'inline-flex items-center rounded-md border px-2 py-0.5 text-xs font-medium transition-colors',
+  {
+    variants: {
+      variant: {
+        default: 'border-transparent bg-primary text-primary-foreground',
+        secondary: 'border-transparent bg-secondary text-secondary-foreground',
+        outline: 'text-foreground',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+    },
+  },
+)
+
+function Badge({
+  className,
+  variant,
+  ...props
+}: React.ComponentProps<'div'> & VariantProps<typeof badgeVariants>) {
+  return <div className={cn(badgeVariants({ variant }), className)} {...props} />
+}
+
+export { Badge, badgeVariants }

vendor/fish-speech/awesome_webui/src/components/ui/button.tsx

@@ -0,0 +1,44 @@
+/* eslint-disable react-refresh/only-export-components */
+import * as React from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const buttonVariants = cva(
+  'inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors disabled:pointer-events-none disabled:opacity-50 outline-none focus-visible:ring-2 focus-visible:ring-ring/70 focus-visible:ring-offset-2 focus-visible:ring-offset-background',
+  {
+    variants: {
+      variant: {
+        default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+        destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+        outline: 'border bg-card hover:bg-accent hover:text-accent-foreground',
+        secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+        ghost: 'hover:bg-accent hover:text-accent-foreground',
+      },
+      size: {
+        default: 'h-9 px-4 py-2',
+        sm: 'h-8 rounded-md px-3 text-xs',
+        lg: 'h-11 rounded-md px-6',
+        icon: 'size-9',
+      },
+    },
+    defaultVariants: {
+      variant: 'default',
+      size: 'default',
+    },
+  },
+)
+
+type ButtonProps = React.ComponentProps<'button'> &
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean
+  }
+
+function Button({ className, variant, size, asChild = false, ...props }: ButtonProps) {
+  const Comp = asChild ? Slot : 'button'
+
+  return <Comp className={cn(buttonVariants({ variant, size, className }))} {...props} />
+}
+
+export { Button, buttonVariants }

vendor/fish-speech/awesome_webui/src/components/ui/card.tsx

@@ -0,0 +1,31 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+function Card({ className, ...props }: React.ComponentProps<'div'>) {
+  return (
+    <div
+      data-slot="card"
+      className={cn('rounded-xl border bg-card text-card-foreground shadow-sm', className)}
+      {...props}
+    />
+  )
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('flex flex-col space-y-1.5 p-6', className)} {...props} />
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('text-base font-semibold leading-none tracking-tight', className)} {...props} />
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('text-sm text-muted-foreground', className)} {...props} />
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('p-6 pt-0', className)} {...props} />
+}
+
+export { Card, CardContent, CardDescription, CardHeader, CardTitle }

vendor/fish-speech/awesome_webui/src/components/ui/collapsible.tsx

@@ -0,0 +1,7 @@
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible'
+
+const Collapsible = CollapsiblePrimitive.Root
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent
+
+export { Collapsible, CollapsibleContent, CollapsibleTrigger }

vendor/fish-speech/awesome_webui/src/components/ui/dialog.tsx

@@ -0,0 +1,86 @@
+import * as React from 'react'
+import * as DialogPrimitive from '@radix-ui/react-dialog'
+import { X } from 'lucide-react'
+
+import { cn } from '@/lib/utils'
+
+const Dialog = DialogPrimitive.Root
+const DialogTrigger = DialogPrimitive.Trigger
+const DialogPortal = DialogPrimitive.Portal
+const DialogClose = DialogPrimitive.Close
+
+function DialogOverlay({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
+  return (
+    <DialogPrimitive.Overlay
+      className={cn('fixed inset-0 z-50 bg-black/40', className)}
+      {...props}
+    />
+  )
+}
+
+function DialogContent({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Content>) {
+  return (
+    <DialogPortal>
+      <DialogOverlay />
+      <DialogPrimitive.Content
+        className={cn(
+          'fixed left-1/2 top-1/2 z-50 grid w-full max-w-lg -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl border bg-background p-6 shadow-lg duration-200',
+          className,
+        )}
+        {...props}
+      >
+        {children}
+        <DialogClose className="absolute right-4 top-4 rounded-sm opacity-70 transition-opacity hover:opacity-100 focus-visible:ring-2 focus-visible:ring-ring/70">
+          <X className="size-4" />
+          <span className="sr-only">Close</span>
+        </DialogClose>
+      </DialogPrimitive.Content>
+    </DialogPortal>
+  )
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('flex flex-col space-y-1.5 text-left', className)} {...props} />
+}
+
+function DialogFooter({ className, ...props }: React.ComponentProps<'div'>) {
+  return <div className={cn('flex flex-col-reverse gap-2 sm:flex-row sm:justify-end', className)} {...props} />
+}
+
+function DialogTitle({ className, ...props }: React.ComponentProps<typeof DialogPrimitive.Title>) {
+  return (
+    <DialogPrimitive.Title
+      className={cn('text-lg font-semibold leading-none tracking-tight', className)}
+      {...props}
+    />
+  )
+}
+
+function DialogDescription({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Description>) {
+  return (
+    <DialogPrimitive.Description
+      className={cn('text-sm text-muted-foreground', className)}
+      {...props}
+    />
+  )
+}
+
+export {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+}

vendor/fish-speech/awesome_webui/src/components/ui/label.tsx

@@ -0,0 +1,15 @@
+import * as React from 'react'
+import * as LabelPrimitive from '@radix-ui/react-label'
+
+import { cn } from '@/lib/utils'
+
+function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>) {
+  return (
+    <LabelPrimitive.Root
+      className={cn('text-sm font-medium leading-none', className)}
+      {...props}
+    />
+  )
+}
+
+export { Label }

vendor/fish-speech/awesome_webui/src/components/ui/scroll-area.tsx

@@ -0,0 +1,43 @@
+import * as React from 'react'
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area'
+
+import { cn } from '@/lib/utils'
+
+function ScrollArea({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.Root>) {
+  return (
+    <ScrollAreaPrimitive.Root className={cn('relative overflow-hidden', className)} {...props}>
+      <ScrollAreaPrimitive.Viewport className="h-full w-full rounded-[inherit]">
+        {children}
+      </ScrollAreaPrimitive.Viewport>
+      <ScrollBar />
+      <ScrollAreaPrimitive.Corner />
+    </ScrollAreaPrimitive.Root>
+  )
+}
+
+function ScrollBar({
+  className,
+  orientation = 'vertical',
+  ...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>) {
+  return (
+    <ScrollAreaPrimitive.ScrollAreaScrollbar
+      orientation={orientation}
+      className={cn(
+        'flex touch-none select-none p-px transition-colors',
+        orientation === 'vertical' && 'h-full w-2.5 border-l border-l-transparent',
+        orientation === 'horizontal' && 'h-2.5 flex-col border-t border-t-transparent',
+        className,
+      )}
+      {...props}
+    >
+      <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
+    </ScrollAreaPrimitive.ScrollAreaScrollbar>
+  )
+}
+
+export { ScrollArea, ScrollBar }

vendor/fish-speech/awesome_webui/src/components/ui/separator.tsx

@@ -0,0 +1,26 @@
+import * as React from 'react'
+import * as SeparatorPrimitive from '@radix-ui/react-separator'
+
+import { cn } from '@/lib/utils'
+
+function Separator({
+  className,
+  orientation = 'horizontal',
+  decorative = true,
+  ...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+  return (
+    <SeparatorPrimitive.Root
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        'shrink-0 bg-border',
+        orientation === 'horizontal' ? 'h-px w-full' : 'h-full w-px',
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Separator }

vendor/fish-speech/awesome_webui/src/components/ui/slider.tsx

@@ -0,0 +1,23 @@
+import * as React from 'react'
+import * as SliderPrimitive from '@radix-ui/react-slider'
+
+import { cn } from '@/lib/utils'
+
+function Slider({
+  className,
+  ...props
+}: React.ComponentProps<typeof SliderPrimitive.Root>) {
+  return (
+    <SliderPrimitive.Root
+      className={cn('relative flex w-full touch-none select-none items-center', className)}
+      {...props}
+    >
+      <SliderPrimitive.Track className="relative h-1.5 w-full grow overflow-hidden rounded-full bg-muted">
+        <SliderPrimitive.Range className="absolute h-full bg-primary" />
+      </SliderPrimitive.Track>
+      <SliderPrimitive.Thumb className="block size-4 rounded-full border border-primary/20 bg-background shadow-sm transition-colors focus-visible:ring-2 focus-visible:ring-ring/70 focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:pointer-events-none disabled:opacity-50" />
+    </SliderPrimitive.Root>
+  )
+}
+
+export { Slider }

vendor/fish-speech/awesome_webui/src/components/ui/switch.tsx

@@ -0,0 +1,27 @@
+import * as React from 'react'
+import * as SwitchPrimitive from '@radix-ui/react-switch'
+
+import { cn } from '@/lib/utils'
+
+function Switch({
+  className,
+  ...props
+}: React.ComponentProps<typeof SwitchPrimitive.Root>) {
+  return (
+    <SwitchPrimitive.Root
+      className={cn(
+        'peer inline-flex h-6 w-11 shrink-0 cursor-pointer items-center rounded-full border border-transparent bg-input shadow-xs transition-colors outline-none focus-visible:ring-2 focus-visible:ring-ring/70 focus-visible:ring-offset-2 focus-visible:ring-offset-background data-[state=checked]:bg-primary data-[state=unchecked]:bg-muted-foreground/30 disabled:cursor-not-allowed disabled:opacity-50',
+        className,
+      )}
+      {...props}
+    >
+      <SwitchPrimitive.Thumb
+        className={cn(
+          'pointer-events-none block size-5 rounded-full bg-background shadow-sm ring-0 transition-transform data-[state=checked]:translate-x-5 data-[state=unchecked]:translate-x-0',
+        )}
+      />
+    </SwitchPrimitive.Root>
+  )
+}
+
+export { Switch }

vendor/fish-speech/awesome_webui/src/components/ui/textarea.tsx

@@ -0,0 +1,17 @@
+import * as React from 'react'
+
+import { cn } from '@/lib/utils'
+
+function Textarea({ className, ...props }: React.ComponentProps<'textarea'>) {
+  return (
+    <textarea
+      className={cn(
+        'flex min-h-16 w-full rounded-lg border border-input bg-background px-3 py-2 text-sm shadow-xs outline-none transition-[color,box-shadow] placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-ring/70 disabled:cursor-not-allowed disabled:opacity-50',
+        className,
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Textarea }

vendor/fish-speech/awesome_webui/src/components/ui/toggle-group.tsx

@@ -0,0 +1,49 @@
+import * as React from 'react'
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group'
+import { cva, type VariantProps } from 'class-variance-authority'
+
+import { cn } from '@/lib/utils'
+
+const toggleGroupItemVariants = cva(
+  'inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:ring-2 focus-visible:ring-ring/70 focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-primary data-[state=on]:text-primary-foreground border border-border bg-card',
+  {
+    variants: {
+      size: {
+        default: 'h-9 px-3',
+        sm: 'h-8 px-2.5 text-xs',
+        lg: 'h-10 px-4',
+      },
+    },
+    defaultVariants: {
+      size: 'default',
+    },
+  },
+)
+
+function ToggleGroup({
+  className,
+  ...props
+}: React.ComponentProps<typeof ToggleGroupPrimitive.Root>) {
+  return (
+    <ToggleGroupPrimitive.Root
+      className={cn('flex items-center gap-2', className)}
+      {...props}
+    />
+  )
+}
+
+function ToggleGroupItem({
+  className,
+  size,
+  ...props
+}: React.ComponentProps<typeof ToggleGroupPrimitive.Item> &
+  VariantProps<typeof toggleGroupItemVariants>) {
+  return (
+    <ToggleGroupPrimitive.Item
+      className={cn(toggleGroupItemVariants({ size }), className)}
+      {...props}
+    />
+  )
+}
+
+export { ToggleGroup, ToggleGroupItem }

vendor/fish-speech/awesome_webui/src/index.css

@@ -0,0 +1,71 @@
+@import "tailwindcss";
+
+:root {
+  --background: 0 0% 96%;
+  --foreground: 240 10% 3.9%;
+  --card: 0 0% 100%;
+  --card-foreground: 240 10% 3.9%;
+  --popover: 0 0% 100%;
+  --popover-foreground: 240 10% 3.9%;
+  --primary: 240 5.9% 10%;
+  --primary-foreground: 0 0% 98%;
+  --secondary: 240 4.8% 95.9%;
+  --secondary-foreground: 240 5.9% 10%;
+  --muted: 240 4.8% 95.9%;
+  --muted-foreground: 240 3.8% 46.1%;
+  --accent: 240 4.8% 95.9%;
+  --accent-foreground: 240 5.9% 10%;
+  --destructive: 0 72.2% 50.6%;
+  --destructive-foreground: 0 0% 98%;
+  --border: 240 5.9% 88%;
+  --input: 240 5.9% 88%;
+  --ring: 240 5% 64.9%;
+  --radius: 0.75rem;
+}
+
+@theme inline {
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-popover: hsl(var(--popover));
+  --color-popover-foreground: hsl(var(--popover-foreground));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-accent: hsl(var(--accent));
+  --color-accent-foreground: hsl(var(--accent-foreground));
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+
+  html {
+    min-width: 320px;
+  }
+
+  body {
+    @apply bg-background text-foreground antialiased;
+    font-family: "Inter", "Avenir Next", "Segoe UI", sans-serif;
+  }
+
+  button,
+  input,
+  textarea {
+    font: inherit;
+  }
+}

vendor/fish-speech/awesome_webui/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs))
+}

vendor/fish-speech/awesome_webui/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

vendor/fish-speech/docs/ar/finetune.md

@@ -0,0 +1,125 @@
+# الضبط الدقيق (Fine-tuning)
+
+من الواضح أنك عندما فتحت هذه الصفحة، لم تكن راضيًا عن أداء النموذج المدرب مسبقًا في وضع zero-shot. أنت ترغب في إجراء ضبط دقيق لنموذج لتحسين أدائه على مجموعة البيانات الخاصة بك.
+
+في الإصدار الحالي، ما عليك سوى إجراء الضبط الدقيق لجزء 'LLAMA'.
+
+## الضبط الدقيق لـ LLAMA
+### 1. إعداد مجموعة البيانات
+
+```
+.
+├── SPK1
+│   ├── 21.15-26.44.lab
+│   ├── 21.15-26.44.mp3
+│   ├── 27.51-29.98.lab
+│   ├── 27.51-29.98.mp3
+│   ├── 30.1-32.71.lab
+│   └── 30.1-32.71.mp3
+└── SPK2
+    ├── 38.79-40.85.lab
+    └── 38.79-40.85.mp3
+```
+
+تحتاج إلى تحويل مجموعة البيانات الخاصة بك إلى التنسيق أعلاه ووضعها تحت مجلد `data`. يمكن أن يكون للملف الصوتي الامتدادات `.mp3`، `.wav`، أو `.flac`، ويجب أن يكون لملف التعليقات التوضيحية الامتداد `.lab`.
+
+!!! info "تنسيق مجموعة البيانات"
+    يحتاج ملف التعليقات التوضيحية `.lab` فقط إلى احتواء النص المكتوب للمقطع الصوتي، دون الحاجة إلى تنسيق خاص. على سبيل المثال، إذا كان محتوى `hi.mp3` هو "مرحبًا، وداعًا"، فسيحتوي ملف `hi.lab` على سطر واحد من النص: "مرحبًا، وداعًا".
+
+!!! warning "تحذير"
+    يوصى بتطبيق تسوية جهارة الصوت (loudness normalization) على مجموعة البيانات. يمكنك استخدام [fish-audio-preprocess](https://github.com/fishaudio/audio-preprocess) للقيام بذلك.
+    ```bash
+    fap loudness-norm data-raw data --clean
+    ```
+
+### 2. الاستخراج الدفعي للرموز الدلالية (semantic tokens)
+
+تأكد من أنك قمت بتنزيل أوزان VQGAN. إذا لم تكن قد فعلت، قم بتشغيل الأمر التالي:
+
+```bash
+huggingface-cli download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini
+```
+
+يمكنك بعد ذلك تشغيل الأمر التالي لاستخراج الرموز الدلالية:
+
+```bash
+python tools/vqgan/extract_vq.py data \
+    --num-workers 1 --batch-size 16 \
+    --config-name "modded_dac_vq" \
+    --checkpoint-path "checkpoints/openaudio-s1-mini/codec.pth"
+```
+
+!!! note "ملاحظة"
+    يمكنك ضبط `--num-workers` و `--batch-size` لزيادة سرعة الاستخراج، ولكن يرجى التأكد من عدم تجاوز حد ذاكرة وحدة معالجة الرسومات (GPU) الخاصة بك.
+
+سيقوم هذا الأمر بإنشاء ملفات `.npy` في مجلد `data`، كما هو موضح أدناه:
+
+```
+.
+├── SPK1
+│   ├── 21.15-26.44.lab
+│   ├── 21.15-26.44.mp3
+│   ├── 21.15-26.44.npy
+│   ├── 27.51-29.98.lab
+│   ├── 27.51-29.98.mp3
+│   ├── 27.51-29.98.npy
+│   ├── 30.1-32.71.lab
+│   ├── 30.1-32.71.mp3
+│   └── 30.1-32.71.npy
+└── SPK2
+    ├── 38.79-40.85.lab
+    ├── 38.79-40.85.mp3
+    └── 38.79-40.85.npy
+```
+
+### 3. حزم مجموعة البيانات في protobuf
+
+```bash
+python tools/llama/build_dataset.py \
+    --input "data" \
+    --output "data/protos" \
+    --text-extension .lab \
+    --num-workers 16
+```
+
+بعد انتهاء تنفيذ الأمر، يجب أن ترى ملف `protos` في مجلد `data`.
+
+### 4. أخيرًا، الضبط الدقيق باستخدام LoRA
+
+بالمثل، تأكد من أنك قمت بتنزيل أوزان `LLAMA`. إذا لم تكن قد فعلت، قم بتشغيل الأمر التالي:
+
+```bash
+huggingface-cli download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini
+```
+
+أخيرًا، يمكنك بدء الضبط الدقيق عن طريق تشغيل الأمر التالي:
+
+```bash
+python fish_speech/train.py --config-name text2semantic_finetune \
+    project=$project \
+    +lora@model.model.lora_config=r_8_alpha_16
+```
+
+!!! note "ملاحظة"
+    يمكنك تعديل معلمات التدريب مثل `batch_size`، `gradient_accumulation_steps`، وما إلى ذلك لتناسب ذاكرة وحدة معالجة الرسومات الخاصة بك عن طريق تعديل `fish_speech/configs/text2semantic_finetune.yaml`.
+
+!!! note "ملاحظة"
+    لمستخدمي Windows، يمكنك استخدام `trainer.strategy.process_group_backend=gloo` لتجنب مشكلات `nccl`.
+
+بعد اكتمال التدريب، يمكنك الرجوع إلى قسم [الاستدلال (inference)](inference.md) لاختبار نموذجك.
+
+!!! info "معلومات"
+    بشكل افتراضي، سيتعلم النموذج فقط أنماط كلام المتحدث وليس جرس الصوت (timbre). لا تزال بحاجة إلى استخدام التلقينات (prompts) لضمان استقرار جرس الصوت.
+    إذا كنت ترغب في تعلم جرس الصوت، يمكنك زيادة عدد خطوات التدريب، ولكن هذا قد يؤدي إلى الإفراط في التخصيص (overfitting).
+
+بعد التدريب، تحتاج إلى تحويل أوزان LoRA إلى أوزان عادية قبل إجراء الاستدلال.
+
+```bash
+python tools/llama/merge_lora.py \
+	--lora-config r_8_alpha_16 \
+	--base-weight checkpoints/openaudio-s1-mini \
+	--lora-weight results/$project/checkpoints/step_000000010.ckpt \
+	--output checkpoints/openaudio-s1-mini-yth-lora/
+```
+!!! note "ملاحظة"
+    يمكنك أيضًا تجربة نقاط تحقق (checkpoints) أخرى. نقترح استخدام أقدم نقطة تحقق تلبي متطلباتك، حيث إنها غالبًا ما تؤدي أداءً أفضل على البيانات خارج التوزيع (OOD).

vendor/fish-speech/docs/ar/index.md

@@ -0,0 +1,192 @@
+<div align="center">
+<h1>Fish Speech</h1>
+
+<p><a href="../en/">English</a> | <a href="../zh/">简体中文</a> | <a href="../pt/">Portuguese</a> | <a href="../ja/">日本語</a> | <a href="../ko/">한국어</a> | <strong>العربية</strong></p>
+
+<a href="https://www.producthunt.com/products/fish-speech?embed=true&utm_source=badge-top-post-badge&utm_medium=badge&utm_source=badge-fish&#0045;audio&#0045;s1" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=1023740&theme=light&period=daily&t=1761164814710" alt="Fish&#0032;Audio&#0032;S1 - Expressive&#0032;Voice&#0032;Cloning&#0032;and&#0032;Text&#0045;to&#0045;Speech | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+<a href="https://trendshift.io/repositories/7014" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/7014" alt="fishaudio%2Ffish-speech | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/>
+</a>
+</div>
+
+<br>
+
+<div align="center">
+    <img src="https://count.getloli.com/get/@fish-speech?theme=asoul" /><br>
+</div>
+
+<br>
+
+<div align="center">
+    <a target="_blank" href="https://discord.gg/Es5qTB9BcN">
+        <img alt="Discord" src="https://img.shields.io/discord/1214047546020728892?color=%23738ADB&label=Discord&logo=discord&logoColor=white&style=flat-square"/>
+    </a>
+    <a target="_blank" href="https://hub.docker.com/r/fishaudio/fish-speech">
+        <img alt="Docker" src="https://img.shields.io/docker/pulls/fishaudio/fish-speech?style=flat-square&logo=docker"/>
+    </a>
+    <a target="_blank" href="https://pd.qq.com/s/bwxia254o">
+      <img alt="QQ Channel" src="https://img.shields.io/badge/QQ-blue?logo=tencentqq">
+    </a>
+</div>
+
+<div align="center">
+    <a target="_blank" href="https://huggingface.co/fishaudio/s2">
+        <img alt="HuggingFace Model" src="https://img.shields.io/badge/🤗%20-models-orange"/>
+    </a>
+    <a target="_blank" href="https://fish.audio/blog/fish-audio-open-sources-s2/">
+        <img alt="Fish Audio Blog" src="https://img.shields.io/badge/Blog-Fish_Audio_S2-1f7a8c?style=flat-square&logo=readme&logoColor=white"/>
+    </a>
+    <a target="_blank" href="https://arxiv.org/abs/2603.08823">
+        <img alt="Paper | Technical Report" src="https://img.shields.io/badge/Paper-Technical_Report-b31b1b?style=flat-square"/>
+    </a>
+</div>
+
+!!! info "تنبيه الترخيص"
+    يتم إصدار قاعدة الأكواد هذه وأوزان النماذج المرتبطة بها بموجب رخصة **FISH AUDIO RESEARCH LICENSE**. يرجى الرجوع إلى [LICENSE](https://github.com/fishaudio/fish-speech/blob/main/LICENSE) لمزيد من التفاصيل.
+
+!!! warning "إخلاء المسؤولية القانونية"
+    نحن لا نتحمل أي مسؤولية عن أي استخدام غير قانوني لقاعدة الأكواد. يرجى مراجعة القوانين المحلية المتعلقة بـ DMCA والقوانين الأخرى ذات الصلة.
+
+## البدء السريع
+
+### ابدأ من الوثائق
+
+هذه هي الوثائق الرسمية لـ Fish Audio S2، ويمكنك البدء مباشرة عبر الروابط التالية:
+
+- [التثبيت](https://speech.fish.audio/ar/install/)
+- [الاستدلال عبر سطر الأوامر](https://speech.fish.audio/ar/inference/)
+- [استدلال WebUI](https://speech.fish.audio/ar/inference/)
+- [الاستدلال عبر الخادم](https://speech.fish.audio/ar/server/)
+- [إعداد Docker](https://speech.fish.audio/ar/install/)
+
+> [!IMPORTANT]
+> **بالنسبة لخادم SGLang، راجع [SGLang-Omni README](https://github.com/sgl-project/sglang-omni/blob/main/sglang_omni/models/fishaudio_s2_pro/README.md).**
+
+### دليل وكلاء LLM
+
+```
+قم بتثبيت وإعداد Fish Audio S2 باتباع التعليمات في https://speech.fish.audio/ar/install/ .
+```
+
+## Fish Audio S2
+**أفضل نظام لتحويل النص إلى كلام بين الأنظمة مفتوحة المصدر ومغلقة المصدر**
+
+Fish Audio S2 هو أحدث نموذج من [Fish Audio](https://fish.audio/). تم تدريبه على أكثر من 10 ملايين ساعة صوتية عبر نحو 50 لغة، ويجمع بين المواءمة بالتعلم المعزز وبنية Dual-Autoregressive لإنتاج كلام طبيعي وواقعي وغني بالتعبير العاطفي.
+
+يدعم S2 التحكم الدقيق في النبرة والعاطفة داخل النص نفسه باستخدام وسوم باللغة الطبيعية مثل `[laugh]` و`[whispers]` و`[super happy]`، كما يدعم بشكل أصيل توليد متحدثين متعددين وحوارات متعددة الأدوار.
+
+يمكنك تجربة النموذج مباشرة عبر [موقع Fish Audio](https://fish.audio/)، وقراءة المزيد في [منشور المدونة](https://fish.audio/blog/fish-audio-open-sources-s2/) و[التقرير التقني](https://arxiv.org/abs/2603.08823).
+
+### إصدارات النموذج
+
+| النموذج | الحجم | التوفر | الوصف |
+|------|------|-------------|-------------|
+| S2-Pro | 4B معلمة | [HuggingFace](https://huggingface.co/fishaudio/s2-pro) | نموذج رائد كامل الميزات بأعلى مستوى من الجودة والاستقرار |
+
+يمكن العثور على مزيد من التفاصيل في [التقرير التقني](https://arxiv.org/abs/2411.01156).
+
+## نتائج القياس المعياري
+
+| المعيار | Fish Audio S2 |
+|------|------|
+| Seed-TTS Eval — WER (الصينية) | **0.54%** (الأفضل إجمالاً) |
+| Seed-TTS Eval — WER (الإنجليزية) | **0.99%** (الأفضل إجمالاً) |
+| Audio Turing Test (مع التعليمات) | **0.515** المتوسط البعدي |
+| EmergentTTS-Eval — معدل الفوز | **81.88%** (الأعلى إجمالاً) |
+| Fish Instruction Benchmark — TAR | **93.3%** |
+| Fish Instruction Benchmark — الجودة | **4.51 / 5.0** |
+| متعدد اللغات (MiniMax Testset) — أفضل WER | **11 من 24** لغة |
+| متعدد اللغات (MiniMax Testset) — أفضل SIM | **17 من 24** لغة |
+
+في Seed-TTS Eval، حقق S2 أقل WER بين جميع النماذج التي تم تقييمها، بما في ذلك الأنظمة المغلقة: Qwen3-TTS ‏(0.77/1.24)، وMiniMax Speech-02 ‏(0.99/1.90)، وSeed-TTS ‏(1.12/2.25). وفي Audio Turing Test، تفوقت قيمة 0.515 على Seed-TTS ‏(0.417) بنسبة 24% وعلى MiniMax-Speech ‏(0.387) بنسبة 33%. وفي EmergentTTS-Eval، حقق S2 نتائج قوية بشكل خاص في الخصائص شبه اللغوية (91.61%)، والأسئلة (84.41%)، والتعقيد النحوي (83.39%).
+
+## أبرز المميزات
+
+<img src="../assets/totalability.png" width=200%>
+
+### تحكم مضمّن دقيق عبر اللغة الطبيعية
+
+يتيح Fish Audio S2 تحكمًا موضعيًا في توليد الكلام من خلال تضمين تعليمات باللغة الطبيعية مباشرة عند مواقع كلمات أو عبارات محددة داخل النص. وبدلًا من الاعتماد على مجموعة ثابتة من الوسوم المُعرّفة مسبقًا، يقبل S2 أوصافًا نصية حرة مثل [whisper in small voice] أو [professional broadcast tone] أو [pitch up]، مما يتيح تحكمًا مفتوحًا في التعبير على مستوى الكلمة.
+
+### بنية Dual-Autoregressive
+
+يعتمد S2 على Transformer أحادي الاتجاه (Decoder-only) مع مُرمّز صوتي قائم على RVQ (عدد 10 codebooks وبمعدل إطارات يقارب 21 هرتز). وتُقسّم بنية Dual-AR عملية التوليد إلى مرحلتين:
+
+- **Slow AR** يعمل على المحور الزمني ويتنبأ بالـ semantic codebook الأساسي.
+- **Fast AR** يولّد الـ 9 residual codebooks المتبقية في كل خطوة زمنية لإعادة بناء التفاصيل الصوتية الدقيقة.
+
+هذا التصميم غير المتماثل (4B معلمة على المحور الزمني و400M على محور العمق) يرفع كفاءة الاستدلال مع الحفاظ على جودة الصوت.
+
+### المواءمة بالتعلم المعزز
+
+يستخدم S2 خوارزمية Group Relative Policy Optimization (GRPO) للمواءمة بعد التدريب. ويتم إعادة استخدام نفس النماذج التي استُخدمت لتصفية بيانات التدريب وتعليقها كنماذج مكافأة في التعلم المعزز مباشرة، مما يلغي عدم تطابق التوزيع بين بيانات ما قبل التدريب وأهداف ما بعد التدريب. وتجمع إشارة المكافأة بين الدقة الدلالية، والالتزام بالتعليمات، وتقييم التفضيل الصوتي، وتشابه النبرة.
+
+### البث الإنتاجي عبر SGLang
+
+لأن بنية Dual-AR متماثلة بنيويًا مع نماذج LLM autoregressive القياسية، فإن S2 يرث مباشرة تحسينات الخدمة الأصلية في SGLang، بما في ذلك: continuous batching، وpaged KV cache، وCUDA graph replay، وprefix caching المعتمد على RadixAttention.
+
+على بطاقة NVIDIA H200 واحدة:
+
+- **عامل الزمن الحقيقي (RTF):** 0.195
+- **الزمن حتى أول مقطع صوتي:** حوالي 100 مللي ثانية
+- **معدل المعالجة:** أكثر من 3,000 acoustic tokens/s مع الحفاظ على RTF أقل من 0.5
+
+### دعم لغات متعددة
+
+يدعم Fish Audio S2 تحويل النص إلى كلام بجودة عالية ولغات متعددة دون الحاجة إلى رموز صوتية أو معالجة مسبقة خاصة بكل لغة. بما في ذلك:
+
+**الإنجليزية، الصينية، اليابانية، الكورية، العربية، الألمانية، الفرنسية...**
+
+**وأكثر من ذلك بكثير!**
+
+القائمة في توسع مستمر، تحقق من [Fish Audio](https://fish.audio/) لمعرفة أحدث الإصدارات.
+
+### توليد أصلي لمتحدثين متعددين
+
+<img src="../assets/chattemplate.png" width=200%>
+
+يسمح Fish Audio S2 للمستخدمين برفع صوت مرجعي يحتوي على متحدثين متعددين، وسيتعامل النموذج مع ميزات كل متحدث عبر رمز `<|speaker:i|>`. يمكنك بعد ذلك التحكم في أداء النموذج باستخدام رمز معرف المتحدث، مما يسمح بتوليد واحد يتضمن متحدثين متعددين. لم تعد بحاجة لرفع ملفات مرجعية منفصلة لكل متحدث.
+
+### توليد حوارات متعددة الأدوار
+
+بفضل توسيع سياق النموذج، يمكن لنموذجنا الآن استخدام المعلومات السابقة لتحسين التعبير في المحتوى المولد لاحقاً، مما يزيد من طبيعية المحتوى.
+
+### استنساخ صوت سريع
+
+يدعم Fish Audio S2 استنساخ الصوت بدقة باستخدام عينة مرجعية قصيرة (عادةً 10-30 ثانية). يلتقط النموذج نبرة الصوت، وأسلوب التحدث، والميول العاطفية، مما ينتج أصواتاً مستنسخة واقعية ومتسقة دون الحاجة إلى ضبط دقيق إضافي.
+لاستخدام خادم SGLang، راجع [SGLang-Omni README](https://github.com/sgl-project/sglang-omni/blob/main/sglang_omni/models/fishaudio_s2_pro/README.md) .
+
+---
+
+## شكر وتقدير
+
+- [VITS2 (daniilrobnikov)](https://github.com/daniilrobnikov/vits2)
+- [Bert-VITS2](https://github.com/fishaudio/Bert-VITS2)
+- [GPT VITS](https://github.com/innnky/gpt-vits)
+- [MQTTS](https://github.com/b04901014/MQTTS)
+- [GPT Fast](https://github.com/pytorch-labs/gpt-fast)
+- [GPT-SoVITS](https://github.com/RVC-Boss/GPT-SoVITS)
+- [Qwen3](https://github.com/QwenLM/Qwen3)
+
+## التقرير التقني
+```bibtex
+@misc{fish-speech-v1.4,
+      title={Fish-Speech: Leveraging Large Language Models for Advanced Multilingual Text-to-Speech Synthesis},
+      author={Shijia Liao and Yuxuan Wang and Tianyu Li and Yifan Cheng and Ruoyi Zhang and Rongzhi Zhou and Yijin Xing},
+      year={2024},
+      eprint={2411.01156},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD},
+      url={https://arxiv.org/abs/2411.01156},
+}
+
+@misc{liao2026fishaudios2technical,
+      title={Fish Audio S2 Technical Report}, 
+      author={Shijia Liao and Yuxuan Wang and Songting Liu and Yifan Cheng and Ruoyi Zhang and Tianyu Li and Shidong Li and Yisheng Zheng and Xingwei Liu and Qingzheng Wang and Zhizhuo Zhou and Jiahua Liu and Xin Chen and Dawei Han},
+      year={2026},
+      eprint={2603.08823},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD},
+      url={https://arxiv.org/abs/2603.08823}, 
+}
+```

vendor/fish-speech/docs/ar/inference.md

@@ -0,0 +1,98 @@
+# الاستنتاج
+
+يتطلب نموذج Fish Audio S2 ذاكرة فيديو (VRAM) كبيرة. نوصي باستخدام وحدة معالجة رسومات (GPU) بسعة 24 جيجابايت على الأقل للاستنتاج.
+
+## تحميل الأوزان
+
+أولاً ، تحتاج إلى تحميل أوزان النموذج:
+
+```bash
+hf download fishaudio/s2-pro --local-dir checkpoints/s2-pro
+```
+
+## الاستنتاج عبر خط الأوامر
+
+!!! note
+    إذا كنت تخطط لترك النموذج يختار نغمة الصوت عشوائيًا ، فيمكنك تخطي هذه الخطوة.
+
+### 1. الحصول على رموز VQ من الصوت المرجعي
+
+```bash
+python fish_speech/models/dac/inference.py \
+    -i "test.wav" \
+    --checkpoint-path "checkpoints/s2-pro/codec.pth"
+```
+
+يجب أن تحصل على `fake.npy` و `fake.wav`.
+
+### 2. توليد الرموز الدلالية (Semantic tokens) من النص:
+
+```bash
+python fish_speech/models/text2semantic/inference.py \
+    --text "النص الذي تريد تحويله" \
+    --prompt-text "النص المرجعي الخاص بك" \
+    --prompt-tokens "fake.npy" \
+    # --compile
+```
+
+سيقوم هذا الأمر بإنشاء ملف `codes_N` في دليل العمل ، حيث N هو عدد صحيح يبدأ من 0.
+
+!!! note
+    قد ترغب في استخدام `--compile` لدمج نوى CUDA لاستنتاج أسرع. ومع ذلك ، نوصي باستخدام تحسين تسريع الاستنتاج sglang الخاص بنا.
+    بالمقابل ، إذا كنت لا تخطط لاستخدام التسريع ، يمكنك التعليق على معلمة `--compile`.
+
+!!! info
+    بالنسبة لوحدات معالجة الرسومات التي لا تدعم bf16 ، قد تحتاج إلى استخدام معلمة `--half`.
+
+### 3. توليد الصوت من الرموز الدلالية:
+
+```bash
+python fish_speech/models/dac/inference.py \
+    -i "codes_0.npy" \
+```
+
+بعد ذلك ستحصل على ملف `fake.wav`.
+
+## استنتاج WebUI
+
+### 1. Gradio WebUI
+
+للحفاظ على التوافق، ما زلنا نحتفظ بواجهة Gradio WebUI السابقة.
+
+```bash
+python tools/run_webui.py # --compile إذا كنت بحاجة إلى تسريع
+```
+
+### 2. Awesome WebUI
+
+تعد Awesome WebUI واجهة ويب حديثة تعتمد على TypeScript، وتوفر ميزات أغنى وتجربة مستخدم أفضل.
+
+**بناء WebUI:**
+
+يجب أن يكون لديك Node.js و npm مثبتين على جهازك المحلي أو الخادم.
+
+1. ادخل إلى دليل `awesome_webui`:
+   ```bash
+   cd awesome_webui
+   ```
+2. تثبيت التبعيات:
+   ```bash
+   npm install
+   ```
+3. بناء WebUI:
+   ```bash
+   npm run build
+   ```
+
+**بدء تشغيل خادم الخلفية:**
+
+بعد بناء WebUI، عد إلى دليل جذر المشروع وقم بتشغيل خادم API:
+
+```bash
+python tools/api_server.py --listen 0.0.0.0:8888 --compile
+```
+
+**الوصول:**
+
+بمجرد تشغيل الخادم، يمكنك الوصول إليه عبر المتصفح على العنوان التالي:
+`http://localhost:8888/ui`

vendor/fish-speech/docs/ar/install.md

@@ -0,0 +1,189 @@
+## المتطلبات
+
+- ذاكرة وحدة معالجة الرسومات (GPU): 24 جيجابايت (للاستدلال)
+- النظام: Linux, WSL
+
+## إعداد النظام
+
+يدعم Fish Audio S2 طرق تثبيت متعددة. اختر الطريقة التي تناسب بيئة التطوير الخاصة بك.
+
+**المتطلبات الأساسية**: قم بتثبيت تبعيات النظام لمعالجة الصوت:
+``` bash
+apt install portaudio19-dev libsox-dev ffmpeg
+```
+
+### Conda
+
+```bash
+conda create -n fish-speech python=3.12
+conda activate fish-speech
+
+# تثبيت نسخة GPU (اختر إصدار CUDA الخاص بك: cu126, cu128, cu129)
+pip install -e .[cu129]
+
+# تثبيت نسخة CPU فقط
+pip install -e .[cpu]
+
+# التثبيت الافتراضي (يستخدم فهرس PyTorch الافتراضي)
+pip install -e .
+
+# إذا واجهت خطأ أثناء التثبيت بسبب pyaudio، ففكر في استخدام الأمر التالي:
+# conda install pyaudio
+# ثم قم بتشغيل pip install -e . مرة أخرى
+```
+
+### UV
+
+يوفر UV حلاً أسرع لتثبيت التبعيات:
+
+```bash
+# تثبيت نسخة GPU (اختر إصدار CUDA الخاص بك: cu126, cu128, cu129)
+uv sync --python 3.12 --extra cu129
+
+# تثبيت نسخة CPU فقط
+uv sync --python 3.12 --extra cpu
+```
+### دعم Intel Arc XPU
+
+لمستخدمي وحدات معالجة الرسومات Intel Arc، قم بالتثبيت مع دعم XPU على النحو التالي:
+
+```bash
+conda create -n fish-speech python=3.12
+conda activate fish-speech
+
+# تثبيت مكتبة C++ القياسية المطلوبة
+conda install libstdcxx -c conda-forge
+
+# تثبيت PyTorch مع دعم Intel XPU
+pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/xpu
+
+# تثبيت Fish Speech
+pip install -e .
+```
+
+!!! warning
+    خيار `compile` غير مدعوم على أنظمة Windows و macOS. إذا كنت ترغب في التشغيل مع التجميع، ستحتاج إلى تثبيت Triton بنفسك.
+
+
+## إعداد Docker
+
+يوفر نموذج سلسلة Fish Audio S2 خيارات نشر متعددة مع Docker لتلبية الاحتياجات المختلفة. يمكنك استخدام الصور المعدة مسبقًا من Docker Hub، أو البناء محليًا باستخدام Docker Compose، أو بناء صور مخصصة يدويًا.
+
+لقد قدمنا صور Docker لكل من واجهة المستخدم الرسومية (WebUI) وخادم API، لكل من وحدات معالجة الرسومات (GPU) (CUDA 12.6 افتراضيًا) ووحدات المعالجة المركزية (CPU). يمكنك استخدام الصور المعدة مسبقًا من Docker Hub، أو البناء محليًا باستخدام Docker Compose، أو بناء صور مخصصة يدويًا. إذا كنت ترغب في البناء محليًا، فاتبع الإرشادات أدناه. إذا كنت ترغب فقط في استخدام الصور المعدة مسبقًا، فاتبع مباشرةً [دليل الاستدلال](inference.md).
+
+### المتطلبات الأساسية
+
+- تثبيت Docker و Docker Compose
+- تثبيت NVIDIA Docker runtime (لدعم GPU)
+- ذاكرة GPU لا تقل عن 24 جيجابايت للاستدلال باستخدام CUDA
+
+### استخدام Docker Compose
+
+للتطوير أو التخصيص، يمكنك استخدام Docker Compose للبناء والتشغيل محليًا:
+
+```bash
+# أولاً، استنسخ المستودع
+git clone https://github.com/fishaudio/fish-speech.git
+cd fish-speech
+
+# بدء واجهة المستخدم الرسومية (WebUI) مع CUDA
+docker compose --profile webui up
+
+# بدء واجهة المستخدم الرسومية (WebUI) مع تحسين التجميع
+COMPILE=1 docker compose --profile webui up
+
+# بدء خادم API
+docker compose --profile server up
+
+# بدء خادم API مع تحسين التجميع
+COMPILE=1 docker compose --profile server up
+
+# النشر باستخدام CPU فقط
+BACKEND=cpu docker compose --profile webui up
+```
+
+#### متغيرات البيئة لـ Docker Compose
+
+يمكنك تخصيص النشر باستخدام متغيرات البيئة:
+
+```bash
+# مثال على ملف .env
+BACKEND=cuda              # أو cpu
+COMPILE=1                 # تمكين تحسين التجميع
+GRADIO_PORT=7860         # منفذ واجهة المستخدم الرسومية (WebUI)
+API_PORT=8080            # منفذ خادم API
+UV_VERSION=0.8.15        # إصدار مدير الحزم UV
+```
+
+سيقوم الأمر ببناء الصورة وتشغيل الحاوية. يمكنك الوصول إلى واجهة المستخدم الرسومية (WebUI) على `http://localhost:7860` وخادم API على `http://localhost:8080`.
+
+### البناء اليدوي باستخدام Docker
+
+للمستخدمين المتقدمين الذين يرغبون في تخصيص عملية البناء:
+
+```bash
+# بناء صورة واجهة المستخدم الرسومية (WebUI) مع دعم CUDA
+docker build \
+    --platform linux/amd64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cuda \
+    --build-arg CUDA_VER=12.6.0 \
+    --build-arg UV_EXTRA=cu126 \
+    --target webui \
+    -t fish-speech-webui:cuda .
+
+# بناء صورة خادم API مع دعم CUDA
+docker build \
+    --platform linux/amd64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cuda \
+    --build-arg CUDA_VER=12.6.0 \
+    --build-arg UV_EXTRA=cu126 \
+    --target server \
+    -t fish-speech-server:cuda .
+
+# بناء صورة CPU فقط (تدعم منصات متعددة)
+docker build \
+    --platform linux/amd64,linux/arm64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cpu \
+    --target webui \
+    -t fish-speech-webui:cpu .
+
+# بناء صورة التطوير
+docker build \
+    --platform linux/amd64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cuda \
+    --target dev \
+    -t fish-speech-dev:cuda .
+```
+
+#### وسيطات البناء
+
+- `BACKEND`: `cuda` أو `cpu` (الافتراضي: `cuda`)
+- `CUDA_VER`: إصدار CUDA (الافتراضي: `12.6.0`)
+- `UV_EXTRA`: حزمة UV إضافية لـ CUDA (الافتراضي: `cu126`)
+- `UBUNTU_VER`: إصدار Ubuntu (الافتراضي: `24.04`)
+- `PY_VER`: إصدار Python (الافتراضي: `3.12`)
+
+### تحميل المجلدات
+
+تتطلب كلتا الطريقتين تحميل المجلدات التالية:
+
+- `./checkpoints:/app/checkpoints` - مجلد أوزان النموذج
+- `./references:/app/references` - مجلد ملفات الصوت المرجعية
+
+### متغيرات البيئة
+
+- `COMPILE=1` - تمكين `torch.compile` لتسريع الاستدلال (حوالي 10 أضعاف)
+- `GRADIO_SERVER_NAME=0.0.0.0` - مضيف خادم واجهة المستخدم الرسومية (WebUI)
+- `GRADIO_SERVER_PORT=7860` - منفذ خادم واجهة المستخدم الرسومية (WebUI)
+- `API_SERVER_NAME=0.0.0.0` - مضيف خادم API
+- `API_SERVER_PORT=8080` - منفذ خادم API
+
+!!! note
+    تتوقع حاويات Docker أن يتم تحميل أوزان النموذج في `/app/checkpoints`. تأكد من تنزيل أوزان النموذج المطلوبة قبل بدء الحاويات.
+
+!!! warning
+    يتطلب دعم GPU وجود NVIDIA Docker runtime. للنشر باستخدام CPU فقط، قم بإزالة علامة `--gpus all` واستخدم صور CPU.

vendor/fish-speech/docs/en/finetune.md

@@ -0,0 +1,128 @@
+# Fine-tuning
+
+!!! warning 
+    We highly do note recoomand users to do fine-tuning on an RL trained model. Fine-tuning a model after RL can shift the model distribution, which may lead to degraded performance.
+
+In the current version, you only need to finetune the 'LLAMA' part.
+
+## Fine-tuning LLAMA
+### 1. Prepare the dataset
+
+```
+.
+├── SPK1
+│   ├── 21.15-26.44.lab
+│   ├── 21.15-26.44.mp3
+│   ├── 27.51-29.98.lab
+│   ├── 27.51-29.98.mp3
+│   ├── 30.1-32.71.lab
+│   └── 30.1-32.71.mp3
+└── SPK2
+    ├── 38.79-40.85.lab
+    └── 38.79-40.85.mp3
+```
+
+You need to convert your dataset into the above format and place it under `data`. The audio file can have the extensions `.mp3`, `.wav`, or `.flac`, and the annotation file should have the extension `.lab`.
+
+!!! info
+    The `.lab` annotation file only needs to contain the transcription of the audio, with no special formatting required. For example, if `hi.mp3` says "Hello, goodbye," then the `hi.lab` file would contain a single line of text: "Hello, goodbye."
+
+!!! warning
+    It's recommended to apply loudness normalization to the dataset. You can use [fish-audio-preprocess](https://github.com/fishaudio/audio-preprocess) to do this.
+
+    ```bash
+    fap loudness-norm data-raw data --clean
+    ```
+
+
+### 2. Batch extraction of semantic tokens
+
+Make sure you have downloaded the VQGAN weights. If not, run the following command:
+
+```bash
+huggingface-cli download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini
+```
+
+You can then run the following command to extract semantic tokens:
+
+```bash
+python tools/vqgan/extract_vq.py data \
+    --num-workers 1 --batch-size 16 \
+    --config-name "modded_dac_vq" \
+    --checkpoint-path "checkpoints/openaudio-s1-mini/codec.pth"
+```
+
+!!! note
+    You can adjust `--num-workers` and `--batch-size` to increase extraction speed, but please make sure not to exceed your GPU memory limit.
+
+This command will create `.npy` files in the `data` directory, as shown below:
+
+```
+.
+├── SPK1
+│   ├── 21.15-26.44.lab
+│   ├── 21.15-26.44.mp3
+│   ├── 21.15-26.44.npy
+│   ├── 27.51-29.98.lab
+│   ├── 27.51-29.98.mp3
+│   ├── 27.51-29.98.npy
+│   ├── 30.1-32.71.lab
+│   ├── 30.1-32.71.mp3
+│   └── 30.1-32.71.npy
+└── SPK2
+    ├── 38.79-40.85.lab
+    ├── 38.79-40.85.mp3
+    └── 38.79-40.85.npy
+```
+
+### 3. Pack the dataset into protobuf
+
+```bash
+python tools/llama/build_dataset.py \
+    --input "data" \
+    --output "data/protos" \
+    --text-extension .lab \
+    --num-workers 16
+```
+
+After the command finishes executing, you should see the `protos` file in the `data` directory.
+
+### 4. Finally, fine-tuning with LoRA
+
+Similarly, make sure you have downloaded the `LLAMA` weights. If not, run the following command:
+
+```bash
+huggingface-cli download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini
+```
+
+Finally, you can start the fine-tuning by running the following command:
+
+```bash
+python fish_speech/train.py --config-name text2semantic_finetune \
+    project=$project \
+    +lora@model.model.lora_config=r_8_alpha_16
+```
+
+!!! note
+    You can modify the training parameters such as `batch_size`, `gradient_accumulation_steps`, etc. to fit your GPU memory by modifying `fish_speech/configs/text2semantic_finetune.yaml`.
+
+!!! note
+    For Windows users, you can use `trainer.strategy.process_group_backend=gloo` to avoid `nccl` issues.
+
+After training is complete, you can refer to the [inference](inference.md) section to test your model.
+
+!!! info
+    By default, the model will only learn the speaker's speech patterns and not the timbre. You still need to use prompts to ensure timbre stability.
+    If you want to learn the timbre, you can increase the number of training steps, but this may lead to overfitting.
+
+After training, you need to convert the LoRA weights to regular weights before performing inference.
+
+```bash
+python tools/llama/merge_lora.py \
+	--lora-config r_8_alpha_16 \
+	--base-weight checkpoints/openaudio-s1-mini \
+	--lora-weight results/$project/checkpoints/step_000000010.ckpt \
+	--output checkpoints/openaudio-s1-mini-yth-lora/
+```
+!!! note
+    You may also try other checkpoints. We suggest using the earliest checkpoint that meets your requirements, as they often perform better on out-of-distribution (OOD) data.

vendor/fish-speech/docs/en/index.md

@@ -0,0 +1,191 @@
+<div align="center">
+<h1>Fish Speech</h1>
+
+<p><strong>English</strong> | <a href="../zh/">简体中文</a> | <a href="../pt/">Portuguese</a> | <a href="../ja/">日本語</a> | <a href="../ko/">한국어</a> | <a href="../ar/">العربية</a> | <a href="../es/">Español</a></p>
+
+<a href="https://www.producthunt.com/products/fish-speech?embed=true&utm_source=badge-top-post-badge&utm_medium=badge&utm_source=badge-fish&#0045;audio&#0045;s1" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=1023740&theme=light&period=daily&t=1761164814710" alt="Fish&#0032;Audio&#0032;S1 - Expressive&#0032;Voice&#0032;Cloning&#0032;and&#0032;Text&#0045;to&#0045;Speech | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+<a href="https://trendshift.io/repositories/7014" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/7014" alt="fishaudio%2Ffish-speech | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/>
+</a>
+</div>
+
+<br>
+
+<div align="center">
+    <img src="https://count.getloli.com/get/@fish-speech?theme=asoul" /><br>
+</div>
+
+<br>
+
+<div align="center">
+    <a target="_blank" href="https://discord.gg/Es5qTB9BcN">
+        <img alt="Discord" src="https://img.shields.io/discord/1214047546020728892?color=%23738ADB&label=Discord&logo=discord&logoColor=white&style=flat-square"/>
+    </a>
+    <a target="_blank" href="https://hub.docker.com/r/fishaudio/fish-speech">
+        <img alt="Docker" src="https://img.shields.io/docker/pulls/fishaudio/fish-speech?style=flat-square&logo=docker"/>
+    </a>
+    <a target="_blank" href="https://pd.qq.com/s/bwxia254o">
+      <img alt="QQ Channel" src="https://img.shields.io/badge/QQ-blue?logo=tencentqq">
+    </a>
+</div>
+
+<div align="center">
+    <a target="_blank" href="https://huggingface.co/fishaudio/s2">
+        <img alt="HuggingFace Model" src="https://img.shields.io/badge/🤗%20-models-orange"/>
+    </a>
+    <a target="_blank" href="https://fish.audio/blog/fish-audio-open-sources-s2/">
+        <img alt="Fish Audio Blog" src="https://img.shields.io/badge/Blog-Fish_Audio_S2-1f7a8c?style=flat-square&logo=readme&logoColor=white"/>
+    </a>
+    <a target="_blank" href="https://arxiv.org/abs/2603.08823">
+        <img alt="Paper | Technical Report" src="https://img.shields.io/badge/Paper-Technical_Report-b31b1b?style=flat-square"/>
+    </a>
+</div>
+
+!!! info "License Notice"
+    This codebase and its associated model weights are released under **FISH AUDIO RESEARCH LICENSE**. Please refer to [LICENSE](https://github.com/fishaudio/fish-speech/blob/main/LICENSE) for more details. We will take action against any violation of the license.
+
+!!! warning "Legal Disclaimer"
+    We do not hold any responsibility for any illegal usage of the codebase. Please refer to your local laws about DMCA and other related laws.
+
+## Quick Start
+
+### For Human
+
+Here are the official documents for Fish Audio S2, follow the instructions to get started easily.
+
+- [Installation](https://speech.fish.audio/install/)
+- [Command Line Inference](https://speech.fish.audio/inference/#command-line-inference)
+- [WebUI Inference](https://speech.fish.audio/inference/#webui-inference)
+- [Server Inference](https://speech.fish.audio/server/)
+- [Docker Setup](https://speech.fish.audio/install/#docker-setup)
+
+> [!IMPORTANT]
+> **For SGLang server, please read [SGLang-Omni README](https://github.com/sgl-project/sglang-omni/blob/main/sglang_omni/models/fishaudio_s2_pro/README.md).**
+
+### For LLM Agent
+
+```
+Install and configure Fish-Audio S2 by following the instructions here: https://speech.fish.audio/install/
+```
+
+## Fish Audio S2  
+**Best text-to-speech system among both open source and closed source**
+
+Fish Audio S2 is the latest model developed by [Fish Audio](https://fish.audio/). Trained on over 10 million hours of audio across approximately 50 languages, S2 combines reinforcement learning alignment with a Dual-Autoregressive architecture to generate speech that sounds natural, realistic, and emotionally rich.
+
+S2 supports fine-grained inline control of prosody and emotion using natural-language tags like `[laugh]`, `[whispers]`, and `[super happy]`, as well as native multi-speaker and multi-turn generation.
+
+Visit the [Fish Audio website](https://fish.audio/) for live playground. Read the [blog post](https://fish.audio/blog/fish-audio-open-sources-s2/) and [technical report](https://arxiv.org/abs/2603.08823) for more details.
+
+### Model Variants
+
+| Model | Size | Availability | Description |
+|------|------|-------------|-------------|
+| S2-Pro | 4B parameters | [HuggingFace](https://huggingface.co/fishaudio/s2-pro) | Full-featured flagship model with maximum quality and stability |
+
+More details of the model can be found in the [technical report](https://arxiv.org/abs/2411.01156).
+
+## Benchmark Results
+
+| Benchmark | Fish Audio S2 |
+|------|------|
+| Seed-TTS Eval — WER (Chinese) | **0.54%** (best overall) |
+| Seed-TTS Eval — WER (English) | **0.99%** (best overall) |
+| Audio Turing Test (with instruction) | **0.515** posterior mean |
+| EmergentTTS-Eval — Win Rate | **81.88%** (highest overall) |
+| Fish Instruction Benchmark — TAR | **93.3%** |
+| Fish Instruction Benchmark — Quality | **4.51 / 5.0** |
+| Multilingual (MiniMax Testset) — Best WER | **11 of 24** languages |
+| Multilingual (MiniMax Testset) — Best SIM | **17 of 24** languages |
+
+On Seed-TTS Eval, S2 achieves the lowest WER among all evaluated models including closed-source systems: Qwen3-TTS (0.77/1.24), MiniMax Speech-02 (0.99/1.90), Seed-TTS (1.12/2.25). On the Audio Turing Test, 0.515 surpasses Seed-TTS (0.417) by 24% and MiniMax-Speech (0.387) by 33%. On EmergentTTS-Eval, S2 achieves particularly strong results in paralinguistics (91.61% win rate), questions (84.41%), and syntactic complexity (83.39%).
+
+## Highlights
+
+<img src="../assets/totalability.png" width=200%>
+
+### Fine-Grained Inline Control via Natural Language
+
+S2 enables localized control over speech generation by embedding natural-language instructions directly at specific word or phrase positions within the text. Rather than relying on a fixed set of predefined tags, S2 accepts free-form textual descriptions — such as `[whisper in small voice]`, `[professional broadcast tone]`, or `[pitch up]` — allowing open-ended expression control at the word level.
+
+### Dual-Autoregressive Architecture
+
+S2 builds on a decoder-only transformer combined with an RVQ-based audio codec (10 codebooks, ~21 Hz frame rate). The Dual-AR architecture splits generation into two stages:
+
+- **Slow AR** operates along the time axis and predicts the primary semantic codebook.
+- **Fast AR** generates the remaining 9 residual codebooks at each time step, reconstructing fine-grained acoustic detail.
+
+This asymmetric design — 4B parameters along the time axis, 400M parameters along the depth axis — keeps inference efficient while preserving audio fidelity.
+
+### Reinforcement Learning Alignment
+
+S2 uses Group Relative Policy Optimization (GRPO) for post-training alignment. The same models used to filter and annotate training data are directly reused as reward models during RL — eliminating distribution mismatch between pre-training data and post-training objectives. The reward signal combines semantic accuracy, instruction adherence, acoustic preference scoring, and timbre similarity.
+
+### Production Streaming via SGLang
+
+Because the Dual-AR architecture is structurally isomorphic to standard autoregressive LLMs, S2 directly inherits all LLM-native serving optimizations from SGLang — including continuous batching, paged KV cache, CUDA graph replay, and RadixAttention-based prefix caching.
+
+On a single NVIDIA H200 GPU:
+
+- **Real-Time Factor (RTF):** 0.195
+- **Time-to-first-audio:** ~100 ms
+- **Throughput:** 3,000+ acoustic tokens/s while maintaining RTF below 0.5
+
+### Multilingual Support
+
+S2 supports high-quality multilingual text-to-speech without requiring phonemes or language-specific preprocessing. Including:
+
+**English, Chinese, Japanese, Korean, Arabics, German, French...**
+
+**AND MORE!**
+
+The list is constantly expanding, check [Fish Audio](https://fish.audio/) for the latest releases.
+
+### Native Multi-Speaker Generation
+
+<img src="../assets/chattemplate.png" width=200%>
+
+Fish Audio S2 allows users to upload reference audio with multi-speaker, the model will deal with every speaker's feature via `<|speaker:i|>` token. Then you can control the model's performance with the speaker id token, allowing a single generation to include multiple speakers. You no longer need to upload reference audio separately for each speaker.
+
+### Multi-Turn Generation
+
+Thanks to the expansion of the model context, our model can now use previous information to improve the expressiveness of subsequent generated content, thereby increasing the naturalness of the content.
+
+### Rapid Voice Cloning
+
+Fish Audio S2 supports accurate voice cloning using a short reference sample (typically 10–30 seconds). The model captures timbre, speaking style, and emotional tendencies, producing realistic and consistent cloned voices without additional fine-tuning.
+Please refer to [SGLang-Omni README](https://github.com/sgl-project/sglang-omni/blob/main/sglang_omni/models/fishaudio_s2_pro/README.md) to use the SGLang server.
+---
+
+## Credits
+
+- [VITS2 (daniilrobnikov)](https://github.com/daniilrobnikov/vits2)
+- [Bert-VITS2](https://github.com/fishaudio/Bert-VITS2)
+- [GPT VITS](https://github.com/innnky/gpt-vits)
+- [MQTTS](https://github.com/b04901014/MQTTS)
+- [GPT Fast](https://github.com/pytorch-labs/gpt-fast)
+- [GPT-SoVITS](https://github.com/RVC-Boss/GPT-SoVITS)
+- [Qwen3](https://github.com/QwenLM/Qwen3)
+
+## Tech Report
+```bibtex
+@misc{fish-speech-v1.4,
+      title={Fish-Speech: Leveraging Large Language Models for Advanced Multilingual Text-to-Speech Synthesis},
+      author={Shijia Liao and Yuxuan Wang and Tianyu Li and Yifan Cheng and Ruoyi Zhang and Rongzhi Zhou and Yijin Xing},
+      year={2024},
+      eprint={2411.01156},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD},
+      url={https://arxiv.org/abs/2411.01156},
+}
+
+@misc{liao2026fishaudios2technical,
+      title={Fish Audio S2 Technical Report}, 
+      author={Shijia Liao and Yuxuan Wang and Songting Liu and Yifan Cheng and Ruoyi Zhang and Tianyu Li and Shidong Li and Yisheng Zheng and Xingwei Liu and Qingzheng Wang and Zhizhuo Zhou and Jiahua Liu and Xin Chen and Dawei Han},
+      year={2026},
+      eprint={2603.08823},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD},
+      url={https://arxiv.org/abs/2603.08823}, 
+}
+```

vendor/fish-speech/docs/en/inference.md

@@ -0,0 +1,98 @@
+# Inference
+
+The Fish Audio S2 model requires a large amount of VRAM. We recommend using a GPU with at least 24GB for inference.
+
+## Download Weights
+
+First, you need to download the model weights:
+
+```bash
+hf download fishaudio/s2-pro --local-dir checkpoints/s2-pro
+```
+
+## Command Line Inference
+
+!!! note
+    If you plan to let the model randomly choose a voice timbre, you can skip this step.
+
+### 1. Get VQ tokens from reference audio
+
+```bash
+python fish_speech/models/dac/inference.py \
+    -i "test.wav" \
+    --checkpoint-path "checkpoints/s2-pro/codec.pth"
+```
+
+You should get a `fake.npy` and a `fake.wav`.
+
+### 2. Generate Semantic tokens from text:
+
+```bash
+python fish_speech/models/text2semantic/inference.py \
+    --text "The text you want to convert" \
+    --prompt-text "Your reference text" \
+    --prompt-tokens "fake.npy" \
+    # --compile
+```
+
+This command will create a `codes_N` file in the working directory, where N is an integer starting from 0.
+
+!!! note
+    You may want to use `--compile` to fuse CUDA kernels for faster inference. However, we recommend using our sglang inference acceleration optimization.
+    Correspondingly, if you do not plan to use acceleration, you can comment out the `--compile` parameter.
+
+!!! info
+    For GPUs that do not support bf16, you may need to use the `--half` parameter.
+
+### 3. Generate vocals from semantic tokens:
+
+```bash
+python fish_speech/models/dac/inference.py \
+    -i "codes_0.npy" \
+```
+
+After that, you will get a `fake.wav` file.
+
+## WebUI Inference
+
+### 1. Gradio WebUI
+
+For compatibility, we still maintain the Gradio WebUI.
+
+```bash
+python tools/run_webui.py # --compile if you need acceleration
+```
+
+### 2. Awesome WebUI
+
+Awesome WebUI is a modernized Web interface built with TypeScript, offering richer features and a better user experience.
+
+**Build WebUI:**
+
+You need to have Node.js and npm installed on your local machine or server.
+
+1. Enter the `awesome_webui` directory:
+   ```bash
+   cd awesome_webui
+   ```
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the WebUI:
+   ```bash
+   npm run build
+   ```
+
+**Start Backend Server:**
+
+After building the WebUI, return to the project root and start the API server:
+
+```bash
+python tools/api_server.py --listen 0.0.0.0:8888 --compile
+```
+
+**Access:**
+
+Once the server is running, you can access it via your browser:
+`http://localhost:8888/ui`

vendor/fish-speech/docs/en/install.md

@@ -0,0 +1,228 @@
+## Requirements
+
+- GPU Memory: 24GB (Inference)
+- System: Linux, WSL
+
+## System Setup
+
+Fish Audio S2 supports multiple installation methods. Choose the one that best fits your development environment.
+
+**Prerequisites**: Install system dependencies for audio processing:
+``` bash
+apt install portaudio19-dev libsox-dev ffmpeg
+```
+
+### Conda
+
+```bash
+conda create -n fish-speech python=3.12
+conda activate fish-speech
+
+# GPU installation (choose your CUDA version: cu126, cu128, cu129)
+pip install -e .[cu129]
+
+# CPU-only installation
+pip install -e .[cpu]
+
+# Default installation (uses PyTorch default index)
+pip install -e .
+
+# If you encounter an error during installation due to pyaudio, consider using the following command:
+# conda install pyaudio
+# Then run pip install -e . again
+```
+
+### UV
+
+UV provides faster dependency resolution and installation:
+
+```bash
+# GPU installation (choose your CUDA version: cu126, cu128, cu129)
+uv sync --python 3.12 --extra cu129
+
+# CPU-only installation
+uv sync --python 3.12 --extra cpu
+```
+### Intel Arc XPU support
+
+For Intel Arc GPU users, install with XPU support:
+
+```bash
+conda create -n fish-speech python=3.12
+conda activate fish-speech
+
+# Install required C++ standard library
+conda install libstdcxx -c conda-forge
+
+# Install PyTorch with Intel XPU support
+pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/xpu
+
+# Install Fish Speech
+pip install -e .
+```
+
+!!! warning
+    The `compile` option is not supported on Windows and macOS. If you want to run with compile, you need to install Triton manually.
+
+
+## Docker Setup
+
+Fish Audio S2 series model provides multiple Docker deployment options to suit different needs. You can use pre-built images from Docker Hub, build locally with Docker Compose, or manually build custom images.
+
+We provide Docker images for both WebUI and API server on both GPU (CUDA126 by default) and CPU. You can use the pre-built images from Docker Hub, build locally with Docker Compose, or manually build custom images. If you want to build locally, follow the instructions below. If you only want to use pre-built images, follow the [inference guide](inference.md).
+
+### Prerequisites
+
+- Docker and Docker Compose installed
+- NVIDIA Docker runtime (for GPU support)
+- At least 24GB GPU memory for CUDA inference
+
+# Use docker compose
+
+For development or customization, you can use Docker Compose to build and run locally:
+
+```bash
+# Clone the repository first
+git clone https://github.com/fishaudio/fish-speech.git
+cd fish-speech
+
+# Start WebUI with CUDA
+docker compose --profile webui up
+
+# Start WebUI with compile optimization
+COMPILE=1 docker compose --profile webui up
+
+# Start API server
+docker compose --profile server up
+
+# Start API server with compile optimization  
+COMPILE=1 docker compose --profile server up
+
+# For CPU-only deployment
+BACKEND=cpu docker compose --profile webui up
+```
+
+#### Environment Variables for Docker Compose
+
+You can customize the deployment using environment variables:
+
+```bash
+# .env file example
+BACKEND=cuda              # or cpu
+COMPILE=1                 # Enable compile optimization
+GRADIO_PORT=7860         # WebUI port
+API_PORT=8080            # API server port
+UV_VERSION=0.8.15        # UV package manager version
+CUDA_VER=12.9.0          # CUDA base image version (e.g. 12.6.0 for older drivers)
+UV_EXTRA=cu129           # PyTorch CUDA variant (cu126, cu128, cu129) — must match CUDA_VER
+```
+
+The command will build the image and run the container. You can access the WebUI at `http://localhost:7860` and the API server at `http://localhost:8080`.
+
+### Manual Docker Build
+
+For advanced users who want to customize the build process:
+
+```bash
+# Build WebUI image with CUDA support
+docker build \
+    --platform linux/amd64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cuda \
+    --build-arg CUDA_VER=12.9.0 \
+    --build-arg UV_EXTRA=cu129 \
+    --target webui \
+    -t fish-speech-webui:cuda .
+
+# Build API server image with CUDA support
+docker build \
+    --platform linux/amd64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cuda \
+    --build-arg CUDA_VER=12.9.0 \
+    --build-arg UV_EXTRA=cu129 \
+    --target server \
+    -t fish-speech-server:cuda .
+
+# Build CPU-only images (supports multi-platform)
+docker build \
+    --platform linux/amd64,linux/arm64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cpu \
+    --target webui \
+    -t fish-speech-webui:cpu .
+
+# Build development image
+docker build \
+    --platform linux/amd64 \
+    -f docker/Dockerfile \
+    --build-arg BACKEND=cuda \
+    --target dev \
+    -t fish-speech-dev:cuda .
+```
+
+#### Build Arguments
+
+- `BACKEND`: `cuda` or `cpu` (default: `cuda`)
+- `CUDA_VER`: CUDA version (default: `12.6.0`)
+- `UV_EXTRA`: UV extra for CUDA (default: `cu126`)
+- `UBUNTU_VER`: Ubuntu version (default: `24.04`)
+- `PY_VER`: Python version (default: `3.12`)
+
+### Volume Mounts
+
+Both methods require mounting these directories:
+
+- `./checkpoints:/app/checkpoints` - Model weights directory
+- `./references:/app/references` - Reference audio files directory
+
+### Environment Variables
+
+- `COMPILE=1` - Enable torch.compile for faster inference (~10x speedup)
+- `GRADIO_SERVER_NAME=0.0.0.0` - WebUI server host
+- `GRADIO_SERVER_PORT=7860` - WebUI server port
+- `API_SERVER_NAME=0.0.0.0` - API server host  
+- `API_SERVER_PORT=8080` - API server port
+
+!!! note
+    The Docker containers expect model weights to be mounted at `/app/checkpoints`. Make sure to download the required model weights before starting the containers.
+
+!!! warning
+    GPU support requires NVIDIA Docker runtime. For CPU-only deployment, remove the `--gpus all` flag and use CPU images.
+
+### AMD ROCm support
+
+Fish Speech runs on AMD GPUs via ROCm. The ROCm image is based on the official `rocm/pytorch` image, which already ships a gfx-tuned PyTorch, so no separate torch install is needed. Verified on RDNA4 (Radeon AI PRO R9700 / gfx1201) with ROCm 7.2.3; RDNA3 (gfx1100/gfx1101) should also work.
+
+**Prerequisites:**
+
+- AMD GPU with ROCm support (RDNA3 / RDNA4)
+- ROCm drivers installed on the host
+- Docker with GPU passthrough (`/dev/kfd` and `/dev/dri`)
+
+**Using Docker Compose:**
+
+```bash
+# WebUI
+docker compose -f compose.rocm.yml --profile webui up --build
+
+# API server
+docker compose -f compose.rocm.yml --profile server up --build
+```
+
+**Manual build and run:**
+
+```bash
+docker build -f docker/Dockerfile.rocm --target webui -t fish-speech-webui:rocm .
+
+docker run \
+    --device=/dev/kfd --device=/dev/dri \
+    --group-add video --group-add render \
+    -e ROCBLAS_USE_HIPBLASLT=0 \
+    -v ./checkpoints:/app/checkpoints \
+    -p 7860:7860 \
+    fish-speech-webui:rocm
+```
+
+!!! note
+    `ROCBLAS_USE_HIPBLASLT=0` is set by default for RDNA4 (gfx1201) stability; RDNA3 users may not need it. Fish Speech uses `scaled_dot_product_attention`, which dispatches to ROCm's AOTriton flash-attention backend automatically — no custom kernel build is required. The first run is slower while MIOpen auto-tunes kernels. `torch.compile` is enabled by default (`COMPILE=1`); set `COMPILE=0` to disable.

vendor/fish-speech/docs/en/server.md

@@ -0,0 +1,80 @@
+# Server
+
+This page covers server-side inference for Fish Audio S2, plus quick links for WebUI inference and Docker deployment.
+
+## API Server Inference
+
+Fish Speech provides an HTTP API server entrypoint at `tools/api_server.py`.
+
+### Start the server locally
+
+```bash
+python tools/api_server.py \
+  --llama-checkpoint-path checkpoints/s2-pro \
+  --decoder-checkpoint-path checkpoints/s2-pro/codec.pth \
+  --listen 0.0.0.0:8080
+```
+
+Common options:
+
+- `--compile`: enable `torch.compile` optimization
+- `--half`: use fp16 mode
+- `--api-key`: require bearer token authentication
+- `--workers`: set worker process count
+
+### Health check
+
+```bash
+curl -X GET http://127.0.0.1:8080/v1/health
+```
+
+Expected response:
+
+```json
+{"status":"ok"}
+```
+
+### Main API endpoint
+
+- `POST /v1/tts` for text-to-speech generation
+- `POST /v1/vqgan/encode` for VQ encode
+- `POST /v1/vqgan/decode` for VQ decode
+
+### Python client example
+
+The base TTS model is selected when the server starts. In the example above, the server is started with the `checkpoints/s2-pro` weights, so every request sent to `http://127.0.0.1:8080/v1/tts` will use **S2-Pro** automatically. There is no separate per-request `model` field in `tools/api_client.py` for local server calls.
+
+```bash
+python tools/api_client.py \
+  --url http://127.0.0.1:8080/v1/tts \
+  --text "Hello from Fish Speech" \
+  --output s2-pro-demo
+```
+
+If you want to select a saved reference voice, use `--reference_id`. This chooses the **voice reference**, not the base TTS model:
+
+```bash
+python tools/api_client.py \
+  --url http://127.0.0.1:8080/v1/tts \
+  --text "Hello from Fish Speech" \
+  --reference_id my-speaker \
+  --output s2-pro-demo
+```
+
+## WebUI Inference
+
+For WebUI usage, see:
+
+- [WebUI Inference](https://speech.fish.audio/inference/#webui-inference)
+
+## Docker
+
+For Docker-based server or WebUI deployment, see:
+
+- [Docker Setup](https://speech.fish.audio/install/#docker-setup)
+
+You can also start the server profile directly with Docker Compose:
+
+```bash
+docker compose --profile server up
+```

vendor/fish-speech/docs/es/finetune.md

@@ -0,0 +1,131 @@
+# Fine-tuning
+
+!!! warning
+Recomendamos encarecidamente no realizar fine-tuning sobre un modelo entrenado con RL. Ajustar un modelo después de RL puede cambiar la distribución del modelo, lo que puede llevar a una degradación del rendimiento.
+
+En la versión actual, solo necesitas hacer fine-tuning de la parte ‘LLAMA’.
+
+## Fine-tuning LLAMA
+
+### 1. Preparar el dataset
+
+```
+.
+├── SPK1
+│   ├── 21.15-26.44.lab
+│   ├── 21.15-26.44.mp3
+│   ├── 27.51-29.98.lab
+│   ├── 27.51-29.98.mp3
+│   ├── 30.1-32.71.lab
+│   └── 30.1-32.71.mp3
+└── SPK2
+    ├── 38.79-40.85.lab
+    └── 38.79-40.85.mp3
+```
+
+Necesitas convertir tu dataset al formato anterior y colocarlo dentro de `data`. El archivo de audio puede tener extensiones `.mp3`, `.wav` o `.flac`, y el archivo de anotación debe tener la extensión `.lab`.
+
+!!! info
+El archivo de anotación `.lab` solo necesita contener la transcripción del audio, sin ningún formato especial. Por ejemplo, si `hi.mp3` dice "Hello, goodbye," entonces el archivo `hi.lab` contendría una única línea de texto: "Hello, goodbye."
+
+!!! warning
+Se recomienda aplicar normalización de loudness al dataset. Puedes usar [fish-audio-preprocess](https://github.com/fishaudio/audio-preprocess) para hacerlo.
+
+````
+```bash
+fap loudness-norm data-raw data --clean
+```
+````
+
+### 2. Extracción por lotes de tokens semánticos
+
+Asegúrate de haber descargado los pesos de VQGAN. Si no, ejecuta el siguiente comando:
+
+```bash
+huggingface-cli download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini
+```
+
+Luego puedes ejecutar el siguiente comando para extraer los tokens semánticos:
+
+```bash
+python tools/vqgan/extract_vq.py data \
+    --num-workers 1 --batch-size 16 \
+    --config-name "modded_dac_vq" \
+    --checkpoint-path "checkpoints/openaudio-s1-mini/codec.pth"
+```
+
+!!! note
+Puedes ajustar `--num-workers` y `--batch-size` para aumentar la velocidad de extracción, pero asegúrate de no exceder el límite de memoria de tu GPU.
+
+Este comando creará archivos `.npy` en el directorio `data`, como se muestra a continuación:
+
+```
+.
+├── SPK1
+│   ├── 21.15-26.44.lab
+│   ├── 21.15-26.44.mp3
+│   ├── 21.15-26.44.npy
+│   ├── 27.51-29.98.lab
+│   ├── 27.51-29.98.mp3
+│   ├── 27.51-29.98.npy
+│   ├── 30.1-32.71.lab
+│   ├── 30.1-32.71.mp3
+│   └── 30.1-32.71.npy
+└── SPK2
+    ├── 38.79-40.85.lab
+    ├── 38.79-40.85.mp3
+    └── 38.79-40.85.npy
+```
+
+### 3. Empaquetar el dataset en protobuf
+
+```bash
+python tools/llama/build_dataset.py \
+    --input "data" \
+    --output "data/protos" \
+    --text-extension .lab \
+    --num-workers 16
+```
+
+Después de que el comando termine de ejecutarse, deberías ver el archivo `protos` en el directorio `data`.
+
+### 4. Finalmente, fine-tuning con LoRA
+
+De manera similar, asegúrate de haber descargado los pesos de `LLAMA`. Si no, ejecuta el siguiente comando:
+
+```bash
+huggingface-cli download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini
+```
+
+Finalmente, puedes comenzar el fine-tuning ejecutando el siguiente comando:
+
+```bash
+python fish_speech/train.py --config-name text2semantic_finetune \
+    project=$project \
+    +lora@model.model.lora_config=r_8_alpha_16
+```
+
+!!! note
+Puedes modificar parámetros de entrenamiento como `batch_size`, `gradient_accumulation_steps`, etc., para ajustarlos a la memoria de tu GPU editando `fish_speech/configs/text2semantic_finetune.yaml`.
+
+!!! note
+Para usuarios de Windows, puedes usar `trainer.strategy.process_group_backend=gloo` para evitar problemas con `nccl`.
+
+Una vez que el entrenamiento esté completo, puedes consultar la sección de [inference](inference.md) para probar tu modelo.
+
+!!! info
+Por defecto, el modelo solo aprenderá los patrones de habla del hablante y no el timbre. Aún necesitas usar prompts para asegurar la estabilidad del timbre.
+Si quieres aprender el timbre, puedes aumentar el número de pasos de entrenamiento, pero esto puede llevar a overfitting.
+
+Después del entrenamiento, necesitas convertir los pesos LoRA a pesos normales antes de realizar inferencia.
+
+```bash
+python tools/llama/merge_lora.py \
+	--lora-config r_8_alpha_16 \
+	--base-weight checkpoints/openaudio-s1-mini \
+	--lora-weight results/$project/checkpoints/step_000000010.ckpt \
+	--output checkpoints/openaudio-s1-mini-yth-lora/
+```
+
+!!! note
+También puedes probar otros checkpoints. Sugerimos usar el checkpoint más temprano que cumpla con tus requisitos, ya que suelen rendir mejor en datos fuera de distribución (OOD).

vendor/fish-speech/docs/es/index.md

@@ -0,0 +1,191 @@
+<div align="center">
+<h1>Fish Speech</h1>
+
+<p><a href="../en/">English</a> | <a href="../zh/">简体中文</a> | <a href="../pt/">Portuguese</a> | <a href="../ja/">日本語</a> | <a href="../ko/">한국어</a> | <a href="../ar/">العربية</a> | <strong>Español</strong></p>
+
+<a href="https://www.producthunt.com/products/fish-speech?embed=true&utm_source=badge-top-post-badge&utm_medium=badge&utm_source=badge-fish&#0045;audio&#0045;s1" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/top-post-badge.svg?post_id=1023740&theme=light&period=daily&t=1761164814710" alt="Fish&#0032;Audio&#0032;S1 - Clonación&#0032;de&#0032;voz&#0032;expresiva&#0032;y&#0032;texto&#0045;a&#0045;voz | Product Hunt" style="width: 250px; height: 54px;" width="250" height="54" /></a> <a href="https://trendshift.io/repositories/7014" target="_blank"> <img src="https://trendshift.io/api/badge/repositories/7014" alt="fishaudio%2Ffish-speech | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/> </a>
+
+</div>
+
+<br>
+
+<div align="center">
+    <img src="https://count.getloli.com/get/@fish-speech?theme=asoul" /><br>
+</div>
+
+<br>
+
+<div align="center">
+    <a target="_blank" href="https://discord.gg/Es5qTB9BcN">
+        <img alt="Discord" src="https://img.shields.io/discord/1214047546020728892?color=%23738ADB&label=Discord&logo=discord&logoColor=white&style=flat-square"/>
+    </a>
+    <a target="_blank" href="https://hub.docker.com/r/fishaudio/fish-speech">
+        <img alt="Docker" src="https://img.shields.io/docker/pulls/fishaudio/fish-speech?style=flat-square&logo=docker"/>
+    </a>
+    <a target="_blank" href="https://pd.qq.com/s/bwxia254o">
+      <img alt="QQ Channel" src="https://img.shields.io/badge/QQ-blue?logo=tencentqq">
+    </a>
+</div>
+
+<div align="center">
+    <a target="_blank" href="https://huggingface.co/fishaudio/s2">
+        <img alt="HuggingFace Model" src="https://img.shields.io/badge/🤗%20-models-orange"/>
+    </a>
+    <a target="_blank" href="https://fish.audio/blog/fish-audio-open-sources-s2/">
+        <img alt="Fish Audio Blog" src="https://img.shields.io/badge/Blog-Fish_Audio_S2-1f7a8c?style=flat-square&logo=readme&logoColor=white"/>
+    </a>
+    <a target="_blank" href="https://github.com/fishaudio/fish-speech/blob/main/FishAudioS2TecReport.pdf">
+        <img alt="Paper | Technical Report" src="https://img.shields.io/badge/Paper-Technical_Report-b31b1b?style=flat-square"/>
+    </a>
+</div>
+
+!!! info "Aviso de Licencia"
+Este código y sus pesos de modelo asociados se publican bajo **FISH AUDIO RESEARCH LICENSE**. Por favor, consulta [LICENSE](https://github.com/fishaudio/fish-speech/blob/main/LICENSE) para más detalles. Tomaremos acciones contra cualquier violación de la licencia.
+
+!!! warning "Aviso Legal"
+No asumimos ninguna responsabilidad por el uso ilegal de este código. Por favor, consulta las leyes locales sobre DMCA y otras leyes relacionadas.
+
+## Inicio Rápido
+
+### Para Humanos
+
+Aquí están los documentos oficiales de Fish Audio S2, sigue las instrucciones para comenzar fácilmente.
+
+* [Instalación](https://speech.fish.audio/install/)
+* [Inferencia por Línea de Comandos](https://speech.fish.audio/inference/#command-line-inference)
+* [Inferencia con WebUI](https://speech.fish.audio/inference/#webui-inference)
+* [Inferencia en Servidor](https://speech.fish.audio/server/)
+* [Configuración con Docker](https://speech.fish.audio/install/#docker-setup)
+
+> [!IMPORTANT]
+> **Para el servidor SGLang, por favor lee [SGLang-Omni README](https://github.com/sgl-project/sglang-omni/blob/main/sglang_omni/models/fishaudio_s2_pro/README.md).**
+
+### Para Agente LLM
+
+```
+Instala y configura Fish-Audio S2 siguiendo las instrucciones aquí: https://speech.fish.audio/install/
+```
+
+## Fish Audio S2
+
+**Mejor sistema de texto a voz entre código abierto y cerrado**
+
+Fish Audio S2 es el modelo más reciente desarrollado por [Fish Audio](https://fish.audio/). Entrenado con más de 10 millones de horas de audio en aproximadamente 50 idiomas, S2 combina alineación mediante aprendizaje por refuerzo con una arquitectura Dual-Autoregresiva para generar voz natural, realista y emocionalmente rica.
+
+S2 soporta control detallado en línea de prosodia y emoción usando etiquetas en lenguaje natural como `[laugh]`, `[whispers]` y `[super happy]`, así como generación nativa multi-hablante y multi-turno.
+
+Visita el [sitio web de Fish Audio](https://fish.audio/) para el playground en vivo. Lee el [blog](https://fish.audio/blog/fish-audio-open-sources-s2/) para más detalles.
+
+### Variantes del Modelo
+
+| Modelo | Tamaño        | Disponibilidad                                         | Descripción                                                                 |
+| ------ | ------------- | ------------------------------------------------------ | --------------------------------------------------------------------------- |
+| S2-Pro | 4B parámetros | [HuggingFace](https://huggingface.co/fishaudio/s2-pro) | Modelo insignia con todas las funcionalidades, máxima calidad y estabilidad |
+
+Más detalles del modelo pueden encontrarse en el [reporte técnico](https://arxiv.org/abs/2411.01156).
+
+## Resultados de Benchmark
+
+| Benchmark                                   | Fish Audio S2                |
+| ------------------------------------------- | ---------------------------- |
+| Seed-TTS Eval — WER (Chino)                 | **0.54%** (mejor global)     |
+| Seed-TTS Eval — WER (Inglés)                | **0.99%** (mejor global)     |
+| Test de Turing de Audio (con instrucción)   | **0.515** media posterior    |
+| EmergentTTS-Eval — Win Rate                 | **81.88%** (más alto global) |
+| Fish Instruction Benchmark — TAR            | **93.3%**                    |
+| Fish Instruction Benchmark — Calidad        | **4.51 / 5.0**               |
+| Multilenguaje (MiniMax Testset) — Mejor WER | **11 de 24** idiomas         |
+| Multilenguaje (MiniMax Testset) — Mejor SIM | **17 de 24** idiomas         |
+
+En Seed-TTS Eval, S2 logra el menor WER entre todos los modelos evaluados incluyendo sistemas cerrados: Qwen3-TTS (0.77/1.24), MiniMax Speech-02 (0.99/1.90), Seed-TTS (1.12/2.25). En el Test de Turing de Audio, 0.515 supera a Seed-TTS (0.417) en un 24% y a MiniMax-Speech (0.387) en un 33%. En EmergentTTS-Eval, S2 obtiene resultados particularmente fuertes en paralingüística (91.61% win rate), preguntas (84.41%) y complejidad sintáctica (83.39%).
+
+## Características Destacadas
+
+<img src="../assets/totalability.png" width=200%>
+
+### Control Fino en Línea mediante Lenguaje Natural
+
+S2 permite control localizado sobre la generación de voz incrustando instrucciones en lenguaje natural directamente en posiciones específicas del texto. En lugar de depender de un conjunto fijo de etiquetas, S2 acepta descripciones libres como `[whisper in small voice]`, `[professional broadcast tone]` o `[pitch up]`, permitiendo control expresivo abierto a nivel de palabra.
+
+### Arquitectura Dual-Autoregresiva
+
+S2 se basa en un transformer solo-decoder combinado con un códec de audio basado en RVQ (10 codebooks, ~21 Hz). La arquitectura Dual-AR divide la generación en dos etapas:
+
+* **AR Lento** opera en el eje temporal y predice el codebook semántico principal.
+* **AR Rápido** genera los 9 codebooks residuales restantes en cada paso temporal, reconstruyendo detalles acústicos finos.
+
+Este diseño asimétrico — 4B parámetros en el eje temporal y 400M en el eje de profundidad — mantiene la inferencia eficiente sin perder fidelidad.
+
+### Alineación con Aprendizaje por Refuerzo
+
+S2 utiliza Group Relative Policy Optimization (GRPO) para alineación post-entrenamiento. Los mismos modelos usados para filtrar y anotar datos se reutilizan como modelos de recompensa durante RL, eliminando desajustes de distribución. La señal de recompensa combina precisión semántica, cumplimiento de instrucciones, preferencia acústica y similitud de timbre.
+
+### Streaming en Producción con SGLang
+
+Debido a que la arquitectura Dual-AR es estructuralmente isomórfica a los LLM autoregresivos estándar, S2 hereda optimizaciones como batching continuo, caché KV paginado, CUDA graph replay y caching de prefijos basado en RadixAttention.
+
+En una sola GPU NVIDIA H200:
+
+* **RTF:** 0.195
+* **Tiempo hasta primer audio:** ~100 ms
+* **Throughput:** 3,000+ tokens acústicos/s manteniendo RTF < 0.5
+
+### Soporte Multilenguaje
+
+S2 soporta texto a voz multilenguaje de alta calidad sin requerir fonemas ni preprocesamiento específico del idioma. Incluye:
+
+**Inglés, Chino, Japonés, Coreano, Árabe, Alemán, Francés...**
+
+**¡Y MÁS!**
+
+La lista continúa expandiéndose, revisa [Fish Audio](https://fish.audio/) para las últimas novedades.
+
+### Generación Multi-Hablante Nativa
+
+<img src="../assets/chattemplate.png" width=200%>
+
+Fish Audio S2 permite a los usuarios subir audio de referencia con múltiples hablantes; el modelo gestionará las características de cada uno mediante el token `<|speaker:i|>`. Luego puedes controlar el comportamiento del modelo con ese identificador, permitiendo múltiples voces en una sola generación. Ya no necesitas subir audio por separado para cada hablante.
+
+### Generación Multi-Turno
+
+Gracias a la expansión del contexto del modelo, ahora puede usar información previa para mejorar la expresividad del contenido generado, aumentando la naturalidad.
+
+### Clonación de Voz Rápida
+
+Fish Audio S2 permite clonación de voz precisa usando una muestra corta (10–30 segundos). El modelo captura timbre, estilo y emoción, produciendo voces realistas y consistentes sin fine-tuning adicional.
+Por favor consulta [SGLang-Omni README](https://github.com/sgl-project/sglang-omni/blob/main/sglang_omni/models/fishaudio_s2_pro/README.md) para usar el servidor SGLang.
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+## Créditos
+
+* [VITS2 (daniilrobnikov)](https://github.com/daniilrobnikov/vits2)
+* [Bert-VITS2](https://github.com/fishaudio/Bert-VITS2)
+* [GPT VITS](https://github.com/innnky/gpt-vits)
+* [MQTTS](https://github.com/b04901014/MQTTS)
+* [GPT Fast](https://github.com/pytorch-labs/gpt-fast)
+* [GPT-SoVITS](https://github.com/RVC-Boss/GPT-SoVITS)
+* [Qwen3](https://github.com/QwenLM/Qwen3)
+
+## Reporte Técnico
+
+```bibtex
+@misc{fish-speech-v1.4,
+      title={Fish-Speech: Leveraging Large Language Models for Advanced Multilingual Text-to-Speech Synthesis},
+      author={Shijia Liao and Yuxuan Wang and Tianyu Li and Yifan Cheng and Ruoyi Zhang and Rongzhi Zhou and Yijin Xing},
+      year={2024},
+      eprint={2411.01156},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD},
+      url={https://arxiv.org/abs/2411.01156},
+}
+
+@misc{liao2026fishaudios2technical,
+      title={Fish Audio S2 Technical Report}, 
+      author={Shijia Liao and Yuxuan Wang and Songting Liu and Yifan Cheng and Ruoyi Zhang and Tianyu Li and Shidong Li and Yisheng Zheng and Xingwei Liu and Qingzheng Wang and Zhizhuo Zhou and Jiahua Liu and Xin Chen and Dawei Han},
+      year={2026},
+      eprint={2603.08823},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD},
+      url={https://arxiv.org/abs/2603.08823}, 
+}
+```

vendor/fish-speech/docs/es/inference.md

@@ -0,0 +1,58 @@
+# Inferencia
+
+El modelo Fish Audio S2 requiere una gran cantidad de VRAM. Recomendamos usar una GPU con al menos 24GB para la inferencia.
+
+## Descargar Pesos
+
+Primero, necesitas descargar los pesos del modelo:
+
+```bash
+hf download fishaudio/s2-pro --local-dir checkpoints/s2-pro
+```
+
+## Inferencia por Línea de Comandos
+
+!!! note
+Si planeas dejar que el modelo elija aleatoriamente el timbre de voz, puedes omitir este paso.
+
+### 1. Obtener tokens VQ a partir de audio de referencia
+
+```bash
+python fish_speech/models/dac/inference.py \
+    -i "test.wav" \
+    --checkpoint-path "checkpoints/s2-pro/codec.pth"
+```
+
+Deberías obtener un `fake.npy` y un `fake.wav`.
+
+### 2. Generar tokens semánticos a partir de texto:
+
+```bash
+python fish_speech/models/text2semantic/inference.py \
+    --text "El texto que quieres convertir" \
+    --prompt-text "Tu texto de referencia" \
+    --prompt-tokens "fake.npy" \
+    # --compile
+```
+
+Este comando creará un archivo `codes_N` en el directorio de trabajo, donde N es un entero que comienza desde 0.
+
+!!! note
+Puede que quieras usar `--compile` para fusionar kernels CUDA y acelerar la inferencia. Sin embargo, recomendamos usar nuestra optimización de aceleración de inferencia con sglang.
+Correspondientemente, si no planeas usar aceleración, puedes comentar el parámetro `--compile`.
+
+!!! info
+Para GPUs que no soportan bf16, puede que necesites usar el parámetro `--half`.
+
+### 3. Generar audio a partir de tokens semánticos:
+
+```bash
+python fish_speech/models/dac/inference.py \
+    -i "codes_0.npy" \
+```
+
+Después de eso, obtendrás un archivo `fake.wav`.
+
+## Inferencia con WebUI
+
+Próximamente.