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

# Developer Glossary

> Key terms for Livepeer developers – SDKs, APIs, AI pipelines, streaming protocols, and integration concepts.

export const LinkIcon = ({href, target = '_blank', rel = 'noopener noreferrer', style = {}, className = '', icon = 'arrow-up-right-from-square', size = 12, ...iconProps}) => {
  return <a href={href} target={target} rel={rel} className={className} style={{
    borderBottom: 'none',
    textDecoration: 'none',
    ...style
  }}>
      <Icon icon={icon} size={size} {...iconProps} />
    </a>;
};

export const CopyText = ({text, label, className = '', style = {}, ...rest}) => {
  const handleCopy = () => {
    navigator.clipboard.writeText(text);
  };
  return <span className={className} style={{
    display: 'flex',
    alignItems: 'center',
    padding: '0.2rem 0.4rem',
    borderRadius: "4px",
    fontSize: '0.85rem',
    fontFamily: 'monospace',
    backgroundColor: 'var(--lp-color-bg-card)',
    border: '1px solid var(--lp-color-border-default)',
    minWidth: 0,
    overflow: 'hidden',
    ...style
  }} {...rest}>
      {label && <strong style={{
    flexShrink: 0,
    marginRight: "var(--lp-spacing-2)"
  }}>{label}</strong>}
      <span style={{
    overflow: 'hidden',
    textOverflow: 'ellipsis',
    whiteSpace: 'nowrap',
    flex: 1,
    minWidth: 0
  }}>
        {text}
      </span>
      <button onClick={handleCopy} style={{
    background: 'none',
    border: 'none',
    cursor: 'pointer',
    padding: '0 0 0 0.4rem',
    display: 'inline-flex',
    alignItems: 'center',
    color: 'var(--lp-color-text-secondary)',
    flexShrink: 0
  }} title="Copy to clipboard">
        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
          <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
          <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
        </svg>
      </button>
    </span>;
};

export const glossaryBadges = [{
  color: 'blue',
  label: 'Video'
}, {
  color: 'purple',
  label: 'AI'
}, {
  color: 'green',
  label: 'Livepeer'
}, {
  color: 'yellow',
  label: 'Technical'
}];

export const LazyLoad = ({children, height = "200px", offset = "200px", fadeDuration = 400, className = "", style = {}, ...rest}) => {
  const ref = useRef(null);
  const [visible, setVisible] = useState(false);
  const [ready, setReady] = useState(false);
  useEffect(() => {
    const el = ref.current;
    if (!el) return;
    const observer = new IntersectionObserver(([entry]) => {
      if (entry.isIntersecting) {
        setVisible(true);
        observer.disconnect();
      }
    }, {
      rootMargin: offset
    });
    observer.observe(el);
    return () => observer.disconnect();
  }, []);
  useEffect(() => {
    if (!visible) return;
    const frameId = requestAnimationFrame(() => {
      setReady(true);
    });
    return () => cancelAnimationFrame(frameId);
  }, [visible]);
  const placeholder = <div ref={ref} className={className} style={{
    minHeight: height,
    ...style
  }} {...rest} />;
  if (!visible) return placeholder;
  return <div ref={ref} className={className} style={{
    opacity: ready ? 1 : 0,
    transition: `opacity ${fadeDuration}ms ease-in`,
    ...style
  }} {...rest}>
      {children}
    </div>;
};

