> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sglang.io/llms.txt
> Use this file to discover all available pages before exploring further.

# FLUX

export const FluxDeployment = () => {
  const config = {
    modelFamily: 'FLUX',
    options: {
      hardware: {
        name: 'hardware',
        title: 'Hardware Platform',
        items: [{
          id: 'b200',
          label: 'B200',
          default: true
        }, {
          id: 'b300',
          label: 'B300',
          default: false
        }, {
          id: 'h200',
          label: 'H200',
          default: false
        }, {
          id: 'h100',
          label: 'H100',
          default: false
        }, {
          id: 'mi355x',
          label: 'MI355X',
          default: false
        }, {
          id: 'mi325x',
          label: 'MI325X',
          default: false
        }, {
          id: 'mi300x',
          label: 'MI300X',
          default: false
        }, {
          id: 'a2',
          label: 'A2',
          default: false
        }, {
          id: 'a3',
          label: 'A3',
          default: false
        }]
      },
      version: {
        name: 'version',
        title: 'Model Version',
        items: [{
          id: 'flux1-dev',
          label: 'FLUX.1-dev',
          subtitle: '12B',
          default: true
        }, {
          id: 'flux2-dev',
          label: 'FLUX.2-dev',
          subtitle: '32B',
          default: false
        }]
      }
    },
    modelConfigs: {
      'flux1-dev': {
        repoId: 'black-forest-labs/FLUX.1-dev'
      },
      'flux2-dev': {
        repoId: 'black-forest-labs/FLUX.2-dev'
      }
    },
    generateCommand: function (values) {
      const {hardware, version} = values;
      const config = this.modelConfigs[version];
      if (hardware === 'a2') {
        if (version === 'flux1-dev') {
          return `sglang serve \\
  --model-path ${config.repoId} \\
  --num-gpus 1`;
        }
        return `sglang serve \\
  --model-path ${config.repoId} \\
  --tp-size 2 \\
  --num-gpus 2`;
      }
      if (hardware === 'a3') {
        return `#One A3 card has 2 npu chips
sglang serve \\
  --tp-size 2 \\
  --model-path ${config.repoId} \\
  --num-gpus 2`;
      }
      return `sglang serve \\
  --model-path ${config.repoId} \\
  --ulysses-degree=1 \\
  --ring-degree=1`;
    }
  };
  if (!config || !config.options) {
    return <div>Error: Invalid configuration provided</div>;
  }
  const getInitialState = () => {
    const initialState = {};
    Object.entries(config.options).forEach(([key, option]) => {
      if (option.type === 'checkbox') {
        initialState[key] = (option.items || []).filter(item => item.default).map(item => item.id);
        return;
      }
      if (option.type === 'text') {
        initialState[key] = option.default || '';
        return;
      }
      let items = option.items || [];
      if (option.getDynamicItems) {
        const defaultValues = {};
        Object.entries(config.options).forEach(([innerKey, innerOption]) => {
          if (innerOption.type === 'checkbox') {
            defaultValues[innerKey] = (innerOption.items || []).filter(item => item.default).map(item => item.id);
          } else if (innerOption.type === 'text') {
            defaultValues[innerKey] = innerOption.default || '';
          } else if (innerOption.items && innerOption.items.length > 0) {
            const defaultItem = innerOption.items.find(item => item.default);
            defaultValues[innerKey] = defaultItem ? defaultItem.id : innerOption.items[0].id;
          }
        });
        items = option.getDynamicItems(defaultValues);
      }
      const defaultItem = items && items.find(item => item.default);
      initialState[key] = defaultItem ? defaultItem.id : items && items[0] ? items[0].id : '';
    });
    return initialState;
  };
  const [values, setValues] = useState(getInitialState);
  const [isDark, setIsDark] = useState(false);
  useEffect(() => {
    const checkDarkMode = () => {
      const html = document.documentElement;
      const isDarkMode = html.classList.contains('dark') || html.getAttribute('data-theme') === 'dark' || html.style.colorScheme === 'dark';
      setIsDark(isDarkMode);
    };
    checkDarkMode();
    const observer = new MutationObserver(checkDarkMode);
    observer.observe(document.documentElement, {
      attributes: true,
      attributeFilter: ['class', 'data-theme', 'style']
    });
    return () => observer.disconnect();
  }, []);
  useEffect(() => {
    const isAscend = values.hardware === 'a2' || values.hardware === 'a3';
    const targetTabName = isAscend ? 'Ascend A3' : 'NVIDIA B200';
    const allTabs = document.querySelectorAll('button, [role="tab"]');
    allTabs.forEach(tab => {
      const text = tab.textContent.trim();
      if (text === targetTabName && tab.getAttribute('aria-selected') !== 'true') {
        tab.click();
      }
    });
  }, [values.hardware]);
  const handleRadioChange = (optionName, value) => {
    setValues(prev => ({
      ...prev,
      [optionName]: value
    }));
  };
  const handleCheckboxChange = (optionName, itemId, isChecked) => {
    setValues(prev => {
      const currentValues = prev[optionName] || [];
      if (isChecked) {
        return {
          ...prev,
          [optionName]: [...currentValues, itemId]
        };
      }
      return {
        ...prev,
        [optionName]: currentValues.filter(id => id !== itemId)
      };
    });
  };
  const handleTextChange = (optionName, value) => {
    setValues(prev => ({
      ...prev,
      [optionName]: value
    }));
  };
  const command = config.generateCommand ? config.generateCommand.call(config, values) : '';
  const containerStyle = {
    maxWidth: '900px',
    margin: '0 auto',
    display: 'flex',
    flexDirection: 'column',
    gap: '4px'
  };
  const cardStyle = {
    padding: '8px 12px',
    border: `1px solid ${isDark ? '#374151' : '#e5e7eb'}`,
    borderLeft: `3px solid ${isDark ? '#E85D4D' : '#D45D44'}`,
    borderRadius: '4px',
    display: 'flex',
    alignItems: 'center',
    gap: '12px',
    background: isDark ? '#1f2937' : '#fff'
  };
  const titleStyle = {
    fontSize: '13px',
    fontWeight: '600',
    minWidth: '140px',
    flexShrink: 0,
    color: isDark ? '#e5e7eb' : 'inherit'
  };
  const itemsStyle = {
    display: 'flex',
    rowGap: '2px',
    columnGap: '6px',
    flexWrap: 'wrap',
    alignItems: 'center',
    flex: 1
  };
  const labelBaseStyle = {
    padding: '4px 10px',
    border: `1px solid ${isDark ? '#9ca3af' : '#d1d5db'}`,
    borderRadius: '3px',
    cursor: 'pointer',
    display: 'inline-flex',
    flexDirection: 'column',
    alignItems: 'center',
    justifyContent: 'center',
    fontWeight: '500',
    fontSize: '13px',
    transition: 'all 0.2s',
    userSelect: 'none',
    minWidth: '45px',
    textAlign: 'center',
    flex: 1,
    background: isDark ? '#374151' : '#fff',
    color: isDark ? '#e5e7eb' : 'inherit'
  };
  const checkedStyle = {
    background: '#D45D44',
    color: 'white',
    borderColor: '#D45D44'
  };
  const disabledStyle = {
    cursor: 'not-allowed',
    opacity: 0.5
  };
  const subtitleStyle = {
    display: 'block',
    fontSize: '9px',
    marginTop: '1px',
    lineHeight: '1.1',
    opacity: 0.7
  };
  const textInputStyle = {
    flex: 1,
    padding: '8px 10px',
    borderRadius: '4px',
    border: `1px solid ${isDark ? '#4b5563' : '#d1d5db'}`,
    background: isDark ? '#111827' : '#fff',
    color: isDark ? '#e5e7eb' : '#111827',
    fontSize: '13px'
  };
  const commandDisplayStyle = {
    flex: 1,
    padding: '12px 16px',
    background: isDark ? '#111827' : '#f5f5f5',
    borderRadius: '6px',
    fontFamily: "'Menlo', 'Monaco', 'Courier New', monospace",
    fontSize: '12px',
    lineHeight: '1.5',
    color: isDark ? '#e5e7eb' : '#374151',
    whiteSpace: 'pre-wrap',
    overflowX: 'auto',
    margin: 0,
    border: `1px solid ${isDark ? '#374151' : '#e5e7eb'}`
  };
  return <div style={containerStyle} className="not-prose">
      {Object.entries(config.options).map(([key, option]) => {
    if (option.condition && !option.condition(values)) {
      return null;
    }
    const items = option.getDynamicItems ? option.getDynamicItems(values) : option.items || [];
    return <div key={key} style={cardStyle}>
            <div style={titleStyle}>{option.title}</div>
            <div style={itemsStyle}>
              {option.type === 'text' ? <input type="text" value={values[option.name] || ''} placeholder={option.placeholder || ''} onChange={event => handleTextChange(option.name, event.target.value)} style={textInputStyle} /> : option.type === 'checkbox' ? (option.items || []).map(item => {
      const isChecked = (values[option.name] || []).includes(item.id);
      const isDisabled = item.required || typeof item.disabledWhen === 'function' && item.disabledWhen(values);
      return <label key={item.id} title={item.disabledReason || ''} style={{
        ...labelBaseStyle,
        ...isChecked ? checkedStyle : {},
        ...isDisabled ? disabledStyle : {}
      }}>
                      <input type="checkbox" checked={isChecked} disabled={isDisabled} onChange={event => handleCheckboxChange(option.name, item.id, event.target.checked)} style={{
        display: 'none'
      }} />
                      {item.label}
                      {item.subtitle && <small style={{
        ...subtitleStyle,
        color: isChecked ? 'rgba(255,255,255,0.85)' : 'inherit'
      }}>
                          {item.subtitle}
                        </small>}
                    </label>;
    }) : items.map(item => {
      const isChecked = values[option.name] === item.id;
      const isDisabled = Boolean(item.disabled);
      return <label key={item.id} title={item.disabledReason || ''} style={{
        ...labelBaseStyle,
        ...isChecked ? checkedStyle : {},
        ...isDisabled ? disabledStyle : {}
      }}>
                      <input type="radio" name={option.name} value={item.id} checked={isChecked} disabled={isDisabled} onChange={() => !isDisabled && handleRadioChange(option.name, item.id)} style={{
        display: 'none'
      }} />
                      {item.label}
                      {item.subtitle && <small style={{
        ...subtitleStyle,
        color: isChecked ? 'rgba(255,255,255,0.85)' : 'inherit'
      }}>
                          {item.subtitle}
                        </small>}
                    </label>;
    })}
            </div>
          </div>;
  })}

      <div style={cardStyle}>
        <div style={titleStyle}>Run this Command:</div>
        <pre style={commandDisplayStyle}>{command}</pre>
      </div>
    </div>;
};

