diff --git a/.github/workflows/pose_vis.yml b/.github/workflows/pose_vis.yml
new file mode 100644
index 00000000..96229f9e
--- /dev/null
+++ b/.github/workflows/pose_vis.yml
@@ -0,0 +1,21 @@
+on: [push]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Python setup ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install PoseVis
+        run: |
+          cd devices/webcam
+          python setup.py install
+      - name: Run PoseVis tests
+        run: |
+          cd devices/webcam
+          python -m unittest pose_vis/test/tests.py
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 00000000..c7e7da8e
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,8 @@
+{
+    "buck.projectConfig": {
+        "projectPath": "c:\\Users\\das\\Desktop\\labgraph\\manylinux.buckconfig",
+        "flavor": [],
+        "target": "",
+        "platform": "linux-x86_64"
+    }
+}
\ No newline at end of file
diff --git a/devices/webcam/__init__.py b/devices/webcam/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/benchmark.ipynb b/devices/webcam/benchmark.ipynb
new file mode 100644
index 00000000..91047a83
--- /dev/null
+++ b/devices/webcam/benchmark.ipynb
@@ -0,0 +1,361 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5a180c32",
+   "metadata": {},
+   "source": [
+    "## PoseVis Data Quality\n",
+    "\n",
+    "Runs a series of benchmarks and reports data quality metrics such as dropped frame percentage, latency, and jitter."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d73eadd6",
+   "metadata": {},
+   "source": [
+    "### Install py-cpuinfo for System Info"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "470df640",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting py-cpuinfo\n",
+      "  Downloading py_cpuinfo-9.0.0-py3-none-any.whl (22 kB)\n",
+      "Installing collected packages: py-cpuinfo\n",
+      "Successfully installed py-cpuinfo-9.0.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "[notice] A new release of pip available: 22.2.2 -> 22.3\n",
+      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install py-cpuinfo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c966bc06",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Python version: 3.10.8.final.0 (64 bit)\n",
+      "CPU: Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cpuinfo\n",
+    "\n",
+    "info = cpuinfo.get_cpu_info()\n",
+    "print(f\"Python version: {info['python_version']}\")\n",
+    "print(f\"CPU: {info['brand_raw']}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e33b67a",
+   "metadata": {},
+   "source": [
+    "### Run Benchmarks\n",
+    "\n",
+    "Devices tested are: (0) Logitech C270 Webcam, and (1) VUPUMER Webcam"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "555aadb1",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pose_vis.runner: building graph\n",
+      "INFO:pose_vis.runner: logging directory is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runners.benchmark_runner: benchmark output path is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runner: running graph\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### Running benchmark: benchmark_1_sources_1280x720x30\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pose_vis.runner: building graph\n",
+      "INFO:pose_vis.runner: enabling extension: HandsExtension\n",
+      "INFO:pose_vis.runner: logging directory is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runners.benchmark_runner: benchmark output path is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runner: running graph\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### Benchmark complete: benchmark_1_sources_1280x720x30\n",
+      "### Running benchmark: benchmark_1_sources_1280x720x30_HandsExtension\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pose_vis.runner: building graph\n",
+      "INFO:pose_vis.runner: logging directory is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runners.benchmark_runner: benchmark output path is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runner: running graph\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### Benchmark complete: benchmark_1_sources_1280x720x30_HandsExtension\n",
+      "### Running benchmark: benchmark_2_sources_1280x720x30\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pose_vis.runner: building graph\n",
+      "INFO:pose_vis.runner: enabling extension: HandsExtension\n",
+      "INFO:pose_vis.runner: logging directory is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runners.benchmark_runner: benchmark output path is c:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runner: running graph\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### Benchmark complete: benchmark_2_sources_1280x720x30\n",
+      "### Running benchmark: benchmark_2_sources_1280x720x30_HandsExtension\n",
+      "### Benchmark complete: benchmark_2_sources_1280x720x30_HandsExtension\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import pose_vis.pose_vis\n",
+    "\n",
+    "from dataclasses import dataclass\n",
+    "from typing import List, Tuple\n",
+    "from pose_vis.extension import PoseVisExtension\n",
+    "from pose_vis.runner import PoseVisConfig\n",
+    "from pose_vis.runners.benchmark_runner import BenchmarkRunner, BenchmarkRunnerConfig\n",
+    "from pose_vis.extensions.hands import HandsExtension\n",
+    "\n",
+    "@dataclass\n",
+    "class BenchmarkConfig():\n",
+    "    extensions: List[PoseVisExtension]\n",
+    "    logging: bool\n",
+    "    sources: List[int]\n",
+    "    resolution: Tuple[int, int, int]\n",
+    "    runtime: int\n",
+    "\n",
+    "benchmarks = [\n",
+    "    # Single camera, 1280x720x30\n",
+    "    BenchmarkConfig([], False, [0], (1280, 720, 30), 60),\n",
+    "    # Single camera, 1280x720x30, hand tracking\n",
+    "    BenchmarkConfig([HandsExtension()], False, [0], (1280, 720, 30), 60),\n",
+    "    # Two cameras, 1280x720x30\n",
+    "    BenchmarkConfig([], False, [0, 1], (1280, 720, 30), 60),\n",
+    "    # Two cameras, 1280x720x30, hand tracking\n",
+    "    BenchmarkConfig([HandsExtension()], False, [0, 1], (1280, 720, 30), 60),\n",
+    "]\n",
+    "\n",
+    "for benchmark in benchmarks:\n",
+    "    config = PoseVisConfig(\n",
+    "        extensions = benchmark.extensions,\n",
+    "        log_directory = f\"webcam{os.sep}logs\",\n",
+    "        log_name = \"benchmark\",\n",
+    "        enable_logging = benchmark.logging,\n",
+    "        display_framerate = 0,\n",
+    "        stats_history_size = 0)\n",
+    "\n",
+    "    resolutions = [benchmark.resolution for _ in range(len(benchmark.sources))]\n",
+    "    output_name = f\"benchmark_{len(benchmark.sources)}_sources_{resolutions[0][0]}x{resolutions[0][1]}x{resolutions[0][2]}\"\n",
+    "\n",
+    "    if len(benchmark.extensions) > 0:\n",
+    "        ext_names = \"\"\n",
+    "        for i in range(len(benchmark.extensions)):\n",
+    "            sep = \"_\" if i > 0 else \"\"\n",
+    "            ext_names += f\"{sep}{benchmark.extensions[i].__class__.__name__}\"\n",
+    "        output_name = f\"{output_name}_{ext_names}\"\n",
+    "    if benchmark.logging:\n",
+    "        output_name = f\"{output_name}_logging\"\n",
+    "    \n",
+    "    runner_config = BenchmarkRunnerConfig(\n",
+    "        sources = benchmark.sources,\n",
+    "        resolutions = resolutions,\n",
+    "        output_path = f\"webcam{os.sep}logs\",\n",
+    "        output_name = output_name,\n",
+    "        run_time = 60)\n",
+    "    runner = BenchmarkRunner(config, runner_config)\n",
+    "\n",
+    "    print(f\"### Running benchmark: {output_name}\")\n",
+    "    runner.build()\n",
+    "    runner.run()\n",
+    "    print(f\"### Benchmark complete: {output_name}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3ff8a0ea",
+   "metadata": {},
+   "source": [
+    "### Display Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "dc52cb95",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "## Benchmark: benchmark_1_sources_1280x720x30\n",
+      "# runtime: 60.55s\n",
+      "# dropped: 0.75%\n",
+      "# latency: 16.69ms\n",
+      "# jitter: 5.04ms\n",
+      "# [desync]\n",
+      " \n",
+      "## Benchmark: benchmark_1_sources_1280x720x30_HandsExtension\n",
+      "# runtime: 60.45s\n",
+      "# dropped: 0.64%\n",
+      "# latency: 5.17ms\n",
+      "# jitter: 4.14ms\n",
+      "# [desync]\n",
+      " \n",
+      "## Benchmark: benchmark_2_sources_1280x720x30\n",
+      "# runtime: 60.42s\n",
+      "# dropped: 0.64%\n",
+      "# latency: 13.33ms\n",
+      "# jitter: 11.09ms\n",
+      "# [desync]\n",
+      "# from source 0 to source 1: 2.43ms, jitter: 11.02ms\n",
+      " \n",
+      "## Benchmark: benchmark_2_sources_1280x720x30_HandsExtension\n",
+      "# runtime: 60.46s\n",
+      "# dropped: 28.10%\n",
+      "# latency: 4.94ms\n",
+      "# jitter: 5.80ms\n",
+      "# [desync]\n",
+      "# from source 0 to source 1: 0.11ms, jitter: 6.10ms\n",
+      " \n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "import statistics\n",
+    "from pose_vis.utils import absolute_path\n",
+    "from typing import Dict, Union, List, Tuple\n",
+    "\n",
+    "json_files = [_file for _file in os.listdir(absolute_path(f\"webcam{os.sep}logs\")) if _file.endswith(\".json\")]\n",
+    "\n",
+    "for filename in json_files:\n",
+    "    timings: Dict[str, Union[float, int, List[Tuple[float, float, float]]]] = {}\n",
+    "\n",
+    "    with open(absolute_path(f\"webcam{os.sep}logs{os.sep}{filename}\")) as _file:\n",
+    "        timings = json.loads(_file.read())\n",
+    "\n",
+    "    print(f\"## Benchmark: {filename.removesuffix('.json')}\")\n",
+    "    print(f\"# runtime: {timings['runtime']:.2f}s\")\n",
+    "\n",
+    "    expected_frames = timings[\"runtime\"] * timings[\"target_fps\"]\n",
+    "    # Estimate of how many frames were dropped while capturing the source\n",
+    "    source_received_frames_pct = timings[\"frame_index\"] / expected_frames\n",
+    "    print(f\"# dropped: {(100 - (source_received_frames_pct * 100)):.2f}%\")\n",
+    "\n",
+    "    latency: List[float] = []\n",
+    "    desync: List[List[float]] = []\n",
+    "    # device time = system time at frame capture from device\n",
+    "    # All times are captured with time.perf_counter()\n",
+    "    # times: List[(device time, receive time)]\n",
+    "    for i in range(1, len(timings[\"times\"])):\n",
+    "        rel_device = timings[\"times\"][i][0] - timings[\"times\"][0][0]\n",
+    "        rel_receive = timings[\"times\"][i][1] - timings[\"times\"][0][1]\n",
+    "        # TODO: this may not be correct\n",
+    "        # `rel_device` can be greater than `rel_receive`, for now we just take the absolute value\n",
+    "        latency.append(abs(rel_receive - rel_device))\n",
+    "\n",
+    "        if len(timings[\"sync\"]) > 0:\n",
+    "            if i == 1:\n",
+    "                desync = [[] for j in range(len(timings[\"sync\"][i]))]\n",
+    "\n",
+    "            for j in range(len(timings[\"sync\"][i])):\n",
+    "                desync[j].append(abs(timings[\"times\"][i][0] - timings[\"sync\"][i][j]))\n",
+    "    \n",
+    "    print(f\"# latency: {statistics.median(latency) * 1000:.2f}ms\")\n",
+    "    print(f\"# jitter: {statistics.stdev(latency) * 1000:.2f}ms\")\n",
+    "    print(\"# [desync]\")\n",
+    "    for i, li in enumerate(desync):\n",
+    "        print(f\"# from source 0 to source {i + 1}: {statistics.median(desync[i]) * 1000:.2f}ms, jitter: {statistics.stdev(desync[i]) * 1000:.2f}ms\")\n",
+    "    print(\" \")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.13 ('.venv': venv)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "23a593576959775a19d6469cad78770ba03ee1b7699646fbac2d14539ad9dcf0"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/devices/webcam/images/pexels-min-an-1454797.jpg b/devices/webcam/images/pexels-min-an-1454797.jpg
new file mode 100644
index 00000000..f126650f
Binary files /dev/null and b/devices/webcam/images/pexels-min-an-1454797.jpg differ
diff --git a/devices/webcam/images/pexels-min-an-1454797.md b/devices/webcam/images/pexels-min-an-1454797.md
new file mode 100644
index 00000000..d5dc1f7c
--- /dev/null
+++ b/devices/webcam/images/pexels-min-an-1454797.md
@@ -0,0 +1 @@
+This file was obtained from [pexels.com](https://www.pexels.com/photo/person-s-hand-in-shallow-photo-1454797/). It is marked as [free to use](https://www.pexels.com/license/).
\ No newline at end of file
diff --git a/devices/webcam/linux_gstreamer.md b/devices/webcam/linux_gstreamer.md
new file mode 100644
index 00000000..c4d0abb2
--- /dev/null
+++ b/devices/webcam/linux_gstreamer.md
@@ -0,0 +1,96 @@
+# Linux GStreamer Guide
+
+In this guide we will install GStreamer and build OpenCV with GStreamer support. This guide uses a fresh install of Ubuntu 20.04.
+
+## Build OpenCV
+
+Create a virtual environment for use with PoseVis:
+
+    sudo apt install python3.8-venv -y && python3 -m venv .venv && source .venv/bin/activate
+
+Install Numpy:
+
+    python -m pip install numpy
+
+Install GStreamer:
+
+    sudo apt install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libgstreamer-plugins-bad1.0-dev gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav gstreamer1.0-tools gstreamer1.0-x gstreamer1.0-gl gstreamer1.0-gtk3 -y
+
+Install required OpenCV libraries:
+
+    sudo apt install cmake libgtk-3-dev python3-dev -y
+
+We'll be building and installing OpenCV and OpenCV Contrib 4.6.0. Clone the branches:
+
+    sudo apt install git && git clone -b 4.6.0 --single-branch https://github.com/opencv/opencv.git && git clone -b 4.6.0 --single-branch https://github.com/opencv/opencv_contrib.git
+
+Create a build directory for OpenCV and `cd` into it:
+
+    mkdir opencv/build && cd opencv/build
+
+Run CMake with the following config:
+
+    cmake ../ \
+    -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \
+    -D PYTHON_DEFAULT_EXECUTABLE=$(which python3) \
+    -D BUILD_EXAMPLES=OFF \
+    -D INSTALL_C_EXAMPLES=OFF \
+    -D INSTALL_PYTHON_EXAMPLES=OFF \
+    -D BUILD_opencv_python2=OFF \
+    -D PYTHON3_INCLUDE_DIR=$(python -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())") \
+    -D PYTHON3_PACKAGES_PATH=$(python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())") \
+    -D PYTHON_LIBRARY=$(python -c "from distutils.sysconfig import get_config_var; from os.path import dirname, join; print(join(dirname(get_config_var('LIBPC')), get_config_var('LDLIBRARY')))") \
+    -D BUILD_opencv_python3=ON
+
+Check GTK, V4L2, GStreamer, and Python3 status:
+
+    --   GUI:                           GTK3
+    --     GTK+:                        YES (ver 3.24.33)
+
+    ...
+
+    --   Video I/O:
+    --     GStreamer:                   YES (1.20.3)
+    --     v4l/v4l2:                    YES (linux/videodev2.h)
+    
+    ...
+
+    --   Python 3:
+    --     Interpreter:                 /home/cody/.venv/bin/python3 (ver 3.8.15)
+    --     Libraries:                   /usr/lib/x86_64-linux-gnu/libpython3.8.so (ver 3.8.15)
+    --     numpy:                       /home/cody/.venv/lib/python3.8/site-packages/numpy/core/include (ver 1.23.4)
+    --     install path:                /home/cody/.venv/lib/python3.8/site-packages/cv2/python-3.8
+
+If everything looks good, build and install:
+
+    make -j$(nproc) && sudo make install
+
+Fix CV2 Python package permissions: **replace *[user]* with your username**
+
+    export CV2_PATH=$(python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())")/cv2 \
+    sudo chown -R [user] CV2_PATH \
+    sudo chgrp -R [user] CV2_PATH \
+    sudo chmod -R 775 CV2_PATH
+
+## Install MediaPipe
+
+Install MediaPipe from PyPi:
+
+    python -m pip install mediapipe
+
+## Install LabGraph and Test
+
+Install LabGraph from PyPi:
+
+    python -m pip install labgraph
+
+`cd` into your LabGraph installation, assuming you've installed it in your home directory:
+
+    cd ~/labgraph/devices/webcam
+
+Make sure PoseVis with GStreamer integration works:
+
+    python -m pose_vis.pose_vis --sources "videotestsrc ! video/x-raw, width=1280, height=720, framerate=30/1, format=BGR ! appsink"
+
+If all is well, you're now finished. Check [Using PoseVis](readme.md#using-posevis) for more usage examples. Enjoy using PoseVis!
+
diff --git a/devices/webcam/logging_example.ipynb b/devices/webcam/logging_example.ipynb
new file mode 100644
index 00000000..6843d987
--- /dev/null
+++ b/devices/webcam/logging_example.ipynb
@@ -0,0 +1,272 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b60bdb84",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:pose_vis.runner: building graph\n",
+      "INFO:pose_vis.runner: enabling extension: HandsExtension\n",
+      "INFO:pose_vis.runner: logging directory is C:\\Users\\das\\Desktop\\labgraph\\devices\\webcam\\logs\n",
+      "INFO:pose_vis.runner: running graph\n",
+      "WARNING:labgraph.graphs.graph:PoseVis has unused topics:\n",
+      "\t- STREAM/OUTPUT has no subscribers\n",
+      "This could mean that there are publishers and/or subscribers of Cthulhu streams that Labgraph doesn't know about, and/or that data in some topics is being discarded.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "from pose_vis.extensions.hands import HandsExtension\n",
+    "from pose_vis.runner import PoseVisConfig\n",
+    "from pose_vis.runners.source_runner import SourceStreamRunner, SourceStreamRunnerConfig\n",
+    "from pose_vis.utils import absolute_path\n",
+    "\n",
+    "# This runs the SourceStream node in pose_vis/streams/source_stream.py\n",
+    "# It supports videos, image directories, and camera devices\n",
+    "# Given a directory, it will load all images in the directory and run them through\n",
+    "# the graph until all are processed, then closes the graph\n",
+    "# We also enable data logging, outputting to logs/logging_example.h5\n",
+    "config = PoseVisConfig(\n",
+    "    extensions = [HandsExtension()],\n",
+    "    log_directory = f\"webcam{os.sep}logs\",\n",
+    "    log_name = \"logging_example\",\n",
+    "    enable_logging = True,\n",
+    "    # 0 disables the Display node\n",
+    "    display_framerate = 0,\n",
+    "    stats_history_size = 0)\n",
+    "\n",
+    "# Each source will be ran until completion, in this case we only have 1 source\n",
+    "runner_config = SourceStreamRunnerConfig(\n",
+    "    sources = [absolute_path(f\"webcam{os.sep}images\")],\n",
+    "    # Since we're loading images from a directory the resolution doesn't apply,\n",
+    "    # but we need to specify a framerate regardless\n",
+    "    resolutions = [(0, 0, 30)])\n",
+    "\n",
+    "# Build and run the graph\n",
+    "runner = SourceStreamRunner(config, runner_config)\n",
+    "runner.build()\n",
+    "# Other nodes could be inserted into the graph here, check pose_vis/dynamic_graph.py\n",
+    "runner.run()\n",
+    "# Unfortunately Jupyter doesn't grab the child process output, so we're missing the rest of the console output here\n",
+    "# Unused topic warnings can be ignored"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5c95e7a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[landmark {\n",
+      "  x: 0.3666782\n",
+      "  y: 0.6836816\n",
+      "  z: 1.3609244e-06\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.40242448\n",
+      "  y: 0.667752\n",
+      "  z: -0.18654017\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.39794287\n",
+      "  y: 0.5872192\n",
+      "  z: -0.24172299\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.40340263\n",
+      "  y: 0.49869713\n",
+      "  z: -0.24058115\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.3927693\n",
+      "  y: 0.40063044\n",
+      "  z: -0.22521572\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.27260906\n",
+      "  y: 0.47896463\n",
+      "  z: -0.25453687\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.25475854\n",
+      "  y: 0.33122495\n",
+      "  z: -0.31093124\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.24936885\n",
+      "  y: 0.23572053\n",
+      "  z: -0.34202737\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.26004127\n",
+      "  y: 0.16758552\n",
+      "  z: -0.3568705\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.2801903\n",
+      "  y: 0.47701693\n",
+      "  z: -0.14896862\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.30427077\n",
+      "  y: 0.33153397\n",
+      "  z: -0.19376588\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.37751722\n",
+      "  y: 0.2612969\n",
+      "  z: -0.21913196\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.4529705\n",
+      "  y: 0.23412205\n",
+      "  z: -0.23570204\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.29964173\n",
+      "  y: 0.47477144\n",
+      "  z: -0.049662407\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.3382794\n",
+      "  y: 0.3543827\n",
+      "  z: -0.105578855\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.41483483\n",
+      "  y: 0.31347528\n",
+      "  z: -0.16686752\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.48280495\n",
+      "  y: 0.2856946\n",
+      "  z: -0.20450525\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.32483783\n",
+      "  y: 0.4750077\n",
+      "  z: 0.041422643\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.3839665\n",
+      "  y: 0.44780323\n",
+      "  z: -0.016068315\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.45829943\n",
+      "  y: 0.46123245\n",
+      "  z: -0.070152506\n",
+      "}\n",
+      "landmark {\n",
+      "  x: 0.5171263\n",
+      "  y: 0.47498128\n",
+      "  z: -0.10491397\n",
+      "}\n",
+      "]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import cv2\n",
+    "import matplotlib.pyplot as plt\n",
+    "from labgraph.loggers.hdf5.reader import HDF5Reader\n",
+    "from pose_vis.utils import absolute_path\n",
+    "from pose_vis.streams.messages import CaptureResult\n",
+    "from pose_vis.extension import ExtensionResult\n",
+    "from pose_vis.extensions.hands import HandsExtension\n",
+    "\n",
+    "# Let's load the hdf5 log\n",
+    "path = absolute_path(f\"webcam{os.sep}logs{os.sep}logging_example.h5\")\n",
+    "# All data is logged under the \"captures\" dataset\n",
+    "log_types = {\"captures\": CaptureResult}\n",
+    "reader = HDF5Reader(path, log_types)\n",
+    "\n",
+    "# Since the images directory only contains 1 image, there should only be 1 set of messages\n",
+    "message: CaptureResult = reader.logs[\"captures\"][0]\n",
+    "\n",
+    "# Draw an overlay using data created by HandsExtension\n",
+    "# The captures attribute is a list of every source given to the runner\n",
+    "original_image = message.captures[0].frame\n",
+    "overlayed_image = original_image.copy()\n",
+    "HandsExtension.draw_overlay(\n",
+    "    overlayed_image,\n",
+    "    # Like captures, extensions holds results per-stream\n",
+    "    ExtensionResult(data = message.extensions[0][\"HandsExtension\"]))\n",
+    "\n",
+    "# We should convert from BGR to RGB for matplotlib\n",
+    "original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)\n",
+    "overlayed_image = cv2.cvtColor(overlayed_image, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# Let's take a look at the images\n",
+    "fig = plt.figure()\n",
+    "fig.add_subplot(1, 2, 1)\n",
+    "plt.imshow(original_image)\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(\"Original\")\n",
+    "fig.add_subplot(1, 2, 2)\n",
+    "plt.imshow(overlayed_image)\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(\"Overlayed\")\n",
+    "plt.show()\n",
+    "\n",
+    "# We can view the data that the hands extension produced\n",
+    "print(message.extensions[0][\"HandsExtension\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b8a27049",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.8 ('.venv': venv)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "23a593576959775a19d6469cad78770ba03ee1b7699646fbac2d14539ad9dcf0"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/devices/webcam/pose_vis/__init__.py b/devices/webcam/pose_vis/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/pose_vis/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/benchmark.py b/devices/webcam/pose_vis/benchmark.py
new file mode 100644
index 00000000..cb9115d1
--- /dev/null
+++ b/devices/webcam/pose_vis/benchmark.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import asyncio
+import logging
+import time
+import multiprocessing
+import labgraph as lg
+
+from queue import Queue
+from pose_vis.streams.messages import Capture, CaptureResult, ExitSignal
+from pose_vis.benchmark_worker import BenchmarkWorker
+from typing import Optional, List
+
+logger = logging.getLogger(__name__)
+
+class CapturePoint():
+    __slots__ = "rec_time", "captures"
+
+    def __init__(self, rec_time: float, captures: List[Capture]) -> None:
+        self.rec_time = rec_time
+        self.captures = captures
+
+class BenchmarkConfig(lg.Config):
+    """
+    Config for `Benchmark`
+
+    Attributes:
+        `output_path`: `str` path to output results
+        `output_name`: `str` output filename (no extension)
+        `run_time`: `int` how long to benchmark for
+    """
+    output_path: str
+    output_name: str
+    run_time: int
+
+class BenchmarkState(lg.State):
+    """
+    State for `Benchmark`
+
+    Attributes:
+        `start_time`: `float`
+        `done`: `bool`
+        `tasks`: `Optional[multiprocessing.JoinableQueue]`
+        `worker`: `Optional[BenchmarkWorker]`
+    """
+    start_time: float = 0.0
+    done: bool = False
+    points: Optional[Queue] = None
+    tasks: Optional[multiprocessing.JoinableQueue] = None
+    worker: Optional[BenchmarkWorker] = None
+
+class Benchmark(lg.Node):
+    """
+    Records timestamps from `CaptureResult`
+
+    Topics:
+        `INPUT`: `CaptureResult`
+        `OUTPUT_EXIT`: `ExitSignal`
+    """
+    INPUT = lg.Topic(CaptureResult)
+    OUTPUT_EXIT = lg.Topic(ExitSignal)
+    state: BenchmarkState
+    config: BenchmarkConfig
+
+    def setup(self) -> None:
+        logger.info(f" benchmarking for {self.config.run_time} seconds")
+        self.state.points = Queue()
+        self.state.tasks = multiprocessing.JoinableQueue()
+        self.state.worker = BenchmarkWorker(self.state.tasks, 0, self.config.output_path, self.config.output_name)
+        self.state.worker.start()
+
+    @lg.publisher(OUTPUT_EXIT)
+    async def on_done(self) -> lg.AsyncPublisher:
+        while True:
+            point: CapturePoint = None
+            try:
+                point = self.state.points.get_nowait()
+            except:
+                pass
+            if point is not None:
+                cap0 = point.captures[0]
+                self.state.tasks.put((
+                    point.rec_time,
+                    (cap0.frame_index, cap0.proc_runtime, cap0.proc_target_fps, cap0.system_timestamp),
+                    [point.captures[i].system_timestamp for i in range(1, len(point.captures))]))
+            elif self.state.done:
+                break
+            await asyncio.sleep(0.005)
+        yield self.OUTPUT_EXIT, ExitSignal()
+
+    @lg.subscriber(INPUT)
+    async def on_msg(self, message: CaptureResult) -> None:
+        rec_time = time.perf_counter()
+        if self.state.start_time == 0:
+            self.state.start_time = rec_time
+
+        if not self.state.done and rec_time - self.state.start_time >= self.config.run_time:
+            self.state.done = True
+        elif rec_time - self.state.start_time > 5:
+            captures = message.captures[:]
+            # We're ignoring the first 5 seconds to give the graph time to stabilize and get a more accurate result
+            self.state.points.put(CapturePoint(rec_time, captures))
+                
+    def cleanup(self) -> None:
+        logger.info(" closing worker...")
+        self.state.tasks.put(None)
+        self.state.tasks.join()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/benchmark_worker.py b/devices/webcam/pose_vis/benchmark_worker.py
new file mode 100644
index 00000000..bb45ae2b
--- /dev/null
+++ b/devices/webcam/pose_vis/benchmark_worker.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import os
+import json
+import logging
+import multiprocessing
+
+from typing import List
+from typing import Dict, List, Tuple, Union
+
+from pose_vis.streams.messages import Capture
+
+logger = logging.getLogger(__name__)
+
+class BenchmarkWorker(multiprocessing.Process):
+    """
+    Handles capturing performance metrics without skewing results
+    """
+
+    tasks: multiprocessing.JoinableQueue
+    worker_number: int
+    output_path: str
+    output_name: str
+    start_time = 0.0
+    output: Dict[str, Union[float, int, List[Tuple[float, float]], List[List[float]]]] = {"runtime": 0.0, "target_fps": 0, "frame_index": 0, "times": [], "sync": []}
+
+    def __init__(self, tasks: multiprocessing.JoinableQueue, worker_number: int, output_path: str, output_name: str):
+        self.tasks = tasks
+        self.worker_number = worker_number
+        self.output_path = output_path
+        self.output_name = output_name
+        super().__init__()
+    
+    def run(self):
+        logger.info(f" worker {self.worker_number}: started")
+        while True:
+            val: Tuple[float, Tuple[int, float, int, float], List[float]] = self.tasks.get()
+            if val is not None:
+                self.output["runtime"] = val[1][1]
+                self.output["target_fps"] = val[1][2]
+                self.output["frame_index"] = val[1][0]
+                self.output["times"].append((val[1][3], val[0]))
+                if len(val[2]) > 0:
+                    self.output["sync"].append(val[2])
+                self.tasks.task_done()
+            else:
+                self.tasks.task_done()
+                logger.info(f" saving timings to {self.output_path}")
+                with open(os.path.join(self.output_path, f"{self.output_name}.json"), "w") as output:
+                    output.write(json.dumps(self.output))
+                logger.info(f" worker {self.worker_number}: shutting down")
+                break
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/display.py b/devices/webcam/pose_vis/display.py
new file mode 100644
index 00000000..4576fc03
--- /dev/null
+++ b/devices/webcam/pose_vis/display.py
@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Windows-specific performance tuning
+import os
+if os.name == "nt":
+    # Improve sleep timer resolution for this process on Windows
+    # https://learn.microsoft.com/en-us/windows/win32/api/timeapi/nf-timeapi-timebeginperiod
+    import ctypes
+    winmm = ctypes.WinDLL('winmm')
+    winmm.timeBeginPeriod(1)
+
+import logging
+import time
+import labgraph as lg
+
+from typing import Optional, Dict
+from pose_vis.performance_utility import PerfUtility
+from pose_vis.streams.messages import CaptureResult, ExitSignal
+from pose_vis.display_handler import DisplayHandler
+
+logger = logging.getLogger(__name__)
+
+class DisplayConfig(lg.Config):
+    """
+    Config for Display node
+
+    Attributes:
+        `target_framerate`: `int` target framerate for updating CV2 windows
+        `stats_history_size`: `int` how many frame stats to remember
+        `extension_types`: `Dict[str, type]` type lookup for enabled extensions
+    """
+    target_framerate: int
+    stats_history_size: int
+    extension_types: Dict[str, type]
+
+class DisplayState(lg.State):
+    """
+    State for Display node
+
+    Attributes:
+        `handler`: `DisplayHandler`
+        `running`: `bool`
+        `perf`: `PerfUtility`
+    """
+    handler: Optional[DisplayHandler] = None
+    running: bool = True
+    perf: PerfUtility = PerfUtility()
+
+class Display(lg.Node):
+    """
+    Draws overlays and presents them
+
+    Topics:
+        `INPUT`: `CaptureResult`
+    
+    Attributes:
+        `state`: `DisplayState`
+        `config`: `DisplayConfig`
+    """
+    INPUT = lg.Topic(CaptureResult)
+    INPUT_EXIT_STREAM = lg.Topic(ExitSignal)
+    INPUT_EXIT_USER = lg.Topic(ExitSignal)
+    state: DisplayState
+    config: DisplayConfig
+
+    def setup(self) -> None:
+        self.state.handler = DisplayHandler(self.config.stats_history_size, self.config.extension_types)
+        self.state.handler.register_key_callback(self.on_key)
+
+    @lg.subscriber(INPUT)
+    async def update(self, message: CaptureResult) -> None:
+        self.state.handler.update_frames(message.captures[:], message.extensions[:])
+
+    @lg.subscriber(INPUT_EXIT_STREAM)
+    async def on_exit_stream(self, _: ExitSignal) -> None:
+        self.state.running = False
+    
+    @lg.subscriber(INPUT_EXIT_USER)
+    async def on_exit_user(self, _: ExitSignal) -> None:
+        self.state.running = False
+
+    def on_key(self, key: int) -> None:
+        if key == 27:
+            self.state.running = False
+
+    @lg.main
+    def display(self) -> None:
+        while self.state.running:
+            self.state.perf.update_start()
+            self.state.handler.update_windows(self.state.perf.updates_per_second)
+            time.sleep(self.state.perf.get_remaining_sleep_time(self.config.target_framerate))
+            self.state.perf.update_end()
+
+        raise lg.NormalTermination()
+    
+    def cleanup(self):
+        self.state.handler.cleanup()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/display_handler.py b/devices/webcam/pose_vis/display_handler.py
new file mode 100644
index 00000000..b285f0f7
--- /dev/null
+++ b/devices/webcam/pose_vis/display_handler.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import multiprocessing
+import cv2
+import time
+import collections
+import numpy as np
+
+from typing import Callable, List, Dict, Deque, Any
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from pose_vis.streams.messages import Capture
+from pose_vis.stats_worker import StatsWorker, CapturePoint, CaptureStats
+
+class DisplayHandler():
+    """
+    Handles image display, drawing, and CV2 key events
+    """
+    history_size: int
+    extension_types: Dict[str, type]
+    key_callbacks: List[Callable[[int], None]]
+    post_render_callbacks: List[Callable[[int, np.ndarray], None]]
+    tasks: multiprocessing.JoinableQueue
+    results: multiprocessing.Queue
+    worker: StatsWorker
+    stats: CaptureStats = None
+    captures: Deque[Capture] = None
+    extensions: Deque[Dict[str, Any]] = None
+
+    def __init__(self, history_size: int, extension_types: Dict[str, type]) -> None:
+        self.history_size = history_size
+        self.extension_types = extension_types
+        self.key_callbacks = []
+        self.post_render_callbacks = []
+        if self.history_size > 0:
+            self.tasks = multiprocessing.JoinableQueue()
+            self.results = multiprocessing.Queue()
+            self.worker = StatsWorker(self.tasks, self.results, self.history_size)
+            self.worker.start()
+    
+    def register_key_callback(self, method: Callable[[int], None]) -> None:
+        """
+        Registers a callback to be called on successful `cv2.waitKey()`
+        """
+        self.key_callbacks.append(method)
+
+    def register_post_render_callback(self, method: Callable[[int, np.ndarray], None]) -> None:
+        """
+        Registers a callback to be called after rendering extension data
+        """
+        self.post_render_callbacks.append(method)
+
+    def update_frames(self, captures: List[Capture], extensions: List[Dict[str, Any]]) -> None:
+        """
+        Update list of currently presented frames and extension data
+        """
+        received = time.perf_counter()
+        if self.captures is None:
+            num_sources = len(captures)
+            self.captures = collections.deque(maxlen = num_sources)
+            self.extensions = collections.deque(maxlen = num_sources)
+
+        self.captures.extend(captures)
+        self.extensions.extend(extensions)
+
+        if self.history_size > 0:
+            first_cap = self.captures[0]
+            self.tasks.put(CapturePoint(
+                first_cap.frame_index,
+                first_cap.proc_runtime,
+                first_cap.proc_target_fps,
+                received,
+                [cap.system_timestamp for cap in self.captures]))
+
+    def update_windows(self, framerate: int) -> None:
+        """
+        Update CV2 windows and process key presses
+
+        `framerate` is for displaying the current framerate in the window title. Set to 0 to disable
+        """
+        if self.history_size > 0:
+            res = None
+            try:
+                res = self.results.get_nowait()
+                self.stats = res
+            except:
+                pass
+
+        if self.captures is not None:
+            for i in range(len(self.captures)):
+                cap: Capture = self.captures[i]
+                title = f"PoseVis source {cap.stream_id}"
+                frame = cv2.cvtColor(cap.frame.copy(), cv2.COLOR_RGB2BGR)
+                if len(self.extensions) > 0:
+                    ext = self.extensions[i]
+                    for key in ext:
+                        _type: PoseVisExtension = self.extension_types[key]
+                        _type.draw_overlay(frame, ExtensionResult(data = ext[key]))
+                for callback in self.post_render_callbacks:
+                    callback(i, frame)
+                cv2.imshow(title, frame)
+
+                display_info = f"| display: {framerate}fps" if framerate > 0 else ""
+                if self.history_size > 0 and self.stats != None:
+                    desync_string = f" desync: {(self.stats.desync[i - 1] * 1000):05.2f}ms," if i > 0 and len(self.stats.desync) > 0 else ""
+                    source_info = f": {cap.proc_fps}fps, latency: {(self.stats.latency * 1000):05.2f}ms, jitter: {(self.stats.jitter * 1000):05.2f}ms,{desync_string} dropped: {(100 - self.stats.framedrop):05.2f}%"
+                    cv2.setWindowTitle(title, f"{title} {source_info} {display_info}")
+                else:
+                    source_info = f": {cap.proc_fps}fps"
+                    cv2.setWindowTitle(title, f"{title} {source_info} {display_info}")
+
+        key = cv2.waitKey(1)
+        if key != -1:
+            for callback in self.key_callbacks:
+                callback(key)
+
+    def cleanup(self) -> None:
+        """
+        Must be called during program shutdown
+        """
+        if self.history_size > 0:
+            self.tasks.put(None)
+            self.worker.join()
+        cv2.destroyAllWindows()
+
diff --git a/devices/webcam/pose_vis/dynamic_graph.py b/devices/webcam/pose_vis/dynamic_graph.py
new file mode 100644
index 00000000..40af12ed
--- /dev/null
+++ b/devices/webcam/pose_vis/dynamic_graph.py
@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import labgraph as lg
+from typing import List, Tuple, Dict
+
+class DynamicGraph(lg.Graph):
+
+    """
+    DynamicGraph, allows you to construct a Graph object based on run-time parameters.
+    `class ExampleGraph(DynamicGraph):`
+
+    Use ExampleGraph.add_node() to register nodes.
+    The `connections` parameter is expected to be a list with 4 strings:
+    `[Node1Name, Node1TopicName, Node2Name, Node2TopicName]`
+
+    Example:
+        `ExampleGraph.add_node("TestNode2", TestNode2, ["TestNode2", "INPUT", "TestNode1", "OUTPUT", TestNode2Config(...)])`
+    """
+
+    _connections: List[List[str]] = []
+    _logger_connections: List[Tuple[str, str, str]] = []
+    _configs: dict = {}
+    _cls: type = None
+
+    @classmethod
+    def add_node(cls, name: str, _type: type, connection: List[str] = None, config: lg.Config = None) -> None:
+        """
+        Add a node to the graph
+
+        `name`: `str` the node's desired variable name
+        `_type`: `type` the node's type
+        `connection`: `List[str]` optional, expected to have a length of 4
+
+        Example:
+            `[Node1Name, Node1TopicName, Node2Name, Node2TopicName]`
+        
+        `config`: `lg.Config` optional, config object to be given to this node during setup
+        """
+        setattr(cls, name, None)
+        cls.__annotations__[name] = _type
+        cls.__children_types__[name] = _type
+
+        if connection:
+            cls._connections.append(connection)
+        
+        if config:
+            cls._configs[name] = config
+
+    @classmethod
+    def add_connection(cls, connection: List[str]) -> None:
+        """
+        Add a connection between two nodes
+
+        `connection`: `List[str]` expected to have a length of 4
+
+        Example:
+            `[Node1Name, Node1TopicName, Node2Name, Node2TopicName]`
+        """
+        cls._connections.append(connection)
+    
+    @classmethod
+    def add_logger_connection(cls, connection: Tuple[str, str, str]) -> None:
+        """
+        Add a connection to the logger
+
+        `connection`: `Tuple[str, str, str]`
+
+        Example:
+            `(logged stream path, node variable name, node output variable name)`
+        """
+        cls._logger_connections.append(connection)
+
+    def setup(self) -> None:
+        for key in type(self)._configs:
+            self.__getattribute__(key).configure(type(self)._configs[key])
+
+    def connections(self) -> lg.Connections:
+        cons = []
+        for con_list in type(self)._connections:
+            node1: lg.Node = self.__getattribute__(con_list[0])
+            node2: lg.Node = self.__getattribute__(con_list[2])
+            cons.append((node1.__getattribute__(con_list[1]), node2.__getattribute__(con_list[3])))
+        return tuple(cons)
+    
+    def logging(self) -> Dict[str, lg.Topic]:
+        _dict = {}
+        for con in type(self)._logger_connections:
+            _dict[con[0]] = self.__getattribute__(con[1]).__getattribute__(con[2])
+        return _dict
+
+    def process_modules(self) -> Tuple[lg.Module, ...]:
+        mods = ()
+        for key in type(self).__children_types__:
+            mods += (self.__getattribute__(key),)
+        return mods
+
+class DynamicGroup(lg.Group):
+
+    """
+    DynamicGroup, allows you to construct a Group object based on run-time parameters.
+    `class ExampleGroup(DynamicGroup):`
+    
+    Use ExampleGroup.add_node() to register nodes.
+    The `connections` parameter is expected to be a list with 4 strings:
+    `[Node1Name, Node1TopicName, Node2Name, Node2TopicName]`
+
+    Example:
+        `DynamicGroup.add_node("TestNode2", TestNode2, ["TestNode2", "INPUT", "TestNode1", "OUTPUT", TestNode2Config(...)])`
+    """
+
+    _connections: List[List[str]] = []
+    _configs: dict = {}
+
+    @classmethod
+    def add_node(cls, name: str, _type: type, connection: List[str] = None, config: lg.Config = None) -> None:
+        """
+        Add a node to the group
+
+        `name`: `str` the node's desired variable name
+        `_type`: `type` the node's type
+        `connection`: `List[str]` optional, expected to have a length of 4
+
+        Example:
+            `[Node1Name, Node1TopicName, Node2Name, Node2TopicName]`
+        
+        `config`: `lg.Config` optional, config object to be given to this node during setup
+        """
+        setattr(cls, name, None)
+        cls.__annotations__[name] = _type
+        cls.__children_types__[name] = _type
+
+        if connection:
+            cls._connections.append(connection)
+        
+        if config:
+            cls._configs[name] = config
+
+    @classmethod
+    def add_connection(cls, connection: List[str]) -> None:
+        """
+        Add a connection between two nodes
+
+        `connection`: `List[str]` expected to have a length of 4
+
+        Example:
+            `[Node1Name, Node1TopicName, Node2Name, Node2TopicName]`
+        """
+        cls._connections.append(connection)
+
+    @classmethod
+    def add_topic(cls, name: str, topic: lg.Topic) -> None:
+        """
+        Add a topic object
+
+        `name`: `str` the variable's name
+        `topic`: `lg.Topic` the topic object to add
+        """
+        setattr(cls, name, topic)
+
+    def setup(self) -> None:
+        for key in type(self)._configs:
+            self.__getattribute__(key).configure(type(self)._configs[key])
+
+    def connections(self) -> lg.Connections:
+        cons = []
+        for con_list in type(self)._connections:
+            node1: lg.Node = self.__getattribute__(con_list[0])
+            node2: lg.Node = self.__getattribute__(con_list[2])
+            cons.append((node1.__getattribute__(con_list[1]), node2.__getattribute__(con_list[3])))
+        return tuple(cons)
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/extension.py b/devices/webcam/pose_vis/extension.py
new file mode 100644
index 00000000..9c9ba83f
--- /dev/null
+++ b/devices/webcam/pose_vis/extension.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import numpy as np
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from argparse import ArgumentParser, Namespace
+from typing import Any
+
+@dataclass
+class ExtensionResult():
+    """
+    Produced by `PoseVisExtension`
+
+    Attributes:
+        `data`: `Any`
+    """
+    data: Any
+
+class PoseVisExtensionBase(ABC):
+    """
+    Abstract base class for `PoseVisExtension`
+
+    Abstract methods:
+        `register_args(self, parser: ArgumentParser) -> None`
+
+        `check_enabled(self, args: Namespace) -> bool`
+
+        `setup(self) -> None`
+
+        `process_frame(self, frame: np.ndarray) -> ExtensionResult`
+        
+        `cleanup(self) -> None`
+
+        `draw_overlay(cls, result: ExtensionResult) -> None`
+
+        `check_output(cls, result: ExtensionResult) -> bool`
+    """
+    @abstractmethod
+    def register_args(self, parser: ArgumentParser) -> None:
+        """
+        Called before graph initialization and argument parsing
+        
+        Use this to register an argument that will allow this extension to be enabled or disabled
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_enabled(self, args: Namespace) -> bool:
+        """
+        Check the `ArgumentParser.parse_args()` result to determine if this extension should be enabled
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def setup(self) -> None:
+        """
+        Called on video stream setup
+        """
+        pass
+
+    @abstractmethod
+    def process_frame(self, frame: np.ndarray) -> ExtensionResult:
+        """
+        Called once per frame inside of a video stream node
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def cleanup(self) -> None:
+        """
+        Called on graph shutdown
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def draw_overlay(cls, frame: np.ndarray, result: ExtensionResult) -> None:
+        """
+        Called upon displaying extension results
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def check_output(cls, result: ExtensionResult) -> bool:
+        """
+        Method for extensions to check their output via assertions
+        
+        Called during test execution
+        """
+        raise NotImplementedError
+
+class PoseVisExtension(PoseVisExtensionBase):
+    """
+    An extension of the base class that Pose Vis uses to automatically initialize the following variables:
+
+    Attributes:
+        `extension_id`: `int`, a contiguous identifier for each enabled extension
+    
+    Methods:
+        `set_enabled(self, extension_id: int) -> None`
+    """
+    extension_id: int
+
+    def set_enabled(self, extension_id: int) -> None:
+        """
+        Called if this extension passes the `check_enabled` method
+        """
+        self.extension_id = extension_id
diff --git a/devices/webcam/pose_vis/extensions/__init__.py b/devices/webcam/pose_vis/extensions/__init__.py
new file mode 100644
index 00000000..c05b5efe
--- /dev/null
+++ b/devices/webcam/pose_vis/extensions/__init__.py
@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+from pose_vis.extensions import hands
+from pose_vis.extensions import face_detection
+from pose_vis.extensions import face_mesh
+from pose_vis.extensions import pose
+from pose_vis.extensions import holistic
diff --git a/devices/webcam/pose_vis/extensions/face_detection.py b/devices/webcam/pose_vis/extensions/face_detection.py
new file mode 100644
index 00000000..28ecac9b
--- /dev/null
+++ b/devices/webcam/pose_vis/extensions/face_detection.py
@@ -0,0 +1,73 @@
+import logging
+import cv2
+import numpy as np
+import mediapipe as mp
+# Import MediaPipe types for intellisense
+import mediapipe.python.solutions.face_detection as FaceType
+import mediapipe.python.solutions.objectron as ObjectType
+import mediapipe.python.solutions.drawing_utils as DrawingUtilsType
+import mediapipe.python.solutions.drawing_styles as DrawingStylesType
+from mediapipe.framework.formats.landmark_pb2 import NormalizedLandmarkList #? <--
+
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from argparse import ArgumentParser, Namespace
+
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+mp_drawing: DrawingUtilsType = mp.solutions.drawing_utils
+mp_drawing_styles: DrawingStylesType = mp.solutions.drawing_styles
+mp_face: FaceType = mp.solutions.face_detection
+mp_object: ObjectType = mp.solutions.objectron #! <--- for object tracking - testing
+
+class FaceDetectionExtension(PoseVisExtension):
+    face : Optional[FaceType.FaceDetection]
+    object_tracking : Optional[ObjectType.Objectron] #! <---- object tracking - testing
+
+    # argument to enable or disable the face detection extension
+    def register_args(self, parser: ArgumentParser) -> None:
+        parser.add_argument("--face_detection", help="enable the face detection extension", action="store_true", required=False)
+
+    def check_enabled(self, args: Namespace) -> bool:
+        return args.face_detection
+
+    def setup(self) -> None:
+        self.face = mp_face.FaceDetection()
+        self.object_tracking = mp_object.Objectron()
+
+    def process_frame(self, frame: np.ndarray) -> Tuple[np.ndarray, ExtensionResult]:
+        # convert from BGR to RGB
+        #? NormalizedDetectionList
+        mp_results = self.face.process(frame).detections 
+
+        # check if a face detection list is null
+        if mp_results is None:
+            mp_results = []
+
+        return ExtensionResult(data=mp_results)
+
+    @classmethod
+    def draw_overlay(cls, frame: np.ndarray, result: ExtensionResult):
+
+        for detection in result.data:
+            mp_drawing.draw_detection(
+                frame,
+                detection
+            )
+
+    @classmethod
+    def check_output(cls, result: ExtensionResult)-> bool:
+        if len(result.data) > 0:
+            for i in range(result.data):
+                if len(result.data[i]) != 6: 
+                    logger.warning(f'index {i} in result.data is not proper length')
+                    return False
+            return True
+        else:
+            logger.warning(" result is empty")
+        return False
+
+    # clean up called when the graph is shutdown
+    def cleanup(self) -> None:
+        pass
diff --git a/devices/webcam/pose_vis/extensions/face_mesh.py b/devices/webcam/pose_vis/extensions/face_mesh.py
new file mode 100644
index 00000000..0caa3106
--- /dev/null
+++ b/devices/webcam/pose_vis/extensions/face_mesh.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+import cv2
+import numpy as np
+import mediapipe as mp
+# Import MediaPipe types for intellisense
+import mediapipe.python.solutions.face_mesh as FaceType
+import mediapipe.python.solutions.drawing_utils as DrawingUtilsType
+import mediapipe.python.solutions.drawing_styles as DrawingStylesType
+from mediapipe.framework.formats.landmark_pb2 import NormalizedLandmarkList
+
+# Every extension will probably need these imports
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from argparse import ArgumentParser, Namespace
+
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# MediaPipe setup: https://google.github.io/mediapipe/solutions/hands.html
+mp_drawing: DrawingUtilsType = mp.solutions.drawing_utils
+mp_drawing_styles: DrawingStylesType = mp.solutions.drawing_styles
+mp_face_mesh: FaceType = mp.solutions.face_mesh 
+
+# drawing_spec = mp_drawing.DrawingSpec(thickness=1, circle_radius=1)
+
+class FaceMeshExtension(PoseVisExtension):
+    drawing_spec = mp_drawing.DrawingSpec(thickness=1, circle_radius=1)
+
+    face_mesh: Optional[FaceType.FaceMesh] 
+    
+    def register_args(self, parser: ArgumentParser) -> None:
+        parser.add_argument("--face_mesh", help="enable face mesh extension", action="store_true", required=False)
+
+    def check_enabled(self, args: Namespace) -> bool:
+        return args.face_mesh
+
+    def setup(self) -> None:
+        # drawing_spec = mp_drawing.DrawingSpec(thickness=1, circle_radius=1)
+        self.face_mesh = mp_face_mesh.FaceMesh(max_num_faces=1,refine_landmarks=True, min_detection_confidence=0.5, min_tracking_confidence=0.5)
+
+    def process_frame(self, frame: np.ndarray) -> Tuple[np.ndarray, ExtensionResult]:
+        
+        mp_results = self.face_mesh.process(frame).multi_face_landmarks
+
+        if mp_results is None:
+            mp_results = []
+
+        return ExtensionResult(data=mp_results)
+
+    @classmethod
+    def draw_overlay(cls, frame: np.ndarray, result: ExtensionResult):
+        # drawing_spec = mp_drawing.DrawingSpec(thickness=1, circle_radius=1)
+
+
+        for landmark_list in result.data:
+            mp_drawing.draw_landmarks(
+                frame, 
+                landmark_list,
+                mp_face_mesh.FACEMESH_TESSELATION,
+                None,
+                mp_drawing_styles.get_default_face_mesh_tesselation_style()
+            )
+            mp_drawing.draw_landmarks(
+                image = frame,
+                landmark_list = landmark_list,
+                connections = mp_face_mesh.FACEMESH_CONTOURS,
+                landmark_drawing_spec = None,
+                connection_drawing_spec = mp_drawing_styles.get_default_face_mesh_contours_style()
+            )
+            mp_drawing.draw_landmarks(
+                image = frame, 
+                landmark_list = landmark_list,
+                connections = mp_face_mesh.FACEMESH_IRISES,
+                landmark_drawing_spec = None,
+                connection_drawing_spec = mp_drawing_styles.get_default_face_mesh_iris_connections_style()
+            )
+
+
+    @classmethod
+    def check_output(cls, result:ExtensionResult) -> bool:
+        # check the result of 'face_mesh.process' 
+        if len(result.data) > 0:
+            for i in range(result.data):
+                if len(result.data[i]) != 468:  
+                    logger.warning(f"index {i} in result.data is not proper length")
+                    return False
+            return True
+        else:
+            logger.warning("result is empty")
+        return False
+
+
+    def cleanup(self) -> None:
+        pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/extensions/hands.py b/devices/webcam/pose_vis/extensions/hands.py
new file mode 100644
index 00000000..b7444893
--- /dev/null
+++ b/devices/webcam/pose_vis/extensions/hands.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+import numpy as np
+import mediapipe as mp
+
+# Import MediaPipe types for intellisense
+import mediapipe.python.solutions.hands as HandsType
+import mediapipe.python.solutions.drawing_utils as DrawingUtilsType
+import mediapipe.python.solutions.drawing_styles as DrawingStylesType
+
+# Every extension will probably need these imports
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass
+
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# MediaPipe setup: https://google.github.io/mediapipe/solutions/hands.html
+mp_drawing: DrawingUtilsType = mp.solutions.drawing_utils
+mp_drawing_styles: DrawingStylesType = mp.solutions.drawing_styles
+mp_hands: HandsType = mp.solutions.hands
+
+@dataclass
+class HandsConfig():
+    max_num_hands: int = 2
+    model_complexity: int = 0
+    min_detection_confidence: int = 0.5
+    min_tracking_confidence: int = 0.5
+
+# This class is instantiated by Pose Vis automatically
+# You must import this file in extensions/__init__.py for it to be recognized
+class HandsExtension(PoseVisExtension):
+    # Optional here since this class will be serialized to each stream node
+    # otherwise we'll get a "cannot pickle" AttributeError
+    hands: Optional[HandsType.Hands]
+    config: HandsConfig
+
+    def __init__(self, config: HandsConfig = HandsConfig()) -> None:
+        self.config = config
+        super().__init__()
+
+    # Register an argument that allows the user to enable this extension
+    def register_args(self, parser: ArgumentParser):
+        parser.add_argument("--hands", help = "enable the hand tracking extension", action = "store_true", required = False)
+    
+    # Tell Pose Vis if this extension is enabled or not
+    def check_enabled(self, args: Namespace) -> bool:
+        return args.hands
+    
+    # Called when the stream is initialized
+    def setup(self) -> None:
+        # TODO: a way to expose MediaPipe configs
+        self.hands = mp_hands.Hands(
+            max_num_hands = self.config.max_num_hands,
+            model_complexity = self.config.model_complexity,
+            min_detection_confidence = self.config.min_detection_confidence,
+            min_tracking_confidence = self.config.min_tracking_confidence)
+
+    # Called from `FrameProcessor` on each new frame from the stream
+    def process_frame(self, frame: np.ndarray) -> Tuple[np.ndarray, ExtensionResult]:
+        mp_results = self.hands.process(frame)
+        
+        # Convert different results to a dict for easier access
+        results = {"multi_hand_landmarks": [], "multi_hand_world_landmarks": [], "multi_handedness": []}
+        if mp_results.multi_hand_landmarks is not None:
+            results["multi_hand_landmarks"] = mp_results.multi_hand_landmarks
+        if mp_results.multi_hand_world_landmarks is not None:
+            results["multi_hand_world_landmarks"] = mp_results.multi_hand_world_landmarks
+        if mp_results.multi_handedness is not None:
+            results["multi_handedness"] = mp_results.multi_handedness
+        
+        return ExtensionResult(data = results)
+
+    @classmethod
+    def draw_overlay(cls, frame: np.ndarray, result: ExtensionResult) -> None:
+        # Draw the detected hand landmarks onto the image
+        for landmark_list in result.data["multi_hand_landmarks"]:
+            mp_drawing.draw_landmarks(
+                frame,
+                landmark_list,
+                mp_hands.HAND_CONNECTIONS,
+                mp_drawing_styles.get_default_hand_landmarks_style(),
+                mp_drawing_styles.get_default_hand_connections_style())
+
+    @classmethod
+    def check_output(cls, result: ExtensionResult) -> bool:
+        """
+        Checks the results of `hands.process()`, assuming that at least one hand is fully visible in the frame
+        """
+        if "multi_hand_landmarks" in result.data:
+            for i in range(len(result.data["multi_hand_landmarks"])):
+                if len(result.data["multi_hand_landmarks"][i].landmark) != 21:
+                    logger.warning(f" index {i} in result.data is not proper length")
+                    return False
+            return True
+        else:
+            logger.warning(" result is empty")
+        return False
+
+    # Called when the graph shuts down
+    def cleanup(self) -> None:
+        pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/extensions/holistic.py b/devices/webcam/pose_vis/extensions/holistic.py
new file mode 100644
index 00000000..2e4f6b5d
--- /dev/null
+++ b/devices/webcam/pose_vis/extensions/holistic.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+import cv2
+import numpy as np
+import mediapipe as mp
+# Import MediaPipe types for intellisense
+import mediapipe.python.solutions.holistic as HolisticType
+import mediapipe.python.solutions.drawing_utils as DrawingUtilsType
+import mediapipe.python.solutions.drawing_styles as DrawingStylesType
+from mediapipe.framework.formats.landmark_pb2 import NormalizedLandmarkList
+
+# Every extension will probably need these imports
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from argparse import ArgumentParser, Namespace
+
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# medaiapipe setup
+mp_drawing: DrawingUtilsType = mp.solutions.drawing_utils
+mp_drawing_styles: DrawingStylesType = mp.solutions.drawing_styles
+mp_holistic: HolisticType = mp.solutions.holistic
+
+class HolisticExtension(PoseVisExtension):
+    holistic: Optional[HolisticType.Holistic] #! <-- test this
+
+    def register_args(self, parser: ArgumentParser) -> None:
+        parser.add_argument('--holistic', help='enable holistic extension', action='store_true', required=False)
+
+    def check_enabled(self, args: Namespace) -> bool:
+        return args.holistic
+    
+    def setup(self) -> None:
+        self.holistic = mp_holistic.Holistic() #! <-- test
+
+    def process_frame(self, frame: np.ndarray) -> Tuple[np.ndarray, ExtensionResult]:
+        
+        result = self.holistic.process(frame)
+        
+        face_landmarks = result.face_landmarks
+        pose_landmarks = result.pose_landmarks
+
+        if face_landmarks is None:
+            face_landmarks = []
+        if pose_landmarks is None:
+            pose_landmarks = []
+
+        return ExtensionResult(data=result)
+
+    @classmethod
+    def draw_overlay(cls, frame:np.ndarray, result: ExtensionResult):
+
+        # draw holistic
+        #! test these two 
+        mp_drawing.draw_landmarks(
+            frame,
+            result.face_landmarks,
+            mp_holistic.FACEMESH_CONTOURS,
+            None, #! <-- make sure this is correct 
+            mp_drawing_styles.get_default_face_mesh_contours_style()
+        )
+
+        mp_drawing.draw_landmarks(
+            frame, 
+            result.pose_landmarks,
+            mp_holistic.POSE_CONNECTIONS,
+            mp_drawing_styles.get_default_pose_landmarks_style()
+        )
+
+
+    @classmethod
+    def check_output(cls, result:ExtensionResult) -> bool:
+        # recheck this function
+        if len(result.data)>0:
+            for i in range(result.data):
+                if len(result.data[i] != 510): #! <-- this number might not be correct
+                    logger.warning(f'index {i} in result.data is not proper length')
+                    return False
+            return True
+        else:
+            logger.warning('result is empty')
+        return False
+
+    def cleanup(self) -> None:
+        pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/extensions/pose.py b/devices/webcam/pose_vis/extensions/pose.py
new file mode 100644
index 00000000..b2c64d56
--- /dev/null
+++ b/devices/webcam/pose_vis/extensions/pose.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+import numpy as np
+import mediapipe as mp
+
+# Import MediaPipe types for intellisense
+import mediapipe.python.solutions.pose as PoseType
+import mediapipe.python.solutions.drawing_utils as DrawingUtilsType
+import mediapipe.python.solutions.drawing_styles as DrawingStylesType
+from mediapipe.framework.formats.landmark_pb2 import NormalizedLandmarkList
+
+# Every extension will probably need these imports
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from argparse import ArgumentParser, Namespace
+from dataclasses import dataclass
+
+from typing import Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# MediaPipe setup: https://google.github.io/mediapipe/solutions/hands.html
+mp_drawing: DrawingUtilsType = mp.solutions.drawing_utils
+mp_drawing_styles: DrawingStylesType = mp.solutions.drawing_styles
+mp_pose: PoseType = mp.solutions.pose
+
+@dataclass
+class PoseConfig():
+    model_complexity: int = 1
+    smooth_landmarks: bool = True
+    enable_segmentation: bool = False
+    smooth_segmentation: bool = True
+    min_detection_confidence = 0.5
+    min_tracking_confidence = 0.5
+
+class PoseExtension(PoseVisExtension):
+    pose: Optional[PoseType.Pose]
+    config: PoseConfig
+
+    def __init__(self, config: PoseConfig = PoseConfig()) -> None:
+        self.config = config
+        super().__init__()
+
+    # register argument allowing user to run this extension
+    def register_args(self, parser: ArgumentParser) -> None:
+        parser.add_argument('--pose', help='enable pose estimation extension', action = 'store_true', required= False)
+
+    # check to see if extension is enabled or not
+    def check_enabled(self, args: Namespace) -> bool:
+        return args.pose
+
+    def setup(self) -> None:
+        self.pose = mp_pose.Pose(
+            model_complexity = self.config.model_complexity,
+            smooth_landmarks = self.config.smooth_landmarks,
+            enable_segmentation = self.config.enable_segmentation,
+            smooth_segmentation = self.config.smooth_segmentation,
+            min_detection_confidence = self.config.min_detection_confidence, 
+            min_tracking_confidence = self.config.min_tracking_confidence
+        )
+
+    def process_frame(self, frame: np.ndarray) -> ExtensionResult:
+        
+        mp_result = self.pose.process(frame)
+
+        results = {"pose_landmarks":[], "pose_world_landmarks":[]}
+
+        if (mp_result.pose_landmarks is not None):
+            results["pose_landmarks"] = mp_result.pose_landmarks
+        elif(mp_result.pose_world_landmarks is not None):
+            results["pose_world_landmarks"] = mp_result.pose_world_landmarks
+        
+        return ExtensionResult(data=results)
+
+
+    @classmethod
+    def draw_overlay(cls, frame: np.ndarray, result: ExtensionResult):
+
+        # for pose_landmark_list in result.data["pose_landmarks"]:
+        mp_drawing.draw_landmarks(
+            frame, 
+            result.data["pose_landmarks"],
+            mp_pose.POSE_CONNECTIONS,
+            mp_drawing_styles.get_default_pose_landmarks_style()
+        )
+
+    @classmethod
+    def check_output(cls, result: ExtensionResult):
+        if len(result.data) > 0:
+            for i in range(result.data):
+                if len(result.data[i]) != 33:
+                    logger.warning(f' index {i} in result is not proper length')
+                    return False
+            return True
+        else:
+            logger.warning(' result is empty')
+        return False
+
+    def cleanup(self) -> None:
+        pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/__init__.py b/devices/webcam/pose_vis/gesture/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/hand/__init__.py b/devices/webcam/pose_vis/gesture/hand/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/hand/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/hand/annotation.py b/devices/webcam/pose_vis/gesture/hand/annotation.py
new file mode 100644
index 00000000..3aa775ea
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/hand/annotation.py
@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import os
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+
+from typing import Dict, List, Tuple
+from json import JSONEncoder
+from matplotlib.pyplot import Axes
+from matplotlib.figure import Figure
+
+Vector = np.ndarray(shape=(0, 3), dtype=float)
+
+class NumpyJSONEncoder(JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return JSONEncoder.default(self, obj)
+
+class Annotation():
+    """
+    Handles tracking of hand and gesture data
+    """
+    hands: List[np.ndarray] = []
+    gestures: Dict[str, List[np.ndarray]] = {}
+
+    def set_hand_vertices(self, hand_index: int, vertices: Vector) -> None:
+        """
+        Sets vertex data for a hand index. If the hand does not exist, it is created
+        """
+        if np.size(self.hands, axis=0) <= hand_index:
+            self.hands.append(vertices)
+        else:
+            self.hands[hand_index] = vertices
+
+    def clear_hand_vertices(self) -> None:
+        """
+        Clears all hand vertex data
+        """
+        self.hands.clear()
+
+    def add_gesture_data(self, vertices: Vector, label: str) -> None:
+        """
+        Adds gesture data to the given label, if the label doesn't exist, it is created
+        """
+        if label not in self.gestures:
+            self.gestures[label] = []
+        self.gestures[label].append(vertices)
+
+    def save_gestures(self, file_path: str) -> None:
+        """
+        Saves gesture data to the given file path. Must be a full path
+        """
+        with open(file_path, "w") as output:
+            output.write(json.dumps(self.gestures, indent=4, cls=NumpyJSONEncoder))
+
+    def load_gestures(self, file_path: str) -> None:
+        """
+        Loads gesture data from the given file path. Must be a full path
+        """
+        if os.path.exists(file_path):
+            with open(file_path, "r") as _file:
+                gestures: Dict = json.load(_file)
+                for k, v in gestures.items():
+                    self.gestures[k] = []
+                    for vertex_list in v:
+                        self.gestures[k].append(np.asarray(vertex_list))
+
+    def guess_annotations(self, max_difference_value: float) -> List[Tuple[str, float]]:
+        """
+        Returns a list of labels and their difference values for each hand based on `max_difference_value`
+
+        If no gesture is found, returns an empty string and the closest difference value
+        """
+        results: List[Tuple[str, float]] = []
+        for hdx in range(len(self.hands)):
+            differences: List[Tuple[str, float]] = []
+            for label, vertices_list in self.gestures.items():
+                for data_index in range(len(vertices_list)):
+                    diff = 0.0
+                    for indice in range(len(vertices_list[data_index])):
+                        for i in range(len(vertices_list[data_index][indice])):
+                            diff += abs(self.hands[hdx][indice][i] - vertices_list[data_index][indice][i])
+                    differences.append((label, diff))
+            differences.sort(key = lambda x: x[1])
+            if len(differences) > 0 and differences[0][1] <= max_difference_value:
+                results.append(differences[0])
+            else:
+                results.append(("", -1 if len(differences) == 0 else differences[0][1]))
+        return results
+    
+    def configure_plot(self) -> Tuple[Figure, Axes]:
+        """
+        Configures a plot for plotting hand data
+        """
+        fig = plt.figure()
+        ax = fig.add_subplot(projection="3d")
+        fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
+        return (fig, ax)
+
+    def plot_hand(self, hand_index: int, ax: Axes, drawing_order: List[List[int]], bounds: Tuple[int, int], hand_scale: float = 1.0, xyz_order: Tuple[int, int, int] = (0, 1, 2), xyz_scale: Tuple[int, int, int] = (1, 1, 1)) -> None:
+        """
+        Plots hand data
+
+        `drawing_order` must be a list of indice lists, where each indice is connected in order
+
+        `bounds` is the size of the 3D scene
+
+        `hand_scale` scales the raw hand data
+
+        `xyz_order` allows switching which values are used for X, Y, and Z in the plot. `0` is X, `1` is Y, and `2` is Z
+
+        `xyz_scale` scales the flipped X, Y, and Z values
+        """
+        ax.cla()
+        ax.set_xlim3d(bounds[0], bounds[1])
+        ax.set_ylim3d(bounds[0], bounds[1])
+        ax.set_zlim3d(bounds[0], bounds[1])
+        for indices in drawing_order:
+            handx = np.empty(shape=0)
+            handy = np.empty(shape=0)
+            handz = np.empty(shape=0)
+            for indice in indices:
+                world_pos = self.hands[hand_index][indice] * hand_scale
+                handx = np.append(handx, [world_pos[xyz_order[0]] * xyz_scale[0]], axis=0)
+                handy = np.append(handy, [world_pos[xyz_order[1]] * xyz_scale[1]], axis=0)
+                handz = np.append(handz, [world_pos[xyz_order[2]] * xyz_scale[2]], axis=0)
+            ax.plot(handx, handy, handz)
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/hand/data/gestures.json b/devices/webcam/pose_vis/gesture/hand/data/gestures.json
new file mode 100644
index 00000000..c5facd3e
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/hand/data/gestures.json
@@ -0,0 +1,434 @@
+{
+    "Thumbs Up": [
+        [
+            [
+                55.79,
+                33.49,
+                71.73
+            ],
+            [
+                32.97,
+                6.29,
+                62.17
+            ],
+            [
+                18.19,
+                -23.25,
+                54.63
+            ],
+            [
+                6.33,
+                -44.55,
+                38.9
+            ],
+            [
+                1.31,
+                -68.49,
+                21.19
+            ],
+            [
+                -1.3,
+                -18.8,
+                5.97
+            ],
+            [
+                -21.11,
+                -8.72,
+                10.04
+            ],
+            [
+                -24.52,
+                -4.43,
+                36.7
+            ],
+            [
+                -16.02,
+                -5.04,
+                62.18
+            ],
+            [
+                -0.54,
+                -2.62,
+                -2.17
+            ],
+            [
+                -29.21,
+                5.53,
+                3.8
+            ],
+            [
+                -24.45,
+                15.7,
+                32.81
+            ],
+            [
+                -15.57,
+                8.49,
+                54.27
+            ],
+            [
+                0.38,
+                11.75,
+                -3.95
+            ],
+            [
+                -21.88,
+                24.68,
+                1.97
+            ],
+            [
+                -17.79,
+                28.22,
+                29.03
+            ],
+            [
+                -8.23,
+                22.2,
+                47.44
+            ],
+            [
+                3.08,
+                36.58,
+                4.13
+            ],
+            [
+                -16.22,
+                40.8,
+                10.86
+            ],
+            [
+                -13.68,
+                42.82,
+                32.44
+            ],
+            [
+                -3.32,
+                38.39,
+                44.07
+            ]
+        ],
+        [
+            [
+                -56.65,
+                28.66,
+                76.81
+            ],
+            [
+                -31.7,
+                -5.11,
+                63.08
+            ],
+            [
+                -15.86,
+                -29.1,
+                53.03
+            ],
+            [
+                -4.81,
+                -55.9,
+                31.03
+            ],
+            [
+                -1.37,
+                -81.69,
+                11.31
+            ],
+            [
+                -0.5,
+                -26.99,
+                2.45
+            ],
+            [
+                28.73,
+                -17.93,
+                3.78
+            ],
+            [
+                32.44,
+                -13.91,
+                33.41
+            ],
+            [
+                11.29,
+                -16.61,
+                55.31
+            ],
+            [
+                -1.39,
+                -5.34,
+                -1.92
+            ],
+            [
+                34.84,
+                -1.06,
+                -0.65
+            ],
+            [
+                27.51,
+                -0.95,
+                26.83
+            ],
+            [
+                12.73,
+                -6.29,
+                49.37
+            ],
+            [
+                2.19,
+                17.04,
+                -1.81
+            ],
+            [
+                30.69,
+                18.37,
+                5.88
+            ],
+            [
+                25.95,
+                15.72,
+                29.87
+            ],
+            [
+                14.22,
+                13.71,
+                50.57
+            ],
+            [
+                -1.75,
+                33.09,
+                8.38
+            ],
+            [
+                21.82,
+                33.21,
+                13.19
+            ],
+            [
+                20.28,
+                29.5,
+                34.52
+            ],
+            [
+                2.37,
+                27.91,
+                47.24
+            ]
+        ]
+    ],
+    "Peace": [
+        [
+            [
+                22.39,
+                87.28,
+                -1.85
+            ],
+            [
+                -11.71,
+                68.05,
+                -7.0
+            ],
+            [
+                -26.49,
+                40.28,
+                -16.81
+            ],
+            [
+                -26.23,
+                7.6,
+                -32.23
+            ],
+            [
+                -3.57,
+                -15.22,
+                -38.57
+            ],
+            [
+                -27.93,
+                3.5,
+                9.23
+            ],
+            [
+                -41.67,
+                -23.38,
+                3.37
+            ],
+            [
+                -53.21,
+                -43.14,
+                -1.92
+            ],
+            [
+                -64.38,
+                -59.04,
+                -22.75
+            ],
+            [
+                -4.21,
+                -3.56,
+                6.41
+            ],
+            [
+                -10.19,
+                -44.6,
+                -1.5
+            ],
+            [
+                -18.83,
+                -66.01,
+                -14.96
+            ],
+            [
+                -27.4,
+                -88.46,
+                -29.99
+            ],
+            [
+                18.22,
+                -3.06,
+                -5.37
+            ],
+            [
+                5.56,
+                -18.81,
+                -27.92
+            ],
+            [
+                -4.45,
+                -0.2,
+                -41.83
+            ],
+            [
+                -6.99,
+                23.08,
+                -48.86
+            ],
+            [
+                33.4,
+                10.21,
+                -16.24
+            ],
+            [
+                24.38,
+                -3.56,
+                -32.57
+            ],
+            [
+                6.43,
+                3.8,
+                -50.22
+            ],
+            [
+                -2.96,
+                20.02,
+                -58.27
+            ]
+        ],
+        [
+            [
+                -19.06,
+                91.4,
+                2.35
+            ],
+            [
+                13.72,
+                68.5,
+                -11.06
+            ],
+            [
+                20.57,
+                41.16,
+                -30.22
+            ],
+            [
+                8.65,
+                11.33,
+                -49.35
+            ],
+            [
+                -14.14,
+                -14.03,
+                -49.96
+            ],
+            [
+                26.0,
+                -2.86,
+                2.2
+            ],
+            [
+                35.24,
+                -31.08,
+                -0.1
+            ],
+            [
+                38.2,
+                -53.43,
+                -5.46
+            ],
+            [
+                40.13,
+                -70.8,
+                -24.25
+            ],
+            [
+                2.7,
+                -4.95,
+                6.84
+            ],
+            [
+                3.5,
+                -44.92,
+                0.06
+            ],
+            [
+                3.22,
+                -66.45,
+                -16.11
+            ],
+            [
+                6.59,
+                -88.17,
+                -29.47
+            ],
+            [
+                -18.17,
+                0.41,
+                -0.44
+            ],
+            [
+                -14.47,
+                -18.74,
+                -28.59
+            ],
+            [
+                -7.92,
+                0.55,
+                -42.1
+            ],
+            [
+                -3.94,
+                20.2,
+                -40.95
+            ],
+            [
+                -37.31,
+                15.41,
+                -10.47
+            ],
+            [
+                -27.21,
+                7.9,
+                -29.76
+            ],
+            [
+                -15.62,
+                21.68,
+                -39.9
+            ],
+            [
+                -18.23,
+                37.6,
+                -32.57
+            ]
+        ]
+    ]
+}
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/hand/docs/images/adding_poses.png b/devices/webcam/pose_vis/gesture/hand/docs/images/adding_poses.png
new file mode 100644
index 00000000..5d9a8e40
Binary files /dev/null and b/devices/webcam/pose_vis/gesture/hand/docs/images/adding_poses.png differ
diff --git a/devices/webcam/pose_vis/gesture/hand/docs/images/collecting_data.png b/devices/webcam/pose_vis/gesture/hand/docs/images/collecting_data.png
new file mode 100644
index 00000000..67ec190f
Binary files /dev/null and b/devices/webcam/pose_vis/gesture/hand/docs/images/collecting_data.png differ
diff --git a/devices/webcam/pose_vis/gesture/hand/gesture_vis.py b/devices/webcam/pose_vis/gesture/hand/gesture_vis.py
new file mode 100644
index 00000000..b7df92fd
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/hand/gesture_vis.py
@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Windows-specific performance tuning
+import os
+if os.name == "nt":
+    # Improve sleep timer resolution for this process on Windows
+    # https://learn.microsoft.com/en-us/windows/win32/api/timeapi/nf-timeapi-timebeginperiod
+    import ctypes
+    winmm = ctypes.WinDLL('winmm')
+    winmm.timeBeginPeriod(1)
+
+    # Improve device capture startup time on Windows
+    # https://github.com/opencv/opencv/issues/17687
+    os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
+
+import time
+import logging
+import cv2
+import collections
+import numpy as np
+import argparse as ap
+
+from enum import Enum
+from typing import List, Tuple, Any
+from google.protobuf.json_format import MessageToDict
+from pose_vis.utils import parse_sources, parse_resolutions
+from pose_vis.utils import absolute_path
+from pose_vis.streams.utils.capture_handler import CaptureHandler, AllCapturesFinished
+from pose_vis.display import DisplayHandler
+from pose_vis.extensions.hands import HandsExtension, HandsConfig
+from pose_vis.performance_utility import PerfUtility
+from pose_vis.gesture.hand.annotation import Annotation, Vector
+
+logger = logging.getLogger(__name__)
+
+# The maximum difference value to check for when looking for a known pose
+MAX_DIFFERENCE_VALUE = 450
+
+class GV_MODE(Enum):
+    VISUALIZATION = 0,
+    LABEL_INPUT = 1,
+    COLLECTION = 2
+
+class GestureVis():
+    """
+    Runs hand tracking and gesture recognition for provided sources
+    """
+    sources: List[str | int]
+    resolutions: List[Tuple[int, int, int]]
+    cap_handler: CaptureHandler
+    dis_handler: DisplayHandler
+    perf: PerfUtility
+    annotation: Annotation
+    data_dir: str
+    export_files: List[str]
+    export_format: str
+    running: bool = True
+    mode: GV_MODE = GV_MODE.VISUALIZATION
+    hand_labels: List[str]
+    hand_bounds: List[List[int]]
+    label_name: str = ""
+    label_names: List[str] = []
+    video_writers: List[cv2.VideoWriter]
+
+    def __init__(self, sources: List[str | int], resolutions: List[Tuple[int, int, int]], data_dir: str, export_files: List[str], export_format: str) -> None:
+        self.sources = sources
+        self.resolutions = resolutions
+        self.data_dir = data_dir
+        self.annotation = Annotation()
+        self.export_files = export_files
+        self.export_format = export_format
+        self.video_writers = []
+        for i in range(len(export_files)):
+            self.video_writers.append(cv2.VideoWriter(self.export_files[i], cv2.VideoWriter_fourcc(*self.export_format), self.resolutions[i][2], (self.resolutions[i][0], self.resolutions[i][1])))
+        self.annotation.load_gestures(os.path.join(self.data_dir, "gestures.json"))
+    
+    def on_key(self, key: int) -> None:
+        """
+        Input handling, connected to `DisplayHandler->register_key_callback`
+
+        Switches states based on `GV_MODE`
+        """
+        if self.mode == GV_MODE.VISUALIZATION and key == 13:
+            self.mode = GV_MODE.LABEL_INPUT
+        elif self.mode == GV_MODE.LABEL_INPUT:
+            if key == 27:
+                self.mode = GV_MODE.VISUALIZATION
+                self.label_name = ""
+            elif key == 8:
+                self.label_name = self.label_name[:-1]
+            elif key == 13:
+                if len(self.label_name) == 0:
+                    logger.warning(" label is empty")
+                else:
+                    if self.label_name not in self.label_names:
+                        self.label_names.append(self.label_name)
+                    self.mode = GV_MODE.COLLECTION
+            else:
+                character = chr(key)
+                self.label_name += character
+        elif self.mode == GV_MODE.COLLECTION:
+            if key == 27:
+                self.mode = GV_MODE.VISUALIZATION
+                self.label_name = ""
+            elif key == 32:
+                for hdx in range(len(self.annotation.hands)):
+                    self.annotation.add_gesture_data(self.annotation.hands[hdx], self.label_name)
+                self.annotation.save_gestures(os.path.join(self.data_dir, "gestures.json"))
+        elif key == 27:
+            self.running = False
+
+    def get_handedness_labels(self, mp_handedness: Any) -> List[str]:
+        """
+        Puts MediaPipe "handedness" labels into a simple list
+        https://google.github.io/mediapipe/solutions/hands.html#multi_handedness
+        """
+        hand_labels: List[str] = [None] * len(mp_handedness)
+        for label_index, classification in enumerate(mp_handedness):
+            _dict = MessageToDict(classification)["classification"][0]
+            hand_labels[label_index] = _dict["label"]
+        return hand_labels
+
+    def get_bounds_data(self, mp_screen_keypoints: Any, mp_world_keypoints: Any, frame: np.ndarray) -> Tuple[List[List[int]], List[np.ndarray]]:
+        """
+        Gets the screen bounds and vertices for each hand
+        """
+        im_width, im_height = frame.shape[1], frame.shape[0]
+        num_hands = len(mp_screen_keypoints)
+        hand_bounds: List[List[int]] = [None] * num_hands
+        hand_vectors: List[np.ndarray] = []
+        for hand_index, landmark_list_screen in enumerate(mp_screen_keypoints):
+            landmark_list_screen = landmark_list_screen.landmark
+            landmark_list_world = mp_world_keypoints[hand_index].landmark
+
+            bounds_array = np.empty((0, 2), int)
+            for landmark in landmark_list_screen:
+                lx = landmark.x
+                ly = landmark.y
+                
+                bx = min(int(lx * im_width), im_width - 1)
+                by = min(int(ly * im_height), im_height - 1)
+                point = [np.array((bx, by))]
+                bounds_array = np.append(bounds_array, point, axis = 0)
+            
+            hand_vector = np.empty(Vector.shape)
+            for landmark in landmark_list_world:
+                # We're multiplying by 1000 here to convert meters into milimeters
+                hand_vector = np.append(hand_vector, [[round(landmark.x * 1000.0, 2), round(landmark.y * 1000.0, 2), round(landmark.z * 1000.0, 2)]], axis=0)
+            hand_vectors.append(hand_vector)
+
+            x, y, w, h = cv2.boundingRect(bounds_array)
+            hand_bounds[hand_index] = [x, y, x + w, y + h]
+        return (hand_bounds, hand_vectors)
+
+    def draw_hand_annotations(self, source_index: int, frame: np.ndarray) -> None:
+        """
+        Draws the pose annotation label with the lowest `difference` value
+        """
+        if self.mode != GV_MODE.VISUALIZATION:
+            return
+        
+        annotations = self.annotation.guess_annotations(MAX_DIFFERENCE_VALUE)
+        for hdx, ann in enumerate(annotations):
+            label = "?" if len(ann[0]) == 0 else ann[0]
+            bounds = self.hand_bounds[hdx]
+            annotation_str = f"{self.hand_labels[hdx]}: {label} ({ann[1]:.2f})"
+            text_size = cv2.getTextSize(annotation_str, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 1)
+            cv2.rectangle(frame, (bounds[0], bounds[1]), (bounds[0] + text_size[0][0] + 2, bounds[1] - text_size[0][1] - 2), (0, 0, 0), -1)
+            cv2.putText(frame, annotation_str, (bounds[0] + 1, bounds[1] - 1), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)
+        
+        if len(self.video_writers) > 0:
+            self.video_writers[source_index].write(frame)
+
+    def run(self) -> None:
+        """
+        Run GestureVis
+        """
+        # MediaPipe Hands parameters can be found here
+        # https://google.github.io/mediapipe/solutions/hands.html#static_image_mode
+        hands_config = HandsConfig(model_complexity = 1)
+
+        self.cap_handler = CaptureHandler(self.sources, self.resolutions, [HandsExtension(hands_config)])
+        self.dis_handler = DisplayHandler(50, {"HandsExtension": HandsExtension})
+        self.perf = PerfUtility()
+
+        self.dis_handler.register_key_callback(self.on_key)
+        self.dis_handler.register_post_render_callback(self.draw_hand_annotations)
+        self.cap_handler.start_workers()
+        num_sources = len(self.sources)
+        self.annotation_infos = collections.deque(maxlen = num_sources)
+
+        while self.running:
+            self.perf.update_start()
+
+            results = None
+            try:
+                results = self.cap_handler.get_captures()
+            except AllCapturesFinished:
+                self.running = False
+                logger.info(" capture sources have finished playing, exiting")
+                continue
+            captures = [results[i][0] for i in range(num_sources)]
+            extensions = [results[i][1] for i in range(num_sources)]
+
+            for i in range(num_sources):
+                mp_screen_keypoints = extensions[i]["HandsExtension"]["multi_hand_landmarks"]
+                mp_world_keypoints = extensions[i]["HandsExtension"]["multi_hand_world_landmarks"]
+                mp_handedness = extensions[i]["HandsExtension"]["multi_handedness"]
+                
+                self.hand_labels = self.get_handedness_labels(mp_handedness)
+                capture = captures[i]
+                hand_bounds, hand_vectors = self.get_bounds_data(mp_screen_keypoints, mp_world_keypoints, capture.frame)
+                self.hand_bounds = hand_bounds
+                self.annotation.clear_hand_vertices()
+                for vdx, vec in enumerate(hand_vectors):
+                    self.annotation.set_hand_vertices(vdx, vec)
+
+                if self.mode == GV_MODE.LABEL_INPUT:
+                    cv2.putText(capture.frame, "Define or select label: press <esc> to exit", (10, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, f"Specify label name: {self.label_name}_", (10, 24 + (18 * 1)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, f"Defined labels: {self.label_names}", (10, 24 + (18 * 2)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, "Press <Enter> to confirm", (10, 24 + (18 * 3)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                elif self.mode == GV_MODE.COLLECTION:
+                    cv2.putText(capture.frame, "Collect data points: press <esc> to exit", (10, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    label_index = self.label_names.index(self.label_name)
+                    cv2.putText(capture.frame, f"Label: {self.label_name}, index: {label_index}", (10, 24 + (18 * 1)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    num_points = len(self.annotation.gestures[self.label_name]) if self.label_name in self.annotation.gestures else 0
+                    cv2.putText(capture.frame, f"Data points: {num_points}", (10, 24 + (18 * 2)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, "Press <space> to collect data point", (10, 24 + (18 * 3)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+     
+            self.dis_handler.update_frames(captures, extensions)
+            self.dis_handler.update_windows(0)
+
+            time.sleep(self.perf.get_remaining_sleep_time(self.resolutions[0][2]))
+            self.perf.update_end()
+        self.cleanup()
+
+    def cleanup(self) -> None:
+        self.cap_handler.cleanup()
+        self.dis_handler.cleanup()
+        for writer in self.video_writers:
+            writer.release()
+
+parser = ap.ArgumentParser()
+parser.add_argument("--sources", type = str, nargs = "*", help = "which sources to stream (url, device id, video, or image directory)", action = "store", required = False)
+parser.add_argument("--resolutions", type = str, nargs = "*", help = "specify resolution/framerate per stream; format is <stream index or * for all>:<W>x<H>x<FPS> (default *:1280x720x30)", action = "store", required = False)
+default_dir = f"webcam{os.sep}pose_vis{os.sep}gesture{os.sep}hand{os.sep}data"
+parser.add_argument("--data-dir", type = str, nargs = "?", const = default_dir, default = default_dir, help = f"set data directory (default: {default_dir})", action = "store", required = False)
+parser.add_argument("--export", type = str, nargs = "*", help = "export annotated stream as video file", action = "store", required = False)
+parser.add_argument("--export-format", type = str, nargs = "?", const = "MP4V", default = "MP4V", help = "format to write exported video in (default: H264)", action = "store", required = False)
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    sources = parse_sources(args.sources)
+    resolutions = parse_resolutions(len(sources), args.resolutions if args.resolutions is not None else [])
+    export_files = []
+    if args.export is not None:
+        for _file in args.export:
+            export_files.append(absolute_path(_file))
+    GestureVis(sources, resolutions, absolute_path(args.data_dir), export_files, args.export_format).run()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/hand/input_example.ipynb b/devices/webcam/pose_vis/gesture/hand/input_example.ipynb
new file mode 100644
index 00000000..9903b177
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/hand/input_example.ipynb
@@ -0,0 +1,429 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Taking a Look at GestureVis\n",
+    "\n",
+    "In GestureVis, `annotation.py` handles the actual annotation and only depends on Numpy and Matplotlib. It tracks hand data via a skeleton in 3D space, where each vertex is a collection of X, Y, and Z coordinates. The `gesture_vis.py` script handles running PoseVis to collect and convert MediaPipe keypoints into a format that the annotator expects.\n",
+    "The data in this notebook is generated through MediaPipe, but it could easily be from any other hand tracking solution.\n",
+    "\n",
+    "MediaPipe generates a 21-point skeleton:\n",
+    "\n",
+    "![skeleton](https://mediapipe.dev/images/mobile/hand_landmarks.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Initializing the Annotator\n",
+    "\n",
+    "Let's create the annotator object and load the included gestures:\n",
+    "See the [readme](readme.md) for information on how to easily add gestures to `gestures.json`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pose_vis.utils import absolute_path\n",
+    "from pose_vis.gesture.hand.annotation import Annotation, Vector\n",
+    "\n",
+    "annotation = Annotation()\n",
+    "# Two gestures are included in data/gestures.json: \"Peace\" and \"Thumbs Up\"\n",
+    "annotation.load_gestures(absolute_path(\"hand/data/gestures.json\"))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Adding Hand Vertices\n",
+    "\n",
+    "The included gestures are a 21-point list of vertices, and the annotator expects the hands to be as well. It's hard to do this manually, so I recorded two poses with `gesture_vis.py`, and we'll load that data. All units are in milimeters, with their origin being the approximate geometric center of the hand. Find out more at the [MediaPipe documentation](https://google.github.io/mediapipe/solutions/hands.html#multi_hand_world_landmarks)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Thumbs up approximation\n",
+    "pose_1 = \"\"\"\n",
+    "[\n",
+    "    [\n",
+    "        37.49,\n",
+    "        43.01,\n",
+    "        78.26\n",
+    "    ],\n",
+    "    [\n",
+    "        11.91,\n",
+    "        12.52,\n",
+    "        69.02\n",
+    "    ],\n",
+    "    [\n",
+    "        4.26,\n",
+    "        -12.75,\n",
+    "        62.93\n",
+    "    ],\n",
+    "    [\n",
+    "        -1.0,\n",
+    "        -36.02,\n",
+    "        44.17\n",
+    "    ],\n",
+    "    [\n",
+    "        0.84,\n",
+    "        -60.46,\n",
+    "        24.33\n",
+    "    ],\n",
+    "    [\n",
+    "        -6.4,\n",
+    "        -14.37,\n",
+    "        8.72\n",
+    "    ],\n",
+    "    [\n",
+    "        -25.42,\n",
+    "        -6.54,\n",
+    "        8.0\n",
+    "    ],\n",
+    "    [\n",
+    "        -25.98,\n",
+    "        -4.96,\n",
+    "        34.61\n",
+    "    ],\n",
+    "    [\n",
+    "        -16.45,\n",
+    "        -3.8,\n",
+    "        66.46\n",
+    "    ],\n",
+    "    [\n",
+    "        -0.36,\n",
+    "        -3.3,\n",
+    "        -1.3\n",
+    "    ],\n",
+    "    [\n",
+    "        -24.56,\n",
+    "        2.77,\n",
+    "        -4.13\n",
+    "    ],\n",
+    "    [\n",
+    "        -26.39,\n",
+    "        13.06,\n",
+    "        25.06\n",
+    "    ],\n",
+    "    [\n",
+    "        -14.63,\n",
+    "        3.57,\n",
+    "        49.25\n",
+    "    ],\n",
+    "    [\n",
+    "        2.75,\n",
+    "        7.73,\n",
+    "        -7.43\n",
+    "    ],\n",
+    "    [\n",
+    "        -19.48,\n",
+    "        20.25,\n",
+    "        -7.13\n",
+    "    ],\n",
+    "    [\n",
+    "        -17.46,\n",
+    "        22.93,\n",
+    "        20.25\n",
+    "    ],\n",
+    "    [\n",
+    "        -3.18,\n",
+    "        16.78,\n",
+    "        40.69\n",
+    "    ],\n",
+    "    [\n",
+    "        4.67,\n",
+    "        31.13,\n",
+    "        -2.08\n",
+    "    ],\n",
+    "    [\n",
+    "        -12.25,\n",
+    "        29.92,\n",
+    "        2.64\n",
+    "    ],\n",
+    "    [\n",
+    "        -14.05,\n",
+    "        33.27,\n",
+    "        24.07\n",
+    "    ],\n",
+    "    [\n",
+    "        -3.9,\n",
+    "        30.11,\n",
+    "        37.32\n",
+    "    ]\n",
+    "]\n",
+    "\"\"\"\n",
+    "\n",
+    "# Peace sign approximation\n",
+    "pose_2 = \"\"\"\n",
+    "[\n",
+    "    [\n",
+    "        24.62,\n",
+    "        87.31,\n",
+    "        -20.79\n",
+    "    ],\n",
+    "    [\n",
+    "        -8.73,\n",
+    "        69.12,\n",
+    "        -31.87\n",
+    "    ],\n",
+    "    [\n",
+    "        -20.5,\n",
+    "        40.68,\n",
+    "        -40.55\n",
+    "    ],\n",
+    "    [\n",
+    "        -15.52,\n",
+    "        6.57,\n",
+    "        -47.47\n",
+    "    ],\n",
+    "    [\n",
+    "        8.14,\n",
+    "        -18.77,\n",
+    "        -39.59\n",
+    "    ],\n",
+    "    [\n",
+    "        -30.21,\n",
+    "        6.34,\n",
+    "        0.8\n",
+    "    ],\n",
+    "    [\n",
+    "        -42.02,\n",
+    "        -23.56,\n",
+    "        -2.07\n",
+    "    ],\n",
+    "    [\n",
+    "        -54.18,\n",
+    "        -46.19,\n",
+    "        -6.31\n",
+    "    ],\n",
+    "    [\n",
+    "        -63.11,\n",
+    "        -61.07,\n",
+    "        -25.07\n",
+    "    ],\n",
+    "    [\n",
+    "        -5.75,\n",
+    "        -2.41,\n",
+    "        6.32\n",
+    "    ],\n",
+    "    [\n",
+    "        -14.64,\n",
+    "        -45.58,\n",
+    "        4.01\n",
+    "    ],\n",
+    "    [\n",
+    "        -27.03,\n",
+    "        -67.12,\n",
+    "        -9.93\n",
+    "    ],\n",
+    "    [\n",
+    "        -35.28,\n",
+    "        -89.42,\n",
+    "        -22.82\n",
+    "    ],\n",
+    "    [\n",
+    "        18.98,\n",
+    "        -5.47,\n",
+    "        0.61\n",
+    "    ],\n",
+    "    [\n",
+    "        12.47,\n",
+    "        -23.93,\n",
+    "        -22.09\n",
+    "    ],\n",
+    "    [\n",
+    "        6.73,\n",
+    "        -3.04,\n",
+    "        -36.35\n",
+    "    ],\n",
+    "    [\n",
+    "        6.22,\n",
+    "        22.73,\n",
+    "        -37.9\n",
+    "    ],\n",
+    "    [\n",
+    "        38.65,\n",
+    "        5.67,\n",
+    "        -8.14\n",
+    "    ],\n",
+    "    [\n",
+    "        32.73,\n",
+    "        -7.24,\n",
+    "        -23.63\n",
+    "    ],\n",
+    "    [\n",
+    "        21.98,\n",
+    "        5.87,\n",
+    "        -37.88\n",
+    "    ],\n",
+    "    [\n",
+    "        22.24,\n",
+    "        24.88,\n",
+    "        -34.55\n",
+    "    ]\n",
+    "]\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import numpy as np\n",
+    "\n",
+    "# We'll set the approximate \"thumbs up\" as hand 0\n",
+    "annotation.set_hand_vertices(0, np.asarray(json.loads(pose_1)))\n",
+    "\n",
+    "# and the approximate \"peace sign\" as hand 1\n",
+    "annotation.set_hand_vertices(1, np.asarray(json.loads(pose_2)))\n",
+    "\n",
+    "# When using annotation for videos and real time streaming, you'd use annotation.set_hand_vertices() to update each hand's vertices once per frame\n",
+    "# while using annotation.clear_hand_vertices() beforehand if needed"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Guessing Gestures\n",
+    "\n",
+    "The annotator compares its current hand indices to the saved gesture indices, calculates a difference value (always positive), and will label each hand with the appropriate annotation label if the difference value is below the configured value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('Thumbs Up', 332.7499999999999), ('Peace', 394.76000000000005)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from typing import List, Tuple\n",
+    "\n",
+    "# We'll use a max difference value of 450, as we're working in milimeters\n",
+    "# A list of labels is returned, where each index corresponds to a hand index\n",
+    "# The values in the list are the label name, and the calculated difference value\n",
+    "# If no gesture is found, the value is an empty string and the closest difference value\n",
+    "labels: List[Tuple[str, float]] = annotation.guess_annotations(max_difference_value=450)\n",
+    "\n",
+    "print(labels)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Plotting Data\n",
+    "\n",
+    "The annotator can also plot its hand data with Matplotlib:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig, ax = annotation.configure_plot()\n",
+    "\n",
+    "# This is the order to draw and connect vertices in. Take a look at the keypoint ordering in the first cell to get an idea of how this works\n",
+    "drawing_order = [[0, 1, 2, 3, 4], [0, 5, 6, 7, 8], [5, 9, 10, 11, 12], [9, 13, 14, 15, 16], [13, 17, 18, 19, 20], [17, 0]]\n",
+    "# This is size for the 3D scene\n",
+    "bounds = (-100, 100)\n",
+    "# We need to reorder how the X, Y, and Z variables are used to convert Z to up and Y to forward\n",
+    "xyz_order = (0, 2, 1)\n",
+    "# And finally, we need to flip the new forward coordinate as it's backwards\n",
+    "xyz_scale = (1, 1, -1)\n",
+    "annotation.plot_hand(0, ax, drawing_order, bounds, xyz_order=xyz_order, xyz_scale=xyz_scale)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# And the second pose\n",
+    "fig, ax = annotation.configure_plot()\n",
+    "annotation.plot_hand(1, ax, drawing_order, bounds, xyz_order=xyz_order, xyz_scale=xyz_scale)\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.10.8 ('.venv': venv)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "23a593576959775a19d6469cad78770ba03ee1b7699646fbac2d14539ad9dcf0"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/devices/webcam/pose_vis/gesture/hand/readme.md b/devices/webcam/pose_vis/gesture/hand/readme.md
new file mode 100644
index 00000000..a63ddf3d
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/hand/readme.md
@@ -0,0 +1,55 @@
+# Simple Heuristic Gesture Annotation
+
+[Preview Video](https://i.imgur.com/Le4mvmY.mp4)
+
+This script takes the the [world hand landmarks](https://google.github.io/mediapipe/solutions/hands.html#multi_hand_world_landmarks) generated by MediaPipe, compares the current frame's data to a known list of poses, and estimates the best fit.
+
+![Hand Landmarks](https://mediapipe.dev/images/mobile/hand_landmarks.png)
+
+For estimation, a "difference" value is estimated by comparing each unknown pose's keypoint distance to known pose keypoints, the lowest "difference" value wins.
+
+There's a few caveats and room for improvement: the estimation algorithm will always check every pose and rank them via sorting by the lowest "difference" value, every frame. Distances seem to change based on where the hand is in the frame, but this can be alleviated by having multiple data points for a particular pose. Some poses may benefit from finer tuned estimation, such as ignoring directional tracking.
+
+## Data Example
+An example notebook showing how the hand tracking data is used and represented can be found [here](input_example.ipynb).
+
+## Running
+
+Install [PoseVis](https://github.com/Dasfaust/labgraph/blob/hand_tracking/devices/webcam/readme.md)
+
+Check command line arguments:
+```
+python -m pose_vis.gesture.hand.gesture_vis --help
+```
+
+Run with:
+```
+python -m pose_vis.gesture.hand.gesture_vis --sources 0
+```
+
+Exporting videos:
+```
+python -m pose_vis.gesture.hand.gesture_vis --sources test_video.mp4 --resolutions *:1920x1080x30 --export test_video_annotated.mp4
+```
+
+You may specify a codec with:
+```
+python -m pose_vis.gesture.hand.gesture_vis ... --export-format h264
+```
+Codec codes can be found [here](https://learn.microsoft.com/en-us/windows/win32/medfound/video-fourccs).
+
+## Adding Poses
+
+When the script is running, press `Enter` to add poses: (note: this has only been tested on Windows, CV2 keycodes may differ between platforms.)
+
+![Adding Poses](https://github.com/Dasfaust/labgraph/blob/hand_tracking/devices/webcam/pose_vis/gesture/hand/docs/images/adding_poses.png)
+
+Enter a label for this pose and press `Enter` to continue, or `Escape` to exit. In this example, we're adding the label "OK".
+
+![Collecting Data](https://github.com/Dasfaust/labgraph/blob/hand_tracking/devices/webcam/pose_vis/gesture/hand/docs/images/collecting_data.png)
+
+Position your hand into the desired pose, and press `Spacebar` to collect a data point. Press `Escape` when finished, and test your pose.
+
+[Result Preview](https://i.imgur.com/1VnVMlL.mp4)
+
+Pose data, by default, is stored in `pose_vis/gesture/hand/data`, it consists of `labels.json` which are the label names, and a series of `.npy` files which is the recorded pose data that corresponds to each index in the labels array.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/pose/__init__.py b/devices/webcam/pose_vis/gesture/pose/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/pose/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/gesture/pose/pose_gesture_vis.py b/devices/webcam/pose_vis/gesture/pose/pose_gesture_vis.py
new file mode 100644
index 00000000..028981cf
--- /dev/null
+++ b/devices/webcam/pose_vis/gesture/pose/pose_gesture_vis.py
@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Windows-specific performance tuning
+# from types import Union #! correct import?
+import os
+if os.name == "nt":
+    # Improve sleep timer resolution for this process on Windows
+    # https://learn.microsoft.com/en-us/windows/win32/api/timeapi/nf-timeapi-timebeginperiod
+    import ctypes
+    winmm = ctypes.WinDLL('winmm')
+    winmm.timeBeginPeriod(1)
+
+    # Improve device capture startup time on Windows
+    # https://github.com/opencv/opencv/issues/17687
+    os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
+
+import time
+import json
+import logging
+import cv2
+import collections
+import numpy as np
+import argparse as ap
+import math
+
+from pathlib import Path
+from enum import Enum
+from typing import List, Tuple, Any, Deque, Union
+from dataclasses import dataclass
+from google.protobuf.json_format import MessageToDict
+from pose_vis.utils import parse_sources, parse_resolutions
+from pose_vis.utils import absolute_path
+from pose_vis.streams.utils.capture_handler import CaptureHandler, AllCapturesFinished
+from pose_vis.display import DisplayHandler
+# from pose_vis.extensions.hands import HandsExtension, HandsConfig, mp_hands
+from pose_vis.extensions.pose import PoseExtension, PoseConfig, mp_pose
+from pose_vis.performance_utility import PerfUtility
+
+logger = logging.getLogger(__name__)
+
+LANDMARK_DISTANCES = [
+    (mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.LEFT_ELBOW ),
+    (mp_pose.PoseLandmark.LEFT_WRIST, mp_pose.PoseLandmark.LEFT_WRIST ),
+    # (mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.LEFT_ELBOW ),
+    # (mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.LEFT_HIP ),
+    # (mp_pose.PoseLandmark.LEFT_ELBOW, mp_pose.PoseLandmark.LEFT_WRIST ),
+    # ! Maybe add from wrist to thumb/index finger
+
+    (mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.RIGHT_ELBOW),
+    (mp_pose.PoseLandmark.RIGHT_ELBOW, mp_pose.PoseLandmark.RIGHT_WRIST),
+    # (mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.RIGHT_ELBOW),
+    # (mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.RIGHT_HIP ),
+    # (mp_pose.PoseLandmark.RIGHT_ELBOW, mp_pose.PoseLandmark.RIGHT_WRIST ),
+
+
+
+    (mp_pose.PoseLandmark.LEFT_HIP, mp_pose.PoseLandmark.LEFT_KNEE ),
+    (mp_pose.PoseLandmark.LEFT_KNEE, mp_pose.PoseLandmark.LEFT_ANKLE ),
+    # (mp_pose.PoseLandmark.LEFT_HIP, mp_pose.PoseLandmark.LEFT_KNEE ),
+    # (mp_pose.PoseLandmark.LEFT_KNEE, mp_pose.PoseLandmark.LEFT_ANKLE ),
+    # ! Maybe distance from ankle to toe
+
+    (mp_pose.PoseLandmark.RIGHT_HIP, mp_pose.PoseLandmark.RIGHT_KNEE),
+    (mp_pose.PoseLandmark.RIGHT_KNEE, mp_pose.PoseLandmark.RIGHT_ANKLE )
+    # (mp_pose.PoseLandmark.RIGHT_HIP, mp_pose.PoseLandmark.RIGHT_KNEE ),
+    # (mp_pose.PoseLandmark.RIGHT_KNEE, mp_pose.PoseLandmark.RIGHT_ANKLE )
+]
+
+LANDMARK_DIRECTIONS = [
+    # todo --- ADD HERE ---
+    (mp_pose.PoseLandmark.RIGHT_WRIST, mp_pose.PoseLandmark.RIGHT_SHOULDER),
+    (mp_pose.PoseLandmark.LEFT_WRIST, mp_pose.PoseLandmark.LEFT_SHOULDER),
+    (mp_pose.PoseLandmark.RIGHT_ANKLE, mp_pose.PoseLandmark.RIGHT_HIP),
+    (mp_pose.PoseLandmark.LEFT_ANKLE, mp_pose.PoseLandmark.LEFT_HIP),
+]
+
+TORSO_DISTANCE = [
+    (mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.RIGHT_SHOULDER),
+    (mp_pose.PoseLandmark.LEFT_HIP, mp_pose.PoseLandmark.RIGHT_HIP),
+    (mp_pose.PoseLandmark.LEFT_SHOULDER, mp_pose.PoseLandmark.LEFT_HIP),
+    (mp_pose.PoseLandmark.RIGHT_SHOULDER, mp_pose.PoseLandmark.RIGHT_HIP)
+]
+
+DRAW_DEBUG = False
+
+MAX_DIFFERENCE_VALUE = 3 #! play around with this value
+
+
+class GV_MODE(Enum):
+    VISUALIZATION = 0,
+    LABEL_INPUT = 1,
+    COLLECTION = 2
+
+#! revisit this class
+@dataclass
+class AnnotationInfo():
+    pose_labels: List[str]
+    pose_bounds: List[List[int]]
+    gesture_data: List[np.ndarray]
+    draw: bool
+
+class PoseGestureVis():
+    
+    sources: List[Union[str , int]]
+    # sources: List[str | int]
+    resolutions: List[Tuple[int, int, int]]
+    cap_handler: CaptureHandler
+    dis_handler: DisplayHandler
+    perf: PerfUtility
+    annotation_infos: Deque[AnnotationInfo]
+    data_dir: str
+    export_files: List[str]
+    export_format: str
+    running: bool = True
+    mode: GV_MODE = GV_MODE.VISUALIZATION
+    pose_bound: list[list[int]]
+    label_name: str = ""
+    label_names: List[str] = []
+    label_data: List[np.ndarray] = []
+    video_writers: List[cv2.VideoWriter]
+
+    # ! Test this
+    def __init__(self, sources: List[Union[str , int]], resolutions: List[Tuple[int, int, int]], data_dir: str, export_files: List[str], export_format: str) -> None:
+        self.sources = sources
+        self.resolutions = resolutions
+        self.data_dir = data_dir
+        self.export_files = export_files
+        self.export_format = export_format
+        self.video_writers = []
+        for i in range(len(export_files)):
+            self.video_writers.append(cv2.VideoWriter(self.export_files[i], cv2.VideoWriter_fourcc(*self.export_format), self.resolutions[i][2], (self.resolutions[i][0], self.resolutions[i][1])))
+        self.load_data()
+
+    def load_data(self):
+        label_names = os.path.join(self.data_dir, "labels.json")
+
+        if os.path.exists(label_names):
+            with open(label_names, 'r') as _file:
+                self.label_names = json.load(_file)
+
+            np_files = [_file for _file in os.listdir(self.data_dir) if _file.endswith('.npy')]
+            self.label_data = [np.empty(shape=(0, len(LANDMARK_DISTANCES) + (len(LANDMARK_DIRECTIONS) * 3)), dtype=np.float32)] * len(label_names) #! Go over this
+
+            for _file in np_files:
+                index = int(Path(_file).stem)
+                self.label_data[index] = np.load(os.path.join(self.data_sir, _file))
+
+
+    def on_key(self, key: int):
+        if self.mode == GV_MODE.VISUALIZATION and key == 13:
+            self.mode = GV_MODE.LABEL_INPUT
+        elif self.mode == GV_MODE.LABEL_INPUT:
+            if key == 27:
+                self.mode = GV_MODE.VISUALIZATION
+                self.label_name = ""
+            elif key == 8:
+                self.label_name = self.label_name[:-1]
+            elif key == 13:
+                if len(self.label_name) == 0:
+                    logger.warning(" label is empty")
+                else:
+                    if self.label_name not in self.label_names:
+                        self.label_names.append(self.label_name)
+                        self.label_data.append(np.ndarray(shape = (0, len(LANDMARK_DISTANCES) + (len(LANDMARK_DIRECTIONS) * 3)), dtype = np.float32))
+                    self.mode = GV_MODE.COLLECTION
+            else:
+                character = chr(key)
+                self.label_name += character
+        elif self.mode == GV_MODE.COLLECTION:
+            if key == 27:
+                self.mode = GV_MODE.VISUALIZATION
+                self.label_name = ""
+            elif key == 32:
+                self.save_gesture_keypoints()
+        elif key == 27:
+            self.running = False
+
+
+
+    def get_labels(self, mp_lables):
+        print(f'labels - {mp_lables}')
+
+
+
+    def get_bound_data(self, mp_screen_keypoints, mp_world_keypoints, frame:np.ndarray):
+        im_width, im_height = frame.shape[1], frame.shape[0]
+        gesture_data: List[np.array] = [np.empty(shape = (len(LANDMARK_DISTANCES) + (len(LANDMARK_DIRECTIONS) * 3)), dtype = np.float32)]
+        print(f'key - {mp_screen_keypoints}')
+        
+
+        #! fix bugs here
+        for pose_index, landmark_list_screen in enumerate(mp_screen_keypoints):
+            landmark_list_screen = landmark_list_screen.landmark
+            landmark_list_world = mp_world_keypoints[pose_index].landmark
+            bounds_array = np.empty((0, 2), int)
+            gesture_distances = np.empty(shape = (len(LANDMARK_DISTANCES) + (len(LANDMARK_DIRECTIONS) * 3)), dtype = np.float32)
+            for landmark in landmark_list_screen:
+                lx = landmark.x
+                ly = landmark.y
+                
+                bx = min(int(lx * im_width), im_width - 1)
+                by = min(int(ly * im_height), im_height - 1)
+                point = [np.array((bx, by))]
+                bounds_array = np.append(bounds_array, point, axis = 0)
+            
+            palm_size = 0.0
+            for landmark_ids in TORSO_DISTANCE:
+                lid1 = landmark_ids[0]
+                lid2 = landmark_ids[1]
+                landmark1 = landmark_list_world[lid1]
+                landmark2 = landmark_list_world[lid2]
+                palm_size += math.dist((landmark1.x, landmark1.y, landmark1.z), (landmark2.x, landmark2.y, landmark2.z))
+            palm_size = palm_size / len(TORSO_DISTANCE)
+
+            for ddx, landmark_ids in enumerate(LANDMARK_DISTANCES):
+                lid1 = landmark_ids[0]
+                lid2 = landmark_ids[1]
+                landmark1 = landmark_list_world[lid1]
+                landmark2 = landmark_list_world[lid2]
+
+                dist = math.dist((landmark1.x, landmark1.y, landmark1.z), (landmark2.x, landmark2.y, landmark2.z)) / palm_size
+                gesture_distances[ddx] = dist
+
+            dir_index = 0
+            for landmark_ids in LANDMARK_DIRECTIONS:
+                lid1 = landmark_ids[0]
+                lid2 = landmark_ids[1]
+                landmark1 = landmark_list_world[lid1]
+                landmark2 = landmark_list_world[lid2]
+                direction = np.asarray((landmark1.x - landmark2.x, landmark1.y - landmark2.y, landmark1.z - landmark2.z))
+                direction = direction / np.linalg.norm(direction)
+                gesture_distances[len(LANDMARK_DISTANCES) + dir_index] = direction[0]
+                gesture_distances[len(LANDMARK_DISTANCES) + dir_index + 1] = direction[1]
+                gesture_distances[len(LANDMARK_DISTANCES) + dir_index + 2] = direction[2]
+                dir_index += 3
+
+            if DRAW_DEBUG:
+                for ddx, landmark_ids in enumerate(LANDMARK_DISTANCES):
+                    lid1 = landmark_ids[0]
+                    lid2 = landmark_ids[1]
+                    landmark1 = landmark_list_screen[lid1]
+                    landmark2 = landmark_list_screen[lid2]
+
+                    sx1 = min(int(landmark1.x * im_width), im_width - 1)
+                    sy1 = min(int(landmark1.y * im_height), im_height - 1)
+                    cv2.putText(frame, f"({lid1})", (sx1, sy1), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 255), 1, cv2.LINE_AA)
+                    sx2 = min(int(landmark2.x * im_width), im_width - 1)
+                    sy2 = min(int(landmark2.y * im_height), im_height - 1)
+                    cv2.putText(frame, f"({lid2})", (sx2, sy2), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 255), 1, cv2.LINE_AA)
+
+                    cv2.putText(frame, f"({gesture_distances[ddx]:.4f})", ((sx1 + sx2) // 2, (sy1 + sy2) // 2), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1, cv2.LINE_AA)
+                    cv2.line(frame, (sx1, sy1), (sx2, sy2), (192, 192, 192), 1)
+
+            gesture_data[pose_index] = gesture_distances
+
+            x, y, w, h = cv2.boundingRect(bounds_array)
+            pose_bounds[pose_index] = [x, y, x + w, y + h]
+        return (pose_bounds, gesture_data)
+
+    
+    
+    def guess_pose(self, source_index, pose_index):
+        differences = []
+
+        for label_id, pose in enumerate(self.label_data):
+            for i in range(np.ma.size(pose, axis=0)):
+                difference = 0.0
+                for j in range(len(pose[i])):
+                    difference += abs(self.annotation_infos[source_index].gesture_data[pose_index][j] - pose[i][j])
+                differences.append((label_id, difference))
+        differences.sort(key = lambda x: x[1])
+        
+        return differences
+    
+    def draw_annotations(self, source_index: int, frame: np.ndarray):
+        ann_info = self.annotation_infos[source_index]
+        if not ann_info.draw:
+            return
+        
+        for pose_index, bounds in enumerate(ann_info.pose_bounds):
+            label = "?" if len(ann_info.pose_labels) <= pose_index else ann_info.pose_labels[pose_index]
+            classification = "?"
+
+            differences = self.guess_pose(source_index, pose_index)
+            num_guesses = len(differences)
+
+            if num_guesses > 0 and differences[0][1] <= MAX_DIFFERENCE_VALUE:
+                classification = self.label_names[differences[0][0]]
+    
+            diff_str = f" {differences[0][1]:.2f}" if num_guesses > 0 else ""
+            annotation = f"{label}: {classification}{diff_str}"
+            text_size = cv2.getTextSize(annotation, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 1)
+            cv2.rectangle(frame, (bounds[0], bounds[1]), (bounds[0] + text_size[0][0] + 2, bounds[1] - text_size[0][1] - 2), (0, 0, 0), -1)
+            cv2.putText(frame, annotation, (bounds[0] + 1, bounds[1] - 1), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)
+        
+    
+        if len(self.video_writers) > 0:
+            self.video_writers[source_index].write(frame)
+
+    #! TEST THIS 
+    def save_pose_keypoints(self) -> None:
+        label_index = self.label_names.index(self.label_name)
+        for ann_info in self.annotation_infos:
+            for pose_keypoints in ann_info.gesture_data:
+                self.label_data[label_index] =np.append(self.label_data[label_index], [pose_keypoints], axis = 0)
+        
+        with open(os.path.join(self.data_dir, "label.json"), "w") as output:
+            output.write(json.dumps(self.label_names))
+        np.save(os.path.join(self.data_dir, f'{label_index}'), self.label_data[label_index])
+
+    
+
+
+
+    def run(self) -> None:
+        """
+        Run GestureVis
+        """
+        hands_config = PoseConfig(model_complexity = 0)
+
+        self.cap_handler = CaptureHandler(self.sources, self.resolutions, [PoseExtension(PoseConfig)])
+        self.dis_handler = DisplayHandler(50, {"PoseExtension": PoseExtension})
+        self.perf = PerfUtility()
+
+        self.dis_handler.register_key_callback(self.on_key)
+        self.dis_handler.register_post_render_callback(self.draw_annotations)
+        self.cap_handler.start_workers()
+        num_sources = len(self.sources)
+        self.annotation_infos = collections.deque(maxlen = num_sources)
+
+        while self.running:
+            self.perf.update_start()
+
+            results = None
+            try:
+                results = self.cap_handler.get_captures()
+            except AllCapturesFinished:
+                self.running = False
+                logger.info(" capture sources have finished playing, exiting")
+                continue
+            captures = [results[i][0] for i in range(num_sources)]
+            extensions = [results[i][1] for i in range(num_sources)]
+            print(f'len - {len(extensions)}')
+
+            for i in range(num_sources):
+                mp_screen_keypoints = extensions[i]["PoseExtension"]["pose_landmarks"]
+                mp_world_keypoints = extensions[i]["PoseExtension"]["pose_world_landmarks"]
+                
+                
+                
+                capture = captures[i]
+                pose_bounds  = self.get_bound_data(mp_screen_keypoints, mp_world_keypoints, capture.frame)
+                self.pose_bound = pose_bounds
+                # self.annotation_infos.append(AnnotationInfo(hand_labels, hand_bounds, gesture_data, self.mode == GV_MODE.VISUALIZATION))
+
+                if self.mode == GV_MODE.LABEL_INPUT:
+                    cv2.putText(capture.frame, "Define or select label: press <esc> to exit", (10, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, f"Specify label name: {self.label_name}_", (10, 24 + (18 * 1)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, f"Defined labels: {self.label_names}", (10, 24 + (18 * 2)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, "Press <Enter> to confirm", (10, 24 + (18 * 3)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                elif self.mode == GV_MODE.COLLECTION:
+                    cv2.putText(capture.frame, "Collect data points: press <esc> to exit", (10, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    label_index = self.label_names.index(self.label_name)
+                    cv2.putText(capture.frame, f"Label: {self.label_name}, index: {label_index}", (10, 24 + (18 * 1)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    num_points = np.ma.size(self.label_data[label_index], axis = 0)
+                    cv2.putText(capture.frame, f"Data points: {num_points}", (10, 24 + (18 * 2)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+                    cv2.putText(capture.frame, "Press <space> to collect data point", (10, 24 + (18 * 3)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 0, 255), 1, cv2.LINE_AA)
+     
+            self.dis_handler.update_frames(captures, extensions)
+            self.dis_handler.update_windows(0)
+
+            time.sleep(self.perf.get_remaining_sleep_time(self.resolutions[0][2]))
+            self.perf.update_end()
+        self.cleanup()
+
+
+
+
+
+
+
+
+
+
+    
+    def cleanup(self) -> None:
+        self.cap_handler.cleanup()
+        self.dis_handler.cleanup()
+        for writer in self.video_writers:
+            writer.release()
+
+    
+
+
+parser = ap.ArgumentParser()
+parser.add_argument("--sources", type = str, nargs = "*", help = "which sources to stream (url, device id, video, or image directory)", action = "store", required = False)
+parser.add_argument("--resolutions", type = str, nargs = "*", help = "specify resolution/framerate per stream; format is <stream index or * for all>:<W>x<H>x<FPS> (default *:1280x720x30)", action = "store", required = False)
+default_dir = f"webcam{os.sep}pose_vis{os.sep}gesture{os.sep}hand{os.sep}data"
+parser.add_argument("--data-dir", type = str, nargs = "?", const = default_dir, default = default_dir, help = f"set data directory (default: {default_dir})", action = "store", required = False)
+parser.add_argument("--export", type = str, nargs = "*", help = "export annotated stream as video file", action = "store", required = False)
+parser.add_argument("--export-format", type = str, nargs = "?", const = "MP4V", default = "MP4V", help = "format to write exported video in (default: H264)", action = "store", required = False)
+
+
+
+if __name__ == '__main__':
+    args = parser.parse_args()
+
+    sources = parse_sources(args.sources)
+    resolutions = parse_resolutions(len(sources), args.resolutions if args.resolutions is not None else [])
+    export_files = []
+    if args.export is not None:
+        print('export is not NONE')
+        for _file in args.export:
+            export_files.append(absolute_path(_file))
+    print(export_files)
+    PoseGestureVis(sources, resolutions, absolute_path(args.data_dir), export_files, args.export_format).run()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/performance_utility.py b/devices/webcam/pose_vis/performance_utility.py
new file mode 100644
index 00000000..438abc47
--- /dev/null
+++ b/devices/webcam/pose_vis/performance_utility.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import time
+
+class PerfUtility():
+    """
+    Utility class to measure function execution time
+
+    Attributes:
+        `delta_time`: `float` time in seconds between `update_start()` and `update_end()`
+        `last_update_start`: `float` time in seconds when `update_start()` was last called
+        `update_timer`: `float` time between `update_end()` calls, if >= 1 second, resets to 0
+        `update_count`: `int` number of times `update_end()` is called, reset to 0 with `update_timer`
+        `updates_per_second`: `int` the value of the last `update_count` before reset
+        `averaged`: `bool` whether `update_timer` has reached >= 1 second for the first time
+    
+    Functions:
+        `update_start(self) -> None`
+
+        `update_end(self) -> None`
+
+        `get_remaining_sleep_time(self, target_update_rate: int) -> float`
+    """
+
+    delta_time: float = 0.0
+    last_update_start: float = 0.0
+    update_timer: float = 0.0
+    update_count: int = 0
+    updates_per_second: int = 0
+    averaged: bool = False
+
+    def update_start(self) -> None:
+        """
+        Begin profiling function time
+
+        Sets `last_update_start` to the current time
+        """
+        self.last_update_start = time.perf_counter()
+    
+    def update_end(self) -> None:
+        """
+        End profiling function time
+
+        Sets `delta_time`, `updates_per_second`
+        """
+        self.delta_time = time.perf_counter() - self.last_update_start
+        self.update_timer += self.delta_time
+        self.update_count += 1
+        if not self.averaged:
+            self.updates_per_second = self.update_count
+
+        if self.update_timer >= 1.0:
+            self.updates_per_second = self.update_count
+            self.update_timer = 0
+            self.update_count = 0
+            self.averaged = True
+    
+    def get_remaining_sleep_time(self, target_update_rate: int) -> float:
+        """
+        Get wait time in seconds for functions repeating at set intervals
+        Takes `delta_time` into account
+        """
+        target_delta_time = 1.0 / target_update_rate
+        actual_delta_time = time.perf_counter() - self.last_update_start
+        sleep_time = target_delta_time - actual_delta_time
+        return 0 if sleep_time < 0 else sleep_time
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/pose_vis.py b/devices/webcam/pose_vis/pose_vis.py
new file mode 100644
index 00000000..0fd05f51
--- /dev/null
+++ b/devices/webcam/pose_vis/pose_vis.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Windows-specific performance tuning
+import os
+
+if os.name == "nt":
+    # Improve device capture startup time on Windows
+    # https://github.com/opencv/opencv/issues/17687
+    os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
+
+import cProfile
+import pstats
+import logging
+import argparse as ap
+import pose_vis.extensions
+
+from pose_vis.extension import PoseVisExtension
+from pose_vis.utils import parse_sources, parse_resolutions
+from pose_vis.runner import PoseVisConfig
+from pose_vis.runners.source_runner import SourceStreamRunner, SourceStreamRunnerConfig
+from pose_vis.runners.replay_runner import ReplayStreamRunner, ReplayStreamRunnerConfig
+
+logger = logging.getLogger(__name__)
+
+parser = ap.ArgumentParser()
+parser.add_argument("--sources", type = str, nargs = "*", help = "which sources to stream (url, device id, video, or image directory)", action = "store", required = False)
+parser.add_argument("--resolutions", type = str, nargs = "*", help = "specify resolution/framerate per stream; format is <stream index or * for all>:<W>x<H>x<FPS> (default *:1280x720x30)", action = "store", required = False)
+parser.add_argument("--replay", type = str, help = "replay a log file (default: none)", action = "store", required = False)
+parser.add_argument("--display-framerate", type = int, nargs = "?", const = 60, default = 60, help = "specify update rate for video stream presentation; seperate from stream framerate (default: 60)", action = "store", required = False)
+parser.add_argument("--stats-history-size", type = int, nargs = "?", const = 50, default = 50, help = "how many frames to base performance metrics on, 0 to disable (default: 50)", action = "store", required = False)
+parser.add_argument("--logging", help = "enable logging (default: false)", action = "store_true", required = False)
+default_dir = f"webcam{os.sep}logs"
+parser.add_argument("--log-dir", type = str, nargs = "?", const = default_dir, default = default_dir, help = f"set log directory (default: {default_dir})", action = "store", required = False)
+parser.add_argument("--log-name", type = str, help = "set log name (default: random)", action = "store", required = False)
+parser.add_argument("--profile", help = "enable profiling with cProfile *source streaming only (default: false)", action = "store_true", required = False)
+
+if __name__ == "__main__":
+    """
+    Run the graph via command line arguments
+    """
+
+    # Get a list of every available extension
+    extensions = []
+    for cls in PoseVisExtension.__subclasses__():
+        extensions.append(cls())
+
+    # Let extensions register arguments
+    ext: PoseVisExtension
+    for ext in extensions:
+        ext.register_args(parser)
+
+    args = parser.parse_args()
+
+    if args.sources is None and args.replay is None:
+        raise ValueError("Please specify sources to stream or a log to replay")
+
+    enabled_extensions = []
+    # Check if an extension is enabled via its argument
+    for ext in extensions:
+        if ext.check_enabled(args):
+            enabled_extensions.append(ext)
+
+    config = PoseVisConfig(extensions = enabled_extensions,
+        log_directory = args.log_dir,
+        log_name = args.log_name,
+        enable_logging = args.logging,
+        display_framerate = args.display_framerate,
+        stats_history_size = args.stats_history_size)
+
+    if args.replay is None:
+        # Initiate camera streaming
+        sources = parse_sources(args.sources)
+        resolutions = parse_resolutions(len(sources), args.resolutions if args.resolutions is not None else [])
+
+        # Build and run the graph
+        runner_config = SourceStreamRunnerConfig(
+            sources = sources,
+            resolutions = resolutions)
+        runner = SourceStreamRunner(config, runner_config)
+        runner.build()
+
+        if args.profile:
+            with cProfile.Profile() as pr:
+                runner.run()
+            stats = pstats.Stats(pr)
+            stats.dump_stats(filename = "pose_vis.prof")
+            logger.info(" saved 'pose_vis.prof' in the current working directory")
+        else:
+            runner.run()
+    else:
+        # Initiate log replay
+        # Build and run the graph
+        runner_config = ReplayStreamRunnerConfig(args.replay)
+        runner = ReplayStreamRunner(config, runner_config)
+        runner.build()
+        runner.run()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/pose_vis_graph.py b/devices/webcam/pose_vis/pose_vis_graph.py
new file mode 100644
index 00000000..c013273d
--- /dev/null
+++ b/devices/webcam/pose_vis/pose_vis_graph.py
@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+from pose_vis.dynamic_graph import DynamicGraph
+
+class PoseVis(DynamicGraph):
+    """
+    Create an instance of DynamicGraph. It is built with `PoseVisRunner`
+    """
+    pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/runner.py b/devices/webcam/pose_vis/runner.py
new file mode 100644
index 00000000..96c52ee3
--- /dev/null
+++ b/devices/webcam/pose_vis/runner.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+import labgraph as lg
+
+from pose_vis.utils import absolute_path
+from pose_vis.pose_vis_graph import PoseVis
+from pose_vis.extension import PoseVisExtension
+from pose_vis.display import Display, DisplayConfig
+from pose_vis.termination_handler import TerminationHandler
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class PoseVisConfig():
+    """
+    Config for `PoseVisRunner` parent class
+
+    Attributes:
+        `extensions`: `List[PoseVisExtension]` list of extensions to enable
+        `log_directory`: `str` directory to save log files
+        `log_name`: `Optional[str]` name of log file (random if None)
+        `enable_logging`: `bool` enable logging or not
+        `display_framerate`: `int` how fast to run display windows (0 to disable)
+        `stats_history_size`: `int` how many frames to keep track of for performance tracking (0 to disable) this is not enabled if `display_framerate` is 0
+    """
+    extensions: List[PoseVisExtension]
+    log_directory: str
+    log_name: Optional[str]
+    enable_logging: bool
+    display_framerate: int
+    stats_history_size: int
+
+class PoseVisRunner(ABC):
+    """
+    Parent runner class that takes care of basic graph setup
+    """
+    config: PoseVisConfig
+
+    def __init__(self, config: PoseVisConfig) -> None:
+        self.config = config
+
+    def build(self) -> None:
+        """
+        Build the `PoseVis` graph
+        """
+        logger.info(" building graph")
+
+        # Enable extensions
+        for i in range(len(self.config.extensions)):
+            ext: PoseVisExtension = self.config.extensions[i]
+            logger.info(f" enabling extension: {ext.__class__.__name__}")
+            ext.set_enabled(i)
+        
+        # Check if provided log path is a full directory or relative
+        self.config.log_directory = absolute_path(self.config.log_directory)
+        logger.info(f" logging directory is {self.config.log_directory}")
+
+        self.register_nodes()
+
+        if self.config.display_framerate > 0:
+            ext_types = {}
+            for cls in PoseVisExtension.__subclasses__():
+                ext_types[cls.__name__] = cls
+            PoseVis.add_node("DISPLAY", Display, ["STREAM", "OUTPUT", "DISPLAY", "INPUT"], DisplayConfig(
+                target_framerate = self.config.display_framerate,
+                stats_history_size = self.config.stats_history_size,
+                extension_types = ext_types))
+            PoseVis.add_connection(["STREAM", "OUTPUT_EXIT", "DISPLAY", "INPUT_EXIT_STREAM"])
+        else:
+            PoseVis.add_node("TERM_HANDLER", TerminationHandler)
+            PoseVis.add_connection(["STREAM", "OUTPUT_EXIT", "TERM_HANDLER", "INPUT_EXIT_STREAM"])
+        
+        if self.config.enable_logging:
+            PoseVis.add_logger_connection(("captures", "STREAM", "OUTPUT"))
+
+    def run(self) -> None:
+        """
+        Run the `PoseVis` graph
+        """
+        logger_config: lg.LoggerConfig
+        if self.config.log_name:
+            logger_config = lg.LoggerConfig(output_directory = self.config.log_directory, recording_name = self.config.log_name)
+        else:
+            logger_config = lg.LoggerConfig(output_directory = self.config.log_directory)
+
+        logger.info(" running graph")
+        graph = PoseVis()
+        runner_options = lg.RunnerOptions(logger_config = logger_config)
+        runner = lg.ParallelRunner(graph = graph, options = runner_options)
+        runner.run()
+
+    @abstractmethod
+    def register_nodes(self) -> None:
+        """
+        Function called for derived classes to add their specific nodes
+        """
+        raise NotImplementedError
diff --git a/devices/webcam/pose_vis/runners/__init__.py b/devices/webcam/pose_vis/runners/__init__.py
new file mode 100644
index 00000000..948e94e7
--- /dev/null
+++ b/devices/webcam/pose_vis/runners/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
diff --git a/devices/webcam/pose_vis/runners/benchmark_runner.py b/devices/webcam/pose_vis/runners/benchmark_runner.py
new file mode 100644
index 00000000..5346a962
--- /dev/null
+++ b/devices/webcam/pose_vis/runners/benchmark_runner.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+
+from dataclasses import dataclass
+from pose_vis.runner import PoseVisRunner, PoseVisConfig
+from pose_vis.runners.source_runner import SourceStreamRunner, SourceStreamRunnerConfig
+from pose_vis.benchmark import Benchmark, BenchmarkConfig
+from pose_vis.utils import absolute_path
+from pose_vis.pose_vis_graph import PoseVis
+from typing import List, Tuple, Union
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class BenchmarkRunnerConfig():
+    """
+    Config for BenchmarkRunner
+
+    Attributes:
+        `sources`: `List[Union[int, str]]`
+        `resolutions`: `List[Tuple[int, int, int]]`
+        `output_path`: `str`
+        `output_name`: `str`
+        `run_time`: `int`
+    """
+    sources: List[Union[int, str]]
+    resolutions: List[Tuple[int, int, int]]
+    output_path: str
+    output_name: str
+    run_time: int
+
+class BenchmarkRunner(PoseVisRunner):
+    """
+    Runs the `Benchmark` node for gathering performance details
+    """
+    runner_config: BenchmarkRunnerConfig
+
+    def __init__(self, config: PoseVisConfig, runner_config: BenchmarkRunnerConfig) -> None:
+        self.runner_config = runner_config
+        super().__init__(config)
+    
+    def register_nodes(self) -> None:
+        self.runner_config.output_path = absolute_path(self.runner_config.output_path)
+        logger.info(f" benchmark output path is {self.runner_config.output_path}")
+
+        srunner = SourceStreamRunner(self.config, SourceStreamRunnerConfig(self.runner_config.sources, self.runner_config.resolutions))
+        srunner.register_nodes()
+
+        PoseVis.add_node("BENCHMARK", Benchmark, ["STREAM", "OUTPUT", "BENCHMARK", "INPUT"], BenchmarkConfig(
+            self.runner_config.output_path,
+            self.runner_config.output_name,
+            self.runner_config.run_time))
+        
+        if self.config.display_framerate > 0:
+            PoseVis.add_connection(["BENCHMARK", "OUTPUT_EXIT", "DISPLAY", "INPUT_EXIT_USER"])
+        else:
+            PoseVis.add_connection(["BENCHMARK", "OUTPUT_EXIT", "TERM_HANDLER", "INPUT_EXIT_USER"])
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/runners/replay_runner.py b/devices/webcam/pose_vis/runners/replay_runner.py
new file mode 100644
index 00000000..96e42646
--- /dev/null
+++ b/devices/webcam/pose_vis/runners/replay_runner.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+
+from pose_vis.utils import absolute_path
+from pose_vis.runner import PoseVisRunner, PoseVisConfig
+from pose_vis.streams.replay_stream import ReplayStream, ReplayStreamConfig
+from pose_vis.pose_vis_graph import PoseVis
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ReplayStreamRunnerConfig():
+    """
+    Config for ReplayStreamRunner
+
+    Attributes:
+        `path`: `str`
+    """
+    path: str
+
+class ReplayStreamRunner(PoseVisRunner):
+    """
+    Runs the `ReplayStream` node to replay log files
+    """
+    runner_config: ReplayStreamRunnerConfig
+
+    def __init__(self, config: PoseVisConfig, runner_config: ReplayStreamRunnerConfig) -> None:
+        self.runner_config = runner_config
+        super().__init__(config)
+    
+    def register_nodes(self) -> None:
+        self.runner_config.path = absolute_path(self.runner_config.path)
+
+        PoseVis.add_node("STREAM", ReplayStream, config = ReplayStreamConfig(
+            self.config.extensions,
+            self.runner_config.path))
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/runners/source_runner.py b/devices/webcam/pose_vis/runners/source_runner.py
new file mode 100644
index 00000000..0520756f
--- /dev/null
+++ b/devices/webcam/pose_vis/runners/source_runner.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import logging
+
+from dataclasses import dataclass
+from pose_vis.runner import PoseVisRunner, PoseVisConfig
+from pose_vis.streams.source_stream import SourceStream, SourceStreamConfig
+from pose_vis.pose_vis_graph import PoseVis
+from typing import List, Tuple, Union
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SourceStreamRunnerConfig():
+    """
+    Config for SourceStreamRunner
+
+    Attributes:
+        `sources`: `List[Union[int, str]]`
+        `resolutions`: `List[Tuple[int, int, int]]`
+    """
+    sources: List[Union[int, str]]
+    resolutions: List[Tuple[int, int, int]]
+
+class SourceStreamRunner(PoseVisRunner):
+    """
+    Runs the `SourceStream` node to capture video sources
+    """
+    runner_config: SourceStreamRunnerConfig
+
+    def __init__(self, config: PoseVisConfig, runner_config: SourceStreamRunnerConfig) -> None:
+        self.runner_config = runner_config
+        super().__init__(config)
+    
+    def register_nodes(self) -> int:
+        # Sort by framerate to select lowest value
+        # The stream shouldn't run faster than the slowest source
+        _sorted = sorted(self.runner_config.resolutions, key = lambda r: r[2])
+        PoseVis.add_node("STREAM", SourceStream, config = SourceStreamConfig(
+            self.runner_config.sources,
+            self.runner_config.resolutions,
+            self.config.extensions,
+            _sorted[0][2]))
+
+        
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/stats_worker.py b/devices/webcam/pose_vis/stats_worker.py
new file mode 100644
index 00000000..9a540aec
--- /dev/null
+++ b/devices/webcam/pose_vis/stats_worker.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import multiprocessing
+import logging
+import collections
+import statistics
+
+from typing import List
+from pose_vis.utils import relative_latency
+
+logger = logging.getLogger(__name__)
+
+class CapturePoint():
+    """
+    Represents a captured frame's point in time
+    """
+    __slots__ = "frame_index", "runtime", "target_fps", "receive_time", "device_timestamps"
+
+    def __init__(self, frame_index: int, runtime: float, target_fps: int, receive_time: float, device_timestamps: List[float]) -> None:
+        self.frame_index = frame_index
+        self.runtime = runtime
+        self.target_fps = target_fps
+        self.receive_time = receive_time
+        self.device_timestamps = device_timestamps
+
+class CaptureStats():
+    """
+    Represents performance statistics
+    """
+    __slots__ = "framedrop", "latency", "jitter", "desync"
+
+    def __init__(self, framedrop: float, latency: float, jitter: float, desync: List[float]):
+        self.framedrop = framedrop
+        self.latency = latency
+        self.jitter = jitter
+        self.desync = desync
+
+class StatsWorker(multiprocessing.Process):
+    """
+    Processes performance stats without skewing results
+    """
+    tasks: multiprocessing.JoinableQueue
+    results: multiprocessing.Queue
+    history_size: int
+    timestamps: collections.deque
+    desync_vals: List[collections.deque]
+    latency_vals: collections.deque
+
+    def __init__(self, tasks: multiprocessing.JoinableQueue, results: multiprocessing.Queue, history_size: int) -> None:
+        self.tasks = tasks
+        self.results = results
+        self.history_size = history_size
+        super().__init__()
+    
+    def setup(self) -> None:
+        self.timestamps = collections.deque(maxlen = self.history_size)
+        self.latency_vals = collections.deque(maxlen = self.history_size)
+        self.desync_vals = []
+    
+    def run(self) -> None:
+        self.setup()
+        while True:
+            point: CapturePoint = self.tasks.get()
+            if point is not None:
+                extra_sources = 0
+
+                # time created, time received
+                self.timestamps.append((point.device_timestamps[0], point.receive_time))
+                if len(self.timestamps) > 1:
+                    extra_sources = len(point.device_timestamps) - 1
+                    if extra_sources > 0:
+                        if len(self.desync_vals) != extra_sources:
+                            self.desync_vals = [collections.deque(maxlen = self.history_size)] * extra_sources
+                        for i in range(extra_sources):
+                            self.desync_vals[i].append(abs(point.device_timestamps[i + 1] - point.device_timestamps[0]))
+
+                    # TODO: this may not be correct
+                    # `rel_device` can be greater than `rel_receive`, for now we just take the absolute value
+                    self.latency_vals.append(abs(relative_latency(point.device_timestamps[0], point.receive_time, self.timestamps[0][0], self.timestamps[0][1])))
+
+                expected_frames = round(point.runtime * point.target_fps)
+                framedrop = (point.frame_index / (1 if expected_frames == 0 else expected_frames)) * 100
+
+                latency = 0.0
+                jitter = 0.0
+                desync = []
+                if len(self.latency_vals) > 1:
+                    latency = statistics.median(self.latency_vals)
+                    jitter = statistics.stdev(self.latency_vals)
+                    
+                    if extra_sources > 0:
+                        desync = [statistics.median(li) for li in self.desync_vals]
+
+                stats = CaptureStats(
+                    framedrop,
+                    latency,
+                    jitter,
+                    desync)
+
+                self.results.put(stats)
+                self.tasks.task_done()
+            else:
+                self.tasks.task_done()
+                break
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/__init__.py b/devices/webcam/pose_vis/streams/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/messages.py b/devices/webcam/pose_vis/streams/messages.py
new file mode 100644
index 00000000..bb58796d
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/messages.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import labgraph as lg
+import numpy as np
+
+from dataclasses import dataclass
+from typing import Dict, Any, List
+
+@dataclass
+class Capture():
+    """
+    Represents a single video frame
+
+    Attributes:
+        `frame`: `np.ndarray` video frame matrix, shape is (H, W, 3), RGB color space, short datatype
+        `stream_id`: `int` source index for this capture
+        `frame_index`: `int` total frames since startup
+        `system_timestamp`: `float` `time.perf_counter()` value for when this frame was created
+        `proc_delta_time`: `float` time in seconds this frame took to produce
+        `proc_runtime`: `float` total runtime for this source
+        `proc_fps`: `int` frames per second at the time this frame was produced
+        `proc_target_fps`: `int` target frames per second for this source
+    """
+    frame: np.ndarray
+    stream_id: int
+    frame_index: int
+    system_timestamp: float
+    proc_delta_time: float
+    proc_runtime: float
+    proc_fps: int
+    proc_target_fps: int
+
+class CaptureResult(lg.Message):
+    """
+    Represents the current frame from every capture source
+
+    Attributes:
+        `captures`: `List[Capture]` `Capture`s by source index
+        `extensions`: `List[Dict[str, Any]]` extension data by source index
+    """
+    captures: List[Capture]
+    extensions: List[Dict[str, Any]]
+
+class ExitSignal(lg.Message):
+    """
+    Passed to `Display` or `TerminationHandler` when a stream wants to close the graph
+    """
+    pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/replay_stream.py b/devices/webcam/pose_vis/streams/replay_stream.py
new file mode 100644
index 00000000..40f5ea54
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/replay_stream.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Windows-specific performance tuning
+import os
+if os.name == "nt":
+    # Improve sleep timer resolution for this process on Windows
+    # https://learn.microsoft.com/en-us/windows/win32/api/timeapi/nf-timeapi-timebeginperiod
+    import ctypes
+    winmm = ctypes.WinDLL('winmm')
+    winmm.timeBeginPeriod(1)
+
+import logging
+import asyncio
+import labgraph as lg
+
+from pose_vis.streams.messages import CaptureResult, ExitSignal
+from pose_vis.extension import PoseVisExtension
+from pose_vis.performance_utility import PerfUtility
+from typing import Optional, List
+from labgraph.loggers.hdf5.reader import HDF5Reader
+
+logger = logging.getLogger(__name__)
+
+class ReplayStreamConfig(lg.Config):
+    """
+    Config for ReplayStream
+
+    Attributes:
+        `extensions`: `List[PoseVisExtension]` extension objects to be executed on each frame
+        `log_path`: `str` absolute path to log file
+    """
+    extensions: List[PoseVisExtension]
+    log_path: str
+
+class ReplayStreamState(lg.State):
+    """
+    State for ReplayStream
+
+    Attributes:
+        `perf`: `PerfUtility` utility to track frames per second
+        `reader`: `Optional[HDF5Reader]` log file reader utility
+    """
+    # Using optional here as LabGraph expects state attributes to be initialized
+    # We create and assign these objects during setup
+    perf: PerfUtility = PerfUtility()
+    reader: Optional[HDF5Reader] = None
+
+class ReplayStream(lg.Node):
+    """
+    Replays log files
+
+    Topics:
+        `OUTPUT`: `CaptureResult`
+    
+    Attributes:
+        `config`: `LogStreamConfig`
+        `state`: `LogStreamState`
+    """
+    OUTPUT = lg.Topic(CaptureResult)
+    OUTPUT_EXIT = lg.Topic(ExitSignal)
+    config: ReplayStreamConfig
+    state: ReplayStreamState
+
+    @lg.publisher(OUTPUT)
+    @lg.publisher(OUTPUT_EXIT)
+    async def read_log(self) -> lg.AsyncPublisher:
+        num_captures = len(self.state.reader.logs["captures"])
+        for i in range(num_captures):
+            self.state.perf.update_start()
+
+            # TODO: run extensions if enabled
+            capture: CaptureResult = self.state.reader.logs["captures"][i]
+            yield self.OUTPUT, capture
+
+            await asyncio.sleep(capture.stream_time)
+
+            self.state.perf.update_end()
+
+        logger.info(" log replay finished")
+        yield self.OUTPUT_EXIT, ExitSignal()
+
+    def setup(self) -> None:
+        logger.info(f" reading log: {self.config.log_path}")
+        self.state.reader = HDF5Reader(self.config.log_path, {"captures": CaptureResult})
+
+    def cleanup(self) -> None:
+        pass
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/source_stream.py b/devices/webcam/pose_vis/streams/source_stream.py
new file mode 100644
index 00000000..f44c9e3b
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/source_stream.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# Windows-specific performance tuning
+import os
+if os.name == "nt":
+    # Improve sleep timer resolution for this process on Windows
+    # https://learn.microsoft.com/en-us/windows/win32/api/timeapi/nf-timeapi-timebeginperiod
+    import ctypes
+    winmm = ctypes.WinDLL('winmm')
+    winmm.timeBeginPeriod(1)
+
+import time
+import logging
+import traceback
+import asyncio
+import labgraph as lg
+
+from typing import Tuple, List, Union, Optional
+from pose_vis.extension import PoseVisExtension
+from pose_vis.performance_utility import PerfUtility
+from pose_vis.streams.messages import CaptureResult, ExitSignal
+from pose_vis.streams.utils.capture_handler import CaptureHandler, AllCapturesFinished
+
+logger = logging.getLogger(__name__)
+
+class SourceStreamConfig(lg.Config):
+    """
+    Config for `SourceStream`
+
+    Attributes:
+        `sources`: `List[Union[int, str]]` which sources to initialize
+        `resolutions`: `List[Tuple[int, int, int]]` resolution per source
+        NOTE: `SourceStream` will run at the lowest provided framerate
+        `extensions`: `List[PoseVisExtension]` extension instances to be initialized in each source
+        `target_framerate`: `int` target framerate for this node to achieve
+    """
+    sources: List[Union[int, str]]
+    resolutions: List[Tuple[int, int, int]]
+    extensions: List[PoseVisExtension]
+    target_framerate: int
+
+class SourceStreamState(lg.State):
+    """
+    State for `SourceStream`
+
+    Attributes:
+        `handler`: `Optional[CaptureHandler]`
+        `perf`: `PerfUtility`
+    """
+    handler: Optional[CaptureHandler] = None
+    perf: PerfUtility = PerfUtility()
+
+class SourceStream(lg.Node):
+    """
+    Captures frames from all sources and publishes them with a `CaptureResult` message
+
+    Topics:
+        `OUTPUT`: publishes `CaptureResult`
+        `OUTPUT_EXIT` publishes `ExitSignal`
+    """
+    OUTPUT = lg.Topic(CaptureResult)
+    OUTPUT_EXIT = lg.Topic(ExitSignal)
+    config: SourceStreamConfig
+    state: SourceStreamState
+
+    def setup(self) -> None:
+        self.state.handler = CaptureHandler(self.config.sources, self.config.resolutions, self.config.extensions)
+
+    @lg.publisher(OUTPUT)
+    @lg.publisher(OUTPUT_EXIT)
+    async def read_sources(self) -> lg.AsyncPublisher:
+        has_video_source = False
+        
+        num_sources = len(self.config.sources)
+        for i in range(num_sources):
+            if isinstance(self.config.sources[i], str):
+                has_video_source = True
+        
+        self.state.handler.start_workers()
+
+        while True:
+            try:
+                self.state.perf.update_start()
+
+                result = self.state.handler.get_captures()
+                yield self.OUTPUT, CaptureResult(
+                    [result[i][0] for i in range(num_sources)],
+                    [result[i][1] for i in range(num_sources)])
+
+                if has_video_source:
+                    # This gives a more accurate sleep period on Windows without stalling the node
+                    # Doesn't seem to hurt on other systems
+                    wait_time = self.state.perf.get_remaining_sleep_time(self.config.target_framerate)
+                    wait_start = time.perf_counter()
+                    while time.perf_counter() - wait_start < wait_time:
+                        await asyncio.sleep(0.001)
+                else:
+                    # When capturing from a device, CV2 VideoCapture will block to keep the configured framerate
+                    # a small sleep period keeps the node from stalling
+                    await asyncio.sleep(0.002)
+
+                self.state.perf.update_end()
+            except Exception as e:
+                if not isinstance(e, AllCapturesFinished):
+                    logger.critical(traceback.format_exc())
+                    logger.critical(" an exception occurred in a source thread or process, exiting")
+                else:
+                    logger.info(" all captures have finished")
+                break
+        
+        yield self.OUTPUT_EXIT, ExitSignal()
+
+    def cleanup(self) -> None:
+        self.state.handler.cleanup()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/utils/__init__.py b/devices/webcam/pose_vis/streams/utils/__init__.py
new file mode 100644
index 00000000..cd1c80d0
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/utils/__init__.py
@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/utils/capture_handler.py b/devices/webcam/pose_vis/streams/utils/capture_handler.py
new file mode 100644
index 00000000..78594458
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/utils/capture_handler.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import os
+import multiprocessing
+import logging
+import numpy as np
+
+from multiprocessing import shared_memory
+from typing import Tuple, List, Union, Dict, Any
+from pose_vis.streams.utils.capture_worker import CaptureWorker
+from pose_vis.streams.messages import Capture
+from pose_vis.extension import PoseVisExtension
+
+logger = logging.getLogger(__name__)
+
+class AllCapturesFinished(Exception):
+    """
+    Raised when all captures finish (e.g video files are done playing, image directories are processed)
+    """
+    pass
+
+class CaptureHandler():
+    """
+    Handles capturing video frames via `CaptureWorker` objects
+    """
+    sources: List[Union[int, str]]
+    resolutions: List[Tuple[int, int, int]]
+    extensions: List[PoseVisExtension]
+    shared_mems: List[shared_memory.SharedMemory] = []
+    workers: List[CaptureWorker] = []
+    # PipeConnection on Windows, different on Linux/Mac
+    connections: List[Tuple[Any, Any]] = []
+    finished_captures: List[int] = []
+    num_sources: int = 0
+
+    def __init__(self, sources: List[Union[int, str]], resolutions: List[Tuple[int, int, int]], extensions: List[PoseVisExtension]) -> None:
+        self.sources = sources
+        self.resolutions = resolutions
+        self.extensions = extensions
+
+        self.num_sources = len(self.sources)
+        for i in range(self.num_sources):
+            size = np.dtype(np.uint8).itemsize * np.prod((self.resolutions[i][1], self.resolutions[i][0], 3))
+            try:
+                self.shared_mems.append(shared_memory.SharedMemory(create = True, size = size.item(), name = f"pv_worker_{i}"))
+            except FileExistsError as e:
+                if os.name == "nt":
+                    # This can happen if the program crashes and leaves a stray processes running
+                    # Windows will automatically delete the file when it's not in use by a process
+                    # https://github.com/python/cpython/issues/85059
+                    logger.critical(" shared memory file already exists. Please terminate any stray Python processes and try again")
+                    raise e
+                else:
+                    shm = shared_memory.SharedMemory(name = f"pv_worker_{i}")
+                    shm.close()
+                    shm.unlink()
+                    # Unlink and re-create incase the array size has changed
+                    self.shared_mems.append(shared_memory.SharedMemory(create = True, size = size.item(), name = f"pv_worker_{i}"))
+
+            outbound = multiprocessing.Pipe()
+            inbound = multiprocessing.Pipe()
+            self.connections.append((outbound[0], inbound[0]))
+            self.workers.append(CaptureWorker(
+                (outbound[1], inbound[1]),
+                self.extensions,
+                self.sources[i],
+                np.asarray(self.resolutions[i]),
+                i))
+        
+    def start_workers(self) -> None:
+        for i in range(self.num_sources):
+            self.workers[i].start()
+
+    def get_captures(self) -> List[Tuple[Capture, Dict[str, Any], bool]]:
+        if len(self.finished_captures) == self.num_sources:
+            raise AllCapturesFinished
+
+        for i in range(self.num_sources):
+            if i not in self.finished_captures:
+                self.connections[i][0].send(True)
+        
+        result: List[Tuple[Capture, Dict[str, Any], bool]] = [self.connections[i][1].recv() for i in range(self.num_sources) if i not in self.finished_captures]
+        for idx, res in enumerate(result):
+            res[0].frame = np.ndarray(shape = (self.resolutions[i][1], self.resolutions[i][0], 3), dtype = np.uint8, buffer = self.shared_mems[idx].buf)[:]
+
+        for res in result:
+            if res[2]:
+                self.finished_captures.append(res[0].stream_id)
+
+        return result
+    
+    def cleanup(self) -> None:
+        for con in self.connections:
+            con[0].send(False)
+        for worker in self.workers:
+            worker.join()
+        for shm in self.shared_mems:
+            shm.close()
+            shm.unlink()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/streams/utils/capture_worker.py b/devices/webcam/pose_vis/streams/utils/capture_worker.py
new file mode 100644
index 00000000..4150ec40
--- /dev/null
+++ b/devices/webcam/pose_vis/streams/utils/capture_worker.py
@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import os
+import time
+import logging
+import multiprocessing
+import cv2
+import numpy as np
+
+from multiprocessing import shared_memory
+from typing import List, Tuple, Union, Optional, Any
+from pose_vis.streams.messages import Capture
+from pose_vis.extension import PoseVisExtension
+from pose_vis.performance_utility import PerfUtility
+from pose_vis.utils import is_path
+
+# https://docs.opencv.org/4.2.0/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56
+SUPPORTED_IMG_EXTENSIONS = [".bmp", ".jpeg", ".jpg", ".png", ".webp"]
+
+logger = logging.getLogger(__name__)
+
+class CaptureWorker(multiprocessing.Process):
+    """
+    Handles setup of CV2 VideoCapture, frame indexing, runtime tracking, and communication with its parent process
+    """
+    connections: Tuple[Any, Any]
+    shared_mem: shared_memory.SharedMemory
+    extensions: List[PoseVisExtension]
+    worker_number: int
+    cap_source: Union[int, str]
+    resolution: np.ndarray
+    images: List[str] = []
+    capture_finished: bool = False
+    frame_index: int = 0
+    start_time: float = 0.0
+    blank_frame: Optional[np.ndarray] = None
+    capture: Optional[cv2.VideoCapture] = None
+    perf: Optional[PerfUtility] = None
+
+    def __init__(self, connections: Tuple[Any, Any], extensions: List[PoseVisExtension], cap_source: Union[int, str], resolution: np.ndarray, worker_number: int):
+        self.connections = connections
+        self.extensions = extensions
+        self.cap_source = cap_source
+        self.resolution = resolution
+        self.worker_number = worker_number
+        super().__init__()
+    
+    def setup(self) -> None:
+        self.perf = PerfUtility()
+
+        self.shared_mem = shared_memory.SharedMemory(name = f"pv_worker_{self.worker_number}")
+        self.blank_frame = np.zeros(shape = (self.resolution[1], self.resolution[0], 3), dtype = np.uint8)
+        
+        self.open_capture()
+
+        for ext in self.extensions:
+            logger.info(f" worker {self.worker_number}: setting up extension {ext.__class__.__name__}")
+            ext.setup()
+        logger.info(f" worker {self.worker_number}: started")
+
+    def open_capture(self) -> None:
+        if isinstance(self.cap_source, int) or os.path.isfile(self.cap_source) or self.cap_source.find(" ! ") > -1:
+            logger.info(f" opening source [{self.cap_source}]")
+
+            backend = cv2.CAP_MSMF if os.name == "nt" else cv2.CAP_V4L2
+            if isinstance(self.cap_source, str):
+                if not is_path(self.cap_source):
+                    backend = cv2.CAP_GSTREAMER
+
+            self.capture = cv2.VideoCapture(self.cap_source, backend)
+
+            if self.capture.isOpened():
+                if backend != cv2.CAP_GSTREAMER:
+                    self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, self.resolution[0])
+                    self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, self.resolution[1])
+                    self.capture.set(cv2.CAP_PROP_FPS, self.resolution[2])
+                    self.capture.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc("M", "J", "P", "G"))
+                    self.capture.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+                    self.capture.set(cv2.CAP_PROP_AUTOFOCUS, 0)
+                logger.info(f" source [{self.cap_source}] opened with backend: {self.capture.getBackendName()}")
+            else:
+                logger.warning(f" source [{self.cap_source}] could not be opened")
+        
+        else:
+            logger.info(f" opening directory: {self.cap_source}")
+            for _file in os.listdir(self.cap_source):
+                ext = os.path.splitext(_file)[1]
+                if ext.lower() in SUPPORTED_IMG_EXTENSIONS:
+                    self.images.append(os.path.join(self.cap_source, _file))
+            logger.info(f" found {len(self.images)} image(s)")
+
+    def read_capture(self) -> Tuple[np.ndarray, float]:
+        num_images = len(self.images)
+
+        if self.capture is not None and self.capture.isOpened():
+            success, frame = self.capture.read()
+            timestamp = time.perf_counter()
+
+            if success:
+                if isinstance(self.cap_source, str):
+                    if frame.shape != (self.resolution[1], self.resolution[0], 3):
+                        frame = cv2.resize(frame, (self.resolution[0], self.resolution[1]), interpolation = cv2.INTER_NEAREST)
+                frame = cv2.cvtColor(cv2.flip(frame, 1), cv2.COLOR_BGR2RGB)
+
+                frame.flags.writeable = False
+                self.frame_index += 1
+                return (frame, timestamp)
+
+            elif isinstance(self.cap_source, str):
+                self.capture_finished = True
+            else:
+                logger.warning(f" source {self.cap_source} gave unsuccessful grab()")
+
+        elif num_images > 0 and self.frame_index < num_images:
+            if self.frame_index + 1 >= num_images:
+                self.capture_finished = True
+
+            frame = cv2.imread(self.images[self.frame_index], cv2.IMREAD_COLOR)
+            frame = cv2.cvtColor(cv2.flip(frame, 1), cv2.COLOR_BGR2RGB)
+            self.frame_index += 1
+            return (frame, time.perf_counter())
+
+        return (self.blank_frame.copy(), time.time())
+
+    def cleanup(self) -> None:
+        if self.capture is not None and self.capture.isOpened():
+            self.capture.release()
+            logger.info(f" source [{self.cap_source}] released")
+        logger.info(f" worker {self.worker_number}: shutting down")
+        for ext in self.extensions:
+            ext.cleanup()
+    
+    def run(self) -> None:
+        self.setup()
+
+        while True:
+            if self.start_time == 0:
+                self.start_time = time.perf_counter()
+
+            self.perf.update_start()
+            instruction: bool = self.connections[0].recv()
+
+            if instruction:
+                frame, timestamp = self.read_capture()
+                dst = np.ndarray(shape = frame.shape, dtype = frame.dtype, buffer = self.shared_mem.buf)
+                dst[:] = frame[:]
+                cap = Capture(
+                    None,
+                    self.worker_number,
+                    self.frame_index,
+                    timestamp,
+                    self.perf.delta_time if self.perf.delta_time > 0 else 1 / self.resolution[2],
+                    time.perf_counter() - self.start_time,
+                    self.perf.updates_per_second,
+                    self.resolution[2])
+
+                ext_results = {}
+                for ext in self.extensions:
+                    ext_result = ext.process_frame(frame)
+                    ext_results[ext.__class__.__name__] = ext_result.data
+                
+                self.connections[1].send((cap, ext_results, self.capture_finished))
+            else:
+                break
+
+            self.perf.update_end()
+
+        self.cleanup()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/termination_handler.py b/devices/webcam/pose_vis/termination_handler.py
new file mode 100644
index 00000000..e51a11e1
--- /dev/null
+++ b/devices/webcam/pose_vis/termination_handler.py
@@ -0,0 +1,43 @@
+import time
+import labgraph as lg
+
+from pose_vis.streams.messages import ExitSignal
+
+class TerminationHandlerState(lg.State):
+    """
+    State for TerminationHandler
+
+    Attributes:
+        `signal_received`: `bool`
+    """
+    signal_received: bool = False
+
+class TerminationHandler(lg.Node):
+    """
+    Terminates the graph cleanly upon receiving `ExitSignal`
+
+    Topics:
+        `INPUT`: `ExitSignal`
+    
+    Attributes:
+        `state`: `TerminationHandlerState`
+    """
+    INPUT_EXIT_STREAM = lg.Topic(ExitSignal)
+    INPUT_EXIT_USER = lg.Topic(ExitSignal)
+    state: TerminationHandlerState
+
+    @lg.subscriber(INPUT_EXIT_STREAM)
+    async def on_exit_stream(self, _: ExitSignal) -> None:
+        self.state.signal_received = True
+    
+    @lg.subscriber(INPUT_EXIT_USER)
+    async def on_exit_user(self, _: ExitSignal) -> None:
+        self.state.signal_received = True
+    
+    @lg.main
+    def on_main(self) -> None:
+        while True:
+            if self.state.signal_received:
+                break
+            time.sleep(0.1)
+        raise lg.NormalTermination
diff --git a/devices/webcam/pose_vis/test/tests.py b/devices/webcam/pose_vis/test/tests.py
new file mode 100644
index 00000000..1c692bbb
--- /dev/null
+++ b/devices/webcam/pose_vis/test/tests.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import os
+import unittest
+import logging
+import labgraph as lg
+
+from typing import List
+from pose_vis.utils import absolute_path
+from pose_vis.extension import PoseVisExtension, ExtensionResult
+from pose_vis.pose_vis_graph import PoseVis
+from pose_vis.streams.messages import CaptureResult
+from pose_vis.runner import PoseVisConfig
+from pose_vis.runners.source_runner import SourceStreamRunner, SourceStreamRunnerConfig
+from pose_vis.extensions.hands import HandsExtension
+
+logger = logging.getLogger(__name__)
+
+class TestSubscriberConfig(lg.Config):
+    enabled_extensions: List[PoseVisExtension]
+
+class TestSubscriber(lg.Node):
+    INPUT = lg.Topic(CaptureResult)
+    config: TestSubscriberConfig
+
+    @lg.subscriber(INPUT)
+    def on_message(self, message: CaptureResult) -> None:
+        for ext in self.config.enabled_extensions:
+            ext_name = ext.__class__.__name__
+            assert(ext.check_output(ExtensionResult(message.extensions[0][ext_name])))
+            logger.info(f" {ext_name} reported data is OK")
+
+class TestPoseVis(unittest.TestCase):
+    def test_all(self):
+        extensions = [HandsExtension()]
+
+        config = PoseVisConfig(
+            extensions=extensions,
+            log_directory=absolute_path(f"webcam{os.sep}logs"),
+            log_name=None,
+            enable_logging=False,
+            display_framerate=0,
+            stats_history_size=0)
+        
+        runner_config = SourceStreamRunnerConfig(
+            sources=[absolute_path(f"webcam{os.sep}images")],
+            resolutions=[(3186, 5184, 30)])
+
+        runner = SourceStreamRunner(config, runner_config)
+        runner.build()
+
+        PoseVis.add_node(name="TEST_SUBSCRIBER", _type=TestSubscriber, connection=["STREAM", "OUTPUT", "TEST_SUBSCRIBER", "INPUT"], config=TestSubscriberConfig(extensions))
+
+        runner.run()
+
+if __name__ == "__main__":
+    unittest.main()
\ No newline at end of file
diff --git a/devices/webcam/pose_vis/utils.py b/devices/webcam/pose_vis/utils.py
new file mode 100644
index 00000000..54eb6d3e
--- /dev/null
+++ b/devices/webcam/pose_vis/utils.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import re
+import os
+from pathlib import Path
+from typing import List, Tuple, Union
+
+def absolute_path(path: str) -> str:
+    """
+    Returns the absolute path to a file/directory from the current working directory if given a relative path
+    Cleans trailing seperators, and ensures the directory exists
+    """
+    _path = path
+    if not _path.startswith("/") or not re.match(r'[a-zA-Z]:', _path):
+        _path = os.path.join(os.path.dirname(os.getcwd()), _path)
+    Path(os.path.dirname(_path)).mkdir(parents = True, exist_ok = True)
+    return _path
+
+def is_path(what: str):
+    return what.startswith("/") or re.match(r'[a-zA-Z]:', what)
+
+def relative_latency(cur_device_time: float, cur_receive_time: float, first_device_time: float, first_receive_time: float) -> float:
+    """
+    Calcuate relative latency value for current set of times
+    """
+    return (cur_receive_time - first_receive_time) - (cur_device_time - first_device_time)
+
+def parse_sources(input: List[str]) -> List[Union[str, int]]:
+    """
+    Parse a list of string sources into ints or full paths to files or directories
+    """
+    sources = []
+    for arg in input:
+        if arg.isdigit():
+            sources.append(int(arg))
+        else:
+            if arg.find(" ! ") > -1:
+                # This should be a GStreamer string so we'll just pass it through
+                sources.append(arg)
+            else:
+                sources.append(absolute_path(arg))
+    return sources
+
+def parse_resolutions(num_sources: int, resolutions: List[str], default_resolution: Tuple[int, int, int] = (1280, 720, 30)) -> List[Tuple[int, int, int]]:
+    """
+    Convert a list of strings in format 'id:WxHxFPS' to a list of tuples
+
+    Output will match `num_sources` in length. `default_resolution` will be placed where there is none provided in `resolutions` for that index
+
+    `default_resolution` will be overridden by any entry with `*` as its id
+    """
+    default_res = None
+    output = [None] * num_sources
+    for i in range(len(resolutions)):
+        colon_split = resolutions[i].split(":")
+        x_split = colon_split[1].split("x")
+        stream_id = -1 if colon_split[0] == "*" else int(colon_split[0])
+        resolution = (int(x_split[0]), int(x_split[1]), int(x_split[2]))
+        if stream_id > -1:
+            output[stream_id] = resolution
+        else:
+            default_res = resolution
+    
+    if default_res is None:
+        default_res = default_resolution
+    for i in range(len(output)):
+        if output[i] is None:
+            output[i] = default_res
+    
+    return output
\ No newline at end of file
diff --git a/devices/webcam/readme.md b/devices/webcam/readme.md
new file mode 100644
index 00000000..0d4c48db
--- /dev/null
+++ b/devices/webcam/readme.md
@@ -0,0 +1,81 @@
+# PoseVis
+
+PoseVis is a LabGraph extension that streams any number of video sources and generates pose landmark data from [MediaPipe](https://google.github.io/mediapipe/) for each stream independently. MediaPipe [Hands](https://google.github.io/mediapipe/solutions/hands.html), [Face Mesh](https://google.github.io/mediapipe/solutions/face_mesh.html), [Pose](https://google.github.io/mediapipe/solutions/pose.html), and [Holistic](https://google.github.io/mediapipe/solutions/holistic.html) solutions are supported. PoseVis supports data logging and replaying via the [HDF5](https://www.hdfgroup.org/solutions/hdf5/) format. See [Using PoseVis](#using-posevis) for details.
+
+[Usage preview](https://i.imgur.com/FMYIy9r.mp4)
+
+PoseVis can also support other image processing tasks through its extension system. Take a look at the [hands extension](pose_vis/extensions/hands.py) for an example.
+
+# Installation
+
+PoseVis uses [OpenCV](https://opencv.org/) to handle video streams. Out of the box, PoseVis streams camera, video file, and image directory sources from the `MSMF` backend in Windows, and `V4L2` backend in Linux, with the MJPEG format ([see OpenCV backends here](https://docs.opencv.org/3.4/d0/da7/videoio_overview.html)). This configuration should be supported by most [UVC](https://en.wikipedia.org/wiki/USB_video_device_class) devices. Further source stream customization can be achieved by installing [GStreamer](https://gstreamer.freedesktop.org/); steps are detailed below.
+
+## PoseVis General Setup
+
+Requires Python 3.8 or later. Assuming an installation in your user directory, run `setup.py` to install required packages from PyPi:
+
+Linux:
+
+    cd ~/labgraph/devices/webcam
+	python3 setup.py install
+
+Windows:
+
+    cd %HOMEPATH%\labgraph\devices\webcam
+    python setup.py install
+
+See [Using PoseVis](#using-posevis) for usage details.
+
+## GStreamer Support (Optional)
+
+[GStreamer](https://gstreamer.freedesktop.org/) is a multimedia framework that allows you to create your own media pipelines with a simple string input. If you need more flexibility than a simple MJPEG stream, you can install GStreamer using the steps below.
+
+### Example GStreamer Configurations
+
+PoseVis expects color formats from GStreamer to be in the `BGR` color space, and OpenCV requires the use of [appsink](https://gstreamer.freedesktop.org/documentation/app/appsink.html?gi-language=c).
+
+Creating a test source: this configuration creates the [videotestsrc](https://gstreamer.freedesktop.org/documentation/videotestsrc/index.html?gi-language=c) element and configures a 720p @ 30Hz stream in BGR.
+
+    python -m pose_vis.pose_vis --sources "videotestsrc ! video/x-raw, width=1280, height=720, framerate=30/1, format=BGR ! appsink"
+
+Creating a device source in Linux: this configuration captures an MJPEG stream at 720p @ 30Hz from a [V4L2 device](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c) and [converts](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoconvert.html?gi-language=c) the image format into raw BGR.
+
+    python -m pose_vis.pose_vis --sources "v4l2src device=/dev/video0 ! image/jpeg, width=1280, height=720, framerate=30/1 ! jpegparse ! jpegdec ! videoconvert ! video/x-raw, format=BGR ! appsink"
+
+You can also specify [per-camera configurations](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src:extra-controls):
+
+    ... --sources "v4l2src device=/dev/video0 extra-controls='c, exposure_auto=1' ...
+
+### Windows GStreamer Support
+
+Follow the [Windows GStreamer guide](windows_gstreamer.md).
+
+### Linux GStreamer Support
+
+Follow the [Linux GStreamer guide](linux_gstreamer.md).
+
+## Performance
+
+Performance is crucial for real time applications. Check the [benchmark notebook](benchmark.ipynb) example for performance metrics, including details of the system used for benchmarking. You can also run the notebook on your system to get an idea of how PoseVis will perform.
+
+## Using PoseVis
+
+### Test PoseVis via Command Line
+
+Check usage details:
+
+	python -m pose_vis.pose_vis --help
+
+### Using PoseVis in Your Project
+
+Check the [usage guide](using_posevis.md) for an in-depth overview of the concepts used in PoseVis and how to hook into its LabGraph topics.
+
+### PoseVis Usage Examples
+
+#### GestureVis
+
+GestureVis uses data from the MediaPipe hand and body pose extensions to guess the current gesture based on a list of known gestures and draws the appropriate annotations onto the video stream, both online and offline. Check out the hands version [here](pose_vis/gesture/hand/readme.md).
+
+#### Logging Example
+
+The [logging example](logging_example.ipynb) notebook shows a simple way to use HDF5 logging with PoseVis.
diff --git a/devices/webcam/setup.py b/devices/webcam/setup.py
new file mode 100644
index 00000000..f5614188
--- /dev/null
+++ b/devices/webcam/setup.py
@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# Copyright 2004-present Facebook. All Rights Reserved.
+
+import os
+from setuptools import find_packages, setup
+
+# Use LabGraph 2.0.0 on Windows due to a package installation error
+install_requires = ["labgraph==2.0.0"] if os.name == "nt" else ["labgraph>=2.0.1"]
+# More information on MediaPipe installation can be found here: https://google.github.io/mediapipe/getting_started/install.html
+install_requires.extend(["opencv-python>=4.6.0", "mediapipe>=0.8.11"])
+
+setup(
+    name = "pose_vis",
+    version = "1.0.0",
+    description = "Pose visualization with LabGraph and MediaPipe",
+    packages = find_packages(),
+    python_requires = ">=3.8",
+    install_requires = install_requires)
\ No newline at end of file
diff --git a/devices/webcam/using_posevis.md b/devices/webcam/using_posevis.md
new file mode 100644
index 00000000..770a987b
--- /dev/null
+++ b/devices/webcam/using_posevis.md
@@ -0,0 +1,126 @@
+# Using PoseVis
+
+## Runners and Extensions
+
+PoseVis has utility classes called "runners" that handle graph setup and configuration. `SourceStreamRunner` runs both online and offline sources, including GStreamer sources if supported. `ReplayStreamRunner` will replay HDF5 log files, and `BenchmarkRunner` runs configured benchmarks to generate a JSON file with frame timings.
+
+Each runner requires a general PoseVis configuration class plus its own config. In this example, we'll configure `SourceStreamRunner` and connect to its topics with an example node.
+
+```python
+from pose_vis.runner import PoseVisConfig
+from pose_vis.extensions.hands import HandsExtension
+from pose_vis.runners.source_runner import SourceStreamRunnerConfig
+
+config = PoseVisConfig(
+    # Which extensions to enable. Extension types can be found in pose_vis/extensions
+    extensions=[HandsExtension()],
+    # Directory for saving logs (if enabled). This can be relative to the current working directory or a full path
+    log_directory="./logs",
+    # Name for the HDF5 log file. Specifying None creates a random name
+    log_name=None,
+    # Enables or disables logging to HDF5
+    enable_logging=False,
+    # How quickly to update the stream display windows. Specifying 0 disables this node. The display node calls cv2.imshow() for each stream and updates window titles appropriately
+    display_framerate=0,
+    # How many frames to keep track of for displaying performance characteristics. This is built in to the display node, so it's disabled when display_framerate is 0
+    stats_history_size=0)
+
+runner_config = SourceStreamRunnerConfig(
+    # Sources dictate which streams to provide. The list can contain ints, which will stream a device via MSMF on Windows, and V4L2 on Linux
+    # If provided a string that points to a file, PoseVis will consider it to be a video and attempt to load that and play it at the configured resolution and framerate
+    # If provided a directory, PoseVis will look for images and stream those one-by-one at the configured framerate. See SUPPORTED_IMG_EXTENSIONS in pose_vis/streams/utils/capture_worker.py for a list of supported image formats
+    # For both video and image directory sources, PoseVis will automatically terminate the graph when the source is finished playing
+    # If provided a GStreamer string, PoseVis will use the GStreamer backend via OpenCV
+    # Learn more about how PoseVis handles streams at readme.md#installation
+    sources=[0],
+    # Resolutions are represented via a list of tuples containing 3 ints, being width, height, and framerate. This must be specified per-stream, so the list should always be the same length as the sources list
+    # For integer, GStreamer, and video file sources, width and height must be specified. If the input source does not match the specified resolution, it will be resized. For image directories, width and height are ignored and the image size is used
+    # Each stream spawns a subprocess. PoseVis will attempt to keep streams synchronized in time by requesting new frames from each source at the same time and waiting until all sources present a frame before continuing. Because of this, it always run streams at the lowest configured framerate
+    resolutions=[(1280, 720, 30)]
+)
+```
+
+## LabGraph Topics
+
+PoseVis's graph publishes a single topic containing the result every source stream and its extension results via the `CaptureResult` message:
+
+```python
+# pose_vis/streams/messages.py
+
+@dataclass
+class Capture():
+    """
+    Represents a single video frame
+
+    Attributes:
+        `frame`: `np.ndarray` video frame matrix, shape is (H, W, 3), RGB color space, short datatype
+        `stream_id`: `int` source index for this capture
+        `frame_index`: `int` total frames since startup
+        `system_timestamp`: `float` `time.perf_counter()` value for when this frame was created
+        `proc_delta_time`: `float` time in seconds this frame took to produce
+        `proc_runtime`: `float` total runtime for this source
+        `proc_fps`: `int` frames per second at the time this frame was produced
+        `proc_target_fps`: `int` target frames per second for this source
+    """
+    frame: np.ndarray
+    stream_id: int
+    frame_index: int
+    system_timestamp: float
+    proc_delta_time: float
+    proc_runtime: float
+    proc_fps: int
+    proc_target_fps: int
+
+class CaptureResult(lg.Message):
+    """
+    Represents the current frame from every capture source
+
+    Attributes:
+        `captures`: `List[Capture]` `Capture`s by source index
+        `extensions`: `List[Dict[str, Any]]` extension data by source index
+    """
+    captures: List[Capture]
+    extensions: List[Dict[str, Any]]
+```
+
+Extension data varies by extension, but all extensions publish their respective MediaPipe results. Multiple extensions can be enabled at the same time, and each result is listed under the extension class name in the dictionary, so in our case we'd have a `HandsExtension` entry that contains the hand screen and world keypoints, plus handedness datastructure.
+
+```python
+message: CaptureResult ...
+print(message.extensions[0]["HandsExtension"]["multi_hand_landmarks"])
+```
+
+## Running the Graph and Subscribing to Topics
+
+Building on our earlier code, we can now subscribe to PoseVis's topic and run the graph. We'll just define a simple node to print the extension results and add it to the graph:
+
+
+```python
+import labgraph as lg
+from pose_vis.pose_vis_graph import PoseVis
+from pose_vis.streams.messages import CaptureResult
+from pose_vis.runners.source_runner import SourceStreamRunner
+
+# Define a simple node for subscribing to the CaptureResult topic
+class ExampleSubscriber(lg.Node):
+    INPUT = lg.Topic(CaptureResult)
+
+    @lg.subscriber(INPUT)
+    def on_message(self, message: CaptureResult) -> None:
+        print(message.extensions)
+
+# Create the SourceStreamRunner object with our config
+runner = SourceStreamRunner(config, runner_config)
+# Build the PoseVis graph
+runner.build()
+
+# Add our example node to the PoseVis graph
+# This function adds a node with the name EXAMPLE_SUBSCRIBER and type ExampleSubscriber
+# We then specify it should be connected to the STREAM's OUTPUT topic. All runners create a STREAM node with CaptureResult being in the OUTPUT topic slot
+# We can also specify a lg.Config object to use, in this case we don't have one
+PoseVis.add_node(name="EXAMPLE_SUBSCRIBER", _type=ExampleSubscriber, connection=["STREAM", "OUTPUT", "EXAMPLE_SUBSCRIBER", "INPUT"], config=None)
+
+# Finally, we can run the graph
+runner.run()
+```
+
diff --git a/devices/webcam/windows_gstreamer.md b/devices/webcam/windows_gstreamer.md
new file mode 100644
index 00000000..92f9e3f5
--- /dev/null
+++ b/devices/webcam/windows_gstreamer.md
@@ -0,0 +1,88 @@
+# Windows GStreamer Guide
+
+In this guide we will install GStreamer and build OpenCV with GStreamer support. This guide uses Windows 11 21H2 and assumes x64 archiecture but it should work on other Windows versions as well.
+
+## Install GStreamer
+
+Download and install the [latest development and runtime versions](https://gstreamer.freedesktop.org/download/) of GStreamer.
+
+## Install CMake
+
+Download and install the **3.24.3** release of [CMake](https://cmake.org/download/). (**Important:** OpenCV 4.6.0 is not compatible with CMake 3.25.0)
+
+## Install Visual Studio 2019 Build Tools
+
+Download and install [Visual Studio 2019 Build Tools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019).
+
+## Build OpenCV
+
+Create a virtual environment for use with PoseVis:
+
+    cd %HOMEPATH% && python -m venv .venv && call .venv\Scripts\activate
+
+We'll be building and installing OpenCV and OpenCV Contrib 4.6.0. Clone the branches:
+
+    git clone -b 4.6.0 --single-branch https://github.com/opencv/opencv.git && git clone -b 4.6.0 --single-branch https://github.com/opencv/opencv_contrib.git
+
+Create a build directory for OpenCV and `cd` into it:
+
+    md opencv\build && cd opencv\build
+
+Set some environment variables for Python support: this looks confusing but all it does is define `PYTHON_INCLUDE_PATH`, `PYTHON_PACKAGES_PATH`, and `PYTHON_LIB_PATH` in the current environment
+
+    FOR /F "tokens=* USEBACKQ" %v IN (`python -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())"`) do (SET PYTHON_INCLUDE_PATH=%v) && FOR /F "tokens=* USEBACKQ" %v IN (`python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"`) do (SET PYTHON_PACKAGES_PATH=%v) && FOR /F "tokens=* USEBACKQ" %v IN (`python -c "import os; import sys; import sysconfig; pyver = sysconfig.get_config_var('py_version_nodot'); print(os.path.join(sys.path[3].replace('lib', 'libs'), f'python{pyver}.lib'))"`) do (SET PYTHON_LIB_PATH=%v)
+
+Add GStreamer to the `PATH` variable:
+
+    set PATH=%PATH%;%GSTREAMER_1_0_ROOT_MSVC_X86_64%bin && set PATH=%PATH%;%GSTREAMER_1_0_ROOT_MSVC_X86_64%lib && set PATH=%PATH%;%GSTREAMER_1_0_ROOT_MSVC_X86_64%
+
+Install Numpy:
+
+    python -m pip install numpy
+
+Run CMake with the following config:
+
+    cmake -G "Visual Studio 16 2019" -A x64 ../ -D CMAKE_CONFIGURATION_TYPES=Release -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules -D WITH_GSTREAMER=ON -D BUILD_EXAMPLES=OFF -D INSTALL_C_EXAMPLES=OFF -D INSTALL_PYTHON_EXAMPLES=OFF -D BUILD_opencv_python2=OFF -D PYTHON3_INCLUDE_DIR=%PYTHON_INCLUDE_PATH% -D PYTHON3_PACKAGES_PATH=%PYTHON_PACKAGES_PATH% -D PYTHON_LIBRARY=%PYTHON_LIB_PATH% -D BUILD_opencv_python3=ON -D WITH_VTK=OFF
+
+Check GStreamer and Python3 status:
+
+    ...
+
+    --   Video I/O:                        
+    --     GStreamer:                   YES (1.20.4)
+
+    ...
+
+    --   Python 3:
+    --     Interpreter:                 C:/Users/das/.venv/Scripts/python.exe (ver 3.10.8)
+    --     Libraries:                   C:/Python310/libs/python310.lib (ver 3.10.8)
+    --     numpy:                       C:/Users/das/.venv/lib/site-packages/numpy/core/include (ver 1.23.5)
+    --     install path:                C:/Users/das/.venv/Lib/site-packages/cv2/python-3.10
+
+    ...
+
+If the configuration is correct, build and install OpenCV:
+
+    cmake --build ./ --target INSTALL --config Release
+
+## Install MediaPipe
+
+Install MediaPipe from PyPi:
+
+    python -m pip install mediapipe
+
+## Install LabGraph and Test
+
+Install LabGraph from PyPi:
+
+    python -m pip install labgraph==2.0.0
+
+`cd` into your LabGraph installation, assuming you've installed it in your home directory:
+
+    cd %HOMEPATH%\labgraph\devices\webcam
+
+Make sure PoseVis with GStreamer integration works:
+
+    python -m pose_vis.pose_vis --sources "videotestsrc ! video/x-raw, width=1280, height=720, framerate=30/1, format=BGR ! appsink"
+
+If all is well, you're now finished. Check [Using PoseVis](readme.md#using-posevis) for more usage examples. Enjoy using PoseVis!
\ No newline at end of file