export const CustomDivider = ({color = "var(--lp-color-border-default)", middleText = "", spacing = "default", style = {}, className = "", ...rest}) => {
  const spacingPresets = {
    default: {
      margin: "24px 0"
    },
    overlap: {
      margin: "-1rem 0 -1rem 0"
    },
    tight: {
      margin: "0 0 -1rem 0"
    },
    section: {
      margin: "0 0 -2rem 0"
    },
    sectionOverlap: {
      margin: "-1rem 0 -2rem 0"
    },
    deepOverlap: {
      margin: "-1rem 0 -1.5rem 0"
    }
  };
  const spacingStyle = spacingPresets[spacing] || spacingPresets.default;
  return <div role="separator" aria-orientation="horizontal" className={className} style={{
    display: "flex",
    alignItems: "center",
    ...spacingStyle,
    fontSize: style?.fontSize || "16px",
    height: "fit-content",
    ...style
  }} {...rest}>
      <span style={{
    marginRight: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
      </span>
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      {middleText && <>
          <Icon icon="circle" size={2} />
          <span style={{
    margin: "0 8px",
    fontWeight: "bold",
    color: color,
    opacity: 0.7
  }}>
            {middleText}
          </span>
          <Icon icon="circle" size={2} />
        </>}
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      <span style={{
    marginLeft: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <span style={{
    display: "inline-block",
    transform: "scaleX(-1)"
  }}>
          <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
        </span>
      </span>
    </div>;
};

export const DynamicTable = ({tableTitle = null, headerList = [], itemsList = [], monospaceColumns = [], columnWidths = {}, contentFitColumns = [], showSeparators = false, margin, className = "", style = {}, ...rest}) => {
  if (!headerList.length) {
    return <div>No headers provided</div>;
  }
  const safeContentFitColumns = Array.isArray(contentFitColumns) ? contentFitColumns : [];
  const usesContentFitColumns = safeContentFitColumns.length > 0;
  const isContentFitColumn = header => safeContentFitColumns.includes(header);
  const getColumnStyle = header => {
    const widthStyle = columnWidths[header] ? {
      width: columnWidths[header],
      minWidth: columnWidths[header],
      maxWidth: columnWidths[header]
    } : {};
    const contentFitStyle = !columnWidths[header] && isContentFitColumn(header) ? {
      width: "1%",
      whiteSpace: "nowrap"
    } : {};
    return {
      ...contentFitStyle,
      ...widthStyle
    };
  };
  return <div className={className} style={style} {...rest}>
      {tableTitle && <div style={{
    fontStyle: "italic",
    margin: 0
  }}>
          <strong>{tableTitle}</strong>
        </div>}
      <div style={{
    overflowX: "auto",
    ...margin != null && ({
      margin
    })
  }} role="region" tabIndex={0} aria-label={tableTitle ? `Scrollable table: ${tableTitle}` : "Scrollable table"}>
        <table data-docs-dynamic-table style={{
    width: "100%",
    tableLayout: usesContentFitColumns ? "auto" : "fixed",
    borderCollapse: "collapse",
    fontSize: "0.9rem",
    marginTop: 0
  }}>
          <thead>
            <tr style={{
    backgroundColor: "var(--lp-color-accent)",
    color: "var(--lp-color-on-accent)",
    borderBottom: "1px solid var(--lp-color-border-default)"
  }}>
              {headerList.map((header, index) => <th key={index} style={{
    padding: "10px 8px",
    textAlign: "left",
    fontWeight: "600",
    color: "var(--lp-color-on-accent)",
    ...getColumnStyle(header)
  }}>
                  {header}
                </th>)}
            </tr>
          </thead>
          <tbody>
            {itemsList.filter(item => showSeparators || !item?.__separator).map((item, rowIndex) => item?.__separator ? <tr key={rowIndex} style={{
    backgroundColor: "var(--lp-color-accent)",
    color: "var(--lp-color-on-accent)",
    borderBottom: "1px solid var(--lp-color-accent)"
  }}>
                  <td colSpan={headerList.length} style={{
    padding: "6px 8px",
    fontWeight: "700",
    color: "var(--lp-color-on-accent)",
    letterSpacing: "0.01em"
  }}>
                    {(item[headerList[0]] ?? item.Category) ?? "Category"}
                  </td>
                </tr> : <tr key={rowIndex} style={{
    borderBottom: "1px solid var(--lp-color-border-default)"
  }}>
                  {headerList.map((header, colIndex) => {
    const value = (item[header] ?? item[header.toLowerCase()]) ?? "-";
    const isMonospace = monospaceColumns.includes(colIndex);
    return <td key={colIndex} style={{
      padding: "8px 8px",
      fontFamily: isMonospace ? "monospace" : "inherit",
      wordWrap: "break-word",
      overflowWrap: "break-word",
      ...getColumnStyle(header)
    }}>
                        {isMonospace ? <code>{value}</code> : value}
                      </td>;
  })}
                </tr>)}
          </tbody>
        </table>
      </div>
    </div>;
};

export const SearchTable = ({TableComponent = null, tableTitle = null, headerList = [], itemsList = [], monospaceColumns = [], margin, searchPlaceholder = 'Search...', searchColumns = [], categoryColumn = 'Category', filterColumns = [], columnWidths = {}, contentFitColumns = [], columnVariant = {}, categoryBadges = [], textIcons = [], showSeparators = false, separatorColumn = null, boldFirstColumn = true, className = '', style = {}}) => {
  const allFilterCols = [categoryColumn, ...filterColumns];
  const [query, setQuery] = useState('');
  const [selections, setSelections] = useState(() => {
    const init = {};
    allFilterCols.forEach(col => {
      init[col] = 'All';
    });
    return init;
  });
  const safeHeaderList = Array.isArray(headerList) ? headerList : [];
  const safeItemsList = Array.isArray(itemsList) ? itemsList : [];
  const safeMonospaceColumns = Array.isArray(monospaceColumns) ? monospaceColumns : [];
  const safeSearchColumns = Array.isArray(searchColumns) ? searchColumns : [];
  const activeColumns = safeSearchColumns.length ? safeSearchColumns : safeHeaderList;
  const normalizedQuery = query.trim().toLowerCase();
  const badgeColorMap = {};
  categoryBadges.forEach(b => {
    badgeColorMap[b.label.toLowerCase()] = b.color;
  });
  const textIconMap = {};
  textIcons.forEach(t => {
    textIconMap[t.label.toLowerCase()] = t.icon;
  });
  const getOptionsForColumn = (colName, colIndex) => {
    let scoped = safeItemsList;
    for (let i = 0; i < colIndex; i++) {
      const prevCol = allFilterCols[i];
      const prevSel = selections[prevCol];
      if (prevSel !== 'All') {
        scoped = scoped.filter(item => String(item?.[prevCol] || '') === prevSel);
      }
    }
    return [...new Set(scoped.map(item => String(item?.[colName] || '')).filter(Boolean))].sort((a, b) => a.localeCompare(b, 'en', {
      sensitivity: 'base'
    }));
  };
  const filteredItems = safeItemsList.filter(item => allFilterCols.every(col => {
    const sel = selections[col];
    return sel === 'All' || String(item?.[col] || '') === sel;
  }));
  const searchedItems = !normalizedQuery ? filteredItems : filteredItems.filter(item => activeColumns.some(column => {
    const value = (item?.[column] ?? item?.[String(column).toLowerCase()]) ?? '';
    return String(value).toLowerCase().includes(normalizedQuery);
  }));
  const sortedItems = [...searchedItems].sort((a, b) => {
    for (const col of allFilterCols) {
      const cmp = String(a[col] || '').localeCompare(String(b[col] || ''), 'en', {
        sensitivity: 'base'
      });
      if (cmp !== 0) return cmp;
    }
    return 0;
  });
  const firstColumnName = safeHeaderList[0];
  const renderVariant = (value, variant, item, header) => {
    if (variant === 'bold' && typeof value === 'string') {
      return <strong>{value}</strong>;
    }
    if (variant === 'badge' && typeof value === 'string') {
      const colorName = badgeColorMap[value.toLowerCase()];
      if (colorName) {
        return <Badge color={colorName}>{value}</Badge>;
      }
    }
    if (variant === 'textIcon' && typeof value === 'string') {
      const icon = textIconMap[value.toLowerCase()];
      if (icon) {
        return <span style={{
          display: 'inline-flex',
          alignItems: 'center',
          gap: '0.35rem'
        }}>
            {icon} {value}
          </span>;
      }
    }
    if (variant === 'addressWrapper' && typeof value === 'string') {
      const href = item?.[`_${header}Href`] ?? item?._addressHref;
      return <div style={{
        display: 'flex',
        alignItems: 'center',
        gap: '0.35rem',
        width: '100%',
        minWidth: 0
      }}>
          <CopyText text={value} style={{
        flex: 1
      }} />
          {href && <LinkIcon href={href} color="var(--lp-color-accent)" />}
        </div>;
    }
    return value;
  };
  const displayItems = sortedItems.map(item => {
    const out = {
      ...item,
      _sepKey: String(item[separatorColumn || categoryColumn] || '')
    };
    for (const header of safeHeaderList) {
      if (columnVariant[header] && out[header] !== undefined) {
        out[header] = renderVariant(out[header], columnVariant[header], item, header);
      }
    }
    if (boldFirstColumn && firstColumnName && !columnVariant[firstColumnName] && typeof out[firstColumnName] === 'string') {
      out[firstColumnName] = <strong>{out[firstColumnName]}</strong>;
    }
    return out;
  });
  const withSeparators = [];
  let lastSep = '';
  displayItems.forEach(item => {
    const sepKey = item._sepKey || '';
    if (showSeparators && sepKey && sepKey !== lastSep) {
      withSeparators.push({
        __separator: true,
        [safeHeaderList[0]]: sepKey.toUpperCase()
      });
      lastSep = sepKey;
    }
    withSeparators.push(item);
  });
  const selectStyle = {
    minWidth: '150px',
    padding: '8px 12px',
    borderRadius: '8px',
    border: '1px solid var(--lp-color-border-default)',
    background: 'var(--lp-color-bg-page)',
    color: 'var(--lp-color-text-secondary)'
  };
  const updateSelection = (col, colIndex, value) => {
    const next = {
      ...selections,
      [col]: value
    };
    for (let i = colIndex + 1; i < allFilterCols.length; i++) {
      next[allFilterCols[i]] = 'All';
    }
    setSelections(next);
  };
  return <div className={className} style={style}>
      <div style={{
    marginBottom: "var(--lp-spacing-2)",
    display: 'flex',
    flexWrap: 'wrap',
    gap: "var(--lp-spacing-2)",
    alignItems: 'center'
  }}>
        <input type="text" value={query} placeholder={searchPlaceholder} onChange={e => setQuery(e.target.value)} aria-label="Filter table rows" style={{
    width: '100%',
    maxWidth: '420px',
    padding: '8px 12px',
    borderRadius: '8px',
    border: '1px solid var(--lp-color-border-default)',
    background: 'var(--lp-color-bg-page)',
    color: 'var(--lp-color-text-secondary)'
  }} />
        {allFilterCols.map((col, colIndex) => {
    const options = getOptionsForColumn(col, colIndex);
    if (options.length === 0) return null;
    const parentLabel = colIndex > 0 && selections[allFilterCols[colIndex - 1]] !== 'All' ? selections[allFilterCols[colIndex - 1]] : col.toLowerCase() + 's';
    return <select key={col} value={selections[col]} onChange={e => updateSelection(col, colIndex, e.target.value)} aria-label={`Filter by ${col}`} style={selectStyle}>
              <option value="All">All {parentLabel}</option>
              {options.map(o => <option key={o} value={o}>
                  {o}
                </option>)}
            </select>;
  })}
      </div>

      {typeof TableComponent === 'function' ? <TableComponent tableTitle={tableTitle} headerList={safeHeaderList} itemsList={withSeparators} monospaceColumns={safeMonospaceColumns} columnWidths={columnWidths} contentFitColumns={contentFitColumns} showSeparators={showSeparators} margin={margin} /> : <Warning>SearchTable requires a `TableComponent` prop.</Warning>}
    </div>;
};

{/* ==========================SECTION: SEARCH TIP========================= */}

<Tip>
  **Finding terms quickly**

  * **Cmd+K** (Mac) / **Ctrl+K** (Windows) – search all Livepeer docs
  * **Cmd+F** (Mac) / **Ctrl+F** (Windows) – search within this page
  * Use the category filter below to narrow by topic
</Tip>

<Note />

Terms developers encounter across Livepeer's SDKs, AI Gateway API, streaming protocols, and protocol integration layer.

<CustomDivider />

<LazyLoad height="600px">
  <SearchTable
    TableComponent={DynamicTable}
    showSeparators={true}
    filterColumns={["Niche"]}
    columnWidths={{ Definition: '50%' }}
    columnVariant={{ Category: "badge" }}
    categoryBadges={glossaryBadges}
    headerList={["Term", "Category", "Niche", "Definition"]}
    searchColumns={["Term", "Definition"]}
    itemsList={[
{ Term: "AI Gateway API", Category: "livepeer", Niche: "product", Definition: "REST API endpoint layer for routing AI inference requests through Livepeer's gateway nodes to GPU orchestrators on the network." },
{ Term: "Arbitrum", Category: "web3", Niche: "chain", Definition: "A Layer 2 Optimistic Rollup settling to Ethereum, processing transactions off-chain while inheriting Ethereum-grade security." },
{ Term: "Batch AI", Category: "ai", Niche: "pipeline", Definition: "Running a trained model on a group of inputs asynchronously, optimising GPU utilisation through parallelisation." },
{ Term: "BYOC (Bring Your Own Container)", Category: "livepeer", Niche: "deployment", Definition: "Deployment pattern where teams supply custom Docker containers for AI workloads, enabling arbitrary Python-based models to run on the Livepeer network." },
{ Term: "Cascade", Category: "livepeer", Niche: "upgrade", Definition: "Strategic vision for Livepeer to become the leading platform for real-time AI video pipelines, and the associated protocol upgrade enabling the AI inference subnet." },
{ Term: "Cold Start", Category: "ai", Niche: "concept", Definition: "Latency incurred when a model must be loaded from storage into GPU memory before the first inference request, often ranging from 5 to 90 seconds." },
{ Term: "CPU (Central Processing Unit)", Category: "technical", Niche: "hardware", Definition: "The primary general-purpose processor in a computer; in Livepeer, CPU handles node software overhead while GPU handles intensive transcoding and AI inference workloads." },
{ Term: "ComfyStream", Category: "livepeer", Niche: "product", Definition: "Livepeer project running ComfyUI workflows as a real-time media processing backend for live streams." },
{ Term: "ComfyUI", Category: "ai", Niche: "framework", Definition: "Open-source node-based graphical interface for building and executing AI image and video generation workflows." },
{ Term: "Daydream", Category: "livepeer", Niche: "product", Definition: "Livepeer's hosted real-time AI video platform turning live camera input into AI-transformed visuals with sub-second latency." },
{ Term: "Delegation", Category: "web3", Niche: "tokenomics", Definition: "LPT holders staking tokens toward orchestrators they trust, sharing in rewards without running infrastructure." },
{ Term: "Delegator", Category: "livepeer", Niche: "role", Definition: "Token holder who stakes LPT to an orchestrator to secure the network, participate in governance, and earn rewards." },
{ Term: "Developer Stack", Category: "livepeer", Niche: "product", Definition: "Set of SDKs, APIs, UI components, and hosted services for integrating video and AI capabilities into applications." },
{ Term: "Diffusion Models", Category: "ai", Niche: "concept", Definition: "Generative models learning to produce data by reversing a gradual noising process applied during training." },
{ Term: "Embedding", Category: "ai", Niche: "concept", Definition: "Learned numerical vector representation in continuous space where similar items map to nearby points, enabling semantic search and cross-modal reasoning." },
{ Term: "Endpoint", Category: "technical", Niche: "dev", Definition: "Specific URL path where an API receives and processes requests." },
{ Term: "Ethereum", Category: "web3", Niche: "chain", Definition: "A decentralised, open-source blockchain with smart contract functionality; native cryptocurrency is Ether (ETH)." },
{ Term: "FrameProcessor", Category: "livepeer", Niche: "sdk", Definition: "Pattern in PyTrickle for building real-time video processing applications with custom per-frame processing logic." },
{ Term: "GB (Gigabyte)", Category: "technical", Niche: "hardware", Definition: "A unit of digital storage equal to 1,073,741,824 bytes (binary); used in Livepeer hardware specifications for RAM, VRAM, and storage requirements." },
{ Term: "Gateway", Category: "livepeer", Niche: "role", Definition: "Node that submits jobs, routes work to orchestrators, manages payment flows, and provides a protocol interface for developers." },
{ Term: "go-livepeer", Category: "livepeer", Niche: "sdk", Definition: "Official Go implementation of the Livepeer protocol containing Broadcaster, Orchestrator, Transcoder, Gateway, and Worker roles in a single binary." },
{ Term: "GPU Operator", Category: "livepeer", Niche: "role", Definition: "An orchestrator operator contributing GPU hardware and AI model capacity to the Livepeer network for inference workloads." },
{ Term: "HLS (HTTP Live Streaming)", Category: "video", Niche: "protocol", Definition: "HTTP Live Streaming protocol by Apple that encodes video into multiple quality levels with an index playlist for adaptive bitrate delivery." },
{ Term: "HuggingFace", Category: "ai", Niche: "platform", Definition: "An AI platform and open-source community providing model repositories, datasets, and inference APIs; a primary source for AI models deployed on Livepeer orchestrator nodes." },
{ Term: "Image-to-Image", Category: "ai", Niche: "pipeline", Definition: "AI pipeline transforming an input image into a modified output image guided by a text prompt or conditioning signal." },
{ Term: "Image-to-Text", Category: "ai", Niche: "pipeline", Definition: "AI pipeline generating a textual description from an input image, encompassing captioning and optical character recognition." },
{ Term: "Image-to-Video", Category: "ai", Niche: "pipeline", Definition: "AI pipeline generating a short video clip conditioned on a single input image, animating a still frame." },
{ Term: "Inference", Category: "ai", Niche: "concept", Definition: "Running a trained model on new input data to produce predictions or generated output, as opposed to training the model." },
{ Term: "JavaScript", Category: "technical", Niche: "language", Definition: "A high-level interpreted scripting language used for web and server-side development; Livepeer's primary SDKs and gateway clients expose JavaScript/TypeScript APIs." },
{ Term: "JWT (JSON Web Token)", Category: "technical", Niche: "security", Definition: "JSON Web Token – a compact, URL-safe signed token used to authenticate and authorise requests between parties." },
{ Term: "KYC (Know Your Customer)", Category: "operational", Niche: "process", Definition: "Know Your Customer – identity verification process for regulatory compliance, requiring users to provide identifying information before accessing certain features." },
{ Term: "LIP (Livepeer Improvement Proposal)", Category: "livepeer", Niche: "protocol", Definition: "Livepeer Improvement Proposal – formal design document describing a proposed change to the protocol, governance process, or ecosystem standard." },
{ Term: "Live-video-to-video", Category: "ai", Niche: "pipeline", Definition: "AI pipeline applying generative models to a continuous video stream frame-by-frame at interactive frame rates." },
{ Term: "Livepeer Cloud", Category: "livepeer", Niche: "product", Definition: "Platform by the Livepeer Cloud SPE increasing network accessibility with a free community AI gateway and managed developer services." },
{ Term: "Livepeer Studio", Category: "livepeer", Niche: "product", Definition: "Developer platform for adding live and on-demand video experiences to applications, providing stream management, asset storage, analytics, and billing." },
{ Term: "Livepeer.js", Category: "livepeer", Niche: "sdk", Definition: "JavaScript library for the Livepeer API providing programmatic access to Studio features including stream and asset management." },
{ Term: "livepeer-python-gateway", Category: "livepeer", Niche: "sdk", Definition: "An open-source Python reference implementation of a Livepeer gateway, enabling job submission, payment flow management, and pipeline routing from Python applications." },
{ Term: "LLM (Large Language Model)", Category: "ai", Niche: "concept", Definition: "Large language model – neural network trained on massive text corpora to understand and generate natural language." },
{ Term: "LoRA (Low-Rank Adaptation)", Category: "ai", Niche: "model", Definition: "Low-Rank Adaptation – parameter-efficient fine-tuning technique injecting trainable low-rank matrices into transformer layers to specialise a model without full retraining." },
{ Term: "LPT (Livepeer Token)", Category: "livepeer", Niche: "protocol", Definition: "ERC-20 governance and staking token used for orchestrator selection, delegation, reward distribution, and network security." },
{ Term: "Low-Latency", Category: "video", Niche: "streaming", Definition: "A system characteristic where the delay between an event occurring and a response being delivered is minimised; in Livepeer, sub-500ms round-trip times are targeted for real-time AI video pipelines." },
{ Term: "Model", Category: "ai", Niche: "concept", Definition: "Mathematical structure (neural network with learned weights) enabling predictions or generation for new inputs, identified by a model ID and pipeline type." },
{ Term: "Model Card", Category: "ai", Niche: "concept", Definition: "Standardised documentation describing a model's intended use, training data, evaluation metrics, and known limitations." },
{ Term: "Model ID", Category: "ai", Niche: "concept", Definition: "Unique string identifier specifying which AI model to invoke on a repository hub, for example `stabilityai/stable-diffusion-xl-base-1.0`." },
{ Term: "Multimodal", Category: "ai", Niche: "concept", Definition: "AI systems capable of processing and integrating multiple data types – such as text, images, audio, and video – for cross-modal understanding and generation." },
{ Term: "NaaP (Network as a Platform)", Category: "livepeer", Niche: "product", Definition: "Network-as-a-Product – the framing of delivering the Livepeer Network as a reliable, SLA-backed product layer with improved orchestrator selection and accessibility." },
{ Term: "Ollama", Category: "ai", Niche: "model", Definition: "Open-source tool for running large language models locally with a CLI and OpenAI-compatible REST API." },
{ Term: "Orchestrator", Category: "livepeer", Niche: "role", Definition: "Supply-side operator contributing GPU resources, receiving jobs, performing transcoding or AI inference, and earning rewards from the Livepeer protocol." },
{ Term: "Protocol Layer", Category: "livepeer", Niche: "protocol", Definition: "On-chain layer governing staking, delegation, rewards, and verification via smart contracts deployed on Arbitrum." },
{ Term: "PyTorch", Category: "ai", Niche: "framework", Definition: "Open-source deep learning framework providing GPU-accelerated tensor computation and automatic differentiation, developed by Meta." },
{ Term: "PyTrickle", Category: "livepeer", Niche: "sdk", Definition: "Python package for real-time video and audio streaming with custom processing, built on the Livepeer Trickle protocol." },
{ Term: "Real-time AI", Category: "ai", Niche: "concept", Definition: "Running AI models on live streaming input with latency low enough for interactive speeds, typically under 100 milliseconds." },
{ Term: "Reward Call", Category: "livepeer", Niche: "protocol", Definition: "On-chain transaction an active orchestrator submits each protocol round to mint and distribute new LPT inflation rewards to itself and its delegators." },
{ Term: "RTMP (Real-Time Messaging Protocol)", Category: "video", Niche: "protocol", Definition: "Real-Time Messaging Protocol for streaming audio, video, and data over TCP on port 1935, the standard ingest protocol for live broadcasting." },
{ Term: "RTX (NVIDIA RTX)", Category: "technical", Niche: "hardware", Definition: "NVIDIA's current consumer GPU product line featuring dedicated Tensor cores that accelerate AI/ML inference workloads; RTX GPUs are well-suited for Livepeer AI pipeline tasks." },
{ Term: "SAM 2", Category: "ai", Niche: "model", Definition: "Meta's unified foundation model for promptable segmentation in images and videos with streaming memory, enabling interactive region selection." },
{ Term: "Sampler", Category: "ai", Niche: "concept", Definition: "Algorithm controlling the denoising process in diffusion models by defining the noise schedule and update rule for each generation step." },
{ Term: "SDXL (Stable Diffusion XL)", Category: "ai", Niche: "model", Definition: "Stable Diffusion XL – advanced text-to-image model with a 3× larger UNet and dual text encoders, generating images at 1024×1024 resolution." },
{ Term: "Segmentation", Category: "ai", Niche: "pipeline", Definition: "AI task partitioning a digital image into regions by assigning a semantic label to every pixel, identifying and outlining objects." },
{ Term: "Self-Hosted", Category: "technical", Niche: "deployment", Definition: "A deployment model in which the operator runs their own infrastructure instead of relying on a managed cloud service; Livepeer gateways and AI nodes can be self-hosted on any compatible hardware." },
{ Term: "Smart Contract", Category: "web3", Niche: "concept", Definition: "Self-executing program deployed on a blockchain that automatically enforces agreement terms without intermediaries." },
{ Term: "SLA (Service Level Agreement)", Category: "technical", Niche: "operations", Definition: "A formal commitment between a service provider and a customer defining expected performance levels, uptime guarantees, and remediation obligations." },
{ Term: "Solidity", Category: "technical", Niche: "dev", Definition: "Statically-typed, contract-oriented programming language for writing smart contracts on Ethereum and EVM-compatible chains." },
{ Term: "SPE (Special Purpose Entity)", Category: "livepeer", Niche: "entity", Definition: "Special Purpose Entity – a treasury-funded organisational unit with a defined scope, fixed budget, and accountability structure for executing ecosystem workstreams." },
{ Term: "StreamDiffusion", Category: "ai", Niche: "model", Definition: "Optimised real-time diffusion pipeline using stream batching and stochastic similarity filtering to reduce latency for live video transforms." },
{ Term: "StreamPlace", Category: "livepeer", Niche: "product", Definition: "Project building the video layer for decentralised social platforms, focused on the AT Protocol ecosystem." },
{ Term: "Sub-second Latency", Category: "video", Niche: "playback", Definition: "Video delivery with end-to-end delay under one second, typically achieved via WebRTC's UDP-based transport." },
{ Term: "SVD (Stable Video Diffusion)", Category: "ai", Niche: "model", Definition: "Stability AI's latent diffusion model generating 14–25 frame video clips at 576×1024 resolution conditioned on a single input image." },
{ Term: "TensorRT", Category: "ai", Niche: "framework", Definition: "NVIDIA's inference SDK optimising models through quantisation, layer fusion, and kernel auto-tuning for low-latency GPU inference." },
{ Term: "Text-to-Image", Category: "ai", Niche: "pipeline", Definition: "AI pipeline generating an image from a natural language text prompt using a language encoder and a diffusion model." },
{ Term: "Text-to-Speech", Category: "ai", Niche: "pipeline", Definition: "AI pipeline synthesising spoken audio from written text using phonetic conversion and audio synthesis models." },
{ Term: "Torch", Category: "ai", Niche: "framework", Definition: "Open-source deep learning framework providing GPU-accelerated tensor computation and automatic differentiation, developed by Meta. Also known as PyTorch." },
{ Term: "Transcoding", Category: "video", Niche: "processing", Definition: "Direct digital-to-digital conversion of video from one encoding format, resolution, or bitrate to another, producing multiple adaptive renditions." },
{ Term: "Treasury", Category: "livepeer", Niche: "protocol", Definition: "On-chain pool of LPT and ETH governed by token holders via the LivepeerGovernor contract, used to fund public goods and ecosystem development." },
{ Term: "Trickle Streaming Protocol", Category: "livepeer", Niche: "sdk", Definition: "Low-latency HTTP-based streaming protocol for real-time media transport between Livepeer nodes, enabling frame-level AI processing on live streams." },
{ Term: "Video on Demand (VOD)", Category: "video", Niche: "delivery", Definition: "A media delivery model where recorded video content is stored server-side and streamed to viewers on request at any time, in contrast to live streaming." },
{ Term: "VRAM (Video RAM)", Category: "technical", Niche: "infra", Definition: "Video RAM – dedicated GPU memory used for storing graphics data, model weights, and intermediate tensors during AI inference." },
{ Term: "Warm Model", Category: "ai", Niche: "concept", Definition: "AI model already loaded into GPU memory and ready to serve inference requests immediately, without cold-start delay." },
{ Term: "Webhook", Category: "technical", Niche: "dev", Definition: "HTTP callback mechanism that sends a POST request to a configured URL when a specific platform event occurs, enabling event-driven integrations." },
{ Term: "WebRTC", Category: "video", Niche: "protocol", Definition: "Open standard providing browsers and mobile apps with real-time peer-to-peer audio, video, and data exchange without plugins." },
{ Term: "Whisper", Category: "ai", Niche: "model", Definition: "OpenAI's encoder-decoder transformer for speech recognition and translation, pre-trained on 680,000 hours of multilingual audio." },
{ Term: "World Model", Category: "ai", Niche: "application", Definition: "Neural network representing and predicting environment dynamics, enabling an AI agent to plan by simulating future outcomes." },
{ Term: "Zero-to-Hero", Category: "livepeer", Niche: "product", Definition: "Guided learning path taking a developer from no prior knowledge of Livepeer to competent ecosystem participation through structured tutorials and exercises." },
]}
  />
</LazyLoad>

<CustomDivider />

## Livepeer Protocol Terms

<AccordionGroup>
  <Accordion title="AI Gateway API" icon="book-open">
    **Definition**: REST API endpoint layer for routing AI inference requests through Livepeer's Gateway nodes to GPU Orchestrators on the network.

    **Context**: The AI Gateway API is the primary integration surface for developers submitting AI pipeline requests – text-to-image, live-video-to-video, LLM chat, etc. – to the decentralised Livepeer Network without managing infrastructure directly.

    **Status**: draft

    **Pages**: `developers/ai-gateway`, `developers/api`
  </Accordion>

  <Accordion title="BYOC (Bring Your Own Container)" icon="book-open">
    **Definition**: Deployment pattern where teams supply custom Docker containers for AI workloads, enabling arbitrary Python-based models to run on the Livepeer Network.

    **Context**: BYOC is the Livepeer mechanism that allows builders and Orchestrators to deploy containerised AI workloads – including custom pipelines not natively supported – on network compute.

    **Status**: current

    **Pages**: `developers/compute`, `developers/pipelines`
  </Accordion>

  <Accordion title="Cascade" icon="book-open">
    **Definition**: Strategic vision for Livepeer to become the leading platform for real-time AI video pipelines, and the associated protocol upgrade enabling the AI inference subnet.

    **Context**: Cascade is Livepeer's named strategic phase introducing AI inference as a first-class use case alongside transcoding, activating the AI subnet and GPU Orchestrator market.

    **Status**: current

    **Pages**: `developers/protocol`
  </Accordion>

  <Accordion title="ComfyStream" icon="book-open">
    **Definition**: Livepeer project running ComfyUI workflows as a real-time media processing backend for live streams.

    **Context**: ComfyStream is a Livepeer-maintained integration layer that translates ComfyUI node graphs into streaming AI pipelines compatible with the network's live-video-to-video pipeline, enabling GPU Orchestrators to serve real-time diffusion transforms.

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-video`
  </Accordion>

  <Accordion title="Daydream" icon="book-open">
    **Definition**: Livepeer's hosted real-time AI video platform turning live camera input into AI-transformed visuals with sub-second latency.

    **Context**: Daydream is the flagship consumer-facing product demonstrating Livepeer's real-time AI video capabilities, used by developers as a reference implementation and deployment target for live-video-to-video pipelines.

    **Status**: current

    **Pages**: `developers/ai-video`, `developers/use-cases`
  </Accordion>

  <Accordion title="Delegator" icon="book-open">
    **Definition**: Token holder who stakes LPT to an Orchestrator to secure the network, participate in governance, and earn rewards.

    **Context**: In the developer context, understanding Delegators is relevant when reasoning about LPT staking mechanics and the economic security of the network backing developer workloads.

    **Status**: current

    **Pages**: `developers/protocol`
  </Accordion>

  <Accordion title="Developer Stack" icon="book-open">
    **Definition**: Set of SDKs, APIs, UI components, and hosted services for integrating video and AI capabilities into applications.

    **Context**: The Developer Stack is Livepeer's collective offering for builders – encompassing Livepeer Studio, the AI Gateway API, Livepeer.js, and PyTrickle – enabling video and AI features without managing protocol infrastructure.

    **Status**: current

    **Pages**: `developers/index`, `developers/quickstart`
  </Accordion>

  <Accordion title="FrameProcessor" icon="book-open">
    **Definition**: Pattern in PyTrickle for building real-time video processing applications with custom per-frame processing logic.

    **Context**: FrameProcessor is the Livepeer-defined interface in the PyTrickle SDK that developers implement to apply AI transforms to individual video frames within a live stream pipeline.

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-video`
  </Accordion>

  <Accordion title="Gateway" icon="book-open">
    **Definition**: Node that submits jobs, routes work to Orchestrators, manages payment flows, and provides a protocol interface for developers.

    **Context**: In the developer context, a Gateway is the on-network relay between a developer's application (sending AI or transcoding requests) and the Orchestrators performing compute – abstracting payment channels and Orchestrator selection.

    **Status**: current

    **Pages**: `developers/ai-gateway`, `developers/architecture`
  </Accordion>

  <Accordion title="go-livepeer" icon="book-open">
    **Definition**: Official Go implementation of the Livepeer Protocol containing Broadcaster, Orchestrator, Transcoder, Gateway, and Worker roles in a single binary.

    **Context**: go-livepeer is the canonical node software that developers running protocol-level infrastructure compile and configure; it is the reference implementation against which all SDK behaviour is defined.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/node`
  </Accordion>

  <Accordion title="GPU Operator" icon="book-open">
    **Definition**: An Orchestrator operator contributing GPU hardware and AI model capacity to the Livepeer Network for inference workloads.

    **Context**: GPU Operators are the supply side of the Livepeer AI market; developers routing requests through the AI Gateway API ultimately land on GPU Operator infrastructure.

    **Status**: current

    **Pages**: `developers/compute`, `developers/node`
  </Accordion>

  <Accordion title="LIP (Livepeer Improvement Proposal)" icon="book-open">
    **Definition**: Livepeer Improvement Proposal – formal design document describing a proposed change to the protocol, governance process, or ecosystem standard.

    **Context**: LIPs are the official mechanism through which protocol changes to Livepeer are proposed, debated, and ratified by stakeholders; developers working at the protocol level reference LIPs for specification authority.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/governance`
  </Accordion>

  <Accordion title="Livepeer Cloud" icon="book-open">
    **Definition**: Platform by the Livepeer Cloud SPE increasing network accessibility with a free community AI Gateway and managed developer services.

    **Context**: Livepeer Cloud is a hosted offering making it easier for developers to access Livepeer's AI and video infrastructure without self-hosting Gateway nodes.

    **Status**: current

    **Pages**: `developers/index`, `developers/api`
  </Accordion>

  <Accordion title="Livepeer Studio" icon="book-open">
    **Definition**: Developer platform for adding live and on-demand video experiences to applications, providing stream management, asset storage, analytics, and billing.

    **Context**: Livepeer Studio is the primary hosted developer product; it exposes the REST API and dashboard that most developers use to create streams, upload assets, configure access control, and monitor usage.

    **Status**: current

    **Pages**: `developers/index`, `developers/api`
  </Accordion>

  <Accordion title="Livepeer.js" icon="book-open">
    **Definition**: JavaScript library for the Livepeer API providing programmatic access to Studio features including stream and asset management.

    **Context**: Livepeer.js is the official JavaScript/TypeScript SDK for interacting with Livepeer Studio's REST API, designed for Node.js and browser environments.

    **Status**: current

    **Pages**: `developers/sdks`, `developers/api`
  </Accordion>

  <Accordion title="livepeer-python-gateway" icon="book-open">
    **Definition**: An open-source Python reference implementation of a Livepeer Gateway, enabling job submission, payment flow management, and pipeline routing from Python applications.

    **Context**: Maintained by the community as a lightweight alternative for developers building Python-native integrations with the Livepeer Network.

    **Status**: current

    **Pages**: `developers/sdks`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="LPT (Livepeer Token)" icon="book-open">
    **Definition**: ERC-20 governance and staking token used for Orchestrator selection, delegation, reward distribution, and network security.

    **Context**: LPT is the native utility token of the Livepeer Protocol; developers encounter it when understanding the economic layer backing the compute they consume – staked LPT determines which Orchestrators process their requests.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/staking`
  </Accordion>

  <Accordion title="NaaP (Network as a Platform)" icon="book-open">
    **Definition**: Network-as-a-Product – the framing of delivering the Livepeer Network as a reliable, SLA-backed product layer with improved Orchestrator selection and accessibility.

    **Context**: NaaP is Livepeer's strategic positioning that developers build on, treating the decentralised network as a dependable infrastructure product instead of a raw peer-to-peer substrate.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/architecture`
  </Accordion>

  <Accordion title="Orchestrator" icon="book-open">
    **Definition**: Supply-side operator contributing GPU resources, receiving jobs, performing transcoding or AI inference, and earning rewards from the Livepeer Protocol.

    **Context**: Orchestrators are the network nodes that actually execute the compute underlying developer API calls; understanding Orchestrators helps developers reason about latency, availability, and pricing in the network.

    **Status**: current

    **Pages**: `developers/architecture`, `developers/protocol`
  </Accordion>

  <Accordion title="Protocol Layer" icon="book-open">
    **Definition**: On-chain layer governing staking, delegation, rewards, and verification via smart contracts deployed on Arbitrum.

    **Context**: The Protocol Layer is the blockchain foundation underpinning Livepeer – developers building at the application level interact with it indirectly through the SDK, while protocol developers interact with it directly via smart contracts.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/architecture`
  </Accordion>

  <Accordion title="PyTrickle" icon="book-open">
    **Definition**: Python package for real-time video and audio streaming with custom processing, built on the Livepeer Trickle protocol.

    **Context**: PyTrickle is the official Python SDK for developers building real-time AI video applications on Livepeer, providing the FrameProcessor interface for per-frame model inference.

    **Status**: current

    **Pages**: `developers/sdks`, `developers/streaming`
  </Accordion>

  <Accordion title="Reward Call" icon="book-open">
    **Definition**: On-chain transaction an active Orchestrator submits each protocol round to mint and distribute new LPT inflation rewards to itself and its Delegators.

    **Context**: Developers building tooling or monitoring for the protocol layer encounter reward calls as the primary mechanism by which inflationary LPT is distributed each round.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/staking`
  </Accordion>

  <Accordion title="SPE (Special Purpose Entity)" icon="book-open">
    **Definition**: Special Purpose Entity – a treasury-funded organisational unit with a defined scope, fixed budget, and accountability structure for executing ecosystem workstreams.

    **Context**: SPEs are Livepeer's primary funding and execution vehicle for ecosystem development; developers building tooling or integrations may encounter SPEs when understanding how Livepeer Foundation allocates resources to projects.

    **Status**: current

    **Pages**: `developers/governance`, `developers/protocol`
  </Accordion>

  <Accordion title="StreamPlace" icon="book-open">
    **Definition**: Project building the video layer for decentralised social platforms, focused on the AT Protocol ecosystem.

    **Context**: StreamPlace is a Livepeer ecosystem project demonstrating how the network's streaming infrastructure can underpin decentralised social video applications.

    **Status**: current

    **Pages**: `developers/ai-video`, `developers/use-cases`
  </Accordion>

  <Accordion title="Treasury" icon="book-open">
    **Definition**: On-chain pool of LPT and ETH governed by token holders via the LivepeerGovernor contract, used to fund public goods and ecosystem development.

    **Context**: The Treasury is the protocol-level funding mechanism for Livepeer ecosystem work; developers building tooling or integrations may apply for treasury grants via the governance process.

    **Status**: current

    **Pages**: `developers/protocol`, `developers/governance`
  </Accordion>

  <Accordion title="Trickle Streaming Protocol" icon="book-open">
    **Definition**: Low-latency HTTP-based streaming protocol for real-time media transport between Livepeer nodes, enabling frame-level AI processing on live streams.

    **Context**: The Trickle Streaming Protocol is the Livepeer-native transport layer underpinning PyTrickle and the live-video-to-video pipeline, enabling sub-segment-level media delivery for real-time AI transforms.

    **Status**: current

    **Pages**: `developers/streaming`, `developers/architecture`
  </Accordion>

  <Accordion title="Zero-to-Hero" icon="book-open">
    **Definition**: Guided learning path taking a developer from no prior knowledge of Livepeer to competent ecosystem participation through structured tutorials and exercises.

    **Context**: Zero-to-Hero is Livepeer's flagship onboarding tutorial series for new developers, providing step-by-step guides covering SDK setup, stream creation, AI pipeline integration, and protocol fundamentals.

    **Status**: current

    **Pages**: `developers/guides`, `developers/quickstart`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## AI Terms

<AccordionGroup>
  <Accordion title="Batch AI" icon="book-open">
    **Definition**: Running a trained model on a group of inputs asynchronously, optimising GPU utilisation through parallelisation.

    **External**: [Google Cloud – What is batch inference?](https://cloud.google.com/discover/what-is-batch-inference)

    **Status**: current

    **Pages**: `developers/ai-gateway`, `developers/pipelines`
  </Accordion>

  <Accordion title="Cold Start" icon="book-open">
    **Definition**: Latency incurred when a model must be loaded from storage into GPU memory before the first inference request, often ranging from 5 to 90 seconds.

    **Also known as**: Cold model

    **External**: [OpenMetal – Cold start latency in private AI inference](https://openmetal.io/resources/blog/cold-start-latency-private-ai-inference/)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="ComfyUI" icon="book-open">
    **Definition**: Open-source node-based graphical interface for building and executing AI image and video generation workflows.

    **External**: [ComfyUI on GitHub](https://github.com/Comfy-Org/ComfyUI)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-video`
  </Accordion>

  <Accordion title="Diffusion Models" icon="book-open">
    **Definition**: Generative models learning to produce data by reversing a gradual noising process applied during training.

    **External**: [Wikipedia – Diffusion model](https://en.wikipedia.org/wiki/Diffusion_model)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-video`
  </Accordion>

  <Accordion title="Embedding" icon="book-open">
    **Definition**: Learned numerical vector representation in continuous space where similar items map to nearby points, enabling semantic search and cross-modal reasoning.

    **External**: [Wikipedia – Word embedding](https://en.wikipedia.org/wiki/Word_embedding)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="HuggingFace" icon="book-open">
    **Definition**: An AI platform and open-source community providing model repositories, datasets, and inference APIs; a primary source for AI models deployed on Livepeer Orchestrator nodes.

    **Also known as**: Hugging Face, HF

    **External**: [HuggingFace](https://huggingface.co/)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Image-to-Image" icon="book-open">
    **Definition**: AI pipeline transforming an input image into a modified output image guided by a text prompt or conditioning signal.

    **External**: [Wikipedia – Image translation](https://en.wikipedia.org/wiki/Image_translation)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Image-to-Text" icon="book-open">
    **Definition**: AI pipeline generating a textual description from an input image, encompassing captioning and optical character recognition.

    **External**: [Hugging Face – Image-to-Text task](https://huggingface.co/tasks/image-to-text)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Image-to-Video" icon="book-open">
    **Definition**: AI pipeline generating a short video clip conditioned on a single input image, animating a still frame.

    **External**: [Hugging Face – Image-to-Video task](https://huggingface.co/tasks/image-to-video)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Inference" icon="book-open">
    **Definition**: Running a trained model on new input data to produce predictions or generated output, as opposed to training the model.

    **External**: [Wikipedia – Inference engine](https://en.wikipedia.org/wiki/Inference_engine)

    **Status**: current

    **Pages**: `developers/ai-gateway`, `developers/pipelines`
  </Accordion>

  <Accordion title="Live-video-to-video" icon="book-open">
    **Definition**: AI pipeline applying generative models to a continuous video stream frame-by-frame at interactive frame rates.

    **External**: [StreamDiffusion GitHub](https://github.com/cumulo-autumn/StreamDiffusion)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-video`
  </Accordion>

  <Accordion title="LLM (Large Language Model)" icon="book-open">
    **Definition**: Large language model – neural network trained on massive text corpora to understand and generate natural language.

    **External**: [Wikipedia – Large language model](https://en.wikipedia.org/wiki/Large_language_model)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="LoRA (Low-Rank Adaptation)" icon="book-open">
    **Definition**: Low-Rank Adaptation – parameter-efficient fine-tuning technique injecting trainable low-rank matrices into transformer layers to specialise a model without full retraining.

    **External**: [Hugging Face – LoRA training](https://huggingface.co/docs/diffusers/training/lora)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Model" icon="book-open">
    **Definition**: Mathematical structure (neural network with learned weights) enabling predictions or generation for new inputs, identified by a model ID and pipeline type.

    **External**: [Wikipedia – Machine learning](https://en.wikipedia.org/wiki/Machine_learning)

    **Status**: current

    **Pages**: `developers/pipelines`
  </Accordion>

  <Accordion title="Model Card" icon="book-open">
    **Definition**: Standardised documentation describing a model's intended use, training data, evaluation metrics, and known limitations.

    **External**: [Hugging Face – Model Cards](https://huggingface.co/docs/hub/en/model-cards)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Model ID" icon="book-open">
    **Definition**: Unique string identifier specifying which AI model to invoke on a repository hub, for example `stabilityai/stable-diffusion-xl-base-1.0`.

    **External**: [Hugging Face – Model Cards](https://huggingface.co/docs/hub/en/model-cards)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Multimodal" icon="book-open">
    **Definition**: AI systems capable of processing and integrating multiple data types – such as text, images, audio, and video – for cross-modal understanding and generation.

    **External**: [Wikipedia – Multimodal learning](https://en.wikipedia.org/wiki/Multimodal_learning)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Ollama" icon="book-open">
    **Definition**: Open-source tool for running large language models locally with a CLI and OpenAI-compatible REST API.

    **External**: [Ollama](https://ollama.com/)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="PyTorch" icon="book-open">
    **Definition**: Open-source deep learning framework providing GPU-accelerated tensor computation and automatic differentiation, developed by Meta.

    **Also known as**: Torch

    **External**: [Wikipedia – PyTorch](https://en.wikipedia.org/wiki/PyTorch)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Real-time AI" icon="book-open">
    **Definition**: Running AI models on live streaming input with latency low enough for interactive speeds, typically under 100 milliseconds.

    **External**: [Ultralytics – Real-time inference](https://www.ultralytics.com/glossary/real-time-inference)

    **Status**: current

    **Pages**: `developers/ai-video`, `developers/pipelines`
  </Accordion>

  <Accordion title="SAM 2" icon="book-open">
    **Definition**: Meta's unified foundation model for promptable segmentation in images and videos with streaming memory, enabling interactive region selection.

    **External**: [Hugging Face – SAM 2](https://huggingface.co/docs/transformers/en/model_doc/sam2)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Sampler" icon="book-open">
    **Definition**: Algorithm controlling the denoising process in diffusion models by defining the noise schedule and update rule for each generation step.

    **External**: [Hugging Face – Scheduler features](https://huggingface.co/docs/diffusers/en/using-diffusers/scheduler_features)

    **Status**: current

    **Pages**: `developers/pipelines`
  </Accordion>

  <Accordion title="SDXL (Stable Diffusion XL)" icon="book-open">
    **Definition**: Stable Diffusion XL – advanced text-to-image model with a 3× larger UNet and dual text encoders, generating images at 1024×1024 resolution.

    **External**: [Hugging Face – SDXL](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Segmentation" icon="book-open">
    **Definition**: AI task partitioning a digital image into regions by assigning a semantic label to every pixel, identifying and outlining objects.

    **Also known as**: Segmentation (AI)

    **External**: [Wikipedia – Image segmentation](https://en.wikipedia.org/wiki/Image_segmentation)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="StreamDiffusion" icon="book-open">
    **Definition**: Optimised real-time diffusion pipeline using stream batching and stochastic similarity filtering to reduce latency for live video transforms.

    **External**: [StreamDiffusion on GitHub](https://github.com/cumulo-autumn/StreamDiffusion)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-video`
  </Accordion>

  <Accordion title="SVD (Stable Video Diffusion)" icon="book-open">
    **Definition**: Stability AI's latent diffusion model generating 14–25 frame video clips at 576×1024 resolution conditioned on a single input image.

    **External**: [Hugging Face – Stable Video Diffusion](https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="TensorRT" icon="book-open">
    **Definition**: NVIDIA's inference SDK optimising models through quantisation, layer fusion, and kernel auto-tuning for low-latency GPU inference.

    **External**: [NVIDIA TensorRT](https://developer.nvidia.com/tensorrt)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Text-to-Image" icon="book-open">
    **Definition**: AI pipeline generating an image from a natural language text prompt using a language encoder and a diffusion model.

    **External**: [Wikipedia – Text-to-image model](https://en.wikipedia.org/wiki/Text-to-image_model)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Text-to-Speech" icon="book-open">
    **Definition**: AI pipeline synthesising spoken audio from written text using phonetic conversion and audio synthesis models.

    **External**: [Wikipedia – Speech synthesis](https://en.wikipedia.org/wiki/Speech_synthesis)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Torch" icon="book-open">
    **Definition**: Open-source deep learning framework providing GPU-accelerated tensor computation and automatic differentiation, developed by Meta.

    **Also known as**: PyTorch

    **External**: [Wikipedia – PyTorch](https://en.wikipedia.org/wiki/PyTorch)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Warm Model" icon="book-open">
    **Definition**: AI model already loaded into GPU memory and ready to serve inference requests immediately, without cold-start delay.

    **External**: [OpenMetal – Cold start latency in private AI inference](https://openmetal.io/resources/blog/cold-start-latency-private-ai-inference/)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="Whisper" icon="book-open">
    **Definition**: OpenAI's encoder-decoder transformer for speech recognition and translation, pre-trained on 680,000 hours of multilingual audio.

    **External**: [Hugging Face – Whisper](https://huggingface.co/openai/whisper-large-v3)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/ai-gateway`
  </Accordion>

  <Accordion title="World Model" icon="book-open">
    **Definition**: Neural network representing and predicting environment dynamics, enabling an AI agent to plan by simulating future outcomes.

    **External**: [Wikipedia – Generative artificial intelligence](https://en.wikipedia.org/wiki/Generative_artificial_intelligence)

    **Status**: current

    **Pages**: `developers/ai-video`, `developers/use-cases`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Video Terms

<AccordionGroup>
  <Accordion title="HLS (HTTP Live Streaming)" icon="book-open">
    **Definition**: HTTP Live Streaming protocol by Apple that encodes video into multiple quality levels with an index playlist for adaptive bitrate delivery.

    **External**: [Wikipedia – HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming)

    **Status**: current

    **Pages**: `developers/streaming`, `developers/playback`
  </Accordion>

  <Accordion title="Low-Latency" icon="book-open">
    **Definition**: A system characteristic where the delay between an event occurring and a response being delivered is minimised; in Livepeer, sub-500ms round-trip times are targeted for real-time AI video pipelines.

    **Context**: Critical for interactive AI video applications – high latency breaks the real-time feedback loop between user input and AI-transformed output.

    **Status**: current

    **Pages**: `developers/ai-video`, `developers/streaming`
  </Accordion>

  <Accordion title="RTMP (Real-Time Messaging Protocol)" icon="book-open">
    **Definition**: Real-Time Messaging Protocol for streaming audio, video, and data over TCP on port 1935, the standard ingest protocol for live broadcasting.

    **External**: [Wikipedia – RTMP](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol)

    **Status**: current

    **Pages**: `developers/streaming`, `developers/ingest`
  </Accordion>

  <Accordion title="Sub-second Latency" icon="book-open">
    **Definition**: Video delivery with end-to-end delay under one second, typically achieved via WebRTC's UDP-based transport.

    **External**: [Cloudflare – WebRTC WHIP/WHEP](https://blog.cloudflare.com/webrtc-whip-whep-cloudflare-stream/)

    **Status**: current

    **Pages**: `developers/streaming`, `developers/webrtc`
  </Accordion>

  <Accordion title="Transcoding" icon="book-open">
    **Definition**: Direct digital-to-digital conversion of video from one encoding format, resolution, or bitrate to another, producing multiple adaptive renditions.

    **External**: [Wikipedia – Transcoding](https://en.wikipedia.org/wiki/Transcoding)

    **Status**: current

    **Pages**: `developers/streaming`, `developers/protocol`
  </Accordion>

  <Accordion title="Video on Demand (VOD)" icon="book-open">
    **Definition**: A media delivery model where recorded video content is stored server-side and streamed to viewers on request at any time, in contrast to live streaming.

    **Also known as**: VOD, on-demand video

    **External**: [Video on demand – Wikipedia](https://en.wikipedia.org/wiki/Video_on_demand)

    **Status**: current

    **Pages**: `developers/streaming`, `developers/api`
  </Accordion>

  <Accordion title="WebRTC" icon="book-open">
    **Definition**: Open standard providing browsers and mobile apps with real-time peer-to-peer audio, video, and data exchange without plugins.

    **External**: [Wikipedia – WebRTC](https://en.wikipedia.org/wiki/WebRTC)

    **Status**: current

    **Pages**: `developers/streaming`, `developers/webrtc`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Web3 Terms

<AccordionGroup>
  <Accordion title="Arbitrum" icon="book-open">
    **Definition**: A Layer 2 Optimistic Rollup settling to Ethereum, processing transactions off-chain while inheriting Ethereum-grade security.

    **External**: [Arbitrum documentation](https://docs.arbitrum.io/welcome/arbitrum-gentle-introduction)

    **Status**: current

    **Pages**: `developers/protocol`
  </Accordion>

  <Accordion title="Delegation" icon="book-open">
    **Definition**: LPT holders staking tokens toward Orchestrators they trust, sharing in rewards without running infrastructure.

    **Context**: Delegation is the mechanism through which passive LPT holders contribute to network security and earn yield without operating nodes, relevant to developer documentation covering the protocol economics layer.

    **Status**: current

    **Pages**: `developers/protocol`
  </Accordion>

  <Accordion title="Ethereum" icon="book-open">
    **Definition**: A decentralised, open-source blockchain with smart contract functionality; native cryptocurrency is Ether (ETH).

    **External**: [Wikipedia – Ethereum](https://en.wikipedia.org/wiki/Ethereum)

    **Status**: current

    **Pages**: `developers/protocol`
  </Accordion>

  <Accordion title="Smart Contract" icon="book-open">
    **Definition**: Self-executing programme deployed on a blockchain that automatically enforces agreement terms without intermediaries.

    **External**: [Ethereum – Smart contracts](https://ethereum.org/developers/docs/smart-contracts/)

    **Status**: current

    **Pages**: `developers/protocol`, `developers/architecture`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Technical Terms

<AccordionGroup>
  <Accordion title="CPU (Central Processing Unit)" icon="book-open">
    **Definition**: The primary general-purpose processor in a computer; in Livepeer, CPU handles node software overhead while GPU handles intensive transcoding and AI inference workloads.

    **External**: [Central processing unit – Wikipedia](https://en.wikipedia.org/wiki/Central_processing_unit)

    **Status**: current

    **Pages**: `developers/compute`, `developers/node`
  </Accordion>

  <Accordion title="Endpoint" icon="book-open">
    **Definition**: Specific URL path where an API receives and processes requests.

    **External**: [Wikipedia – Web API](https://en.wikipedia.org/wiki/Web_API)

    **Status**: current

    **Pages**: `developers/api`
  </Accordion>

  <Accordion title="GB (Gigabyte)" icon="book-open">
    **Definition**: A unit of digital storage equal to 1,073,741,824 bytes (binary); used in Livepeer hardware specifications for RAM, VRAM, and storage requirements.

    **External**: [Gigabyte – Wikipedia](https://en.wikipedia.org/wiki/Gigabyte)

    **Status**: current

    **Pages**: `developers/compute`, `developers/node`
  </Accordion>

  <Accordion title="JavaScript" icon="book-open">
    **Definition**: A high-level interpreted scripting language used for web and server-side development; Livepeer's primary SDKs and Gateway clients expose JavaScript/TypeScript APIs.

    **Also known as**: JS

    **External**: [JavaScript – MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript)

    **Status**: current

    **Pages**: `developers/sdks`, `developers/api`
  </Accordion>

  <Accordion title="JWT (JSON Web Token)" icon="book-open">
    **Definition**: JSON Web Token – a compact, URL-safe signed token used to authenticate and authorise requests between parties.

    **External**: [Wikipedia – JSON Web Token](https://en.wikipedia.org/wiki/JSON_Web_Token)

    **Status**: draft

    **Pages**: `developers/access-control`, `developers/api`
  </Accordion>

  <Accordion title="RTX (NVIDIA RTX)" icon="book-open">
    **Definition**: NVIDIA's current consumer GPU product line featuring dedicated Tensor cores that accelerate AI/ML inference workloads; RTX GPUs are well-suited for Livepeer AI pipeline tasks.

    **Also known as**: GeForce RTX

    **External**: [NVIDIA GeForce RTX](https://www.nvidia.com/en-us/geforce/graphics-cards/)

    **Status**: current

    **Pages**: `developers/compute`, `developers/node`
  </Accordion>

  <Accordion title="Self-Hosted" icon="book-open">
    **Definition**: A deployment model in which the operator runs their own infrastructure instead of relying on a managed cloud service; Livepeer Gateways and AI nodes can be self-hosted on any compatible hardware.

    **External**: [Self-hosting – Wikipedia](https://en.wikipedia.org/wiki/Self-hosting_\(web_services\))

    **Status**: current

    **Pages**: `developers/node`, `developers/compute`
  </Accordion>

  <Accordion title="Solidity" icon="book-open">
    **Definition**: Statically-typed, contract-oriented programming language for writing smart contracts on Ethereum and EVM-compatible chains.

    **External**: [Wikipedia – Solidity](https://en.wikipedia.org/wiki/Solidity)

    **Status**: current

    **Pages**: `developers/protocol`, `developers/contracts`
  </Accordion>

  <Accordion title="VRAM (Video RAM)" icon="book-open">
    **Definition**: Video RAM – dedicated GPU memory used for storing graphics data, model weights, and intermediate tensors during AI inference.

    **External**: [Wikipedia – Video random-access memory](https://en.wikipedia.org/wiki/Video_random-access_memory)

    **Status**: current

    **Pages**: `developers/pipelines`, `developers/compute`
  </Accordion>

  <Accordion title="Webhook" icon="book-open">
    **Definition**: HTTP callback mechanism that sends a POST request to a configured URL when a specific platform event occurs, enabling event-driven integrations.

    **External**: [Wikipedia – Webhook](https://en.wikipedia.org/wiki/Webhook)

    **Status**: current

    **Pages**: `developers/api`, `developers/events`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Operational Terms

<AccordionGroup>
  <Accordion title="KYC (Know Your Customer)" icon="book-open">
    **Definition**: Know Your Customer – identity verification process for regulatory compliance, requiring users to provide identifying information before accessing certain features.

    **External**: [Wikipedia – Know your customer](https://en.wikipedia.org/wiki/Know_your_customer)

    **Status**: current

    **Pages**: `developers/access-control`
  </Accordion>

  <Accordion title="SLA (Service Level Agreement)" icon="book-open">
    **Definition**: A formal commitment between a service provider and a customer defining expected performance levels, uptime guarantees, and remediation obligations.

    **External**: [Service-level agreement – Wikipedia](https://en.wikipedia.org/wiki/Service-level_agreement)

    **Status**: current

    **Pages**: `developers/architecture`, `developers/api`
  </Accordion>
</AccordionGroup>

<CustomDivider />

<CardGroup cols={3}>
  <Card title="Developer Docs" icon="code" href="/v2/developers">
    Start building with Livepeer's APIs, SDKs, and AI pipelines
  </Card>

  <Card title="Full Glossary" icon="book" href="/v2/resources/glossary">
    All terms across every Livepeer tab
  </Card>

  <Card title="API Reference" icon="rectangle-terminal" href="/v2/developers/resources/reference/apis">
    Complete reference for Livepeer's REST API endpoints
  </Card>
</CardGroup>