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

# Local Development

> Running Livepeer components locally for development: options for local gateways, local orchestrators, and test networks.

export const TableCell = ({children, align = "left", header = false, style = {}, className = "", ...rest}) => {
  const Component = header ? "th" : "td";
  return <Component className={className} style={{
    padding: "0.75rem 1rem",
    textAlign: align,
    border: header ? "none" : "1px solid var(--lp-color-border-default)",
    ...style
  }} {...rest}>
      {children}
    </Component>;
};

export const TableRow = ({children, header = false, hover = false, style = {}, className = "", ...rest}) => {
  const rowId = `table-row-${Math.random().toString(36).substr(2, 9)}`;
  return <>
      {hover && <style>{`
          #${rowId}:hover {
            background-color: var(--lp-color-bg-card);
          }
        `}</style>}
      <tr id={rowId} className={className} style={{
    ...header && ({
      backgroundColor: "var(--lp-color-accent-strong)",
      color: "var(--lp-color-on-accent)",
      fontWeight: "bold"
    }),
    ...style
  }} {...rest}>
        {children}
      </tr>
    </>;
};

export const StyledTable = ({children, variant = "default", style = {}, className = "", ...rest}) => {
  const wrapperVariants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)",
      overflow: "hidden"
    },
    bordered: {
      border: "2px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-page)",
      overflow: "hidden"
    },
    minimal: {
      border: "none",
      backgroundColor: "transparent",
      overflow: "visible"
    }
  };
  return <div data-docs-styled-table-shell className={className} style={{
    width: "100%",
    padding: 0,
    margin: 0,
    ...wrapperVariants[variant],
    ...style
  }} {...rest}>
      <table data-docs-styled-table style={{
    width: "100%",
    borderCollapse: "collapse",
    borderSpacing: 0,
    margin: 0,
    backgroundColor: "transparent"
  }}>
        {children}
      </table>
    </div>;
};

export const CenteredContainer = ({children, maxWidth = "800px", padding = "0", preset = "default", width = "", minWidth = "", marginRight = "", marginBottom = "", textAlign = "", style = {}, className = "", ...rest}) => {
  const presets = {
    default: {},
    fitContent: {
      width: "fit-content",
      minWidth: "fit-content"
    },
    readable70: {
      width: "70%",
      minWidth: "fit-content"
    },
    readable80: {
      width: "80%",
      minWidth: "fit-content"
    },
    readable90: {
      width: "90%"
    },
    wide900: {
      maxWidth: "900px"
    }
  };
  const presetStyle = presets[preset] || presets.default;
  return <div className={className} style={{
    maxWidth: presetStyle.maxWidth || maxWidth,
    margin: "0 auto",
    padding: padding,
    ...presetStyle.width ? {
      width: presetStyle.width
    } : {},
    ...presetStyle.minWidth ? {
      minWidth: presetStyle.minWidth
    } : {},
    ...width ? {
      width
    } : {},
    ...minWidth ? {
      minWidth
    } : {},
    ...marginRight ? {
      marginRight
    } : {},
    ...marginBottom ? {
      marginBottom
    } : {},
    ...textAlign ? {
      textAlign
    } : {},
    ...style
  }} {...rest}>
      {children}
    </div>;
};

export const LinkArrow = ({href, label, description, newline = true, borderColor, className = '', style = {}, ...rest}) => {
  const linkArrowStyle = {
    display: 'inline-flex',
    alignItems: 'center',
    justifyContent: 'center',
    gap: "var(--lp-spacing-1)",
    width: 'fit-content',
    ...borderColor && ({
      borderColor
    })
  };
  return <span className={className} style={style} {...rest}>
      {newline && <br />}
      <span style={linkArrowStyle}>
        <a href={href} target="_blank" rel="noopener noreferrer">
          {label}
        </a>
        <Icon icon="arrow-up-right" size={14} color="var(--lp-color-accent)" />
      </span>
      {description && description}
      {description && <div style={{
    height: "var(--lp-spacing-3)"
  }} />}
    </span>;
};

<CenteredContainer preset="readable90">
  <Tip>For most development tasks, the community Gateway at dream-Gateway.Livepeer.cloud removes the need to run any local infrastructure. A local Gateway or Orchestrator is necessary only when you need network-level control or are testing node software itself.</Tip>
