diff --git a/composite-pipeline-plan.md b/composite-pipeline-plan.md
new file mode 100644
index 0000000000..3527d52457
--- /dev/null
+++ b/composite-pipeline-plan.md
@@ -0,0 +1,60 @@
+# Composite Pipeline Plan (AprilTag + Object Detection)
+
+## Goals
+- Run AprilTag and Object Detection on the same frame, per camera, without switching pipelines.
+- Publish independent results for each detector in the same output format as today.
+- Keep the main camera result as a combined list (tags + objects).
+- Draw both AprilTag overlays and object detection overlays on the output stream.
+- Avoid pre-optimization; match existing object detection behavior on Orange Pi.
+
+## Outputs (NetworkTables)
+- `/<camera>/result`: combined list (AprilTag + object detections)
+- `/<camera>-tags/result`: AprilTag-only list
+- `/<camera>-objects/result`: object-only list
+
+## Design Overview
+- Add a new `Composite` pipeline type.
+- Add `CompositePipelineSettings` with:
+  - AprilTag-specific fields (tagFamily, decimate, blur, threads, refineEdges, decisionMargin, etc.)
+  - Object detection-specific fields (confidence, nms, model)
+  - Two toggles: `enableAprilTag`, `enableObjectDetection`
+  - Shared advanced settings (exposure, solvePNPEnabled, targetModel, output drawing, etc.)
+- Implement `CompositePipeline` that:
+  - Requests `FrameThresholdType.NONE` and uses the color frame directly.
+  - Builds a reusable grayscale buffer ring for AprilTag detection.
+  - Runs AprilTag detection and pose estimation.
+  - Runs object detection.
+  - Combines targets (tags first, then objects) for the main result.
+  - Preserves `multiTagResult` and `objectDetectionClassNames`.
+- Implement `CompositePipelineResult` to carry split target lists.
+- Update NT publishing to publish three `PhotonPipelineResult` streams.
+- Update OutputStream drawing to render AprilTags and object detections together.
+- Update UI to allow selecting Composite and configuring both AprilTag + Object Detection.
+
+## Code Touch Points
+- `photon-core`
+  - `vision/pipeline/PipelineType.java` (add Composite)
+  - `vision/pipeline/CompositePipelineSettings.java` (new)
+  - `vision/pipeline/CompositePipeline.java` (new)
+  - `vision/pipeline/result/CompositePipelineResult.java` (new)
+  - `vision/processes/PipelineManager.java` (create/switch/clone)
+  - `common/dataflow/networktables/NTDataPublisher.java` (publish combined + split results)
+  - `vision/pipeline/OutputStreamPipeline.java` (draw both overlays)
+- `photon-server`
+  - `server/DataSocketHandler.java` (pipeline type mapping)
+- `photon-client`
+  - `types/PipelineTypes.ts` (Composite settings + defaults)
+  - `types/WebsocketDataTypes.ts` (Composite pipeline enum)
+  - UI components/tabs to show Composite config
+
+## Risks / Notes
+- Combined list changes “best target” semantics on `/<camera>/result` (tags first by default).
+- Composite pipeline runs two detectors per frame; FPS may drop on Orange Pi.
+
+## Implementation Steps
+1. Add Composite pipeline type + settings (Java + TS).
+2. Implement CompositePipeline + CompositePipelineResult.
+3. Publish split results to `/<camera>-tags` and `/<camera>-objects`.
+4. Update output stream drawing to show both overlays.
+5. Update UI to select and configure Composite.
+6. Add minimal tests (if feasible) for pipeline creation + NT publishing paths.
diff --git a/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue b/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
index 84df7cd473..cdbd9b991a 100644
--- a/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
+++ b/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
@@ -32,6 +32,9 @@ const changeCurrentCameraUniqueName = (cameraUniqueName: string) => {
     case PipelineType.ObjectDetection:
       pipelineType.value = WebsocketPipelineType.ObjectDetection;
       break;
+    case PipelineType.Composite:
+      pipelineType.value = WebsocketPipelineType.Composite;
+      break;
   }
 };
 
@@ -138,6 +141,7 @@ const validNewPipelineTypes = computed(() => {
   ];
   if (useSettingsStore().general.supportedBackends.length > 0) {
     pipelineTypes.push({ name: "Object Detection", value: WebsocketPipelineType.ObjectDetection });
+    pipelineTypes.push({ name: "Composite", value: WebsocketPipelineType.Composite });
   }
   return pipelineTypes;
 });
