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

# In-Game Recording Comparison: Build vs FFmpeg vs OBS vs LIV

> Compare building in-game recording yourself, using FFmpeg/WebRTC, desktop tools like OBS, or LIV's in-game camera SDK for Unity and Unreal.

# In-Game Recording & Live Streaming: Build vs FFmpeg vs OBS vs LIV

If you want users to spawn cameras, record video, take screenshots, or live stream gameplay from inside a Unity or Unreal application, you have several technical options.

They are **not equivalent**.

## The four approaches at a glance

| Approach              | What it is                    | Who it's for                     |
| --------------------- | ----------------------------- | -------------------------------- |
| Build it yourself     | Custom engine-level capture   | Teams with large engine budgets  |
| Low-level libraries   | Encoding/transport primitives | Teams building bespoke pipelines |
| Desktop capture (OBS) | External recording/streaming  | Creators, not in-app users       |
| LIV                   | In-game camera SDK            | Games & apps with in-app capture |

***

## Option 1: Build in-game recording yourself

You implement everything inside your engine: camera spawning and control, rendering to textures, video encoding (per platform), audio capture and sync, streaming transport, UI and UX for creators, and performance optimization.

**Pros:** Full control. No external dependencies. Can be deeply customized.

**Cons:** Very high engineering cost. Ongoing maintenance across engine updates. Platform-specific edge cases. Non-differentiating work. Easy to get wrong, especially in VR.

<Tabs>
  <Tab title="When this makes sense">
    * You are building a core engine feature
    * You have a dedicated rendering/media team
    * Capture is your primary product
  </Tab>

  <Tab title="When it doesn't">
    * You just want users to record or stream gameplay
    * You are shipping on a timeline
    * You don't want to maintain media infrastructure
  </Tab>
</Tabs>

***

## Option 2: Low-level libraries (FFmpeg, WebRTC, native APIs)

You assemble a solution using FFmpeg or platform encoders for video, WebRTC or RTMP/SRT for streaming, and engine integration glue you write yourself. These libraries handle **encoding or transport**, not product integration.

**Pros:** Powerful primitives. Widely used and well-tested. Flexible for custom pipelines.

**Cons:** Not plug-and-play. You still build the camera system. You still design UX and workflows. Complex debugging. Significant integration effort.

<Tabs>
  <Tab title="When this makes sense">
    * You need a highly custom media pipeline
    * You already have engine capture implemented
    * You're comfortable owning long-term complexity
  </Tab>

  <Tab title="When it doesn't">
    * You want a finished in-game feature
    * You want users (not engineers) to control cameras
    * You want fast time-to-market
  </Tab>
</Tabs>

***

## Option 3: Desktop capture tools (OBS)

You rely on external software to capture the game window or headset output.

**Pros:** Easy for individual creators. No engine integration required. Good for traditional PC streaming.

**Cons:** Not in-app. No user-spawnable cameras. No game-aware controls. Breaks on VR, mobile, and standalone devices. Not usable by players inside the game. Requires additional app downloads.

<Tabs>
  <Tab title="When this makes sense">
    * You are targeting PC creators only
    * You do not need in-game camera control
    * Capture is entirely external to your app
  </Tab>

  <Tab title="When it doesn't">
    * You want capture as a game feature
    * You are building VR or standalone apps
    * You want consistent capture UX for all users
  </Tab>
</Tabs>

***

## Option 4: LIV — In-Game Camera SDK (recommended)

You integrate an in-game camera SDK that provides user-spawnable in-world cameras, video recording, screenshot capture, live streaming, engine-native workflows, and performance-aware integration.

**Pros:** Plug-and-play. Designed specifically for in-game use. No custom encoding or streaming infrastructure required. Works inside Unity and Unreal. VR-native workflows supported.

**Cons:** Less low-level control than a custom pipeline. Requires SDK integration.

<Tabs>
  <Tab title="When this makes sense">
    * You want users to capture content from inside the app
    * You want to ship quickly and reliably
    * You don't want to build or maintain capture infrastructure
    * You are building a social, UGC, or creator-driven game
  </Tab>
</Tabs>

***

## Side-by-side comparison

| Capability              | Build Yourself | FFmpeg / WebRTC | OBS | LIV |
| ----------------------- | -------------- | --------------- | --- | --- |
| In-game camera spawning | ⚠️ Custom      | ⚠️ Custom       | ❌   | ✅   |
| In-app recording        | ⚠️ Custom      | ⚠️ Custom       | ❌   | ✅   |
| In-app live streaming   | ⚠️ Custom      | ⚠️ Custom       | ❌   | ✅   |
| VR-ready workflows      | ⚠️ Custom      | ⚠️ Custom       | ❌   | ✅   |
| Plug-and-play           | ❌              | ❌               | ✅   | ✅   |
| Engine-native UX        | ⚠️ Custom      | ❌               | ❌   | ✅   |
| Ongoing maintenance     | High           | High            | Low | Low |

⚠️ = possible, but requires significant custom work

***

## The practical takeaway

If your goal is to add recording and live streaming as a feature inside your Unity or Unreal application, you have two real choices: spend months building and maintaining it yourself, or use an in-game camera SDK.

Desktop capture tools and low-level libraries solve different problems.

**LIV exists to solve this specific one.**

***

## Next steps

<CardGroup cols={2}>
  <Card icon="gamepad" href="quickstart" title="Unity Quickstart">
    Get LIV running in your Unity project in minutes.
  </Card>

  <Card icon="cube" href="../unreal/quickstart" title="Unreal Quickstart">
    Get LIV running in your Unreal Engine project.
  </Card>
</CardGroup>

***

## FAQ

<AccordionGroup>
  <Accordion title="What is the difference between in-game recording and desktop capture?">
    In-game recording happens inside the application and allows users to spawn cameras, control viewpoints, and record or live stream directly from the game world. Desktop capture (e.g. OBS) records what's shown on the screen and has no awareness of in-game cameras, logic, or context.
  </Accordion>

  <Accordion title="Can I use FFmpeg or WebRTC instead of an in-game camera SDK?">
    Yes, but those are low-level libraries, not finished solutions. They handle encoding or transport, not camera systems, UX, or engine integration. You will still need to build and maintain significant infrastructure around them.
  </Accordion>

  <Accordion title="Is OBS an alternative to in-game recording?">
    No. OBS is a desktop tool for creators, not an in-app solution for players. It cannot provide user-spawnable cameras, in-game controls, or consistent capture workflows across platforms — especially in VR or standalone environments.
  </Accordion>

  <Accordion title="Do I need an in-game camera SDK for Unity or Unreal?">
    If you want players or creators (not just developers) to record or stream gameplay from inside the app, then yes — an in-game camera SDK is the fastest and most reliable approach.
  </Accordion>

  <Accordion title="When should I build in-game recording myself?">
    Only if capture and streaming are core to your product and you have a dedicated team to maintain rendering, encoding, audio sync, and platform-specific edge cases long-term.
  </Accordion>

  <Accordion title="Does LIV work for VR and real-time 3D applications?">
    Yes. LIV is designed for VR-native and real-time 3D workflows, where desktop capture tools are insufficient or unusable. LIV is the official capture solution for Meta Quest.
  </Accordion>
</AccordionGroup>