</CenteredContainer>

***

Most developer tasks (calling AI pipelines, uploading assets, testing playback) require only an API key or a Gateway endpoint. A full local Livepeer stack is necessary when developing node software, testing custom BYOC containers against a real Orchestrator, or working through payment flows without spending real ETH.

<CustomDivider />

## Choosing a Development Path

<StyledTable variant="bordered">
  <thead>
    <TableRow header>
      <TableCell header>Scenario</TableCell>
      <TableCell header>Recommended path</TableCell>
    </TableRow>
  </thead>

  <tbody>
    <TableRow>
      <TableCell>Calling AI pipelines or video APIs from application code</TableCell>
      <TableCell>Community Gateway at `dream-gateway.livepeer.cloud` (no local setup)</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>Testing a BYOC container or PyTrickle service</TableCell>
      <TableCell>Local Orchestrator with `aiModels.json` registration + community Gateway for routing</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>Developing or testing go-livepeer Gateway logic</TableCell>
      <TableCell>Local Gateway in broadcaster mode connected to mainnet Orchestrators</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>End-to-end protocol testing without real ETH</TableCell>
      <TableCell>Local devnet with a local Gateway + local Orchestrator</TableCell>
    </TableRow>

    <TableRow>
      <TableCell>Testing remote signer or payment flows</TableCell>
      <TableCell>Local Gateway + local signer + local Orchestrator on devnet</TableCell>
    </TableRow>
  </tbody>
</StyledTable>

<CustomDivider />

## Community Gateway (No Setup)

The public community Gateway at `https://dream-gateway.livepeer.cloud` accepts unauthenticated AI inference requests for development. It routes requests to active mainnet Orchestrators; no account or deposit is required.

```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
curl -X POST "https://dream-gateway.livepeer.cloud/text-to-image" \
  -H "Content-Type: application/json" \
  -d '{"model_id": "ByteDance/SDXL-Lightning", "prompt": "a blue house"}'
```

This is appropriate for prototyping and initial integration testing. For sustained development load, run a local Gateway to avoid rate limiting.

<CustomDivider />

## Installing go-livepeer

Download a pre-built binary from the go-livepeer releases page:

```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
# Linux x86-64 (replace RELEASE_VERSION with the latest release tag)
wget https://github.com/livepeer/go-livepeer/releases/download/<RELEASE_VERSION>/livepeer-linux-amd64.tar.gz
tar -zxvf livepeer-linux-amd64.tar.gz
mv livepeer-linux-amd64/* /usr/local/bin/

# GPU-accelerated build (NVIDIA)
wget https://github.com/livepeer/go-livepeer/releases/download/<RELEASE_VERSION>/livepeer-linux-gpu-amd64.tar.gz
tar -zxvf livepeer-linux-gpu-amd64.tar.gz
mv livepeer-linux-gpu-amd64/* /usr/local/bin/
```

macOS (Apple Silicon):

```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
wget https://github.com/livepeer/go-livepeer/releases/download/<RELEASE_VERSION>/livepeer-darwin-arm64.tar.gz
tar -zxvf livepeer-darwin-arm64.tar.gz
mv livepeer-darwin-arm64/* /usr/local/bin/
```

After installation, verify with `livepeer --version` and `livepeer_cli --version`.

<CustomDivider />

Most developers start with the community Gateway and never need local infrastructure. If you do need it, [local Gateway](/v2/developers/guides/local-development/local-Gateway) is the next step.

## Related Pages

<CardGroup cols={2}>
  <Card title="Local Gateway" icon="server" href="/v2/developers/guides/local-development/local-gateway" arrow horizontal>
    Running a go-livepeer broadcaster node locally connected to mainnet.
  </Card>

  <Card title="Local Orchestrator" icon="cpu" href="/v2/developers/guides/local-development/local-orchestrator" arrow horizontal>
    Running a local Orchestrator for testing BYOC containers and payment flows.
  </Card>

  <Card title="Tooling and Metrics" icon="chart" href="/v2/developers/guides/observability-and-debugging/tooling-and-metrics" arrow horizontal>
    Prometheus metrics and the Livepeer/monitor container for local node observation.
  </Card>
</CardGroup>