export const DiffusionModelTags = ({tags = []}) => {
  const normalizedTags = Array.isArray(tags) ? tags : [tags];
  return <div className="not-prose sgd-model-tags">
      {normalizedTags.map(tag => <span key={tag} className="sgd-chip">
          {tag}
        </span>)}
    </div>;
};

<DiffusionModelTags tags={["image", "text-to-image", "image editing", "multi-reference"]} />

## 1. Model Introduction

[FLUX](https://blackforestlabs.ai/) is a family of rectified flow transformer models developed by Black Forest Labs for high-quality image generation from text descriptions.

[FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev) is a 12 billion parameter rectified flow transformer capable of generating images from text descriptions.

**Key Features:**

* **Cutting-edge Output Quality**: Second only to the state-of-the-art FLUX.1 \[pro] model
* **Competitive Prompt Following**: Matches the performance of closed-source alternatives
* **Guidance Distillation**: Trained using guidance distillation for improved efficiency
* **Open Weights**: Available for personal, scientific, and commercial purposes under the FLUX \[dev] Non-Commercial License

[FLUX.2-dev](https://huggingface.co/black-forest-labs/FLUX.2-dev) is a 32 billion parameter rectified flow transformer capable of generating, editing, and combining images based on text instructions.

**Key Features:**

* **State-of-the-art Performance**: Leading open model in text-to-image generation, single-reference editing, and multi-reference editing
* **No Finetuning Required**: Character, object, and style reference without additional training in one model
* **Guidance Distillation**: Trained using guidance distillation for improved efficiency
* **Open Weights**: Available for personal, scientific, and commercial purposes under the FLUX \[dev] Non-Commercial License

For more details, please refer to the [FLUX.1-dev HuggingFace page](https://huggingface.co/black-forest-labs/FLUX.1-dev), [FLUX.2-dev HuggingFace page](https://huggingface.co/black-forest-labs/FLUX.2-dev), and the [official blog post](https://blackforestlabs.ai/announcing-black-forest-labs/).

## 2. SGLang-diffusion Installation

SGLang-diffusion offers multiple installation methods. You can choose the most suitable installation method based on your hardware platform and requirements.

Please refer to the [official SGLang-diffusion installation guide](https://docs.sglang.io/docs/sglang-diffusion/installation) for installation instructions.

## 3. Model Deployment

This section provides deployment configurations optimized for different hardware platforms and use cases.

### 3.1 Basic Configuration

FLUX models are optimized for high-quality image generation. The recommended launch configurations vary by hardware and model version.

**Interactive Command Generator**: Use the configuration selector below to automatically generate the appropriate deployment command for your hardware platform and model version. SGLang supports serving FLUX on NVIDIA B200, H200, H100, and AMD MI355X, MI325X, MI300X GPUs and Ascend A2, A3 NPUs.

<FluxDeployment />

### 3.2 Configuration Tips

Currently supported optimizations are listed [here](/docs/sglang-diffusion/compatibility_matrix).

* `--vae-path`: Path to a custom VAE model or HuggingFace model ID (e.g., fal/FLUX.2-Tiny-AutoEncoder). If not specified, the VAE will be loaded from the main model path.
* `--num-gpus`: Number of GPUs to use
* `--tp-size`: Tensor parallelism size (only for the encoder; should not be larger than 1 if text encoder offload is enabled, as layer-wise offload plus prefetch is faster)
* `--sp-degree`: Sequence parallelism size (typically should match the number of GPUs)
* `--ulysses-degree`: The degree of DeepSpeed-Ulysses-style SP in USP
* `--ring-degree`: The degree of ring attention-style SP in USP

## 4. API Usage

For complete API documentation, please refer to the [official API usage guide](/docs/sglang-diffusion/api/openai_api).

### 4.1 Generate an Image

```python Example theme={null}
import base64
from openai import OpenAI

client = OpenAI(api_key="EMPTY", base_url="http://localhost:3000/v1")

response = client.images.generate(
    model="black-forest-labs/FLUX.1-dev",
    prompt="A cat holding a sign that says hello world",
    size="1024x1024",
    n=1,
    response_format="b64_json",
)

# Save the generated image
image_bytes = base64.b64decode(response.data[0].b64_json)
with open("output.png", "wb") as f:
    f.write(image_bytes)
```

### 4.2 Advanced Usage

#### 4.2.1 Cache-DiT Acceleration

SGLang integrates [Cache-DiT](https://github.com/vipshop/cache-dit), a caching acceleration engine for Diffusion Transformers (DiT), to achieve up to 7.4x inference speedup with minimal quality loss. You can set `SGLANG_CACHE_DIT_ENABLED=True` to enable it. For more details, please refer to the SGLang Cache-DiT [documentation](/docs/sglang-diffusion/cache_dit).

**Basic Usage**

```bash Command theme={null}
SGLANG_CACHE_DIT_ENABLED=true sglang serve --model-path black-forest-labs/FLUX.1-dev
```

**Advanced Usage**

* DBCache Parameters: DBCache controls block-level caching behavior:

<table style={{width: "100%", borderCollapse: "collapse", tableLayout: "fixed"}}>
  <colgroup>
    <col style={{width: "25.0%"}} />

    <col style={{width: "25.0%"}} />

    <col style={{width: "25.0%"}} />

    <col style={{width: "25.0%"}} />
  </colgroup>

  <thead>
    <tr style={{borderBottom: "2px solid #d55816"}}>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.02)"}}>Parameter</th>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.05)"}}>Env Variable</th>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.02)"}}>Default</th>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.05)"}}>Description</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>Fn</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_FN`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>1</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Number of first blocks to always compute</td>
    </tr>

    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>Bn</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_BN`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>0</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Number of last blocks to always compute</td>
    </tr>

    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>W</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_WARMUP`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>4</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Warmup steps before caching starts</td>
    </tr>

    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>R</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_RDT`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>0.24</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Residual difference threshold</td>
    </tr>

    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>MC</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_MC`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>3</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Maximum continuous cached steps</td>
    </tr>
  </tbody>
</table>

* TaylorSeer Configuration: TaylorSeer improves caching accuracy using Taylor expansion:

<table style={{width: "100%", borderCollapse: "collapse", tableLayout: "fixed"}}>
  <colgroup>
    <col style={{width: "25.0%"}} />

    <col style={{width: "25.0%"}} />

    <col style={{width: "25.0%"}} />

    <col style={{width: "25.0%"}} />
  </colgroup>

  <thead>
    <tr style={{borderBottom: "2px solid #d55816"}}>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.02)"}}>Parameter</th>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.05)"}}>Env Variable</th>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.02)"}}>Default</th>
      <th style={{textAlign: "left", padding: "10px 12px", fontWeight: 700, whiteSpace: "nowrap", backgroundColor: "rgba(255,255,255,0.05)"}}>Description</th>
    </tr>
  </thead>

  <tbody>
    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>Enable</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_TAYLORSEER`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>false</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Enable TaylorSeer calibrator</td>
    </tr>

    <tr>
      <td style={{padding: "9px 12px", fontWeight: 500, backgroundColor: "rgba(255,255,255,0.02)"}}>Order</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>`SGLANG_CACHE_DIT_TS_ORDER`</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.02)"}}>1</td>
      <td style={{padding: "9px 12px", backgroundColor: "rgba(255,255,255,0.05)"}}>Taylor expansion order (1 or 2)</td>
    </tr>
  </tbody>
