diff --git a/app.config.js b/app.config.js
index 32ad08b..99f8a9c 100644
--- a/app.config.js
+++ b/app.config.js
@@ -4,7 +4,7 @@ export default {
   expo: {
     name: IS_DEV ? "Muscle Quest (Dev)" : "Muscle Quest",
     slug: "musclequest",
-    version: "0.21.04", // MM.mm.pp
+    version: "0.21.05", // MM.mm.pp
     orientation: "portrait",
     icon: "./assets/images/icon.png",
     scheme: "musclequest",
@@ -14,7 +14,7 @@ export default {
       bundleIdentifier: "com.isotronic.musclequest",
     },
     android: {
-      versionCode: 2104, // MMmmpp
+      versionCode: 2105, // MMmmpp
       googleServicesFile: "./google-services.json",
       adaptiveIcon: {
         foregroundImage: "./assets/images/ic_launcher_foreground.png",
diff --git a/app/(app)/(create-plan)/exercises.tsx b/app/(app)/(create-plan)/exercises.tsx
index 5417d12..0a4a461 100644
--- a/app/(app)/(create-plan)/exercises.tsx
+++ b/app/(app)/(create-plan)/exercises.tsx
@@ -41,11 +41,19 @@ export default function ExercisesScreen() {
     newExerciseId,
     setNewExerciseId,
     replaceExercise,
+    createSuperset,
   } = useWorkoutStore();
-  const { index } = useLocalSearchParams();
+  const { index, supersetForIndex } = useLocalSearchParams<{
+    index: string;
+    supersetForIndex?: string;
+  }>();
   const currentWorkoutIndex = Number(index);
   const currentWorkout = workouts[currentWorkoutIndex];
   const replacing = replaceExerciseIndex !== undefined;
+  const supersetMode = supersetForIndex !== undefined;
+  const supersetForExerciseIndex = supersetMode
+    ? Number(supersetForIndex)
+    : undefined;
 
   const {
     data: settings,
@@ -67,7 +75,7 @@ export default function ExercisesScreen() {
   const [selectedExercises, setSelectedExercises] = useState<number[]>([]);
 
   useEffect(() => {
-    if (currentWorkout?.exercises && !replacing) {
+    if (currentWorkout?.exercises && !replacing && !supersetMode) {
       const existingExerciseIds = currentWorkout.exercises.map(
         (exercise) => exercise.exercise_id,
       );
@@ -84,7 +92,13 @@ export default function ExercisesScreen() {
       // Clear the newExerciseId after it's used
       setNewExerciseId(null);
     }
-  }, [currentWorkout, newExerciseId, replacing, setNewExerciseId]);
+  }, [
+    currentWorkout,
+    newExerciseId,
+    replacing,
+    supersetMode,
+    setNewExerciseId,
+  ]);
 
   const minutes = Math.floor(totalSeconds / 60);
   const seconds = totalSeconds % 60;
@@ -102,13 +116,38 @@ export default function ExercisesScreen() {
 
   const handleSelectExercise = useCallback(
     (exerciseId: number) => {
-      if (replacing) {
-        // Check if this exercise already exists in the current workout
-        const workout = workouts[currentWorkoutIndex];
-        const exerciseAlreadyExists = workout.exercises.some(
-          (e) => e.exercise_id === exerciseId,
-        );
+      const workout = workouts[currentWorkoutIndex];
+      const exerciseAlreadyExists = workout?.exercises.some(
+        (e) => e.exercise_id === exerciseId,
+      );
 
+      if (supersetMode) {
+        // Single-select: pair as superset partner
+        if (exerciseAlreadyExists) {
+          Alert.alert(
+            "Exercise Already Added",
+            "This exercise is already in your workout. Please choose a different one.",
+            [{ text: "OK" }],
+          );
+          return;
+        }
+        const exercise = allExercises.find(
+          (ex) => ex.exercise_id === exerciseId,
+        );
+        if (exercise && supersetForExerciseIndex !== undefined) {
+          const newExercise = {
+            ...exercise,
+            sets:
+              exercise.tracking_type === "time" ? defaultTimeSets : defaultSets,
+          };
+          createSuperset(
+            currentWorkoutIndex,
+            supersetForExerciseIndex,
+            newExercise,
+          );
+          router.back();
+        }
+      } else if (replacing) {
         if (exerciseAlreadyExists) {
           Alert.alert(
             "Exercise Already Added",
@@ -134,7 +173,7 @@ export default function ExercisesScreen() {
             defaultSets,
             defaultTimeSets,
           );
-          router.back(); // Return immediately after replacement
+          router.back();
         }
       } else {
         // Normal add mode - allow multiple selections
@@ -146,14 +185,17 @@ export default function ExercisesScreen() {
       }
     },
     [
+      supersetMode,
+      supersetForExerciseIndex,
       replacing,
       allExercises,
       replaceExerciseIndex,
       defaultTimeSets,
       defaultSets,
       replaceExercise,
+      createSuperset,
       currentWorkoutIndex,
-      workouts, // Make sure 'workouts' is included in dependencies
+      workouts,
     ],
   );
 
@@ -280,7 +322,7 @@ export default function ExercisesScreen() {
             });
           }}
         />
-        {!replacing && (
+        {!replacing && !supersetMode && (
           <View style={styles.bottomButtons}>
             <Button
               mode="outlined"
diff --git a/app/(app)/(create-plan)/sets-overview.tsx b/app/(app)/(create-plan)/sets-overview.tsx
index 7ec8239..5cd7566 100644
--- a/app/(app)/(create-plan)/sets-overview.tsx
+++ b/app/(app)/(create-plan)/sets-overview.tsx
@@ -23,10 +23,19 @@ export default function SetsOverviewScreen() {
   const defaultTime = 60;
   const defaultTotalSeconds = totalSeconds;
 
-  const exercise = workouts[Number(workoutIndex)]?.exercises.find(
+  const currentWorkout = workouts[Number(workoutIndex)];
+  const exercise = currentWorkout?.exercises.find(
     (ex) => ex.exercise_id === Number(exerciseId),
   );
 
+  const supersetPartner = exercise?.supersetGroupId
+    ? currentWorkout?.exercises.find(
+        (ex) =>
+          ex.exercise_id !== Number(exerciseId) &&
+          ex.supersetGroupId === exercise.supersetGroupId,
+      )
+    : null;
+
   const sets = exercise?.sets || [];
 
   const [modalVisible, setModalVisible] = useState(false);
@@ -102,6 +111,14 @@ export default function SetsOverviewScreen() {
           title: exercise?.name,
         }}
       />
+      {supersetPartner && (
+        <View style={styles.supersetBanner}>
+          <ThemedText style={styles.supersetBannerLabel}>Superset</ThemedText>
+          <ThemedText style={styles.supersetBannerPartner}>
+            Paired with {supersetPartner.name}
+          </ThemedText>
+        </View>
+      )}
       <FlatList
         data={sets}
         renderItem={renderSetItem}
@@ -149,6 +166,29 @@ const styles = StyleSheet.create({
     flex: 1,
     padding: 16,
   },
+  supersetBanner: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    backgroundColor: Colors.dark.cardBackground,
+    borderLeftWidth: 3,
+    borderLeftColor: Colors.dark.tint,
+    borderRadius: 8,
+    paddingHorizontal: 14,
+    paddingVertical: 10,
+    marginBottom: 12,
+  },
+  supersetBannerLabel: {
+    fontSize: 12,
+    fontWeight: "700",
+    color: Colors.dark.tint,
+    textTransform: "uppercase",
+    letterSpacing: 1,
+  },
+  supersetBannerPartner: {
+    fontSize: 13,
+    color: Colors.dark.subText,
+  },
   setItem: {
     backgroundColor: Colors.dark.cardBackground,
     padding: 16,
diff --git a/app/(app)/(workout)/index.tsx b/app/(app)/(workout)/index.tsx
index 3a66c1e..2a4b0dd 100644
--- a/app/(app)/(workout)/index.tsx
+++ b/app/(app)/(workout)/index.tsx
@@ -9,7 +9,6 @@ import {
 } from "react-native";
 import {
   IconButton,
-  Card,
   Menu,
   Button,
   ActivityIndicator,
@@ -35,6 +34,7 @@ import {
   linkCompletedWorkoutToWorkout,
 } from "@/utils/database";
 import { cancelRestNotifications } from "@/utils/restNotification";
+import { classifySupersetPosition } from "@/utils/supersetUtils";
 import { useQueryClient } from "@tanstack/react-query";
 
 export default function WorkoutOverviewScreen() {
@@ -486,79 +486,100 @@ export default function WorkoutOverviewScreen() {
           const totalSets = exercise.sets.length;
           const allSetsCompleted = completedCount === totalSets;
           const isLoading = loadingExerciseIndex === index;
-          return (
-            <TouchableOpacity
-              key={exercise.exercise_id}
-              onPress={() => {
-                handleExercisePress(index);
-              }}
+
+          const { isInSuperset, isFirstInSuperset, isSecondInSuperset } =
+            classifySupersetPosition(workout.exercises, index);
+
+          const exerciseCardContent = (
+            <View
+              style={[
+                styles.card,
+                isInSuperset && styles.supersetCard,
+                isFirstInSuperset && styles.supersetCardFirst,
+                isSecondInSuperset && styles.supersetCardLast,
+              ]}
             >
-              <Card style={styles.card}>
-                <Card.Content style={styles.cardContent}>
-                  {/* Circle with the number or checkmark */}
-                  <View
-                    style={[
-                      styles.numberContainer,
-                      allSetsCompleted && styles.numberContainerCompleted,
-                    ]}
-                  >
-                    {isLoading ? (
-                      <ActivityIndicator size="small" color="white" />
-                    ) : allSetsCompleted ? (
-                      <MaterialCommunityIcons
-                        name="check"
-                        size={24}
-                        color="white"
-                      />
-                    ) : (
-                      <ThemedText style={styles.numberText}>
-                        {index + 1}
-                      </ThemedText>
-                    )}
-                  </View>
-
-                  {/* Exercise Info */}
-                  <View style={styles.exerciseInfo}>
-                    <ThemedText style={styles.exerciseName}>
-                      {exercise.name}
-                    </ThemedText>
-                    <ThemedText style={styles.setInfo}>
-                      {completedCount}/{exercise.sets.length} sets completed
-                    </ThemedText>
-                  </View>
-
-                  {/* Options Menu */}
-                  <Menu
-                    visible={menuVisible[index]}
-                    onDismiss={() => handleMenuClose(index)}
-                    anchor={
-                      <IconButton
-                        icon="dots-vertical"
-                        size={24}
-                        onPress={() => handleMenuOpen(index)}
-                        style={styles.optionsButton}
-                        iconColor={Colors.dark.text}
-                      />
-                    }
-                  >
-                    <Menu.Item
-                      onPress={() => {
-                        handleMenuClose(index);
-                        handleDeleteExercise(index);
-                      }}
-                      title="Delete"
+              <View style={styles.cardContent}>
+                {/* Circle with the number or checkmark */}
+                <View
+                  style={[
+                    styles.numberContainer,
+                    allSetsCompleted && styles.numberContainerCompleted,
+                  ]}
+                >
+                  {isLoading ? (
+                    <ActivityIndicator size="small" color="white" />
+                  ) : allSetsCompleted ? (
+                    <MaterialCommunityIcons
+                      name="check"
+                      size={24}
+                      color="white"
                     />
-                    <Menu.Item
-                      onPress={() => {
-                        handleMenuClose(index);
-                        handleReplaceExercise(index);
-                      }}
-                      title="Replace"
+                  ) : (
+                    <ThemedText style={styles.numberText}>
+                      {isFirstInSuperset
+                        ? "A"
+                        : isSecondInSuperset
+                          ? "B"
+                          : index + 1}
+                    </ThemedText>
+                  )}
+                </View>
+
+                {/* Exercise Info */}
+                <View style={styles.exerciseInfo}>
+                  <ThemedText style={styles.exerciseName}>
+                    {exercise.name}
+                  </ThemedText>
+                  <ThemedText style={styles.setInfo}>
+                    {completedCount}/{exercise.sets.length} sets completed
+                  </ThemedText>
+                </View>
+
+                {/* Options Menu */}
+                <Menu
+                  visible={menuVisible[index]}
+                  onDismiss={() => handleMenuClose(index)}
+                  anchor={
+                    <IconButton
+                      icon="dots-vertical"
+                      size={24}
+                      onPress={() => handleMenuOpen(index)}
+                      style={styles.optionsButton}
+                      iconColor={Colors.dark.text}
                     />
-                  </Menu>
-                </Card.Content>
-              </Card>
-            </TouchableOpacity>
+                  }
+                >
+                  <Menu.Item
+                    onPress={() => {
+                      handleMenuClose(index);
+                      handleDeleteExercise(index);
+                    }}
+                    title="Delete"
+                  />
+                  <Menu.Item
+                    onPress={() => {
+                      handleMenuClose(index);
+                      handleReplaceExercise(index);
+                    }}
+                    title="Replace"
+                  />
+                </Menu>
+              </View>
+            </View>
+          );
+
+          return (
+            <View key={exercise.exercise_id}>
+              {isSecondInSuperset ? (
+                <View accessible={false}>{exerciseCardContent}</View>
+              ) : (
+                <TouchableOpacity onPress={() => handleExercisePress(index)}>
+                  {exerciseCardContent}
+                </TouchableOpacity>
+              )}
+              {isFirstInSuperset && <View style={styles.supersetConnector} />}
+            </View>
           );
         })}
         <Button
@@ -595,6 +616,8 @@ const styles = StyleSheet.create({
     marginBottom: 10,
     backgroundColor: Colors.dark.cardBackground,
     borderRadius: 10,
+    paddingHorizontal: 16,
+    paddingVertical: 16,
   },
   cardContent: {
     flexDirection: "row",
@@ -693,4 +716,38 @@ const styles = StyleSheet.create({
     marginTop: 8,
     marginBottom: 50,
   },
+  supersetHeader: {
+    flexDirection: "row",
+    alignItems: "center",
+    marginBottom: 4,
+    marginTop: 8,
+    paddingHorizontal: 4,
+  },
+  supersetHeaderText: {
+    fontSize: 11,
+    fontWeight: "700",
+    color: Colors.dark.tint,
+    textTransform: "uppercase",
+    letterSpacing: 1,
+  },
+  supersetConnector: {
+    width: 3,
+    height: 8,
+    backgroundColor: Colors.dark.tint,
+    marginLeft: 27,
+    marginBottom: 0,
+  },
+  supersetCard: {
+    borderLeftWidth: 3,
+    borderLeftColor: Colors.dark.tint,
+  },
+  supersetCardFirst: {
+    marginBottom: 0,
+    borderBottomLeftRadius: 0,
+    borderBottomRightRadius: 0,
+  },
+  supersetCardLast: {
+    borderTopLeftRadius: 0,
+    borderTopRightRadius: 0,
+  },
 });
diff --git a/app/(app)/(workout)/workout-session.tsx b/app/(app)/(workout)/workout-session.tsx
index cb8acc3..dbe4972 100644
--- a/app/(app)/(workout)/workout-session.tsx
+++ b/app/(app)/(workout)/workout-session.tsx
@@ -20,6 +20,7 @@ import {
 } from "@/utils/restNotification";
 import { Notes } from "@/components/Notes";
 import { convertTimeStrToSeconds } from "@/utils/utility";
+import { findSupersetPartnerIndex } from "@/utils/supersetUtils";
 import { useSoundStore } from "@/store/soundStore";
 
 export default function WorkoutSessionScreen() {
@@ -338,6 +339,18 @@ export default function WorkoutSessionScreen() {
     }
   };
 
+  // Determine superset context
+  const supersetPartnerIndex =
+    workout && currentExercise
+      ? findSupersetPartnerIndex(workout.exercises, currentExerciseIndex)
+      : -1;
+  const isInSuperset = supersetPartnerIndex !== -1;
+  const isFirstInSuperset =
+    isInSuperset && currentExerciseIndex < supersetPartnerIndex;
+  const supersetPartnerExercise = isInSuperset
+    ? workout?.exercises[supersetPartnerIndex]
+    : null;
+
   const handleCompleteSet = () => {
     if (!currentExercise || !currentSet) {
       return;
@@ -375,9 +388,13 @@ export default function WorkoutSessionScreen() {
       validTimeNum.toString(), // Store as seconds
     );
 
-    if (hasNextSet) {
+    if (isFirstInSuperset) {
+      // Cancel any stale rest before moving to superset partner — no rest here
+      stopTimer();
+      void cancelRestNotifications();
+      nextSet();
+    } else if (hasNextSet) {
       void startRestTimer(currentSet.restMinutes, currentSet.restSeconds);
-      // Update state immediately without animation
       nextSet();
     } else {
       // No next set, workout completed — cancel any pending rest notification
@@ -429,6 +446,17 @@ export default function WorkoutSessionScreen() {
         }}
       />
       <View style={{ flex: 1 }}>
+        {isInSuperset && (
+          <View style={styles.supersetBanner}>
+            <ThemedText style={styles.supersetLabel}>
+              Superset {isFirstInSuperset ? "A" : "B"}
+            </ThemedText>
+            <ThemedText style={styles.supersetPartner}>
+              {isFirstInSuperset ? "Next: " : "Prev: "}
+              {supersetPartnerExercise?.name}
+            </ThemedText>
+          </View>
+        )}
         <SessionSetInfo
           exercise_id={currentExercise?.exercise_id || 0}
           exerciseName={currentExercise?.name || ""}
@@ -504,6 +532,30 @@ const styles = StyleSheet.create({
     elevation: 5,
     marginBottom: 0,
   },
+  supersetBanner: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    backgroundColor: Colors.dark.cardBackground,
+    borderRadius: 8,
+    paddingHorizontal: 14,
+    paddingVertical: 8,
+    marginBottom: 8,
+  },
+  supersetLabel: {
+    fontSize: 13,
+    fontWeight: "700",
+    color: Colors.dark.tint,
+    textTransform: "uppercase",
+    letterSpacing: 1,
+  },
+  supersetPartner: {
+    fontSize: 13,
+    color: Colors.dark.subText,
+    flexShrink: 1,
+    textAlign: "right",
+    marginLeft: 8,
+  },
   timerLabel: {
     fontSize: 14,
     color: Colors.dark.text,
diff --git a/components/WorkoutCard.tsx b/components/WorkoutCard.tsx
index 8a6c665..17fcab7 100644
--- a/components/WorkoutCard.tsx
+++ b/components/WorkoutCard.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
 import { StyleSheet, View, TextInput, Alert } from "react-native";
 import { ThemedText } from "@/components/ThemedText";
 import { useWorkoutStore, Workout, UserExercise } from "@/store/workoutStore";
@@ -10,6 +10,22 @@ import Sortable from "react-native-sortables";
 import type { SortableGridRenderItem } from "react-native-sortables";
 import { formatFromTotalSeconds } from "@/utils/utility";
 
+// Each item fed to Sortable.Grid is either a solo exercise or an adjacent superset pair.
+// The pair is treated as a single draggable unit so both exercises move together.
+type SingleItem = {
+  type: "single";
+  exercise: UserExercise;
+  exerciseIndex: number;
+};
+
+type SupersetItem = {
+  type: "superset";
+  exercises: [UserExercise, UserExercise];
+  exerciseIndices: [number, number];
+};
+
+type GroupedItem = SingleItem | SupersetItem;
+
 interface WorkoutCardProps {
   workout: Workout;
   index: number;
@@ -48,17 +64,12 @@ export default function WorkoutCard({
       const exercise = workout.exercises.find(
         (ex) => ex.exercise_id === exerciseId,
       );
-      if (!exercise) {
-        return;
-      }
+      if (!exercise) return;
       Alert.alert(
         "Remove Exercise",
         `Are you sure you want to remove ${exercise.name}?`,
         [
-          {
-            text: "Cancel",
-            style: "cancel",
-          },
+          { text: "Cancel", style: "cancel" },
           {
             text: "Remove",
             style: "destructive",
@@ -76,9 +87,7 @@ export default function WorkoutCard({
 
   const handleReplace = useCallback(
     (exerciseIndex: number) => {
-      // Find the exercise being replaced
       const exercise = workout.exercises[exerciseIndex];
-      // Navigate to the exercises screen to select a replacement, passing target_muscle if available
       router.push({
         pathname: "/(app)/(create-plan)/exercises",
         params: {
@@ -91,11 +100,70 @@ export default function WorkoutCard({
     [workoutIndex, workout.exercises],
   );
 
-  const renderExerciseItem: SortableGridRenderItem<UserExercise> = useCallback(
-    ({ item, index }) => {
-      const exerciseIndex = index;
+  const handleCreateSuperset = useCallback(
+    (exerciseIndex: number) => {
+      router.push({
+        pathname: "/(app)/(create-plan)/exercises",
+        params: {
+          index: workoutIndex,
+          supersetForIndex: exerciseIndex,
+        },
+      });
+    },
+    [workoutIndex],
+  );
+
+  const handleRemoveSuperset = useCallback(
+    (exerciseIndex: number) => {
+      useWorkoutStore
+        .getState()
+        .removeFromSuperset(workoutIndex, exerciseIndex);
+    },
+    [workoutIndex],
+  );
+
+  // Build the grouped data array. Superset pairs become one item so they drag together.
+  const groupedData = useMemo((): GroupedItem[] => {
+    const result: GroupedItem[] = [];
+    const seen = new Set<number>();
+
+    workout.exercises.forEach((exercise, i) => {
+      if (seen.has(exercise.exercise_id)) return;
+      seen.add(exercise.exercise_id);
+
+      const { supersetGroupId } = exercise;
+      if (supersetGroupId) {
+        const partnerIdx = workout.exercises.findIndex(
+          (e, j) => j !== i && e.supersetGroupId === supersetGroupId,
+        );
+        const partner =
+          partnerIdx !== -1 ? workout.exercises[partnerIdx] : null;
+        if (partner && !seen.has(partner.exercise_id)) {
+          seen.add(partner.exercise_id);
+          result.push({
+            type: "superset",
+            exercises: [exercise, partner],
+            exerciseIndices: [i, partnerIdx],
+          });
+          return;
+        }
+      }
+      result.push({ type: "single", exercise, exerciseIndex: i });
+    });
+
+    return result;
+  }, [workout.exercises]);
+
+  // Renders a single exercise row. Used for both solo exercises and each half of a superset.
+  const renderExerciseRow = useCallback(
+    (
+      item: UserExercise,
+      exerciseIndex: number,
+      isFirstInSuperset: boolean,
+      isSecondInSuperset: boolean,
+    ) => {
+      const isInSuperset = isFirstInSuperset || isSecondInSuperset;
 
-      // Calculate min and max reps
       const minReps = Math.min(
         ...item.sets.map((set) => set.repsMin ?? Infinity),
       );
@@ -112,7 +180,6 @@ export default function WorkoutCard({
         repRange = `${minReps} - ${maxReps}`;
       }
 
-      // Calculate min and max time
       const minTime = Math.min(...item.sets.map((set) => set.time ?? Infinity));
       const maxTime = Math.max(
         ...item.sets.map((set) => set.time ?? -Infinity),
@@ -130,11 +197,18 @@ export default function WorkoutCard({
       }
 
       const isToFailure = item.sets.some((set) => set.isToFailure);
-
       const isMenuOpen = menuVisible === item.exercise_id;
 
       return (
-        <View style={[styles.exerciseItem]}>
+        <View
+          key={item.exercise_id}
+          style={[
+            styles.exerciseItem,
+            isInSuperset && styles.supersetExerciseItem,
+            isFirstInSuperset && styles.supersetExerciseFirst,
+            isSecondInSuperset && styles.supersetExerciseLast,
+          ]}
+        >
           <Sortable.Touchable
             onTap={() =>
               router.push(
@@ -174,7 +248,6 @@ export default function WorkoutCard({
                 size={24}
                 onPress={() => openMenu(item.exercise_id)}
                 iconColor={Colors.dark.text}
-                accessibilityLabel={`Open menu for exercise ${item.exercise_id}`}
               />
             }
           >
@@ -192,6 +265,23 @@ export default function WorkoutCard({
               }}
               title="Replace"
             />
+            {isInSuperset ? (
+              <Menu.Item
+                onPress={() => {
+                  closeMenu();
+                  handleRemoveSuperset(exerciseIndex);
+                }}
+                title="Remove Superset"
+              />
+            ) : (
+              <Menu.Item
+                onPress={() => {
+                  closeMenu();
+                  handleCreateSuperset(exerciseIndex);
+                }}
+                title="Create Superset"
+              />
+            )}
             <Menu.Item
               onPress={() => {
                 closeMenu();
@@ -205,14 +295,53 @@ export default function WorkoutCard({
         </View>
       );
     },
-    [handleReplace, menuVisible, removeExercise, workoutIndex],
+    [
+      handleCreateSuperset,
+      handleRemoveSuperset,
+      handleReplace,
+      menuVisible,
+      removeExercise,
+      workoutIndex,
+    ],
   );
 
+  // Renders each Sortable.Grid item — either a solo row or a superset pair block.
+  const renderItem: SortableGridRenderItem<GroupedItem> = useCallback(
+    ({ item }) => {
+      if (item.type === "single") {
+        return (
+          <View>
+            {renderExerciseRow(item.exercise, item.exerciseIndex, false, false)}
+          </View>
+        );
+      }
+      const [exA, exB] = item.exercises;
+      const [idxA, idxB] = item.exerciseIndices;
+      return (
+        <View>
+          <View style={styles.supersetHeader}>
+            <ThemedText style={styles.supersetHeaderText}>Superset</ThemedText>
+          </View>
+          {renderExerciseRow(exA, idxA, true, false)}
+          <View style={styles.supersetConnector} />
+          {renderExerciseRow(exB, idxB, false, true)}
+        </View>
+      );
+    },
+    [renderExerciseRow],
+  );
+
+  // Reorder groups then flatten back to the flat exercises array.
   const handleOrderChange = useCallback(
     ({ fromIndex, toIndex }: { fromIndex: number; toIndex: number }) => {
-      const updatedExercises = [...workout.exercises];
-      const [movedItem] = updatedExercises.splice(fromIndex, 1);
-      updatedExercises.splice(toIndex, 0, movedItem);
+      if (fromIndex === toIndex) return;
+      const reordered = [...groupedData];
+      const [moved] = reordered.splice(fromIndex, 1);
+      reordered.splice(toIndex, 0, moved);
+
+      const updatedExercises = reordered.flatMap((item) =>
+        item.type === "single" ? [item.exercise] : item.exercises,
+      );
 
       const updatedWorkouts = workouts.map((w, i) =>
         i === index ? { ...w, exercises: updatedExercises } : w,
@@ -220,7 +349,7 @@ export default function WorkoutCard({
 
       useWorkoutStore.setState({ workouts: updatedWorkouts });
     },
-    [workout.exercises, workouts, index],
+    [groupedData, workouts, index],
   );
 
   return (
@@ -260,17 +389,19 @@ export default function WorkoutCard({
       />
       {workout.exercises.length > 0 ? (
         <Sortable.Grid
-          columns={1} // Treat as a vertical list
-          data={workout.exercises}
-          keyExtractor={(exercise) => exercise.exercise_id.toString()}
-          renderItem={renderExerciseItem}
+          columns={1}
+          data={groupedData}
+          keyExtractor={(item) =>
+            item.type === "single"
+              ? item.exercise.exercise_id.toString()
+              : `ss-${item.exercises[0].exercise_id}-${item.exercises[1].exercise_id}`
+          }
+          renderItem={renderItem}
           onDragEnd={handleOrderChange}
           showDropIndicator
         />
       ) : (
-        <ThemedText style={styles.workoutInstructions}>
-          No exercises added yet
-        </ThemedText>
+        <ThemedText style={styles.emptyText}>No exercises added yet</ThemedText>
       )}
       <Button
         mode="outlined"
@@ -377,10 +508,42 @@ const styles = StyleSheet.create({
     flex: 1,
   },
   setsAndReps: {
-    fontSize: 14, // Smaller font size for sets and reps
+    fontSize: 14,
     color: "#D8DEE9",
   },
   closeIcon: {
     marginLeft: "auto",
   },
+  supersetHeader: {
+    paddingHorizontal: 4,
+    paddingBottom: 0,
+    marginTop: -7,
+  },
+  supersetHeaderText: {
+    fontSize: 11,
+    fontWeight: "700",
+    color: Colors.dark.tint,
+    textTransform: "uppercase",
+    letterSpacing: 1,
+  },
+  supersetConnector: {
+    width: 3,
+    height: 6,
+    backgroundColor: Colors.dark.tint,
+    marginLeft: 27,
+  },
+  supersetExerciseItem: {
+    borderLeftWidth: 3,
+    borderLeftColor: Colors.dark.tint,
+  },
+  supersetExerciseFirst: {
+    marginBottom: 0,
+    borderBottomLeftRadius: 0,
+    borderBottomRightRadius: 0,
+  },
+  supersetExerciseLast: {
+    borderTopLeftRadius: 0,
+    borderTopRightRadius: 0,
+    marginBottom: 8,
+  },
 });
diff --git a/components/WorkoutDetailsScreen.tsx b/components/WorkoutDetailsScreen.tsx
index c9de35a..fac71d3 100644
--- a/components/WorkoutDetailsScreen.tsx
+++ b/components/WorkoutDetailsScreen.tsx
@@ -6,6 +6,7 @@ import { usePlanQuery } from "@/hooks/usePlanQuery";
 import { UserExercise } from "@/store/workoutStore";
 import { Image } from "expo-image";
 import { byteArrayToBase64, formatFromTotalSeconds } from "@/utils/utility";
+import { classifySupersetPosition } from "@/utils/supersetUtils";
 import { Colors } from "@/constants/Colors";
 import Bugsnag from "@bugsnag/expo";
 import { Notes } from "@/components/Notes";
@@ -18,13 +19,23 @@ export default function WorkoutDetailsScreen() {
 
   const workout = plan?.workouts[Number(workoutIndex)];
 
-  const renderExerciseItem = ({ item }: { item: UserExercise }) => {
+  const renderExerciseItem = ({
+    item,
+    index: exerciseIndex,
+  }: {
+    item: UserExercise;
+    index: number;
+  }) => {
     let base64Image: string | undefined;
     if (item.image) {
       const base64String = byteArrayToBase64(item.image);
       base64Image = `data:image/webp;base64,${base64String}`;
     }
 
+    const exercises = workout?.exercises ?? [];
+    const { isInSuperset, isFirstInSuperset, isSecondInSuperset } =
+      classifySupersetPosition(exercises, exerciseIndex);
+
     const minReps = Math.min(
       ...item.sets.map((set) => set.repsMin ?? Infinity),
     );
@@ -60,42 +71,60 @@ export default function WorkoutDetailsScreen() {
     const exerciseItem = { ...item, image: undefined };
 
     return (
-      <TouchableOpacity
-        onPress={() => {
-          router.push({
-            pathname: "/(app)/exercise-details",
-            params: { exercise_id: exerciseItem.exercise_id.toString() },
-          });
-        }}
-      >
-        <View style={styles.exerciseItem}>
-          {item.image.length > 0 ? (
-            <Image style={styles.exerciseImage} source={{ uri: base64Image }} />
-          ) : item.local_animated_uri ? (
-            <Image
-              style={styles.exerciseImage}
-              source={item.local_animated_uri}
-            />
-          ) : (
-            <Image style={styles.exerciseImage} source={fallbackImage} />
-          )}
-          <View style={styles.exerciseInfo}>
-            <ThemedText style={styles.exerciseName}>{item.name}</ThemedText>
-            <ThemedText style={styles.exerciseSets}>
-              {item?.sets?.length
-                ? `${item.sets.length} Sets`
-                : "No Sets Available"}
-              {item.tracking_type === "time"
-                ? timeRange
-                  ? ` | ${timeRange} ${isToFailure ? "(to Failure)" : ""}`
-                  : ""
-                : repRange
-                  ? ` | ${repRange} ${isToFailure ? "(to Failure) " : ""}Reps`
-                  : ""}
-            </ThemedText>
+      <View>
+        {isFirstInSuperset && (
+          <View style={styles.supersetHeader}>
+            <ThemedText style={styles.supersetHeaderText}>Superset</ThemedText>
           </View>
-        </View>
-      </TouchableOpacity>
+        )}
+        <TouchableOpacity
+          onPress={() => {
+            router.push({
+              pathname: "/(app)/exercise-details",
+              params: { exercise_id: exerciseItem.exercise_id.toString() },
+            });
+          }}
+        >
+          <View
+            style={[
+              styles.exerciseItem,
+              isInSuperset && styles.supersetExerciseItem,
+              isFirstInSuperset && styles.supersetExerciseFirst,
+              isSecondInSuperset && styles.supersetExerciseLast,
+            ]}
+          >
+            {item.image.length > 0 ? (
+              <Image
+                style={styles.exerciseImage}
+                source={{ uri: base64Image }}
+              />
+            ) : item.local_animated_uri ? (
+              <Image
+                style={styles.exerciseImage}
+                source={item.local_animated_uri}
+              />
+            ) : (
+              <Image style={styles.exerciseImage} source={fallbackImage} />
+            )}
+            <View style={styles.exerciseInfo}>
+              <ThemedText style={styles.exerciseName}>{item.name}</ThemedText>
+              <ThemedText style={styles.exerciseSets}>
+                {item?.sets?.length
+                  ? `${item.sets.length} Sets`
+                  : "No Sets Available"}
+                {item.tracking_type === "time"
+                  ? timeRange
+                    ? ` | ${timeRange} ${isToFailure ? "(to Failure)" : ""}`
+                    : ""
+                  : repRange
+                    ? ` | ${repRange} ${isToFailure ? "(to Failure) " : ""}Reps`
+                    : ""}
+              </ThemedText>
+            </View>
+          </View>
+        </TouchableOpacity>
+        {isFirstInSuperset && <View style={styles.supersetConnector} />}
+      </View>
     );
   };
 
@@ -124,6 +153,7 @@ export default function WorkoutDetailsScreen() {
       />
       <FlatList
         style={styles.container}
+        contentContainerStyle={styles.contentContainer}
         data={workout?.exercises}
         renderItem={renderExerciseItem}
         keyExtractor={(item: any, index: number) => index.toString()}
@@ -135,8 +165,10 @@ export default function WorkoutDetailsScreen() {
 const styles = StyleSheet.create({
   container: {
     flex: 1,
+  },
+  contentContainer: {
     paddingTop: 16,
-    paddingBottom: 50,
+    paddingBottom: 30,
     paddingHorizontal: 16,
   },
   exerciseItem: {
@@ -164,4 +196,36 @@ const styles = StyleSheet.create({
     fontSize: 14,
     color: Colors.dark.text,
   },
+  supersetHeader: {
+    paddingHorizontal: 4,
+    paddingBottom: 0,
+    marginTop: -8,
+  },
+  supersetHeaderText: {
+    fontSize: 11,
+    fontWeight: "700",
+    color: Colors.dark.tint,
+    textTransform: "uppercase",
+    letterSpacing: 1,
+  },
+  supersetConnector: {
+    width: 3,
+    height: 6,
+    backgroundColor: Colors.dark.tint,
+    marginLeft: 27,
+  },
+  supersetExerciseItem: {
+    borderLeftWidth: 3,
+    borderLeftColor: Colors.dark.tint,
+  },
+  supersetExerciseFirst: {
+    marginBottom: 0,
+    borderBottomLeftRadius: 0,
+    borderBottomRightRadius: 0,
+  },
+  supersetExerciseLast: {
+    borderTopLeftRadius: 0,
+    borderTopRightRadius: 0,
+    marginBottom: 8,
+  },
 });
diff --git a/constants/WhatsNew.ts b/constants/WhatsNew.ts
index df27ff2..172ffe7 100644
--- a/constants/WhatsNew.ts
+++ b/constants/WhatsNew.ts
@@ -68,6 +68,14 @@ Or start a Quick Workout from the home screen, add exercises on the fly, and opt
 📅 New: Weekly Schedule for Your Plan!
 
 You can now assign workouts to specific days of the week directly in the plan editor. Tap any day to pick a workout or mark it as a rest day. Use the auto-suggest button to instantly generate a balanced schedule based on your weekly goal.
+`,
+  },
+  {
+    version: 2609,
+    message: `
+🔗 New: Supersets!
+
+Pair two exercises together as a superset directly in the plan editor. Sets are kept in sync between both exercises, and supersets are clearly grouped with a visual indicator throughout the app.
 `,
   },
 ];
diff --git a/hooks/useActivePlanQuery.ts b/hooks/useActivePlanQuery.ts
index 9d2c6ed..de05696 100644
--- a/hooks/useActivePlanQuery.ts
+++ b/hooks/useActivePlanQuery.ts
@@ -29,7 +29,8 @@ export const fetchActivePlanData = async (): Promise<Plan | null> => {
         exercises.secondary_muscles,
         exercises.tracking_type,
         user_workout_exercises.sets,
-        user_workout_exercises.exercise_order
+        user_workout_exercises.exercise_order,
+        user_workout_exercises.superset_group_id
       FROM user_plans
       LEFT JOIN user_workouts ON user_workouts.plan_id = user_plans.id
       LEFT JOIN user_workout_exercises ON user_workout_exercises.workout_id = user_workouts.id
@@ -75,6 +76,7 @@ export const fetchActivePlanData = async (): Promise<Plan | null> => {
             : [],
           tracking_type: row.tracking_type || "",
           sets: row.sets ? JSON.parse(row.sets) : [],
+          supersetGroupId: row.superset_group_id ?? undefined,
         });
       }
     }
diff --git a/hooks/useAllPlansQuery.ts b/hooks/useAllPlansQuery.ts
index ed39236..e813ecf 100644
--- a/hooks/useAllPlansQuery.ts
+++ b/hooks/useAllPlansQuery.ts
@@ -34,6 +34,7 @@ export interface RawPlan {
   tracking_type: string | null;
   sets: string | null;
   exercise_order: number | null;
+  superset_group_id?: string | null;
 }
 
 export const transformRawPlans = (
diff --git a/hooks/usePlanQuery.ts b/hooks/usePlanQuery.ts
index 17fcb05..d9d55b9 100644
--- a/hooks/usePlanQuery.ts
+++ b/hooks/usePlanQuery.ts
@@ -28,6 +28,7 @@ export interface WorkoutRecord {
       isWarmup: boolean;
       toFailure: boolean;
     }[];
+    supersetGroupId?: string;
   }[];
 }
 
@@ -48,6 +49,7 @@ export interface RawWorkoutRecord {
   tracking_type: string | null;
   sets: string | null;
   exercise_order: number | null;
+  superset_group_id: string | null;
 }
 
 const fetchPlanData = async (planId: number): Promise<Plan | null> => {
@@ -82,7 +84,8 @@ const fetchWorkoutsForPlan = async (
         exercises.secondary_muscles,
         exercises.tracking_type,
         user_workout_exercises.sets,
-        user_workout_exercises.exercise_order
+        user_workout_exercises.exercise_order,
+        user_workout_exercises.superset_group_id
       FROM user_workouts
       LEFT JOIN user_workout_exercises ON user_workout_exercises.workout_id = user_workouts.id
       LEFT JOIN exercises ON exercises.exercise_id = user_workout_exercises.exercise_id
@@ -133,6 +136,7 @@ const parseWorkouts = (rawWorkouts: RawWorkoutRecord[]) => {
           : [],
         tracking_type: rawWorkout.tracking_type || "",
         sets: rawWorkout.sets ? JSON.parse(rawWorkout.sets) : [],
+        supersetGroupId: rawWorkout.superset_group_id ?? undefined,
       });
     }
   }
diff --git a/store/activeWorkoutStore.ts b/store/activeWorkoutStore.ts
index fe1a246..cbda850 100644
--- a/store/activeWorkoutStore.ts
+++ b/store/activeWorkoutStore.ts
@@ -5,6 +5,7 @@ import { UserExercise, Workout } from "./workoutStore";
 import { router } from "expo-router";
 import { CompletedWorkout } from "@/hooks/useCompletedWorkoutsQuery";
 import { formatFromTotalSeconds } from "@/utils/utility";
+import { findSupersetPartnerIndex } from "@/utils/supersetUtils";
 import Bugsnag from "@bugsnag/expo";
 
 /**
@@ -202,39 +203,188 @@ const useActiveWorkoutStore = create<ActiveWorkoutStore>()(
             },
           };
 
-          // Check if current set is warm-up
+          // Helper: build carry-over values for an exercise's next set
+          const buildNextSetValues = (
+            exerciseIndex: number,
+            exercise: (typeof workout.exercises)[0],
+            fromSetIndex: number,
+            toSetIndex: number,
+          ) => {
+            const exTrackingType = exercise.tracking_type || "weight";
+            const isWarmup = exercise.sets[fromSetIndex]?.isWarmup || false;
+            const isDropSet = exercise.sets[fromSetIndex]?.isDropSet || false;
+            const isNextDropSet =
+              toSetIndex < exercise.sets.length &&
+              exercise.sets[toSetIndex]?.isDropSet;
+            const currentSetValues =
+              weightAndReps[exerciseIndex]?.[fromSetIndex] || {};
+            const previousExData = previousWorkoutData
+              ?.flatMap((w) => w.exercises)
+              .find((prevEx) => prevEx.exercise_id === exercise.exercise_id);
+            const nextHistorical =
+              previousExData?.sets[toSetIndex] || undefined;
+
+            return {
+              ...(exTrackingType === "weight" ||
+              exTrackingType === "" ||
+              exTrackingType === "assisted"
+                ? {
+                    weight:
+                      (isWarmup || isDropSet || isNextDropSet) &&
+                      nextHistorical?.weight
+                        ? nextHistorical.weight.toString()
+                        : currentSetValues.weight,
+                    reps:
+                      nextHistorical?.reps !== undefined
+                        ? nextHistorical.reps?.toString()
+                        : undefined,
+                  }
+                : {}),
+              ...(exTrackingType === "reps"
+                ? {
+                    reps:
+                      nextHistorical?.reps !== undefined
+                        ? nextHistorical.reps?.toString()
+                        : undefined,
+                  }
+                : {}),
+              ...(exTrackingType === "time"
+                ? {
+                    time:
+                      nextHistorical?.time !== undefined
+                        ? formatFromTotalSeconds(nextHistorical.time ?? 0)
+                        : undefined,
+                  }
+                : {}),
+            };
+          };
+
+          // --- Superset handling ---
+          if (currentExercise.supersetGroupId) {
+            const partnerIndex = findSupersetPartnerIndex(
+              workout.exercises,
+              currentExerciseIndex,
+            );
+
+            if (partnerIndex !== -1) {
+              const isFirstInSuperset = currentExerciseIndex < partnerIndex;
+
+              if (isFirstInSuperset) {
+                // Move to partner (second exercise), same set index — no rest
+                const partnerSetIndex = currentSetIndices[partnerIndex] || 0;
+                return {
+                  currentExerciseIndex: partnerIndex,
+                  currentSetIndices: {
+                    ...currentSetIndices,
+                    [partnerIndex]: partnerSetIndex,
+                  },
+                  completedSets: updatedCompletedSets,
+                };
+              }
+
+              // Second in superset: advance both exercises' set indices then rest
+              const firstIndex = partnerIndex;
+              const firstExercise = workout.exercises[firstIndex];
+              const updatedSetIndices = {
+                ...currentSetIndices,
+                [currentExerciseIndex]: nextSetIndex,
+                [firstIndex]: nextSetIndex,
+              };
+
+              const firstNextValues = buildNextSetValues(
+                firstIndex,
+                firstExercise,
+                currentSetIndex,
+                nextSetIndex,
+              );
+              const secondNextValues = buildNextSetValues(
+                currentExerciseIndex,
+                currentExercise,
+                currentSetIndex,
+                nextSetIndex,
+              );
+              const updatedWeightAndReps = {
+                ...weightAndReps,
+                [firstIndex]: {
+                  ...(weightAndReps[firstIndex] || {}),
+                  [nextSetIndex]: firstNextValues,
+                },
+                [currentExerciseIndex]: {
+                  ...(weightAndReps[currentExerciseIndex] || {}),
+                  [nextSetIndex]: secondNextValues,
+                },
+              };
+
+              const supersetLength = Math.max(
+                currentExercise.sets.length,
+                firstExercise.sets.length,
+              );
+              if (nextSetIndex < supersetLength) {
+                return {
+                  currentExerciseIndex: firstIndex,
+                  currentSetIndices: updatedSetIndices,
+                  completedSets: updatedCompletedSets,
+                  weightAndReps: updatedWeightAndReps,
+                };
+              }
+
+              // Superset fully done — find next uncompleted exercise after both
+              const maxIndex = Math.max(currentExerciseIndex, firstIndex);
+              let nextExerciseIndex = maxIndex + 1;
+              while (nextExerciseIndex < workout.exercises.length) {
+                const totalSets =
+                  workout.exercises[nextExerciseIndex].sets.length;
+                const isComplete =
+                  updatedCompletedSets[nextExerciseIndex] &&
+                  Object.keys(updatedCompletedSets[nextExerciseIndex])
+                    .length === totalSets;
+                if (!isComplete) break;
+                nextExerciseIndex++;
+              }
+
+              if (nextExerciseIndex < workout.exercises.length) {
+                return {
+                  currentExerciseIndex: nextExerciseIndex,
+                  currentSetIndices: updatedSetIndices,
+                  completedSets: updatedCompletedSets,
+                  weightAndReps: updatedWeightAndReps,
+                };
+              }
+
+              router.back();
+              return {
+                currentSetIndices: updatedSetIndices,
+                completedSets: updatedCompletedSets,
+                weightAndReps: updatedWeightAndReps,
+              };
+            }
+          }
+
+          // --- Normal (non-superset) logic ---
           const isWarmup =
             currentExercise.sets[currentSetIndex]?.isWarmup || false;
-
-          // Check if current set is a drop set
           const isDropSet =
             currentExercise.sets[currentSetIndex]?.isDropSet || false;
-
-          // Check if next set is drop set
           const isNextDropSet =
             nextSetIndex < currentExercise.sets.length &&
             currentExercise.sets[nextSetIndex]?.isDropSet;
 
-          // Update the set index for the current exercise
           const updatedSetIndices = {
             ...currentSetIndices,
             [currentExerciseIndex]: nextSetIndex,
           };
 
-          // Retrieve historical data for the next set
           const previousExerciseData = previousWorkoutData
             ?.flatMap((workout) => workout.exercises)
             .find(
               (prevEx) => prevEx.exercise_id === currentExercise.exercise_id,
             );
 
-          // Retrieve values from the current set and historical data for the next set
           const currentSetValues =
             weightAndReps[currentExerciseIndex]?.[currentSetIndex] || {};
           const nextSetValues =
             previousExerciseData?.sets[nextSetIndex] || undefined;
 
-          // Determine the values to carry over based on `tracking_type`
           const updatedNextSetValues = {
             ...(trackingType === "weight" || trackingType === ""
               ? {
@@ -280,7 +430,6 @@ const useActiveWorkoutStore = create<ActiveWorkoutStore>()(
               : {}),
           };
 
-          // Update the weightAndReps with the new values for the next set
           const updatedWeightAndReps = {
             ...weightAndReps,
             [currentExerciseIndex]: {
@@ -289,7 +438,6 @@ const useActiveWorkoutStore = create<ActiveWorkoutStore>()(
             },
           };
 
-          // If there are more sets in the current exercise, update the store accordingly
           if (nextSetIndex < currentExercise.sets.length) {
             return {
               currentSetIndices: updatedSetIndices,
@@ -298,7 +446,6 @@ const useActiveWorkoutStore = create<ActiveWorkoutStore>()(
             };
           }
 
-          // Move to the next exercise if all sets are complete in the current exercise
           let nextExerciseIndex = currentExerciseIndex + 1;
           while (nextExerciseIndex < workout.exercises.length) {
             const totalSets = workout.exercises[nextExerciseIndex].sets.length;
@@ -308,7 +455,6 @@ const useActiveWorkoutStore = create<ActiveWorkoutStore>()(
                 totalSets;
 
             if (!isExerciseCompleted) {
-              // Found the next uncompleted exercise
               return {
                 currentExerciseIndex: nextExerciseIndex,
                 currentSetIndices: updatedSetIndices,
@@ -318,7 +464,6 @@ const useActiveWorkoutStore = create<ActiveWorkoutStore>()(
             nextExerciseIndex++;
           }
 
-          // If all exercises are completed, navigate back
           router.back();
           return {
             currentSetIndices: updatedSetIndices,
diff --git a/store/workoutStore.ts b/store/workoutStore.ts
index d513279..70348fc 100644
--- a/store/workoutStore.ts
+++ b/store/workoutStore.ts
@@ -1,5 +1,6 @@
 import { create } from "zustand";
 import { Exercise } from "@/utils/database";
+import * as Crypto from "expo-crypto";
 
 export interface Set {
   repsMin: number | undefined;
@@ -16,6 +17,7 @@ export interface UserExercise extends Exercise {
   sets: Set[];
   exercise_order?: number;
   is_deleted?: boolean;
+  supersetGroupId?: string;
 }
 
 export interface Workout {
@@ -65,6 +67,12 @@ interface WorkoutStore {
     exerciseId: number,
     setIndex: number,
   ) => void;
+  createSuperset: (
+    workoutIndex: number,
+    exerciseIndex: number,
+    newExercise: UserExercise,
+  ) => void;
+  removeFromSuperset: (workoutIndex: number, exerciseIndex: number) => void;
   // Schedule state (day_of_week 0-6 -> workout array index)
   planSchedule: Record<number, number>;
   setPlanSchedule: (schedule: Record<number, number>) => void;
@@ -222,23 +230,35 @@ const useWorkoutStore = create<WorkoutStore>((set) => ({
   },
   addSetToExercise: (workoutIndex: number, exerciseId: number, newSet: Set) => {
     set((state) => {
-      const workouts = state.workouts.map((workout, wIndex) => {
-        if (wIndex !== workoutIndex) {
-          return workout;
-        }
-        const exercises = workout.exercises.map((exercise) => {
-          if (exercise.exercise_id !== exerciseId) {
-            return exercise;
+      const workout = state.workouts[workoutIndex];
+      if (!workout) return state;
+
+      const targetExercise = workout.exercises.find(
+        (e) => e.exercise_id === exerciseId,
+      );
+      const supersetGroupId = targetExercise?.supersetGroupId;
+      const partner = supersetGroupId
+        ? workout.exercises.find(
+            (e) =>
+              e.exercise_id !== exerciseId &&
+              e.supersetGroupId === supersetGroupId,
+          )
+        : null;
+
+      const workouts = state.workouts.map((w, wIndex) => {
+        if (wIndex !== workoutIndex) return w;
+        const exercises = w.exercises.map((exercise) => {
+          if (exercise.exercise_id === exerciseId) {
+            return { ...exercise, sets: [...exercise.sets, newSet] };
           }
-          return {
-            ...exercise,
-            sets: [...exercise.sets, newSet],
-          };
+          // Mirror to superset partner: copy partner's last set as template
+          if (partner && exercise.exercise_id === partner.exercise_id) {
+            const lastSet = exercise.sets[exercise.sets.length - 1] ?? newSet;
+            return { ...exercise, sets: [...exercise.sets, { ...lastSet }] };
+          }
+          return exercise;
         });
-        return {
-          ...workout,
-          exercises,
-        };
+        return { ...w, exercises };
       });
       return { workouts };
     });
@@ -283,28 +303,87 @@ const useWorkoutStore = create<WorkoutStore>((set) => ({
     setIndex: number,
   ) => {
     set((state) => {
-      const workouts = state.workouts.map((workout, wIndex) => {
+      const workout = state.workouts[workoutIndex];
+      if (!workout) return state;
+
+      const targetExercise = workout.exercises.find(
+        (e) => e.exercise_id === exerciseId,
+      );
+      const supersetGroupId = targetExercise?.supersetGroupId;
+      const partner = supersetGroupId
+        ? workout.exercises.find(
+            (e) =>
+              e.exercise_id !== exerciseId &&
+              e.supersetGroupId === supersetGroupId,
+          )
+        : null;
+
+      const workouts = state.workouts.map((w, wIndex) => {
         if (wIndex !== workoutIndex) {
-          return workout;
+          return w;
         }
-        const exercises = workout.exercises.map((exercise) => {
-          if (exercise.exercise_id !== exerciseId) {
-            return exercise;
+        const exercises = w.exercises.map((exercise) => {
+          if (exercise.exercise_id === exerciseId) {
+            // Must keep at least 1 set
+            if (exercise.sets.length <= 1) return exercise;
+            return {
+              ...exercise,
+              sets: exercise.sets.filter((_, sIndex) => sIndex !== setIndex),
+            };
           }
-          const sets = exercise.sets.filter((_, sIndex) => sIndex !== setIndex);
-          return {
-            ...exercise,
-            sets,
-          };
+          // Mirror removal to superset partner
+          if (partner && exercise.exercise_id === partner.exercise_id) {
+            if (exercise.sets.length <= 1) return exercise;
+            return {
+              ...exercise,
+              sets: exercise.sets.filter((_, sIndex) => sIndex !== setIndex),
+            };
+          }
+          return exercise;
         });
         return {
-          ...workout,
+          ...w,
           exercises,
         };
       });
       return { workouts };
     });
   },
+  createSuperset: (workoutIndex, exerciseIndex, newExercise) =>
+    set((state) => {
+      const groupId = Crypto.randomUUID();
+      const updatedWorkouts = state.workouts.map((w, i) => {
+        if (i !== workoutIndex) return w;
+        const exercises = [...w.exercises];
+        exercises[exerciseIndex] = {
+          ...exercises[exerciseIndex],
+          supersetGroupId: groupId,
+        };
+        exercises.splice(exerciseIndex + 1, 0, {
+          ...newExercise,
+          supersetGroupId: groupId,
+        });
+        return { ...w, exercises };
+      });
+      return { workouts: updatedWorkouts };
+    }),
+
+  removeFromSuperset: (workoutIndex, exerciseIndex) =>
+    set((state) => {
+      const updatedWorkouts = state.workouts.map((w, i) => {
+        if (i !== workoutIndex) return w;
+        const groupId = w.exercises[exerciseIndex]?.supersetGroupId;
+        if (!groupId) return w;
+        const exercises = w.exercises.map((e) => {
+          if (e.supersetGroupId !== groupId) return e;
+          const { supersetGroupId: _, ...rest } = e;
+          return rest as UserExercise;
+        });
+        return { ...w, exercises };
+      });
+      return { workouts: updatedWorkouts };
+    }),
+
   // Schedule actions
   planSchedule: {},
   setPlanSchedule: (schedule) =>
diff --git a/utils/database.ts b/utils/database.ts
index 78397ec..cc955e0 100644
--- a/utils/database.ts
+++ b/utils/database.ts
@@ -499,9 +499,15 @@ export const insertWorkouts = async (
         // Insert into user_workout_exercises
         await txn.runAsync(
           `INSERT INTO user_workout_exercises (
-            workout_id, exercise_id, sets, exercise_order
-          ) VALUES (?, ?, ?, ?)`,
-          [workoutId, exercise_id, JSON.stringify(sets), exerciseOrder],
+            workout_id, exercise_id, sets, exercise_order, superset_group_id
+          ) VALUES (?, ?, ?, ?, ?)`,
+          [
+            workoutId,
+            exercise_id,
+            JSON.stringify(sets),
+            exerciseOrder,
+            exercise.supersetGroupId ?? null,
+          ],
         );
       }
     }
@@ -598,21 +604,23 @@ export const updateWorkoutPlan = async (
           if (!existingExerciseIds.includes(exercise.exercise_id)) {
             // Insert new exercise
             await txn.runAsync(
-              `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order) VALUES (?, ?, ?, ?)`,
+              `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order, superset_group_id) VALUES (?, ?, ?, ?, ?)`,
               [
                 workoutId,
                 exercise.exercise_id,
                 JSON.stringify(exercise.sets),
                 exerciseOrder,
+                exercise.supersetGroupId ?? null,
               ],
             );
           } else {
             // Update existing exercise
             await txn.runAsync(
-              `UPDATE user_workout_exercises SET sets = ?, exercise_order = ? WHERE workout_id = ? AND exercise_id = ?`,
+              `UPDATE user_workout_exercises SET sets = ?, exercise_order = ?, superset_group_id = ? WHERE workout_id = ? AND exercise_id = ?`,
               [
                 JSON.stringify(exercise.sets),
                 exerciseOrder,
+                exercise.supersetGroupId ?? null,
                 workoutId,
                 exercise.exercise_id,
               ],
@@ -641,12 +649,13 @@ export const appendExercisesToWorkout = async (
     const baseOrder = (row?.maxOrder ?? -1) + 1;
     for (const [i, exercise] of exercises.entries()) {
       await txn.runAsync(
-        `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order) VALUES (?, ?, ?, ?)`,
+        `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order, superset_group_id) VALUES (?, ?, ?, ?, ?)`,
         [
           workoutId,
           exercise.exercise_id,
           JSON.stringify(exercise.sets),
           baseOrder + i,
+          exercise.supersetGroupId ?? null,
         ],
       );
     }
@@ -1133,6 +1142,7 @@ interface RawStandaloneWorkout {
   tracking_type: string | null;
   sets: string | null;
   exercise_order: number | null;
+  superset_group_id: string | null;
 }
 
 export const getStandaloneWorkouts = async (): Promise<Workout[]> => {
@@ -1155,7 +1165,8 @@ export const getStandaloneWorkouts = async (): Promise<Workout[]> => {
       e.secondary_muscles,
       e.tracking_type,
       uwe.sets,
-      uwe.exercise_order
+      uwe.exercise_order,
+      uwe.superset_group_id
     FROM user_workouts uw
     LEFT JOIN user_workout_exercises uwe ON uwe.workout_id = uw.id AND uwe.is_deleted = FALSE
     LEFT JOIN exercises e ON e.exercise_id = uwe.exercise_id
@@ -1204,6 +1215,7 @@ export const getStandaloneWorkouts = async (): Promise<Workout[]> => {
             return [];
           }
         })(),
+        supersetGroupId: row.superset_group_id ?? undefined,
       });
     }
   }
@@ -1224,12 +1236,13 @@ export const createStandaloneWorkout = async (
     newWorkoutId = result.lastInsertRowId;
     for (const [order, exercise] of exercises.entries()) {
       await txn.runAsync(
-        `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order) VALUES (?, ?, ?, ?)`,
+        `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order, superset_group_id) VALUES (?, ?, ?, ?, ?)`,
         [
           newWorkoutId,
           exercise.exercise_id,
           JSON.stringify(exercise.sets),
           order,
+          exercise.supersetGroupId ?? null,
         ],
       );
     }
@@ -1275,22 +1288,24 @@ export const updateStandaloneWorkout = async (
       const existingRow = existingByOrder.get(order);
       if (existingRow) {
         await txn.runAsync(
-          `UPDATE user_workout_exercises SET exercise_id = ?, sets = ?, exercise_order = ?, is_deleted = FALSE WHERE id = ?`,
+          `UPDATE user_workout_exercises SET exercise_id = ?, sets = ?, exercise_order = ?, superset_group_id = ?, is_deleted = FALSE WHERE id = ?`,
           [
             exercise.exercise_id,
             JSON.stringify(exercise.sets),
             order,
+            exercise.supersetGroupId ?? null,
             existingRow.id,
           ],
         );
       } else {
         await txn.runAsync(
-          `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order) VALUES (?, ?, ?, ?)`,
+          `INSERT INTO user_workout_exercises (workout_id, exercise_id, sets, exercise_order, superset_group_id) VALUES (?, ?, ?, ?, ?)`,
           [
             workoutId,
             exercise.exercise_id,
             JSON.stringify(exercise.sets),
             order,
+            exercise.supersetGroupId ?? null,
           ],
         );
       }
diff --git a/utils/initAppCheck.ts b/utils/initAppCheck.ts
index 93d6507..47683ae 100644
--- a/utils/initAppCheck.ts
+++ b/utils/initAppCheck.ts
@@ -8,7 +8,9 @@ import Constants from "expo-constants";
 export async function setupAppCheck(): Promise<void> {
   const extra = Constants.expoConfig?.extra;
   const isDevBuild = extra?.appVariant === "development";
-  const debugToken: string | undefined = extra?.appCheckDebugToken ?? undefined;
+  const rawDebugToken = extra?.appCheckDebugToken;
+  const debugToken =
+    typeof rawDebugToken === "string" ? rawDebugToken : undefined;
 
   try {
     const rnfbProvider: ReactNativeFirebaseAppCheckProvider =
diff --git a/utils/initUserDataDB.ts b/utils/initUserDataDB.ts
index f6b67f8..2ef742e 100644
--- a/utils/initUserDataDB.ts
+++ b/utils/initUserDataDB.ts
@@ -247,4 +247,16 @@ export async function initUserDataDB() {
       ALTER TABLE user_workouts ADD COLUMN image_url TEXT;
     `);
   }
+
+  const user_workout_exercisesResult = await db.getAllAsync(`
+    PRAGMA table_info(user_workout_exercises);
+  `);
+  const supersetGroupIdExists = user_workout_exercisesResult.some(
+    (col: any) => col.name === "superset_group_id",
+  );
+  if (!supersetGroupIdExists) {
+    await db.execAsync(`
+      ALTER TABLE user_workout_exercises ADD COLUMN superset_group_id TEXT;
+    `);
+  }
 }
diff --git a/utils/supersetUtils.ts b/utils/supersetUtils.ts
new file mode 100644
index 0000000..d3c57d3
--- /dev/null
+++ b/utils/supersetUtils.ts
@@ -0,0 +1,72 @@
+import { UserExercise } from "@/store/workoutStore";
+
+/**
+ * Asserts that every `supersetGroupId` present in `exercises` appears exactly
+ * twice — one occurrence per exercise in the pair. Throws a `RangeError`
+ * naming the offending `supersetGroupId` if the cardinality constraint is
+ * violated.
+ *
+ * Call this after loading or mutating workout exercises so that
+ * {@link findSupersetPartnerIndex} can rely on the invariant being satisfied.
+ */
+export function validateSupersetCardinality(exercises: UserExercise[]): void {
+  const counts = new Map<string, number>();
+  for (const e of exercises) {
+    if (e.supersetGroupId) {
+      counts.set(e.supersetGroupId, (counts.get(e.supersetGroupId) ?? 0) + 1);
+    }
+  }
+  for (const [id, count] of counts) {
+    if (count !== 2) {
+      throw new RangeError(
+        `supersetGroupId "${id}" appears ${count} time(s) in exercises; ` +
+          `expected exactly 2. Check the data passed to findSupersetPartnerIndex.`,
+      );
+    }
+  }
+}
+
+/**
+ * Returns the index of the superset partner of the exercise at `index`,
+ * or -1 if the exercise is not in a superset.
+ *
+ * **Cardinality contract**: each `supersetGroupId` must appear exactly twice in
+ * `exercises` (one entry per exercise in the pair). If the group contains fewer
+ * or more than two exercises the data is corrupt; use
+ * {@link validateSupersetCardinality} after loading exercises to enforce this
+ * invariant before calling this function.
+ */
+export function findSupersetPartnerIndex(
+  exercises: UserExercise[],
+  index: number,
+): number {
+  const supersetGroupId = exercises[index]?.supersetGroupId;
+  if (!supersetGroupId) return -1;
+
+  return exercises.findIndex(
+    (e, i) => i !== index && e.supersetGroupId === supersetGroupId,
+  );
+}
+
+/**
+ * Returns superset position flags for the exercise at `index`.
+ */
+export function classifySupersetPosition(
+  exercises: UserExercise[],
+  index: number,
+): {
+  isInSuperset: boolean;
+  partnerIndex: number;
+  isFirstInSuperset: boolean;
+  isSecondInSuperset: boolean;
+} {
+  const partnerIndex = findSupersetPartnerIndex(exercises, index);
+  const isInSuperset = partnerIndex !== -1;
+
+  return {
+    isInSuperset,
+    partnerIndex,
+    isFirstInSuperset: isInSuperset && index < partnerIndex,
+    isSecondInSuperset: isInSuperset && index > partnerIndex,
+  };
+}