> ## 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.

# Home Glossary

> Key terms and concepts from the Livepeer home section – network overview, protocol roles, and ecosystem terminology.

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>
  Machine-readable term index: [glossary-data.json](./glossary-data.json)
</Note>

Essential vocabulary for understanding Livepeer's network architecture, protocol roles, token economics, and AI video capabilities – covering every term used across the home section.

<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: "Agents", Category: "ai", Niche: "concept", Definition: "Systems that perceive their environment and act autonomously to achieve goals, often powered by LLMs with tools." },
{ Term: "AI Pipeline", Category: "ai", Niche: "pipeline", Definition: "End-to-end construct orchestrating data flow through processing steps to produce output." },
{ Term: "AI Video", Category: "ai", Niche: "application", Definition: "Broad category encompassing AI-powered video processing tasks such as generation, transformation, and inference on live or recorded streams." },
{ Term: "Arbitrum", Category: "web3", Niche: "chain", Definition: "A Layer 2 Optimistic Rollup settling to Ethereum, processing transactions off-chain with Ethereum-grade security." },
{ Term: "Avatar", Category: "ai", Niche: "application", Definition: "Graphical representation of a user or AI entity, from 2D images to fully animated 3D digital characters." },
{ Term: "Blockchain", Category: "web3", Niche: "concept", Definition: "A distributed ledger of records (blocks) securely linked via cryptographic hashes, managed by peer-to-peer consensus." },
{ Term: "BYOC (Bring Your Own Compute / Bring Your Own Container)", Category: "livepeer", Niche: "deployment", Definition: "Deployment pattern where users supply custom Docker containers for AI workloads 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." },
{ Term: "ComfyUI", Category: "ai", Niche: "framework", Definition: "Open-source node-based graphical interface for building and executing AI image and video generation workflows." },
{ Term: "ComfyStream", Category: "livepeer", Niche: "product", Definition: "ComfyUI custom node running real-time media workflows for AI-powered video and audio on live streams." },
{ Term: "Compute Marketplace", Category: "livepeer", Niche: "product", Definition: "Decentralized market matching GPU supply from orchestrators with demand from applications and gateways." },
{ Term: "Confluent Upgrade", Category: "livepeer", Niche: "upgrade", Definition: "Alternate name for the Confluence upgrade deploying Livepeer's core protocol contracts to Arbitrum Mainnet." },
{ Term: "Daydream", Category: "livepeer", Niche: "product", Definition: "Livepeer's hosted realtime AI video platform turning live camera input into AI-transformed visuals with sub-second latency." },
{ Term: "DeAI (Decentralized AI)", Category: "ai", Niche: "application", Definition: "Distributed AI computation on blockchain networks enabling permissionless, trustless inference without centralized providers." },
{ Term: "Decentralization", Category: "web3", Niche: "concept", Definition: "Transfer of control from a centralized entity to a distributed network, reducing single points of failure." },
{ 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: "Delta Upgrade", Category: "livepeer", Niche: "upgrade", Definition: "Planned future Livepeer protocol phase focused on full decentralization with Truebit-based verification." },
{ Term: "Digital Twin", Category: "ai", Niche: "application", Definition: "Virtual replica of a physical object or system continuously synchronized with real-world data." },
{ Term: "ETH (Ether)", Category: "web3", Niche: "token", Definition: "The native cryptocurrency of Ethereum, used to pay transaction fees (gas) and as the fee currency for Livepeer payment settlements." },
{ Term: "Ethereum", Category: "web3", Niche: "chain", Definition: "A decentralized, open-source blockchain with smart contract functionality; native cryptocurrency is Ether (ETH)." },
{ Term: "Foundation", Category: "livepeer", Niche: "entity", Definition: "Non-profit Cayman Islands Foundation Company stewarding long-term vision, ecosystem growth, and core development of the Livepeer protocol." },
{ Term: "Frame Rate", Category: "video", Niche: "encoding", Definition: "Frequency at which consecutive frames are captured or displayed, measured in frames per second (fps); common rates are 24, 30, and 60 fps." },
{ Term: "Gateway", Category: "livepeer", Niche: "role", Definition: "Node that submits jobs, routes work to orchestrators, manages payment flows, and provides a protocol interface for applications." },
{ Term: "Generative Video", Category: "ai", Niche: "application", Definition: "AI-produced video created by models that synthesize novel temporal frame sequences from text prompts or conditioning signals." },
{ Term: "Governance", Category: "operational", Niche: "governance", Definition: "System of rules and processes for protocol decision-making including on-chain voting via LPT stake weight." },
{ Term: "GPU (Graphics Processing Unit)", Category: "technical", Niche: "infra", Definition: "Specialized processor for parallel computation used in rendering, video encoding, and AI inference workloads." },
{ Term: "GPU Operator", Category: "livepeer", Niche: "role", Definition: "An orchestrator operator contributing GPU resources for transcoding or AI inference on the Livepeer network." },
{ Term: "Inference", Category: "ai", Niche: "concept", Definition: "Running a trained model on new input data to produce predictions or generated outputs, as opposed to the training process." },
{ Term: "Interactive Media", Category: "ai", Niche: "application", Definition: "Digital content dynamically responding to user input in real time, combining text, images, audio, and video." },
{ Term: "Job", Category: "livepeer", Niche: "protocol", Definition: "A unit of work submitted to the Livepeer network specifying stream ID, transcoding options or AI pipeline, and price." },
{ Term: "Latency", Category: "video", Niche: "playback", Definition: "Delay between capture at source and display on the viewer's device, accumulating at every pipeline stage." },
{ 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: "Layer-2", Category: "web3", Niche: "chain", Definition: "A separate blockchain extending a Layer 1 by handling transactions off-chain while inheriting the security guarantees of the base chain." },
{ Term: "LIP (Livepeer Improvement Proposal)", Category: "operational", Niche: "governance", Definition: "Formal design document proposing changes to the Livepeer protocol, governance parameters, or ecosystem standards." },
{ Term: "Livepeer Inc", Category: "livepeer", Niche: "entity", Definition: "Original company that built Livepeer's initial protocol architecture and core software." },
{ 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: "Marketplace", Category: "livepeer", Niche: "product", Definition: "System matching service demand from applications and gateways with supply from GPU operators and orchestrators." },
{ Term: "Micropayments", Category: "economic", Niche: "payment", Definition: "Small-value payments for streaming services, implemented in Livepeer via a probabilistic lottery scheme to minimize on-chain transaction costs." },
{ Term: "Model", Category: "ai", Niche: "concept", Definition: "Mathematical structure (neural network with learned weights) enabling predictions or content generation for new inputs." },
{ Term: "Node", Category: "technical", Niche: "infra", Definition: "Computing device connected to a network participating in protocol operations such as transcoding, routing, or staking." },
{ Term: "NPC (Non-Player Character)", Category: "ai", Niche: "application", Definition: "Non-player character not controlled by a human, increasingly powered by AI for dynamic, real-time interactions." },
{ Term: "Orchestrator", Category: "livepeer", Niche: "role", Definition: "Supply-side operator contributing GPU resources, receiving jobs, performing transcoding or AI inference, and earning rewards." },
{ Term: "Open Source", Category: "technical", Niche: "concept", Definition: "Software distributed with its source code under a licence permitting study, modification, and redistribution; Livepeer's protocol, go-livepeer node software, and SDK libraries are all open source." },
{ Term: "Permissionless", Category: "web3", Niche: "concept", Definition: "Property where anyone can participate without requiring approval from a central authority." },
{ Term: "Probabilistic Micropayments", Category: "economic", Niche: "payment", Definition: "Lottery-based payment model where only winning tickets are redeemed on-chain, amortizing transaction costs across many small payments." },
{ Term: "Proof of Utility", Category: "livepeer", Niche: "protocol", Definition: "Model where participants prove they performed useful work for the network rather than just staking capital." },
{ Term: "Real-time", Category: "video", Niche: "playback", Definition: "Video delivery or AI processing with latency low enough for bidirectional interaction, typically under 500ms via WebRTC." },
{ Term: "Reward", Category: "economic", Niche: "reward", Definition: "Combination of inflationary LPT and ETH fees earned by orchestrators and delegators each protocol round." },
{ Term: "Scalability", Category: "technical", Niche: "infra", Definition: "Ability to handle increasing workload by adding resources without degradation in performance or reliability." },
{ Term: "SLAM (Simultaneous Localization and Mapping)", Category: "ai", Niche: "application", Definition: "Computational method constructing a map of an unknown environment while simultaneously tracking an agent's location within it." },
{ Term: "Smart Contract", Category: "web3", Niche: "concept", Definition: "Self-executing program on a blockchain that automatically enforces agreement terms without intermediaries." },
{ Term: "Snowmelt", Category: "livepeer", Niche: "upgrade", Definition: "Alpha phase of the Livepeer roadmap where the protocol was designed and incentives implemented, culminating in testnet launch." },
{ Term: "SPE (Special Purpose Entity)", Category: "livepeer", Niche: "entity", Definition: "Treasury-funded unit with a defined scope, budget, accountability structure, and operational timeline approved via governance." },
{ Term: "Staking", Category: "economic", Niche: "reward", Definition: "Locking LPT tokens in a proof-of-stake protocol to participate in network security, governance, and earn inflationary rewards." },
{ Term: "Streamflow", Category: "livepeer", Niche: "upgrade", Definition: "Performance phase upgrade introducing peer-to-peer distribution, WebRTC support, and the Orchestrator/Transcoder split." },
{ Term: "Streaming", Category: "video", Niche: "playback", Definition: "Continuous delivery of multimedia over a network rendered in real time, as opposed to full download before playback." },
{ Term: "Style Transfer", Category: "ai", Niche: "application", Definition: "Using deep neural networks to apply the visual style of one image or video to the content of another." },
{ Term: "Synthetic Data", Category: "ai", Niche: "application", Definition: "Artificially generated data produced by algorithms rather than real-world events, used for training AI models when real data is scarce or sensitive." },
{ Term: "Transcoding", Category: "video", Niche: "processing", Definition: "Direct digital-to-digital conversion of video from one encoding format or bitrate to another for adaptive multi-rendition delivery." },
{ Term: "Treasury", Category: "economic", Niche: "treasury", Definition: "Pool of LPT held on-chain for funding public goods and ecosystem development, governed by token holder votes." },
{ Term: "Tributary", Category: "livepeer", Niche: "upgrade", Definition: "Beta phase of the Livepeer roadmap where LPMS supported most live streaming use cases and mainnet was deployed." },
{ Term: "Trustless", Category: "web3", Niche: "concept", Definition: "System property where participants interact using cryptographic proofs rather than requiring trust in any third party." },
{ Term: "Upscaling", Category: "ai", Niche: "pipeline", Definition: "Increasing image or video resolution using AI models that predict high-frequency detail not present in the source." },
{ Term: "VOD (Video on Demand)", Category: "video", Niche: "playback", Definition: "Video on demand – system allowing users to access pre-recorded content at any time, contrasting with live streaming." },
{ Term: "World Model", Category: "ai", Niche: "application", Definition: "Neural network representing and predicting environment dynamics, enabling an AI agent to plan by simulating outcomes." },
]}
  />