</table>

Combined Configuration Example:

```bash Command theme={null}
SGLANG_CACHE_DIT_ENABLED=true \
SGLANG_CACHE_DIT_FN=2 \
SGLANG_CACHE_DIT_BN=1 \
SGLANG_CACHE_DIT_WARMUP=4 \
SGLANG_CACHE_DIT_RDT=0.4 \
SGLANG_CACHE_DIT_MC=4 \
SGLANG_CACHE_DIT_TAYLORSEER=true \
SGLANG_CACHE_DIT_TS_ORDER=2 \
sglang serve --model-path black-forest-labs/FLUX.1-dev
```

#### 4.2.2 CPU Offload

* `--dit-cpu-offload`: Use CPU offload for DiT inference. Enable if run out of memory.
* `--text-encoder-cpu-offload`: Use CPU offload for text encoder inference.
* `--vae-cpu-offload`: Use CPU offload for VAE.
* `--pin-cpu-memory`: Pin memory for CPU offload. Only added as a temp workaround if it throws "CUDA error: invalid argument".

## 5. Benchmark

### 5.1 Speedup Benchmark

#### 5.1.1 Generate a image

Test Environment:

* Hardware: NVIDIA B200 GPU (1x)
* Model: black-forest-labs/FLUX.1-dev
* sglang diffusion version: 0.5.6.post2