@@ -176,6 +180,7 @@ const pipelineTypesWrapper = computed<{ name: string; value: number }[]>(() => {
   ];
   if (useSettingsStore().general.supportedBackends.length > 0) {
     pipelineTypes.push({ name: "Object Detection", value: WebsocketPipelineType.ObjectDetection });
+    pipelineTypes.push({ name: "Composite", value: WebsocketPipelineType.Composite });
   }
 
   if (useCameraSettingsStore().isDriverMode) {
@@ -238,6 +243,9 @@ useCameraSettingsStore().$subscribe((mutation, state) => {
     case PipelineType.ObjectDetection:
       pipelineType.value = WebsocketPipelineType.ObjectDetection;
       break;
+    case PipelineType.Composite:
+      pipelineType.value = WebsocketPipelineType.Composite;
+      break;
   }
 });
 const wrappedCameras = computed<SelectItem[]>(() =>
diff --git a/photon-client/src/components/dashboard/ConfigOptions.vue b/photon-client/src/components/dashboard/ConfigOptions.vue
index be8e017233..9f842abc2d 100644
--- a/photon-client/src/components/dashboard/ConfigOptions.vue
+++ b/photon-client/src/components/dashboard/ConfigOptions.vue
@@ -89,18 +89,19 @@ const tabGroups = computed<ConfigOption[][]>(() => {
   const isAruco = useCameraSettingsStore().currentWebsocketPipelineType === WebsocketPipelineType.Aruco;
   const isObjectDetection =
     useCameraSettingsStore().currentWebsocketPipelineType === WebsocketPipelineType.ObjectDetection;
+  const isComposite = useCameraSettingsStore().currentWebsocketPipelineType === WebsocketPipelineType.Composite;
 
   return getTabGroups()
     .map((tabGroup) =>
       tabGroup.filter(
         (tabConfig) =>
           !(!allow3d && tabConfig.tabName === "3D") && //Filter out 3D tab any time 3D isn't calibrated
-          !((!allow3d || isAprilTag || isAruco || isObjectDetection) && tabConfig.tabName === "PnP") && //Filter out the PnP config tab if 3D isn't available, or we're doing AprilTags
-          !((isAprilTag || isAruco || isObjectDetection) && tabConfig.tabName === "Threshold") && //Filter out threshold tab if we're doing AprilTags
-          !((isAprilTag || isAruco || isObjectDetection) && tabConfig.tabName === "Contours") && //Filter out contours if we're doing AprilTags
-          !(!isAprilTag && tabConfig.tabName === "AprilTag") && //Filter out apriltag unless we actually are doing AprilTags
+          !((!allow3d || isAprilTag || isAruco || isObjectDetection || isComposite) && tabConfig.tabName === "PnP") && //Filter out the PnP config tab if 3D isn't available, or we're doing AprilTags
+          !((isAprilTag || isAruco || isObjectDetection || isComposite) && tabConfig.tabName === "Threshold") && //Filter out threshold tab if we're doing AprilTags
+          !((isAprilTag || isAruco || isObjectDetection || isComposite) && tabConfig.tabName === "Contours") && //Filter out contours if we're doing AprilTags
+          !(!(isAprilTag || isComposite) && tabConfig.tabName === "AprilTag") && //Filter out apriltag unless we actually are doing AprilTags
           !(!isAruco && tabConfig.tabName === "ArUco") &&
-          !(!isObjectDetection && tabConfig.tabName === "Object Detection") //Filter out ArUco unless we actually are doing ArUco
+          !(!(isObjectDetection || isComposite) && tabConfig.tabName === "Object Detection") //Filter out ArUco unless we actually are doing ArUco
       )
     )
     .filter((it) => it.length); // Remove empty tab groups
diff --git a/photon-client/src/components/dashboard/tabs/AprilTagTab.vue b/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
index 249f80607e..1251d244c7 100644
--- a/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
+++ b/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
@@ -1,32 +1,51 @@
 <script setup lang="ts">
-import { PipelineType } from "@/types/PipelineTypes";
+import { type AprilTagPipelineSettings, type CompositePipelineSettings, PipelineType } from "@/types/PipelineTypes";
 import PvSelect from "@/components/common/pv-select.vue";
 import PvSlider from "@/components/common/pv-slider.vue";
 import PvSwitch from "@/components/common/pv-switch.vue";
 import { computed } from "vue";
 import { useStateStore } from "@/stores/StateStore";
-import type { ActivePipelineSettings } from "@/types/PipelineTypes";
 import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
 import { useDisplay } from "vuetify";
 
 // TODO fix pipeline typing in order to fix this, the store settings call should be able to infer that only valid pipeline type settings are exposed based on pre-checks for the entire config section
 // Defer reference to store access method
-const currentPipelineSettings = computed<ActivePipelineSettings>(
-  () => useCameraSettingsStore().currentPipelineSettings
+const currentPipelineSettings = computed<AprilTagPipelineSettings | CompositePipelineSettings>(
+  () => useCameraSettingsStore().currentPipelineSettings as AprilTagPipelineSettings
 );
 const { mdAndDown } = useDisplay();
 const interactiveCols = computed(() =>
   mdAndDown.value && (!useStateStore().sidebarFolded || useCameraSettingsStore().isDriverMode) ? 8 : 7
 );
+const aprilTagDisabled = computed(
+  () =>
+    currentPipelineSettings.value.pipelineType === PipelineType.Composite &&
+    !currentPipelineSettings.value.enableAprilTag
+);
 </script>
 
 <template>
-  <div v-if="currentPipelineSettings.pipelineType === PipelineType.AprilTag">
+  <div
+    v-if="
+      currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
+      currentPipelineSettings.pipelineType === PipelineType.Composite
+    "
+  >
+    <pv-switch
+      v-if="currentPipelineSettings.pipelineType === PipelineType.Composite"
+      v-model="currentPipelineSettings.enableAprilTag"
+      label="Enable AprilTag"
+      :switch-cols="interactiveCols"
+      @update:modelValue="
+        (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ enableAprilTag: value }, false)
+      "
+    />
     <pv-select
       v-model="currentPipelineSettings.tagFamily"
       label="Target family"
       :items="['AprilTag 36h11 (6.5in)', 'AprilTag 16h5 (6in)']"
       :select-cols="interactiveCols"
+      :disabled="aprilTagDisabled"
       @update:modelValue="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ tagFamily: value }, false)"
     />
     <pv-slider
@@ -36,6 +55,7 @@ const interactiveCols = computed(() =>
       tooltip="Increases FPS at the expense of range by reducing image resolution initially"
       :min="1"
       :max="8"
+      :disabled="aprilTagDisabled"
       @update:modelValue="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ decimate: value }, false)"
     />
     <pv-slider
@@ -46,6 +66,7 @@ const interactiveCols = computed(() =>
       :min="0"
       :max="5"
       :step="0.1"
+      :disabled="aprilTagDisabled"
       @update:modelValue="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ blur: value }, false)"
     />
     <pv-slider
@@ -55,6 +76,7 @@ const interactiveCols = computed(() =>
       tooltip="Number of threads spawned by the AprilTag detector"
       :min="1"
       :max="8"
+      :disabled="aprilTagDisabled"
       @update:modelValue="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ threads: value }, false)"
     />
     <pv-slider
@@ -64,6 +86,7 @@ const interactiveCols = computed(() =>
       tooltip="Tags with a 'margin' (decoding quality score) less than this wil be rejected. Increase this to reduce the number of false positive detections"
       :min="0"
       :max="250"
+      :disabled="aprilTagDisabled"
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ decisionMargin: value }, false)
       "
@@ -75,6 +98,7 @@ const interactiveCols = computed(() =>
       tooltip="Number of iterations the pose estimation algorithm will run, 50-100 is a good starting point"
       :min="0"
       :max="500"
+      :disabled="aprilTagDisabled"
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ numIterations: value }, false)
       "
@@ -84,6 +108,7 @@ const interactiveCols = computed(() =>
       :switch-cols="interactiveCols"
       label="Refine Edges"
       tooltip="Further refines the AprilTag corner position initial estimate, suggested left on"
+      :disabled="aprilTagDisabled"
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ refineEdges: value }, false)
       "
diff --git a/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue b/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue
index d06956293e..49ff2b3225 100644
--- a/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue
+++ b/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue
@@ -1,9 +1,10 @@
 <script setup lang="ts">
 import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
-import { type ObjectDetectionPipelineSettings, PipelineType } from "@/types/PipelineTypes";
+import { type CompositePipelineSettings, type ObjectDetectionPipelineSettings, PipelineType } from "@/types/PipelineTypes";
 import PvSlider from "@/components/common/pv-slider.vue";
 import PvSelect from "@/components/common/pv-select.vue";
 import PvRangeSlider from "@/components/common/pv-range-slider.vue";
+import PvSwitch from "@/components/common/pv-switch.vue";
 import { computed } from "vue";
 import { useStateStore } from "@/stores/StateStore";
 import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
@@ -12,7 +13,7 @@ import type { ObjectDetectionModelProperties } from "@/types/SettingTypes";
 
 // TODO fix pipeline typing in order to fix this, the store settings call should be able to infer that only valid pipeline type settings are exposed based on pre-checks for the entire config section
 // Defer reference to store access method
-const currentPipelineSettings = computed<ObjectDetectionPipelineSettings>(
+const currentPipelineSettings = computed<ObjectDetectionPipelineSettings | CompositePipelineSettings>(
   () => useCameraSettingsStore().currentPipelineSettings as ObjectDetectionPipelineSettings
 );
 
@@ -31,6 +32,11 @@ const { mdAndDown } = useDisplay();
 const interactiveCols = computed(() =>
   mdAndDown.value && (!useStateStore().sidebarFolded || useCameraSettingsStore().isDriverMode) ? 9 : 8
 );
+const objectDetectionDisabled = computed(
+  () =>
+    currentPipelineSettings.value.pipelineType === PipelineType.Composite &&
+    !currentPipelineSettings.value.enableObjectDetection
+);
 
 // Filters out models that are not supported by the current backend, and returns a flattened list.
 const supportedModels = computed<ObjectDetectionModelProperties[]>(() => {
@@ -63,13 +69,28 @@ const selectedModel = computed({
 </script>
 
 <template>
-  <div v-if="currentPipelineSettings.pipelineType === PipelineType.ObjectDetection">
+  <div
+    v-if="
+      currentPipelineSettings.pipelineType === PipelineType.ObjectDetection ||
+      currentPipelineSettings.pipelineType === PipelineType.Composite
+    "
+  >
+    <pv-switch
+      v-if="currentPipelineSettings.pipelineType === PipelineType.Composite"
+      v-model="currentPipelineSettings.enableObjectDetection"
+      label="Enable Object Detection"
+      :switch-cols="interactiveCols"
+      @update:modelValue="
+        (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ enableObjectDetection: value }, false)
+      "
+    />
     <pv-select
       v-model="selectedModel"
       label="Model"
       tooltip="The model used to detect objects in the camera feed"
       :select-cols="interactiveCols"
       :items="supportedModels.map((model) => model.nickname)"
+      :disabled="objectDetectionDisabled"
     />
 
     <pv-slider
@@ -81,6 +102,7 @@ const selectedModel = computed({
       :min="0"
       :max="1"
       :step="0.01"
+      :disabled="objectDetectionDisabled"
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ confidence: value }, false)
       "
@@ -94,6 +116,7 @@ const selectedModel = computed({
       :min="0"
       :max="1"
       :step="0.01"
+      :disabled="objectDetectionDisabled"
       @update:modelValue="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ nms: value }, false)"
     />
     <pv-range-slider
@@ -103,6 +126,7 @@ const selectedModel = computed({
       :max="100"
       :slider-cols="interactiveCols"
       :step="0.01"
+      :disabled="objectDetectionDisabled"
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ contourArea: value }, false)
       "
@@ -115,6 +139,7 @@ const selectedModel = computed({
       :max="100"
       :slider-cols="interactiveCols"
       :step="0.01"
+      :disabled="objectDetectionDisabled"
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ contourRatio: value }, false)
       "
@@ -125,6 +150,7 @@ const selectedModel = computed({
       tooltip="Used to determine how to calculate target landmarks, as well as aspect ratio"
       :items="['Portrait', 'Landscape']"
       :select-cols="interactiveCols"
+      :disabled="objectDetectionDisabled"
       @update:modelValue="
         (value) =>
           useCameraSettingsStore().changeCurrentPipelineSetting(
@@ -139,6 +165,7 @@ const selectedModel = computed({
       tooltip="Chooses the sorting mode used to determine the 'best' targets to provide to user code"
       :select-cols="interactiveCols"
       :items="['Largest', 'Smallest', 'Highest', 'Lowest', 'Rightmost', 'Leftmost', 'Centermost']"
+      :disabled="objectDetectionDisabled"
       @update:modelValue="
         (value) =>
           useCameraSettingsStore().changeCurrentPipelineSetting(
diff --git a/photon-client/src/components/dashboard/tabs/OutputTab.vue b/photon-client/src/components/dashboard/tabs/OutputTab.vue
index 22033ead30..f6533cbc3a 100644
--- a/photon-client/src/components/dashboard/tabs/OutputTab.vue
+++ b/photon-client/src/components/dashboard/tabs/OutputTab.vue
@@ -18,6 +18,10 @@ const isTagPipeline = computed(
     useCameraSettingsStore().currentPipelineType === PipelineType.Aruco
 );
 
+const isFiducialPipeline = computed(
+  () => isTagPipeline.value || useCameraSettingsStore().currentPipelineType === PipelineType.Composite
+);
+
 interface MetricItem {
   header: string;
   value?: string;
@@ -75,7 +79,8 @@ const interactiveCols = computed(() =>
     <pv-switch
       v-if="
         (currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
-          currentPipelineSettings.pipelineType === PipelineType.Aruco) &&
+          currentPipelineSettings.pipelineType === PipelineType.Aruco ||
+          currentPipelineSettings.pipelineType === PipelineType.Composite) &&
         useCameraSettingsStore().isCurrentVideoFormatCalibrated &&
         useCameraSettingsStore().currentPipelineSettings.solvePNPEnabled
       "
@@ -83,7 +88,10 @@ const interactiveCols = computed(() =>
       label="Do Multi-Target Estimation"
       tooltip="If enabled, all visible fiducial targets will be used to provide a single pose estimate from their combined model."
       :switch-cols="interactiveCols"
-      :disabled="!isTagPipeline"
+      :disabled="
+        !isFiducialPipeline ||
+        (currentPipelineSettings.pipelineType === PipelineType.Composite && !currentPipelineSettings.enableAprilTag)
+      "
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ doMultiTarget: value }, false)
       "
@@ -91,7 +99,8 @@ const interactiveCols = computed(() =>
     <pv-switch
       v-if="
         (currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
-          currentPipelineSettings.pipelineType === PipelineType.Aruco) &&
+          currentPipelineSettings.pipelineType === PipelineType.Aruco ||
+          currentPipelineSettings.pipelineType === PipelineType.Composite) &&
         useCameraSettingsStore().isCurrentVideoFormatCalibrated &&
         useCameraSettingsStore().currentPipelineSettings.solvePNPEnabled
       "
@@ -99,7 +108,11 @@ const interactiveCols = computed(() =>
       label="Always Do Single-Target Estimation"
       tooltip="If disabled, visible fiducial targets used for multi-target estimation will not also be used for single-target estimation."
       :switch-cols="interactiveCols"
-      :disabled="!isTagPipeline || !currentPipelineSettings.doMultiTarget"
+      :disabled="
+        !isFiducialPipeline ||
+        !currentPipelineSettings.doMultiTarget ||
+        (currentPipelineSettings.pipelineType === PipelineType.Composite && !currentPipelineSettings.enableAprilTag)
+      "
       @update:modelValue="
         (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ doSingleTargetAlways: value }, false)
       "
diff --git a/photon-client/src/components/dashboard/tabs/TargetsTab.vue b/photon-client/src/components/dashboard/tabs/TargetsTab.vue
index fc2c2b59aa..ace4b57113 100644
--- a/photon-client/src/components/dashboard/tabs/TargetsTab.vue
+++ b/photon-client/src/components/dashboard/tabs/TargetsTab.vue
@@ -45,13 +45,19 @@ const resetCurrentBuffer = () => {
               <th
                 v-if="
                   currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
-                  currentPipelineSettings.pipelineType === PipelineType.Aruco
+                  currentPipelineSettings.pipelineType === PipelineType.Aruco ||
+                  currentPipelineSettings.pipelineType === PipelineType.Composite
                 "
                 class="text-center text-white"
               >
                 Fiducial ID
               </th>
-              <template v-if="currentPipelineSettings.pipelineType === PipelineType.ObjectDetection">
+              <template
+                v-if="
+                  currentPipelineSettings.pipelineType === PipelineType.ObjectDetection ||
+                  currentPipelineSettings.pipelineType === PipelineType.Composite
+                "
+              >
                 <th class="text-center text-white">Class</th>
                 <th class="text-center text-white">Confidence</th>
               </template>
@@ -86,23 +92,34 @@ const resetCurrentBuffer = () => {
               <td
                 v-if="
                   currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
-                  currentPipelineSettings.pipelineType === PipelineType.Aruco
+                  currentPipelineSettings.pipelineType === PipelineType.Aruco ||
+                  currentPipelineSettings.pipelineType === PipelineType.Composite
                 "
                 class="text-center"
               >
-                {{ target.fiducialId }}
+                {{ target.fiducialId >= 0 ? target.fiducialId : "-" }}
               </td>
               <td
-                v-if="currentPipelineSettings.pipelineType === PipelineType.ObjectDetection"
+                v-if="
+                  currentPipelineSettings.pipelineType === PipelineType.ObjectDetection ||
+                  currentPipelineSettings.pipelineType === PipelineType.Composite
+                "
                 class="text-center text-white"
               >
-                {{ useStateStore().currentPipelineResults?.classNames[target.classId] }}
+                {{
+                  target.classId >= 0
+                    ? useStateStore().currentPipelineResults?.classNames[target.classId]
+                    : "-"
+                }}
               </td>
               <td
-                v-if="currentPipelineSettings.pipelineType === PipelineType.ObjectDetection"
+                v-if="
+                  currentPipelineSettings.pipelineType === PipelineType.ObjectDetection ||
+                  currentPipelineSettings.pipelineType === PipelineType.Composite
+                "
                 class="text-center text-white"
               >
-                {{ target.confidence.toFixed(2) }}
+                {{ target.confidence >= 0 ? target.confidence.toFixed(2) : "-" }}
               </td>
               <template v-if="!useCameraSettingsStore().currentPipelineSettings.solvePNPEnabled">
                 <td class="text-center">{{ target.pitch.toFixed(2) }}&deg;</td>
@@ -118,12 +135,19 @@ const resetCurrentBuffer = () => {
               <template
                 v-if="
                   (currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
-                    currentPipelineSettings.pipelineType === PipelineType.Aruco) &&
+                    currentPipelineSettings.pipelineType === PipelineType.Aruco ||
+                    currentPipelineSettings.pipelineType === PipelineType.Composite) &&
                   useCameraSettingsStore().currentPipelineSettings.solvePNPEnabled
                 "
               >
                 <td class="text-center">
-                  {{ target.ambiguity >= 0 ? target.ambiguity.toFixed(2) : "(In Multi-Target)" }}
+                  {{
+                    target.fiducialId >= 0
+                      ? target.ambiguity >= 0
+                        ? target.ambiguity.toFixed(2)
+                        : "(In Multi-Target)"
+                      : "-"
+                  }}
                 </td>
               </template>
             </tr>
@@ -134,7 +158,8 @@ const resetCurrentBuffer = () => {
     <v-container
       v-if="
         (currentPipelineSettings.pipelineType === PipelineType.AprilTag ||
-          currentPipelineSettings.pipelineType === PipelineType.Aruco) &&
+          currentPipelineSettings.pipelineType === PipelineType.Aruco ||
+          currentPipelineSettings.pipelineType === PipelineType.Composite) &&
         currentPipelineSettings.doMultiTarget &&
         useCameraSettingsStore().isCurrentVideoFormatCalibrated &&
         useCameraSettingsStore().currentPipelineSettings.solvePNPEnabled
diff --git a/photon-client/src/types/PipelineTypes.ts b/photon-client/src/types/PipelineTypes.ts
index 17a9f1cbdf..14e2743e70 100644
--- a/photon-client/src/types/PipelineTypes.ts
+++ b/photon-client/src/types/PipelineTypes.ts
@@ -10,7 +10,8 @@ export enum PipelineType {
   ColoredShape = 4,
   AprilTag = 5,
   Aruco = 6,
-  ObjectDetection = 7
+  ObjectDetection = 7,
+  Composite = 8
 }
 
 export enum AprilTagFamily {
@@ -323,6 +324,63 @@ export const DefaultObjectDetectionPipelineSettings: ObjectDetectionPipelineSett
   model: {} as ObjectDetectionModelProperties
 };
 
+export interface CompositePipelineSettings extends PipelineSettings {
+  pipelineType: PipelineType.Composite;
+
+  enableAprilTag: boolean;
+  enableObjectDetection: boolean;
+
+  hammingDist: number;
+  numIterations: number;
+  decimate: number;
+  blur: number;
+  decisionMargin: number;
+  refineEdges: boolean;
+  debug: boolean;
+  threads: number;
+  tagFamily: AprilTagFamily;
+  doMultiTarget: boolean;
+  doSingleTargetAlways: boolean;
+
+  confidence: number;
+  nms: number;
+  box_thresh: number;
+  model: ObjectDetectionModelProperties;
+}
+
+export type ConfigurableCompositePipelineSettings = Partial<Omit<CompositePipelineSettings, "pipelineType">> &
+  ConfigurablePipelineSettings;
+
+export const DefaultCompositePipelineSettings: CompositePipelineSettings = {
+  ...DefaultPipelineSettings,
+  pipelineType: PipelineType.Composite,
+  cameraGain: 75,
+  targetModel: TargetModel.AprilTag6p5in_36h11,
+  ledMode: false,
+  outputShowMultipleTargets: true,
+  cameraExposureRaw: 20,
+
+  enableAprilTag: true,
+  enableObjectDetection: true,
+
+  hammingDist: 0,
+  numIterations: 40,
+  decimate: 1,
+  blur: 0,
+  decisionMargin: 35,
+  refineEdges: true,
+  debug: false,
+  threads: 4,
+  tagFamily: AprilTagFamily.Family36h11,
+  doMultiTarget: false,
+  doSingleTargetAlways: false,
+
+  confidence: 0.9,
+  nms: 0.45,
+  box_thresh: 0.25,
+  model: {} as ObjectDetectionModelProperties
+};
+
 export interface Calibration3dPipelineSettings extends PipelineSettings {
   drawAllSnapshots: boolean;
 }
@@ -345,6 +403,7 @@ export type ActivePipelineSettings =
   | AprilTagPipelineSettings
   | ArucoPipelineSettings
   | ObjectDetectionPipelineSettings
+  | CompositePipelineSettings
   | Calibration3dPipelineSettings;
 
 export type ActiveConfigurablePipelineSettings =
@@ -353,4 +412,5 @@ export type ActiveConfigurablePipelineSettings =
   | ConfigurableAprilTagPipelineSettings
   | ConfigurableArucoPipelineSettings
   | ConfigurableObjectDetectionPipelineSettings
+  | ConfigurableCompositePipelineSettings
   | ConfigurableCalibration3dPipelineSettings;
diff --git a/photon-client/src/types/WebsocketDataTypes.ts b/photon-client/src/types/WebsocketDataTypes.ts
index d1f18bc29d..739b0a2702 100644
--- a/photon-client/src/types/WebsocketDataTypes.ts
+++ b/photon-client/src/types/WebsocketDataTypes.ts
@@ -118,5 +118,6 @@ export enum WebsocketPipelineType {
   ColoredShape = 1,
   AprilTag = 2,
   Aruco = 3,
-  ObjectDetection = 4
+  ObjectDetection = 4,
+  Composite = 5
 }
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
index 7eff9733a0..71db35511c 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
@@ -22,6 +22,7 @@
 import edu.wpi.first.networktables.NetworkTableEvent;
 import edu.wpi.first.networktables.NetworkTablesJNI;
 import java.util.List;
+import java.util.Optional;
 import java.util.function.BooleanSupplier;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -32,7 +33,9 @@
 import org.photonvision.common.networktables.NTTopicSet;
 import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.targeting.PhotonPipelineResult;
+import org.photonvision.targeting.MultiTargetPNPResult;
 import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.photonvision.vision.pipeline.result.CompositePipelineResult;
 import org.photonvision.vision.pipeline.result.CalibrationPipelineResult;
 import org.photonvision.vision.target.TrackedTarget;
 
@@ -42,6 +45,8 @@ public class NTDataPublisher implements CVPipelineResultConsumer {
     private final NetworkTable rootTable = NetworkTablesManager.getInstance().kRootTable;
 
     private final NTTopicSet ts = new NTTopicSet();
+    private final NTTopicSet tagsTs = new NTTopicSet();
+    private final NTTopicSet objectsTs = new NTTopicSet();
 
     NTDataChangeListener pipelineIndexListener;
     private final Supplier<Integer> pipelineIndexSupplier;
@@ -128,6 +133,8 @@ private void removeEntries() {
         if (pipelineIndexListener != null) pipelineIndexListener.remove();
         if (driverModeListener != null) driverModeListener.remove();
         ts.removeEntries();
+        tagsTs.removeEntries();
+        objectsTs.removeEntries();
     }
 
     private void updateEntries() {
@@ -136,6 +143,8 @@ private void updateEntries() {
         if (fpsLimitListener != null) fpsLimitListener.remove();
 
         ts.updateEntries();
+        tagsTs.updateEntries();
+        objectsTs.updateEntries();
 
         pipelineIndexListener =
                 new NTDataChangeListener(
@@ -153,17 +162,17 @@ private void updateEntries() {
     public void updateCameraNickname(String newCameraNickname) {
         removeEntries();
         ts.subTable = rootTable.getSubTable(newCameraNickname);
+        tagsTs.subTable = rootTable.getSubTable(newCameraNickname + "-tags");
+        objectsTs.subTable = rootTable.getSubTable(newCameraNickname + "-objects");
         updateEntries();
     }
 
     @Override
     public void accept(CVPipelineResult result) {
         CVPipelineResult acceptedResult;
-        if (result
-                instanceof
-                CalibrationPipelineResult) // If the data is from a calibration pipeline, override the list
-            // of targets to be null to prevent the data from being sent and
-            // continue to post blank/zero data to the network tables
+        if (result instanceof CalibrationPipelineResult) {
+            // If the data is from a calibration pipeline, override the list of targets to be null to
+            // prevent the data from being sent and continue to post blank/zero data to the network tables
             acceptedResult =
                     new CVPipelineResult(
                             result.sequenceID,
@@ -171,75 +180,129 @@ public void accept(CVPipelineResult result) {
                             result.fps,
                             List.of(),
                             result.inputAndOutputFrame);
-        else acceptedResult = result;
+        } else {
+            acceptedResult = result;
+        }
         var now = NetworkTablesJNI.now();
         var captureMicros = MathUtils.nanosToMicros(result.getImageCaptureTimestampNanos());
 
         var offset = NetworkTablesManager.getInstance().getOffset();
 
-        // Transform the metadata timestamps from the local nt::Now timebase to the Time Sync Server's
-        // timebase
+        publishToTopicSet(
+                ts,
+                acceptedResult,
+                acceptedResult.targets,
+                acceptedResult.multiTagResult,
+                captureMicros,
+                now,
+                offset);
+
+        if (result instanceof CompositePipelineResult compositeResult) {
+            publishToTopicSet(
+                    tagsTs,
+                    acceptedResult,
+                    compositeResult.aprilTagTargets,
+                    acceptedResult.multiTagResult,
+                    captureMicros,
+                    now,
+                    offset);
+            publishToTopicSet(
+                    objectsTs,
+                    acceptedResult,
+                    compositeResult.objectDetectionTargets,
+                    Optional.<MultiTargetPNPResult>empty(),
+                    captureMicros,
+                    now,
+                    offset);
+        } else {
+            publishToTopicSet(
+                    tagsTs,
+                    acceptedResult,
+                    List.<TrackedTarget>of(),
+                    Optional.<MultiTargetPNPResult>empty(),
+                    captureMicros,
+                    now,
+                    offset);
+            publishToTopicSet(
+                    objectsTs,
+                    acceptedResult,
+                    List.<TrackedTarget>of(),
+                    Optional.<MultiTargetPNPResult>empty(),
+                    captureMicros,
+                    now,
+                    offset);
+        }
+
+        // TODO...nt4... is this needed?
+        rootTable.getInstance().flush();
+    }
+
+    private void publishToTopicSet(
+            NTTopicSet topics,
+            CVPipelineResult result,
+            List<TrackedTarget> targets,
+            Optional<MultiTargetPNPResult> multiTagResult,
+            long captureMicros,
+            long now,
+            long offset) {
+        var safeTargets = targets != null ? targets : List.<TrackedTarget>of();
+
         var simplified =
                 new PhotonPipelineResult(
-                        acceptedResult.sequenceID,
+                        result.sequenceID,
                         captureMicros + offset,
                         now + offset,
                         NetworkTablesManager.getInstance().getTimeSinceLastPong(),
-                        TrackedTarget.simpleFromTrackedTargets(acceptedResult.targets),
-                        acceptedResult.multiTagResult);
+                        TrackedTarget.simpleFromTrackedTargets(safeTargets),
+                        multiTagResult);
 
-        // random guess at size of the array
-        ts.resultPublisher.set(simplified, 1024);
+        topics.resultPublisher.set(simplified, 1024);
         if (ConfigManager.getInstance().getConfig().getNetworkConfig().shouldPublishProto) {
-            ts.protoResultPublisher.set(simplified);
+            topics.protoResultPublisher.set(simplified);
         }
 
-        ts.pipelineIndexPublisher.set(pipelineIndexSupplier.get());
-        ts.driverModePublisher.set(driverModeSupplier.getAsBoolean());
-        ts.fpsLimitPublisher.set(fpsLimitSupplier.get());
-        ts.latencyMillisEntry.set(acceptedResult.getLatencyMillis());
-        ts.fpsEntry.set(acceptedResult.fps);
-        ts.hasTargetEntry.set(acceptedResult.hasTargets());
+        topics.pipelineIndexPublisher.set(pipelineIndexSupplier.get());
+        topics.driverModePublisher.set(driverModeSupplier.getAsBoolean());
+        topics.fpsLimitPublisher.set(fpsLimitSupplier.get());
+        topics.latencyMillisEntry.set(result.getLatencyMillis());
+        topics.fpsEntry.set(result.fps);
+        topics.hasTargetEntry.set(!safeTargets.isEmpty());
 
-        if (acceptedResult.hasTargets()) {
-            var bestTarget = acceptedResult.targets.get(0);
+        if (!safeTargets.isEmpty()) {
+            var bestTarget = safeTargets.get(0);
 
-            ts.targetPitchEntry.set(bestTarget.getPitch());
-            ts.targetYawEntry.set(bestTarget.getYaw());
-            ts.targetAreaEntry.set(bestTarget.getArea());
-            ts.targetSkewEntry.set(bestTarget.getSkew());
+            topics.targetPitchEntry.set(bestTarget.getPitch());
+            topics.targetYawEntry.set(bestTarget.getYaw());
+            topics.targetAreaEntry.set(bestTarget.getArea());
+            topics.targetSkewEntry.set(bestTarget.getSkew());
 
             var pose = bestTarget.getBestCameraToTarget3d();
-            ts.targetPoseEntry.set(pose);
+            topics.targetPoseEntry.set(pose);
 
             var targetOffsetPoint = bestTarget.getTargetOffsetPoint();
-            ts.bestTargetPosX.set(targetOffsetPoint.x);
-            ts.bestTargetPosY.set(targetOffsetPoint.y);
+            topics.bestTargetPosX.set(targetOffsetPoint.x);
+            topics.bestTargetPosY.set(targetOffsetPoint.y);
         } else {
-            ts.targetPitchEntry.set(0);
-            ts.targetYawEntry.set(0);
-            ts.targetAreaEntry.set(0);
-            ts.targetSkewEntry.set(0);
-            ts.targetPoseEntry.set(new Transform3d());
-            ts.bestTargetPosX.set(0);
-            ts.bestTargetPosY.set(0);
+            topics.targetPitchEntry.set(0);
+            topics.targetYawEntry.set(0);
+            topics.targetAreaEntry.set(0);
+            topics.targetSkewEntry.set(0);
+            topics.targetPoseEntry.set(new Transform3d());
+            topics.bestTargetPosX.set(0);
+            topics.bestTargetPosY.set(0);
         }
 
-        // Something in the result can sometimes be null -- so check probably too many things
-        if (acceptedResult.inputAndOutputFrame != null
-                && acceptedResult.inputAndOutputFrame.frameStaticProperties != null
-                && acceptedResult.inputAndOutputFrame.frameStaticProperties.cameraCalibration != null) {
-            var fsp = acceptedResult.inputAndOutputFrame.frameStaticProperties;
-            ts.cameraIntrinsicsPublisher.accept(fsp.cameraCalibration.getIntrinsicsArr());
-            ts.cameraDistortionPublisher.accept(fsp.cameraCalibration.getDistCoeffsArr());
+        if (result.inputAndOutputFrame != null
+                && result.inputAndOutputFrame.frameStaticProperties != null
+                && result.inputAndOutputFrame.frameStaticProperties.cameraCalibration != null) {
+            var fsp = result.inputAndOutputFrame.frameStaticProperties;
+            topics.cameraIntrinsicsPublisher.accept(fsp.cameraCalibration.getIntrinsicsArr());
+            topics.cameraDistortionPublisher.accept(fsp.cameraCalibration.getDistCoeffsArr());
         } else {
-            ts.cameraIntrinsicsPublisher.accept(new double[0]);
-            ts.cameraDistortionPublisher.accept(new double[0]);
+            topics.cameraIntrinsicsPublisher.accept(new double[0]);
+            topics.cameraDistortionPublisher.accept(new double[0]);
         }
 
-        ts.heartbeatPublisher.set(acceptedResult.sequenceID);
-
-        // TODO...nt4... is this needed?
-        rootTable.getInstance().flush();
+        topics.heartbeatPublisher.set(result.sequenceID);
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipelineSettings.java
index 24eea55d9e..fcb70eb9e7 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipelineSettings.java
@@ -33,7 +33,8 @@
     @JsonSubTypes.Type(value = DriverModePipelineSettings.class),
     @JsonSubTypes.Type(value = AprilTagPipelineSettings.class),
     @JsonSubTypes.Type(value = ArucoPipelineSettings.class),
-    @JsonSubTypes.Type(value = ObjectDetectionPipelineSettings.class)
+    @JsonSubTypes.Type(value = ObjectDetectionPipelineSettings.class),
+    @JsonSubTypes.Type(value = CompositePipelineSettings.class)
 })
 public class CVPipelineSettings implements Cloneable {
     public int pipelineIndex = 0;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/CompositePipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/CompositePipeline.java
new file mode 100644
index 0000000000..9712a9cdeb
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/CompositePipeline.java
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import edu.wpi.first.apriltag.AprilTagDetection;
+import edu.wpi.first.apriltag.AprilTagDetector;
+import edu.wpi.first.apriltag.AprilTagPoseEstimate;
+import edu.wpi.first.apriltag.AprilTagPoseEstimator.Config;
+import edu.wpi.first.math.geometry.CoordinateSystem;
+import edu.wpi.first.math.geometry.Pose3d;
+import edu.wpi.first.math.geometry.Rotation3d;
+import edu.wpi.first.math.geometry.Transform3d;
+import edu.wpi.first.math.util.Units;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import org.opencv.imgproc.Imgproc;
+import org.photonvision.common.configuration.ConfigManager;
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
+import org.photonvision.common.util.math.MathUtils;
+import org.photonvision.estimation.TargetModel;
+import org.photonvision.targeting.MultiTargetPNPResult;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.FrameThresholdType;
+import org.photonvision.vision.objects.Model;
+import org.photonvision.vision.objects.NullModel;
+import org.photonvision.vision.opencv.DualOffsetValues;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.pipe.CVPipe.CVPipeResult;
+import org.photonvision.vision.pipe.impl.*;
+import org.photonvision.vision.pipe.impl.AprilTagDetectionPipe.AprilTagDetectionPipeParams;
+import org.photonvision.vision.pipe.impl.AprilTagPoseEstimatorPipe.AprilTagPoseEstimatorPipeParams;
+import org.photonvision.vision.pipe.impl.MultiTargetPNPPipe.MultiTargetPNPPipeParams;
+import org.photonvision.vision.pipe.impl.ObjectDetectionPipe.ObjectDetectionPipeParams;
+import org.photonvision.vision.pipeline.result.CompositePipelineResult;
+import org.photonvision.vision.target.PotentialTarget;
+import org.photonvision.vision.target.TargetOrientation;
+import org.photonvision.vision.target.TrackedTarget;
+import org.photonvision.vision.target.TrackedTarget.TargetCalculationParameters;
+
+public class CompositePipeline extends CVPipeline<CompositePipelineResult, CompositePipelineSettings> {
+    private static final FrameThresholdType PROCESSING_TYPE = FrameThresholdType.NONE;
+
+    private final AprilTagDetectionPipe aprilTagDetectionPipe = new AprilTagDetectionPipe();
+    private final AprilTagPoseEstimatorPipe singleTagPoseEstimatorPipe =
+            new AprilTagPoseEstimatorPipe();
+    private final MultiTargetPNPPipe multiTagPNPPipe = new MultiTargetPNPPipe();
+    private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
+
+    private final ObjectDetectionPipe objectDetectorPipe = new ObjectDetectionPipe();
+    private final SortContoursPipe sortContoursPipe = new SortContoursPipe();
+    private final Collect2dTargetsPipe collect2dTargetsPipe = new Collect2dTargetsPipe();
+    private final FilterObjectDetectionsPipe filterContoursPipe = new FilterObjectDetectionsPipe();
+
+    private final CVMat[] grayRing = new CVMat[] {new CVMat(), new CVMat()};
+    private int grayRingIndex = 0;
+
+    public CompositePipeline() {
+        super(PROCESSING_TYPE);
+        settings = new CompositePipelineSettings();
+    }
+
+    public CompositePipeline(CompositePipelineSettings settings) {
+        super(PROCESSING_TYPE);
+        this.settings = settings;
+    }
+
+    @Override
+    protected void setPipeParamsImpl() {
+        // AprilTag configuration
+        settings.threads = Math.max(1, settings.threads);
+
+        double tagWidth = Units.inchesToMeters(6.5);
+        TargetModel tagModel = TargetModel.kAprilTag36h11;
+        if (settings.tagFamily == AprilTagFamily.kTag16h5) {
+            tagWidth = Units.inchesToMeters(6);
+            tagModel = TargetModel.kAprilTag16h5;
+        }
+
+        var config = new AprilTagDetector.Config();
+        config.numThreads = settings.threads;
+        config.refineEdges = settings.refineEdges;
+        config.quadSigma = (float) settings.blur;
+        config.quadDecimate = settings.decimate;
+
+        var quadParams = new AprilTagDetector.QuadThresholdParameters();
+        quadParams.minClusterPixels = 5;
+        quadParams.maxNumMaxima = 10;
+        quadParams.criticalAngle = 45 * Math.PI / 180.0;
+        quadParams.maxLineFitMSE = 10.0f;
+        quadParams.minWhiteBlackDiff = 5;
+        quadParams.deglitch = false;
+
+        aprilTagDetectionPipe.setParams(
+                new AprilTagDetectionPipeParams(settings.tagFamily, config, quadParams));
+
+        if (frameStaticProperties.cameraCalibration != null) {
+            var cameraMatrix = frameStaticProperties.cameraCalibration.getCameraIntrinsicsMat();
+            if (cameraMatrix != null && cameraMatrix.rows() > 0) {
+                var cx = cameraMatrix.get(0, 2)[0];
+                var cy = cameraMatrix.get(1, 2)[0];
+                var fx = cameraMatrix.get(0, 0)[0];
+                var fy = cameraMatrix.get(1, 1)[0];
+
+                singleTagPoseEstimatorPipe.setParams(
+                        new AprilTagPoseEstimatorPipeParams(
+                                new Config(tagWidth, fx, fy, cx, cy),
+                                frameStaticProperties.cameraCalibration,
+                                settings.numIterations));
+
+                var atfl = ConfigManager.getInstance().getConfig().getApriltagFieldLayout();
+                multiTagPNPPipe.setParams(
+                        new MultiTargetPNPPipeParams(frameStaticProperties.cameraCalibration, atfl, tagModel));
+            }
+        }
+
+        // Object detection configuration
+        Optional<Model> selectedModel =
+                settings.model != null
+                        ? NeuralNetworkModelManager.getInstance()
+                                .getModel(settings.model.modelPath().toString())
+                        : Optional.empty();
+
+        if (selectedModel.isEmpty()) {
+            selectedModel = NeuralNetworkModelManager.getInstance().getDefaultModel();
+        }
+
+        if (selectedModel.isEmpty()) {
+            selectedModel = Optional.of(NullModel.getInstance());
+        }
+
+        objectDetectorPipe.setParams(
+                new ObjectDetectionPipeParams(settings.confidence, settings.nms, selectedModel.get()));
+
+        DualOffsetValues dualOffsetValues =
+                new DualOffsetValues(
+                        settings.offsetDualPointA,
+                        settings.offsetDualPointAArea,
+                        settings.offsetDualPointB,
+                        settings.offsetDualPointBArea);
+
+        sortContoursPipe.setParams(
+                new SortContoursPipe.SortContoursParams(
+                        settings.contourSortMode,
+                        settings.outputShowMultipleTargets ? MAX_MULTI_TARGET_RESULTS : 1,
+                        frameStaticProperties));
+
+        filterContoursPipe.setParams(
+                new FilterObjectDetectionsPipe.FilterContoursParams(
+                        settings.contourArea,
+                        settings.contourRatio,
+                        frameStaticProperties,
+                        settings.contourTargetOrientation == TargetOrientation.Landscape));
+
+        collect2dTargetsPipe.setParams(
+                new Collect2dTargetsPipe.Collect2dTargetsParams(
+                        settings.offsetRobotOffsetMode,
+                        settings.offsetSinglePoint,
+                        dualOffsetValues,
+                        settings.contourTargetOffsetPointEdge,
+                        settings.contourTargetOrientation,
+                        frameStaticProperties));
+    }
+
+    @Override
+    protected CompositePipelineResult process(Frame frame, CompositePipelineSettings settings) {
+        long sumPipeNanosElapsed = 0L;
+
+        var colorMat = frame.colorImage.getMat();
+        if (!colorMat.empty()) {
+            colorMat.copyTo(frame.processedImage.getMat());
+        }
+
+        List<TrackedTarget> aprilTagTargets = new ArrayList<>();
+        Optional<MultiTargetPNPResult> multiTagResult = Optional.empty();
+
+        if (settings.enableAprilTag && !colorMat.empty()) {
+            CVMat grayMat = nextGrayMat(frame.colorImage);
+
+            CVPipeResult<List<AprilTagDetection>> tagDetectionPipeResult =
+                    aprilTagDetectionPipe.run(grayMat);
+            sumPipeNanosElapsed += tagDetectionPipeResult.nanosElapsed;
+
+            List<AprilTagDetection> detections = tagDetectionPipeResult.output;
+            List<AprilTagDetection> usedDetections = new ArrayList<>();
+
+            for (AprilTagDetection detection : detections) {
+                if (detection.getDecisionMargin() < settings.decisionMargin) continue;
+                if (detection.getHamming() > settings.hammingDist) continue;
+
+                usedDetections.add(detection);
+
+                TrackedTarget target =
+                        new TrackedTarget(
+                                detection,
+                                null,
+                                new TargetCalculationParameters(
+                                        false, null, null, null, null, frameStaticProperties));
+                aprilTagTargets.add(target);
+            }
+
+            if (settings.solvePNPEnabled && settings.doMultiTarget) {
+                var multiTagOutput = multiTagPNPPipe.run(aprilTagTargets);
+                sumPipeNanosElapsed += multiTagOutput.nanosElapsed;
+                multiTagResult = multiTagOutput.output;
+            }
+
+            if (settings.solvePNPEnabled) {
+                aprilTagTargets.clear();
+                var atfl = ConfigManager.getInstance().getConfig().getApriltagFieldLayout();
+
+                for (AprilTagDetection detection : usedDetections) {
+                    AprilTagPoseEstimate tagPoseEstimate = null;
+                    if (settings.doSingleTargetAlways
+                            || !(multiTagResult.isPresent()
+                                    && multiTagResult.get().fiducialIDsUsed.contains((short) detection.getId()))) {
+                        var poseResult = singleTagPoseEstimatorPipe.run(detection);
+                        sumPipeNanosElapsed += poseResult.nanosElapsed;
+                        tagPoseEstimate = poseResult.output;
+                    }
+
+                    if (tagPoseEstimate == null && multiTagResult.isPresent()) {
+                        var tagPose = atfl.getTagPose(detection.getId());
+                        if (tagPose.isPresent()) {
+                            var camToTag =
+                                    new Transform3d(
+                                            new Pose3d().plus(multiTagResult.get().estimatedPose.best),
+                                            tagPose.get());
+                            camToTag =
+                                    CoordinateSystem.convert(
+                                            camToTag, CoordinateSystem.NWU(), CoordinateSystem.EDN());
+                            camToTag =
+                                    new Transform3d(
+                                            camToTag.getTranslation(),
+                                            new Rotation3d(0, Math.PI, 0).plus(camToTag.getRotation()));
+                            tagPoseEstimate = new AprilTagPoseEstimate(camToTag, camToTag, 0, 0);
+                        }
+                    }
+
+                    TrackedTarget target =
+                            new TrackedTarget(
+                                    detection,
+                                    tagPoseEstimate,
+                                    new TargetCalculationParameters(
+                                            false, null, null, null, null, frameStaticProperties));
+
+                    if (tagPoseEstimate != null) {
+                        var correctedBestPose =
+                                MathUtils.convertOpenCVtoPhotonTransform(target.getBestCameraToTarget3d());
+                        var correctedAltPose =
+                                MathUtils.convertOpenCVtoPhotonTransform(target.getAltCameraToTarget3d());
+
+                        target.setBestCameraToTarget3d(
+                                new Transform3d(correctedBestPose.getTranslation(), correctedBestPose.getRotation()));
+                        target.setAltCameraToTarget3d(
+                                new Transform3d(correctedAltPose.getTranslation(), correctedAltPose.getRotation()));
+                    }
+
+                    aprilTagTargets.add(target);
+                }
+            }
+        }
+
+        List<TrackedTarget> objectTargets = new ArrayList<>();
+        List<String> classNames = List.of();
+
+        if (settings.enableObjectDetection && !colorMat.empty()) {
+            CVPipeResult<List<NeuralNetworkPipeResult>> neuralNetworkResult =
+                    objectDetectorPipe.run(frame.colorImage);
+            sumPipeNanosElapsed += neuralNetworkResult.nanosElapsed;
+
+            classNames = objectDetectorPipe.getClassNames();
+
+            var filterContoursResult = filterContoursPipe.run(neuralNetworkResult.output);
+            sumPipeNanosElapsed += filterContoursResult.nanosElapsed;
+
+            CVPipeResult<List<PotentialTarget>> sortContoursResult =
+                    sortContoursPipe.run(
+                            filterContoursResult.output.stream()
+                                    .map(shape -> new PotentialTarget(shape))
+                                    .toList());
+            sumPipeNanosElapsed += sortContoursResult.nanosElapsed;
+
+            CVPipeResult<List<TrackedTarget>> collect2dTargetsResult =
+                    collect2dTargetsPipe.run(sortContoursResult.output);
+            sumPipeNanosElapsed += collect2dTargetsResult.nanosElapsed;
+
+            objectTargets = collect2dTargetsResult.output;
+        }
+
+        var combinedTargets = new ArrayList<TrackedTarget>(aprilTagTargets.size() + objectTargets.size());
+        combinedTargets.addAll(aprilTagTargets);
+        combinedTargets.addAll(objectTargets);
+
+        var fpsResult = calculateFPSPipe.run(null);
+        var fps = fpsResult.output;
+
+        return new CompositePipelineResult(
+                frame.sequenceID,
+                sumPipeNanosElapsed,
+                fps,
+                combinedTargets,
+                multiTagResult,
+                frame,
+                classNames,
+                aprilTagTargets,
+                objectTargets);
+    }
+
+    private CVMat nextGrayMat(CVMat colorMat) {
+        var grayMat = grayRing[grayRingIndex];
+        grayRingIndex = (grayRingIndex + 1) % grayRing.length;
+        Imgproc.cvtColor(colorMat.getMat(), grayMat.getMat(), Imgproc.COLOR_BGR2GRAY, 3);
+        return grayMat;
+    }
+
+    @Override
+    public void release() {
+        aprilTagDetectionPipe.release();
+        singleTagPoseEstimatorPipe.release();
+        objectDetectorPipe.release();
+        for (var cvMat : grayRing) {
+            cvMat.release();
+        }
+        super.release();
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/CompositePipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/CompositePipelineSettings.java
new file mode 100644
index 0000000000..3b2802cce9
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/CompositePipelineSettings.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline;
+
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
+import org.photonvision.common.configuration.NeuralNetworkPropertyManager;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.objects.Model;
+import org.photonvision.vision.target.TargetModel;
+
+@JsonTypeName("CompositePipelineSettings")
+public class CompositePipelineSettings extends AdvancedPipelineSettings {
+    public boolean enableAprilTag = true;
+    public boolean enableObjectDetection = true;
+
+    // AprilTag settings
+    public AprilTagFamily tagFamily = AprilTagFamily.kTag36h11;
+    public int decimate = 1;
+    public double blur = 0;
+    public int threads = 4;
+    public boolean debug = false;
+    public boolean refineEdges = true;
+    public int numIterations = 40;
+    public int hammingDist = 0;
+    public int decisionMargin = 35;
+    public boolean doMultiTarget = false;
+    public boolean doSingleTargetAlways = false;
+
+    // Object detection settings
+    public double confidence = 0.9;
+    public double nms = 0.45;
+    public NeuralNetworkPropertyManager.ModelProperties model;
+
+    public CompositePipelineSettings() {
+        super();
+        pipelineType = PipelineType.Composite;
+        outputShowMultipleTargets = true;
+        targetModel = TargetModel.kAprilTag6p5in_36h11;
+        cameraExposureRaw = 20;
+        cameraAutoExposure = false;
+        ledMode = false;
+        model =
+                NeuralNetworkModelManager.getInstance()
+                        .getDefaultModel()
+                        .map(Model::getProperties)
+                        .orElse(null);
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
index 3c772a359a..586ad74f88 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
@@ -18,6 +18,7 @@
 package org.photonvision.vision.pipeline;
 
 import edu.wpi.first.math.Pair;
+import java.util.ArrayList;
 import java.util.List;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.FrameStaticProperties;
@@ -149,7 +150,8 @@ public CVPipelineResult process(
 
             if (!(settings instanceof AprilTagPipelineSettings)
                     && !(settings instanceof ArucoPipelineSettings)
-                    && !(settings instanceof Calibration3dPipelineSettings)) {
+                    && !(settings instanceof Calibration3dPipelineSettings)
+                    && !(settings instanceof CompositePipelineSettings)) {
                 // If we're processing anything other than Apriltags..
                 var draw2dCrosshairResultOnOutput = draw2dCrosshairPipe.run(Pair.of(outMat, targetsToDraw));
                 sumPipeNanosElapsed += pipeProfileNanos[4] = draw2dCrosshairResultOnOutput.nanosElapsed;
@@ -201,6 +203,31 @@ public CVPipelineResult process(
                     pipeProfileNanos[7] = 0;
                     pipeProfileNanos[8] = 0;
                 }
+            } else if (settings instanceof CompositePipelineSettings compositeSettings) {
+                var draw2dCrosshairResultOnOutput =
+                        draw2dCrosshairPipe.run(Pair.of(outMat, targetsToDraw));
+                sumPipeNanosElapsed += pipeProfileNanos[4] = draw2dCrosshairResultOnOutput.nanosElapsed;
+
+                var fiducialTargets = new ArrayList<TrackedTarget>();
+                var objectTargets = new ArrayList<TrackedTarget>();
+                for (var target : targetsToDraw) {
+                    if (target.getFiducialId() >= 0) {
+                        fiducialTargets.add(target);
+                    } else {
+                        objectTargets.add(target);
+                    }
+                }
+
+                if (compositeSettings.solvePNPEnabled) {
+                    var drawOnOutputResult = draw3dAprilTagsPipe.run(Pair.of(outMat, fiducialTargets));
+                    sumPipeNanosElapsed += pipeProfileNanos[7] = drawOnOutputResult.nanosElapsed;
+                } else {
+                    var draw2dTags = draw2dAprilTagsPipe.run(Pair.of(outMat, fiducialTargets));
+                    sumPipeNanosElapsed += pipeProfileNanos[5] = draw2dTags.nanosElapsed;
+                }
+
+                var draw2dObjects = draw2dTargetsPipe.run(Pair.of(outMat, objectTargets));
+                sumPipeNanosElapsed += pipeProfileNanos[6] = draw2dObjects.nanosElapsed;
             } else if (settings instanceof ArucoPipelineSettings) {
                 if (settings.solvePNPEnabled) {
                     // Draw 3d Apriltag markers (camera is calibrated and running in 3d mode)
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java
index 47bc080ff7..af4387942c 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java
@@ -26,7 +26,8 @@ public enum PipelineType {
     ColoredShape(1, ColoredShapePipeline.class),
     AprilTag(2, AprilTagPipeline.class),
     Aruco(3, ArucoPipeline.class),
-    ObjectDetection(4, ObjectDetectionPipeline.class);
+    ObjectDetection(4, ObjectDetectionPipeline.class),
+    Composite(5, CompositePipeline.class);
 
     public final int baseIndex;
     public final Class clazz;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/result/CompositePipelineResult.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/result/CompositePipelineResult.java
new file mode 100644
index 0000000000..3d0d57c09d
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/result/CompositePipelineResult.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipeline.result;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import org.photonvision.targeting.MultiTargetPNPResult;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.target.TrackedTarget;
+
+public class CompositePipelineResult extends CVPipelineResult {
+    public final List<TrackedTarget> aprilTagTargets;
+    public final List<TrackedTarget> objectDetectionTargets;
+
+    public CompositePipelineResult(
+            long sequenceID,
+            double processingNanos,
+            double fps,
+            List<TrackedTarget> combinedTargets,
+            Optional<MultiTargetPNPResult> multiTagResult,
+            Frame inputFrame,
+            List<String> classNames,
+            List<TrackedTarget> aprilTagTargets,
+            List<TrackedTarget> objectDetectionTargets) {
+        super(sequenceID, processingNanos, fps, combinedTargets, multiTagResult, inputFrame, classNames);
+        this.aprilTagTargets = aprilTagTargets != null ? aprilTagTargets : Collections.emptyList();
+        this.objectDetectionTargets =
+                objectDetectionTargets != null ? objectDetectionTargets : Collections.emptyList();
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java b/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java
index 02ecc509a2..6fa8e5522a 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java
@@ -266,6 +266,10 @@ private void recreateUserPipeline() {
                 currentUserPipeline =
                         new ObjectDetectionPipeline((ObjectDetectionPipelineSettings) desiredPipelineSettings);
             }
+            case Composite -> {
+                logger.debug("Creating Composite Pipeline");
+                currentUserPipeline = new CompositePipeline((CompositePipelineSettings) desiredPipelineSettings);
+            }
             case Calib3d, DriverMode, FocusCamera -> {}
         }
     }
@@ -340,6 +344,7 @@ private CVPipelineSettings createSettingsForType(PipelineType type, String nickn
                     case AprilTag -> new AprilTagPipelineSettings();
                     case Aruco -> new ArucoPipelineSettings();
                     case ObjectDetection -> new ObjectDetectionPipelineSettings();
+                    case Composite -> new CompositePipelineSettings();
                     case Calib3d, DriverMode, FocusCamera -> {
                         logger.error("Got invalid pipeline type: " + type);
                         yield null;