</LazyLoad>

<CustomDivider />

## Livepeer Protocol Terms

<AccordionGroup>
  <Accordion title="BYOC (Bring Your Own Compute / Bring Your Own Container)" icon="book-open">
    **Definition**: Bring-Your-Own-Container – deployment pattern where users supply custom Docker containers for AI workloads on the Livepeer Network.

    **Context**: Used in Livepeer to let GPU providers and teams run containerized Python workloads for streaming AI pipelines, enabling flexible compute contributions without requiring standard pipeline implementations.

    **Status**: current

    **Pages**: `home/network`, `home/compute`
  </Accordion>

  <Accordion title="Cascade" icon="book-open">
    **Definition**: Strategic vision for Livepeer to become the leading platform for real-time AI video pipelines.

    **Context**: A named protocol upgrade and roadmap phase introducing AI subnet capabilities; represents Livepeer's strategic pivot toward real-time AI video as a core network offering.

    **Status**: current

    **Pages**: `home/network`, `home/upgrades`
  </Accordion>

  <Accordion title="ComfyStream" icon="book-open">
    **Definition**: ComfyUI custom node running real-time media workflows for AI-powered video and audio on live streams.

    **Context**: A Livepeer project integrating ComfyUI with the network's live streaming infrastructure, enabling ComfyUI workflows to operate as real-time media processing backends for Livepeer streams.

    **Status**: current

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

  <Accordion title="Compute Marketplace" icon="book-open">
    **Definition**: Decentralised market matching GPU supply from Orchestrators with demand from applications and Gateways.

    **Context**: Livepeer's mechanism for coordinating supply (GPU operators) and demand (developers and applications) for compute resources, governed by crypto-economic incentives rather than a centralised provider.

    **Status**: current

    **Pages**: `home/network`, `home/compute`
  </Accordion>

  <Accordion title="Confluent Upgrade" icon="book-open">
    **Definition**: Alternate name for the Confluence upgrade deploying Livepeer's core protocol contracts to Arbitrum Mainnet.

    **Context**: The Confluent upgrade (also called Confluence) was a production migration (LIP-73) moving Livepeer's staking and payment contracts from Ethereum L1 to Arbitrum One, significantly reducing gas costs.

    **Status**: current

    **Pages**: `home/upgrades`
  </Accordion>

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

    **Context**: A Livepeer product and reference implementation demonstrating real-time interactive AI video generation on the network; showcases the full stack from ingest through AI pipeline to playback.

    **Status**: current

    **Pages**: `home/ai-video`, `home/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**: One of the three core protocol roles in Livepeer; Delegators do not run infrastructure themselves but allocate stake to Orchestrators they trust, receiving a share of inflationary rewards proportional to their contribution.

    **Status**: current

    **Pages**: `home/staking`, `home/network`
  </Accordion>

  <Accordion title="Delta Upgrade" icon="book-open">
    **Definition**: Planned future Livepeer Protocol phase focused on full decentralization with Truebit-based verification.

    **Context**: A named milestone on the Livepeer roadmap introducing on-chain verification mechanisms; represents the end-state of trustless work verification for transcoding and AI jobs.

    **Status**: current

    **Pages**: `home/upgrades`
  </Accordion>

  <Accordion title="Foundation" icon="book-open">
    **Definition**: Non-profit Cayman Islands Foundation Company stewarding long-term vision, ecosystem growth, and core development of the Livepeer Protocol.

    **Context**: The Livepeer Foundation was established to assume stewardship responsibilities from Livepeer Inc, overseeing ecosystem grants, governance coordination, and protocol direction on behalf of the community.

    **Status**: current

    **Pages**: `home/governance`, `home/index`
  </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 applications.

    **Context**: In Livepeer, Gateways are the demand-side entry point – they receive requests from developers or applications, select Orchestrators, handle Probabilistic Micropayments, and return results; they replaced the older "Broadcaster" role.

    **Status**: current

    **Pages**: `home/network`, `home/architecture`
  </Accordion>

  <Accordion title="GPU Operator" icon="book-open">
    **Definition**: An Orchestrator operator contributing GPU resources for transcoding or AI inference on the Livepeer Network.

    **Context**: GPU operators are a specific class of Livepeer Network participants who run GPU hardware connected to the network, earning ETH fees by performing compute-intensive tasks such as video transcoding and AI model inference.

    **Status**: current

    **Pages**: `home/compute`, `home/network`
  </Accordion>

  <Accordion title="Job" icon="book-open">
    **Definition**: A unit of work submitted to the Livepeer Network specifying stream ID, transcoding options or AI pipeline, and price.

    **Context**: Jobs are the atomic work unit in the Livepeer Protocol; each job goes through a lifecycle of submission, Orchestrator selection, execution, verification, and payment settlement.

    **Status**: current

    **Pages**: `home/network`, `home/architecture`
  </Accordion>

  <Accordion title="Livepeer Inc" icon="book-open">
    **Definition**: Original company that built Livepeer's initial protocol architecture and core software.

    **Context**: Livepeer Inc founded and launched the Livepeer Network; following the establishment of the Livepeer Foundation, it transitioned from central steward to one contributor among many in the ecosystem.

    **Status**: current

    **Pages**: `home/index`, `home/about`
  </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; staking it determines which Orchestrators receive work, how rewards are distributed, and how governance votes are weighted.

    **Status**: current

    **Pages**: `home/staking`, `home/network`
  </Accordion>

  <Accordion title="Marketplace" icon="book-open">
    **Definition**: System matching service demand from applications and Gateways with supply from GPU operators and Orchestrators.

    **Context**: The Livepeer compute marketplace uses crypto-economic incentives rather than centralised coordination; pricing, routing, and selection are governed by on-chain parameters and off-chain capability advertisement.

    **Status**: current

    **Pages**: `home/network`, `home/compute`
  </Accordion>

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

    **Context**: Orchestrators are the core supply-side participants in Livepeer; they stake LPT to signal commitment, advertise capabilities and prices, coordinate work distribution to transcoder or AI worker processes, and claim inflationary rewards each round.

    **Status**: current

    **Pages**: `home/network`, `home/staking`
  </Accordion>

  <Accordion title="Proof of Utility" icon="book-open">
    **Definition**: Model where participants prove they performed useful work for the network rather than just staking capital.

    **Context**: Livepeer's proof-of-utility mechanism verifies that Orchestrators actually transcoded video or ran AI inference rather than simply holding stake, ensuring that rewards are tied to productive contributions.

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>

  <Accordion title="Snowmelt" icon="book-open">
    **Definition**: Alpha phase of the Livepeer roadmap where the protocol was designed and incentives implemented, culminating in testnet launch.

    **Context**: Snowmelt is the first named milestone in Livepeer's phased roadmap, representing the earliest protocol design and testnet stage before Tributary (beta) and mainnet deployment.

    **Status**: current

    **Pages**: `home/upgrades`
  </Accordion>

  <Accordion title="SPE (Special Purpose Entity)" icon="book-open">
    **Definition**: Treasury-funded unit with a defined scope, budget, accountability structure, and operational timeline approved via governance.

    **Context**: SPEs are Livepeer's primary mechanism for directing on-chain treasury funds; each SPE has a specific mandate (e.g., AI compute, Gateway tooling, governance coordination) and reports progress to the community.

    **Status**: current

    **Pages**: `home/governance`, `home/index`
  </Accordion>

  <Accordion title="Streamflow" icon="book-open">
    **Definition**: Performance phase upgrade introducing peer-to-peer distribution, WebRTC support, and the Orchestrator/Transcoder split.

    **Context**: Streamflow was a major protocol upgrade that separated the Orchestrator and transcoder roles, introduced Probabilistic Micropayments, and enabled scalable live streaming on the Livepeer mainnet.

    **Status**: current

    **Pages**: `home/upgrades`, `home/index`
  </Accordion>

  <Accordion title="Tributary" icon="book-open">
    **Definition**: Beta phase of the Livepeer roadmap where LPMS supported most live streaming use cases and mainnet was deployed.

    **Context**: Tributary represents the second named milestone in Livepeer's phased roadmap, following Snowmelt's testnet stage; it culminated in the launch of the Livepeer mainnet with core transcoding and staking functionality.

    **Status**: current

    **Pages**: `home/upgrades`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## AI Terms

<AccordionGroup>
  <Accordion title="Agents" icon="book-open">
    **Definition**: Systems that perceive their environment and act autonomously to achieve goals, often powered by LLMs with tools.

    **External**: [Intelligent agent (Wikipedia)](https://en.wikipedia.org/wiki/Intelligent_agent)

    **Status**: current

    **Pages**: `home/agents`, `home/ai-video`
  </Accordion>

  <Accordion title="AI Pipeline" icon="book-open">
    **Definition**: End-to-end construct orchestrating data flow through processing steps to produce output.

    **External**: [Pipelines (Hugging Face)](https://huggingface.co/docs/transformers/en/main_classes/pipelines)

    **Status**: current

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

  <Accordion title="AI Video" icon="book-open">
    **Definition**: Broad category encompassing AI-powered video processing tasks such as generation, transformation, and inference on live or recorded streams.

    **Status**: draft

    **Pages**: `home/index`, `home/ai-video`
  </Accordion>

  <Accordion title="Avatar" icon="book-open">
    **Definition**: Graphical representation of a user or AI entity, from 2D images to fully animated 3D digital characters.

    **External**: [Avatar – computing (Wikipedia)](https://en.wikipedia.org/wiki/Avatar_\(computing\))

    **Status**: current

    **Pages**: `home/ai-video`, `home/use-cases`
  </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 (GitHub)](https://github.com/Comfy-Org/ComfyUI)

    **Status**: current

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

  <Accordion title="DeAI (Decentralized AI)" icon="book-open">
    **Definition**: Distributed AI computation on blockchain networks enabling permissionless, trustless inference without centralised providers.

    **External**: [Distributed artificial intelligence (Wikipedia)](https://en.wikipedia.org/wiki/Distributed_artificial_intelligence)

    **Status**: current

    **Pages**: `home/ai-video`, `home/index`
  </Accordion>

  <Accordion title="Digital Twin" icon="book-open">
    **Definition**: Virtual replica of a physical object or system continuously synchronised with real-world data.

    **External**: [Digital twin (Wikipedia)](https://en.wikipedia.org/wiki/Digital_twin)

    **Status**: current

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

  <Accordion title="Generative Video" icon="book-open">
    **Definition**: AI-produced video created by models that synthesize novel temporal frame sequences from text prompts or conditioning signals.

    **External**: [Text-to-video model (Wikipedia)](https://en.wikipedia.org/wiki/Text-to-video_model)

    **Status**: current

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

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

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

    **Status**: current

    **Pages**: `home/ai-video`, `home/compute`
  </Accordion>

  <Accordion title="Interactive Media" icon="book-open">
    **Definition**: Digital content dynamically responding to user input in real time, combining text, images, audio, and video.

    **External**: [Interactive media (Wikipedia)](https://en.wikipedia.org/wiki/Interactive_media)

    **Status**: current

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

  <Accordion title="Model" icon="book-open">
    **Definition**: Mathematical structure (neural network with learned weights) enabling predictions or content generation for new inputs.

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

    **Status**: current

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

  <Accordion title="NPC (Non-Player Character)" icon="book-open">
    **Definition**: Non-player character not controlled by a human, increasingly powered by AI for dynamic, real-time interactions.

    **External**: [Non-player character (Wikipedia)](https://en.wikipedia.org/wiki/Non-player_character)

    **Status**: current

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

  <Accordion title="SLAM (Simultaneous Localization and Mapping)" icon="book-open">
    **Definition**: Computational method constructing a map of an unknown environment while simultaneously tracking an agent's location within it.

    **External**: [Simultaneous localisation and mapping (Wikipedia)](https://en.wikipedia.org/wiki/Simultaneous_localization_and_mapping)

    **Status**: current

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

  <Accordion title="Style Transfer" icon="book-open">
    **Definition**: Using deep neural networks to apply the visual style of one image or video to the content of another.

    **External**: [Neural style transfer (Wikipedia)](https://en.wikipedia.org/wiki/Neural_style_transfer)

    **Status**: current

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

  <Accordion title="Synthetic Data" icon="book-open">
    **Definition**: Artificially generated data produced by algorithms rather than real-world events, used for training AI models when real data is scarce or sensitive.

    **External**: [Synthetic data (Wikipedia)](https://en.wikipedia.org/wiki/Synthetic_data)

    **Status**: current

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

  <Accordion title="Upscaling" icon="book-open">
    **Definition**: Increasing image or video resolution using AI models that predict high-frequency detail not present in the source.

    **External**: [Image scaling (Wikipedia)](https://en.wikipedia.org/wiki/Image_scaling)

    **Status**: current

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

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

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

    **Status**: current

    **Pages**: `home/ai-video`, `home/use-cases`
  </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 with Ethereum-grade security.

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

    **Status**: current

    **Pages**: `home/network`, `home/staking`
  </Accordion>

  <Accordion title="Blockchain" icon="book-open">
    **Definition**: A distributed ledger of records (blocks) securely linked via cryptographic hashes, managed by peer-to-peer consensus.

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

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>

  <Accordion title="Decentralization" icon="book-open">
    **Definition**: Transfer of control from a centralised entity to a distributed network, reducing single points of failure.

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

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>

  <Accordion title="ETH (Ether)" icon="book-open">
    **Definition**: The native cryptocurrency of Ethereum, used to pay transaction fees (gas) and as the fee currency for Livepeer payment settlements.

    **External**: [What is Ether (Ethereum.org)](https://ethereum.org/what-is-ether/)

    **Status**: current

    **Pages**: `home/staking`, `home/network`
  </Accordion>

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

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

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>

  <Accordion title="Layer-2" icon="book-open">
    **Definition**: A separate blockchain extending a Layer 1 by handling transactions off-chain while inheriting the security guarantees of the base chain.

    **External**: [Layer 2 (Ethereum.org)](https://ethereum.org/layer-2/)

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>

  <Accordion title="Open Source" icon="book-open">
    **Definition**: Software distributed with its source code under a licence permitting study, modification, and redistribution; Livepeer's protocol, go-livepeer node software, and SDK libraries are all open source.

    **Tags**: `technical:concept`

    **External**: [Open-source software (Wikipedia)](https://en.wikipedia.org/wiki/Open-source_software)

    **Also known as**: open-source, FOSS

    **Status**: current

    **Pages**: `home/index`, `home/network`
  </Accordion>

  <Accordion title="Permissionless" icon="book-open">
    **Definition**: Property where anyone can participate without requiring approval from a central authority.

    **External**: [Web3 – permissionless (Ethereum.org)](https://ethereum.org/web3)

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>

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

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

    **Status**: current

    **Pages**: `home/network`, `home/governance`
  </Accordion>

  <Accordion title="Trustless" icon="book-open">
    **Definition**: System property where participants interact using cryptographic proofs rather than requiring trust in any third party.

    **External**: [Web3 – trustless (Ethereum.org)](https://ethereum.org/web3)

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Economic Terms

<AccordionGroup>
  <Accordion title="Micropayments" icon="book-open">
    **Definition**: Small-value payments for streaming services, implemented in Livepeer via a probabilistic lottery scheme to minimise on-chain transaction costs.

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

    **Status**: current

    **Pages**: `home/network`, `home/payments`
  </Accordion>

  <Accordion title="Probabilistic Micropayments" icon="book-open">
    **Definition**: Lottery-based payment model where only winning tickets are redeemed on-chain, amortizing transaction costs across many small payments.

    **External**: [Livepeer payments core concepts](https://livepeer.org/docs/video-developers/core-concepts/payments)

    **Status**: current

    **Pages**: `home/payments`, `home/network`
  </Accordion>

  <Accordion title="Reward" icon="book-open">
    **Definition**: Combination of inflationary LPT and ETH fees earned by Orchestrators and Delegators each protocol round.

    **Context**: Rewards in Livepeer have two components: inflationary LPT minted each round (distributed proportional to stake) and ETH fees from winning micropayment tickets (distributed via Fee Cut/share parameters set by each Orchestrator).

    **Status**: current

    **Pages**: `home/staking`, `home/network`
  </Accordion>

  <Accordion title="Staking" icon="book-open">
    **Definition**: Locking LPT tokens in a proof-of-stake protocol to participate in network security, governance, and earn inflationary rewards.

    **External**: [Proof of stake (Ethereum.org)](https://ethereum.org/developers/docs/consensus-mechanisms/pos/)

    **Status**: current

    **Pages**: `home/staking`, `home/network`
  </Accordion>

  <Accordion title="Treasury" icon="book-open">
    **Definition**: Pool of LPT held on-chain for funding public goods and ecosystem development, governed by token holder votes.

    **Context**: The Livepeer on-chain treasury is funded by a percentage of per-round inflationary LPT (Treasury Reward Cut Rate); allocations are approved via the LivepeerGovernor contract using stake-weighted voting.

    **Status**: current

    **Pages**: `home/governance`, `home/staking`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Video Terms

<AccordionGroup>
  <Accordion title="Frame Rate" icon="book-open">
    **Definition**: Frequency at which consecutive frames are captured or displayed, measured in frames per second (fps); common rates are 24, 30, and 60 fps.

    **External**: [Frame rate (Wikipedia)](https://en.wikipedia.org/wiki/Frame_rate)

    **Status**: current

    **Pages**: `home/streaming`, `home/video`
  </Accordion>

  <Accordion title="Latency" icon="book-open">
    **Definition**: Delay between capture at source and display on the viewer's device, accumulating at every pipeline stage.

    **External**: [Latency (Wikipedia)](https://en.wikipedia.org/wiki/Latency_\(audio\))

    **Status**: current

    **Pages**: `home/streaming`
  </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.

    **Tags**: `video:streaming`

    **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**: `home/streaming`, `home/ai-video`
  </Accordion>

  <Accordion title="Real-time" icon="book-open">
    **Definition**: Video delivery or AI processing with latency low enough for bidirectional interaction, typically under 500ms via WebRTC.

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

    **Status**: current

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

  <Accordion title="Streaming" icon="book-open">
    **Definition**: Continuous delivery of multimedia over a network rendered in real time, as opposed to full download before playback.

    **External**: [Streaming media (Wikipedia)](https://en.wikipedia.org/wiki/Streaming_media)

    **Status**: current

    **Pages**: `home/streaming`, `home/index`
  </Accordion>

  <Accordion title="Transcoding" icon="book-open">
    **Definition**: Direct digital-to-digital conversion of video from one encoding format or bitrate to another for adaptive multi-rendition delivery.

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

    **Status**: current

    **Pages**: `home/network`, `home/streaming`
  </Accordion>

  <Accordion title="VOD (Video on Demand)" icon="book-open">
    **Definition**: Video on demand – system allowing users to access pre-recorded content at any time, contrasting with live streaming.

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

    **Status**: current

    **Pages**: `home/streaming`, `home/video`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Technical Terms

<AccordionGroup>
  <Accordion title="GPU (Graphics Processing Unit)" icon="book-open">
    **Definition**: Specialised processor for parallel computation used in rendering, video encoding, and AI inference workloads.

    **External**: [Graphics processing unit (Wikipedia)](https://en.wikipedia.org/wiki/Graphics_processing_unit)

    **Status**: current

    **Pages**: `home/network`, `home/compute`
  </Accordion>

  <Accordion title="Node" icon="book-open">
    **Definition**: Computing device connected to a network participating in protocol operations such as transcoding, routing, or staking.

    **External**: [Node networking (Wikipedia)](https://en.wikipedia.org/wiki/Node_\(networking\))

    **Status**: current

    **Pages**: `home/network`, `home/architecture`
  </Accordion>

  <Accordion title="Scalability" icon="book-open">
    **Definition**: Ability to handle increasing workload by adding resources without degradation in performance or reliability.

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

    **Status**: current

    **Pages**: `home/network`, `home/index`
  </Accordion>
</AccordionGroup>

<CustomDivider />

## Operational Terms

<AccordionGroup>
  <Accordion title="Governance" icon="book-open">
    **Definition**: System of rules and processes for protocol decision-making including on-chain voting via LPT stake weight.

    **External**: [Livepeer Governance (GitHub wiki)](https://github.com/livepeer/wiki/wiki/Governance)

    **Status**: current

    **Pages**: `home/governance`, `home/network`
  </Accordion>

  <Accordion title="LIP (Livepeer Improvement Proposal)" icon="book-open">
    **Definition**: Formal design document proposing changes to the Livepeer Protocol, governance parameters, or ecosystem standards.

    **Context**: LIPs are the primary mechanism for protocol evolution in Livepeer; they follow a structured process from pre-proposal discussion on the governance forum through on-chain vote and execution.

    **Status**: current

    **Pages**: `home/governance`, `home/upgrades`
  </Accordion>
</AccordionGroup>

<CustomDivider />

<CardGroup cols={3}>
  <Card title="About Livepeer" icon="circle-info" href="/v2/about">
    Background on the Livepeer Protocol, mission, and ecosystem
  </Card>

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

  <Card title="Get Started" icon="rocket" href="/v2/home/get-started">
    Entry points for every role in the Livepeer ecosystem
  </Card>
</CardGroup>