<Tabs>
  <Tab title="NVIDIA B200">
    **Server Command**:

    ```shell Command theme={null}
    sglang serve --model-path black-forest-labs/FLUX.1-dev --port 30000
    ```

    **Benchmark Command**:

    ```shell Command theme={null}
    python3 -m sglang.multimodal_gen.benchmarks.bench_serving \
        --backend sglang-video --dataset vbench --task t2v --num-prompts 1 --max-concurrency 1
    ```

    **Result**:

    ```text Output theme={null}
    ================= Serving Benchmark Result =================
    Backend:                                 sglang-image
    Model:                                   black-forest-labs/FLUX.1-dev
    Dataset:                                 vbench
    Task:                                    t2v
    --------------------------------------------------
    Benchmark duration (s):                  50.97
    Request rate:                            inf
    Max request concurrency:                 1
    Successful requests:                     1/1
    --------------------------------------------------
    Request throughput (req/s):              0.02
    Latency Mean (s):                        50.9681
    Latency Median (s):                      50.9681
    Latency P99 (s):                         50.9681
    --------------------------------------------------
    Peak Memory Max (MB):                    27905.19
    Peak Memory Mean (MB):                   27905.19
    Peak Memory Median (MB):                 27905.19
    ============================================================
    ```
  </Tab>

  <Tab title="Ascend A3">
    **Server Command**:

    ```shell Command theme={null}
    #One A3 card has 2 npu chips
    sglang serve --tp-size 2 --sp-degree 1 --model-path black-forest-labs/FLUX.1-dev --num-gpus 2
    ```

    **Benchmark Command**:

    ```shell Command theme={null}
    python -m sglang.multimodal_gen.benchmarks.bench_serving --dataset vbench --task text-to-image --num-prompts 1 --max-concurrency 1
    ```

    **Result**:

    ```text Output theme={null}
    ================= Serving Benchmark Result =================
    Task:                                         text-to-image
    Model:                                        black-forest-labs/FLUX.1-dev
    Dataset:                                      vbench
    --------------------------------------------------
    Benchmark duration (s):                       16.30
    Request rate:                                 inf
    Max request concurrency:                      1
    Successful requests:                          1/1
    Completed outputs:                            1
    Outputs per prompt:                           1
    --------------------------------------------------
    Request throughput (req/s):                   0.06
    Output throughput (outputs/s):                0.06
    Latency Mean (s):                             16.30
    Latency Median (s):                           16.30
    Latency P90 (s):                              16.30
    Latency P95 (s):                              16.30
    Latency P99 (s):                              16.30
    --------------------------------------------------
    Peak Memory Max (MB):                         19972.00
    Peak Memory Mean (MB):                        19972.00
    Peak Memory Median (MB):                      19972.00
    ------------------------------------------------------------
    ```
  </Tab>
</Tabs>

#### 5.1.2 Generate images with high concurrency

<Tabs>
  <Tab title="NVIDIA B200">
    **Server Command** :

    ```shell Command theme={null}
    sglang serve --model-path black-forest-labs/FLUX.1-dev --port 30000
    ```

    **Benchmark Command** :

    ```shell Command theme={null}
    python3 -m sglang.multimodal_gen.benchmarks.bench_serving \
        --backend sglang-image --dataset vbench --task t2v --num-prompts 20 --max-concurrency 20
    ```

    **Result** :

    ```text Output theme={null}
    ================= Serving Benchmark Result =================
    Backend:                                 sglang-image
    Model:                                   black-forest-labs/FLUX.1-dev
    Dataset:                                 vbench
    Task:                                    t2v
    --------------------------------------------------
    Benchmark duration (s):                  111.79
    Request rate:                            inf
    Max request concurrency:                 20
    Successful requests:                     20/20
    --------------------------------------------------
    Request throughput (req/s):              0.18
    Latency Mean (s):                        67.0646
    Latency Median (s):                      66.9691
    Latency P99 (s):                         110.8949
    --------------------------------------------------
    Peak Memory Max (MB):                    27917.19
    Peak Memory Mean (MB):                   27916.59
    Peak Memory Median (MB):                 27917.19
    ============================================================
    ```
  </Tab>

  <Tab title="Ascend A3">
    **Server Command** :

    ```shell Command theme={null}
    #One A3 card has 2 npu chips
    sglang serve --tp-size 2 --sp-degree 1 --model-path black-forest-labs/FLUX.1-dev --num-gpus 2
    ```

    **Benchmark Command** :

    ```shell Command theme={null}
    python -m sglang.multimodal_gen.benchmarks.bench_serving --dataset vbench --task text-to-image --num-prompts 20 --max-concurrency 20
    ```

    **Result** :

    ```text Output theme={null}
    ================= Serving Benchmark Result =================
    Task:                                         text-to-image
    Model:                                        black-forest-labs/FLUX.1-dev
    Dataset:                                      vbench
    --------------------------------------------------
    Benchmark duration (s):                       300.85
    Request rate:                                 inf
    Max request concurrency:                      20
    Successful requests:                          18/20
    Completed outputs:                            18
    Outputs per prompt:                           1
    --------------------------------------------------
    Request throughput (req/s):                   0.06
    Output throughput (outputs/s):                0.06
    Latency Mean (s):                             155.16
    Latency Median (s):                           155.11
    Latency P90 (s):                              266.30
    Latency P95 (s):                              280.15
    Latency P99 (s):                              291.23
    --------------------------------------------------
    Peak Memory Max (MB):                         19972.00
    Peak Memory Mean (MB):                        19972.00
    Peak Memory Median (MB):                      19972.00
    ------------------------------------------------------------
    ```
  </Tab>
</Tabs>