diff --git a/src/pytti/LossAug/DepthLossClass.py b/src/pytti/LossAug/DepthLossClass.py
index 0428806..501a31d 100644
--- a/src/pytti/LossAug/DepthLossClass.py
+++ b/src/pytti/LossAug/DepthLossClass.py
@@ -29,7 +29,6 @@ def init_AdaBins(device=None):
 class DepthLoss(MSELoss):
     @torch.no_grad()
     def set_comp(self, pil_image):
-        # pil_image = pil_image.resize(self.image_shape, Image.LANCZOS)
         self.comp.set_(DepthLoss.make_comp(pil_image))
         if self.use_mask and self.mask.shape[-2:] != self.comp.shape[-2:]:
             self.mask.set_(TF.resize(self.mask, self.comp.shape[-2:]))
diff --git a/src/pytti/LossAug/LatentLossClass.py b/src/pytti/LossAug/LatentLossClass.py
index 8f267b8..a2612b3 100644
--- a/src/pytti/LossAug/LatentLossClass.py
+++ b/src/pytti/LossAug/LatentLossClass.py
@@ -25,37 +25,13 @@ def __init__(
             TF.resize(comp.clone(), (h, w)), weight, stop, name, image_shape
         )
 
+    # Comp and mask should live on the image representation, not the loss class.
     @torch.no_grad()
     def set_comp(self, pil_image, device=DEVICE):
         self.pil_image = pil_image
         self.has_latent = False
         self.direct_loss.set_comp(pil_image.resize(self.image_shape, Image.LANCZOS))
 
-    @classmethod
-    @vram_usage_mode("Latent Image Loss")
-    @torch.no_grad()
-    def TargetImage(
-        cls, prompt_string, image_shape, pil_image=None, is_path=False, device=DEVICE
-    ):
-        text, weight, stop = parse(
-            prompt_string, r"(?<!^http)(?<!s):|:(?!/)", ["", "1", "-inf"]
-        )
-        weight, mask = parse(weight, r"_", ["1", ""])
-        text = text.strip()
-        mask = mask.strip()
-        if pil_image is None and text != "" and is_path:
-            pil_image = Image.open(fetch(text)).convert("RGB")
-        comp = (
-            MSELoss.make_comp(pil_image)
-            if pil_image is not None
-            else torch.zeros(1, 1, 1, 1, device=device)
-        )
-        out = cls(comp, weight, stop, text + " (latent)", image_shape)
-        if pil_image is not None:
-            out.set_comp(pil_image)
-        out.set_mask(mask)
-        return out
-
     def set_mask(self, mask, inverted=False):
         self.direct_loss.set_mask(mask, inverted)
         super().set_mask(mask, inverted)
diff --git a/src/pytti/LossAug/LossOrchestratorClass.py b/src/pytti/LossAug/LossOrchestratorClass.py
index 931537e..0151500 100644
--- a/src/pytti/LossAug/LossOrchestratorClass.py
+++ b/src/pytti/LossAug/LossOrchestratorClass.py
@@ -2,11 +2,12 @@
 from loguru import logger
 from PIL import Image
 
-from pytti.image_models import PixelImage
+from pytti.image_models import PixelImage, RGBImage
 
-# from pytti.LossAug import build_loss
 from pytti.LossAug import TVLoss, HSVLoss, OpticalFlowLoss, TargetFlowLoss
 from pytti.Perceptor.Prompt import parse_prompt
+from pytti.eval_tools import parse_subprompt
+
 
 from pytti.LossAug.BaseLossClass import Loss
 from pytti.LossAug.DepthLossClass import DepthLoss
@@ -15,20 +16,39 @@
 
 #################################
 
+import torch
 
 LOSS_DICT = {"edge": EdgeLoss, "depth": DepthLoss}
 
 
-def build_loss(weight_name, weight, name, img, pil_target):
-    # from pytti.LossAug import LOSS_DICT
+def build_loss(
+    weight_name: str,
+    weight: str,
+    name: str,
+    img: RGBImage,
+    pil_target: Image,
+    device=None,
+):
+    if device is None:
+        device = img.device
 
     weight_name, suffix = weight_name.split("_", 1)
     if weight_name == "direct":
-        Loss = type(img).get_preferred_loss()
+        loss = type(img).get_preferred_loss()
     else:
-        Loss = LOSS_DICT[weight_name]
-    out = Loss.TargetImage(
-        f"{weight_name} {name}:{weight}", img.image_shape, pil_target
+        loss = LOSS_DICT[weight_name]
+
+    if pil_target is not None:
+        resized = pil_target.resize(img.image_shape, Image.LANCZOS)
+        comp = loss.make_comp(resized, device=device)
+    else:
+        # comp = loss.get_default_comp()
+        comp = torch.zeros(1, 1, 1, 1, device=device)
+    out = loss(
+        comp=comp,
+        weight=weight,
+        name=f"{weight_name} {name} (direct)",
+        image_shape=img.image_shape,
     )
     out.set_enabled(pil_target is not None)
     return out
@@ -103,92 +123,51 @@ def configure_stabilization_augs(img, init_image_pil, params, loss_augs):
 
 
 def configure_optical_flows(img, params, loss_augs):
+    logger.debug(params.device)
+    _device = params.device
 
+    # this shouldn't be in this function based on the name.
+    # other loss augs
+    if params.smoothing_weight != 0:
+        loss_augs.append(
+            TVLoss(weight=params.smoothing_weight)
+        )  # , device=params.device))
+
+    optical_flows = []
     if params.animation_mode == "Video Source":
         if params.flow_stabilization_weight == "":
             params.flow_stabilization_weight = "0"
-        optical_flows = [
-            OpticalFlowLoss.TargetImage(
-                f"optical flow stabilization (frame {-2**i}):{params.flow_stabilization_weight}",
-                img.image_shape,
-            )
-            for i in range(params.flow_long_term_samples + 1)
-        ]
-        for optical_flow in optical_flows:
-            optical_flow.set_enabled(False)
-        loss_augs.extend(optical_flows)
+        # TODO: if flow stabilization weight is 0, shouldn't this next block just get skipped?
+        if params.flow_stabilization_weight != "0":
+            # TO DO: if weight is parameterized, need to do a parameteric evaluation here.
+            for i in range(params.flow_long_term_samples + 1):
+                optical_flow = OpticalFlowLoss(
+                    comp=torch.zeros(1, 1, 1, 1, device=_device),  # ,device=DEVICE)
+                    weight=params.flow_stabilization_weight,
+                    name=f"optical flow stabilization (frame {-2**i}) (direct)",
+                    image_shape=img.image_shape,
+                    device=_device,
+                )  # , device=device)
+                optical_flow.set_enabled(False)
+                optical_flows.append(optical_flow)
+
     elif params.animation_mode == "3D" and params.flow_stabilization_weight not in [
         "0",
         "",
     ]:
-        optical_flows = [
-            TargetFlowLoss.TargetImage(
-                f"optical flow stabilization:{params.flow_stabilization_weight}",
-                img.image_shape,
-                device="cuda",
-            )
-        ]
-        for optical_flow in optical_flows:
-            optical_flow.set_enabled(False)
-        loss_augs.extend(optical_flows)
-    else:
-        optical_flows = []
-    # other loss augs
-    if params.smoothing_weight != 0:
-        loss_augs.append(TVLoss(weight=params.smoothing_weight))
-
-    return img, loss_augs, optical_flows
-
-
-#######################################
-
-
-class LossBuilder:
-
-    LOSS_DICT = {"edge": EdgeLoss, "depth": DepthLoss}
-
-    def __init__(self, weight_name, weight, name, img, pil_target):
-        self.weight_name = weight_name
-        self.weight = weight
-        self.name = name
-        self.img = img
-        self.pil_target = pil_target
-
-    # uh.... should the places this is beind used maybe just use Loss.__init__?
-    # TO DO: let's make this a class attribute on something
-
-    @property
-    def weight_category(self):
-        return self.weight_name.split("_")[0]
-
-    @property
-    def loss_factory(self):
-        weight_name = self.weight_category
-        if weight_name == "direct":
-            Loss = type(self.img).get_preferred_loss()
-        else:
-            Loss = self.LOSS_DICT[weight_name]
-        return Loss
+        optical_flow = TargetFlowLoss(
+            comp=torch.zeros(1, 1, 1, 1, device=_device),
+            weight=params.flow_stabilization_weight,
+            name="optical flow stabilization (direct)",
+            image_shape=img.image_shape,
+            device=_device,
+        )
+        optical_flow.set_enabled(False)
+        optical_flows.append(optical_flow)
 
-    def build_loss(self) -> Loss:
-        """
-        Given a weight name, weight, name, image, and target image, returns a loss object
+    loss_augs.extend(optical_flows)
 
-        :param weight_name: The name of the loss function
-        :param weight: The weight of the loss
-        :param name: The name of the loss function
-        :param img: The image to be optimized
-        :param pil_target: The target image
-        :return: The loss function.
-        """
-        Loss = self.loss_factory
-        out = Loss.TargetImage(
-            f"{self.weight_category} {self.name}:{self.weight}",
-            self.img.image_shape,
-            self.pil_target,
-        )
-        out.set_enabled(self.pil_target is not None)
-        return out
+    return img, loss_augs, optical_flows
 
 
 def _standardize_null(weight):
@@ -198,189 +177,3 @@ def _standardize_null(weight):
     if float(weight) == 0:
         weight = ""
     return weight
-
-
-class LossConfigurator:
-    """
-    Groups together procedures for initializing losses
-    """
-
-    def __init__(
-        self,
-        init_image_pil: Image.Image,
-        restore: bool,
-        img: PixelImage,
-        embedder,
-        prompts,
-        # params,
-        ########
-        direct_image_prompts,
-        semantic_stabilization_weight,
-        init_image,
-        semantic_init_weight,
-        animation_mode,
-        flow_stabilization_weight,
-        flow_long_term_samples,
-        smoothing_weight,
-        ###########
-        direct_init_weight,
-        direct_stabilization_weight,
-        depth_stabilization_weight,
-        edge_stabilization_weight,
-    ):
-        self.init_image_pil = init_image_pil
-        self.img = img
-        self.embedder = embedder
-        self.prompts = prompts
-
-        self.init_augs = []
-        self.loss_augs = []
-        self.optical_flows = []
-        self.last_frame_semantic = None
-        self.semantic_init_prompt = None
-
-        # self.params = params
-        self.restore = restore
-
-        ### params
-        self.direct_image_prompts = direct_image_prompts
-        self.semantic_stabilization_weight = _standardize_null(
-            semantic_stabilization_weight
-        )
-        self.init_image = init_image
-        self.semantic_init_weight = _standardize_null(semantic_init_weight)
-        self.animation_mode = animation_mode
-        self.flow_stabilization_weight = _standardize_null(flow_stabilization_weight)
-        self.flow_long_term_samples = flow_long_term_samples
-        self.smoothing_weight = _standardize_null(smoothing_weight)
-
-        ######
-        self.direct_init_weight = _standardize_null(direct_init_weight)
-        self.direct_stabilization_weight = _standardize_null(
-            direct_stabilization_weight
-        )
-        self.depth_stabilization_weight = _standardize_null(depth_stabilization_weight)
-        self.edge_stabilization_weight = _standardize_null(edge_stabilization_weight)
-
-    def process_direct_image_prompts(self):
-        # prompt parsing shouldn't go here.
-        self.loss_augs.extend(
-            type(self.img)
-            .get_preferred_loss()
-            .TargetImage(p.strip(), self.img.image_shape, is_path=True)
-            for p in self.direct_image_prompts.split("|")
-            if p.strip()
-        )
-
-    def process_semantic_stabilization(self):
-        last_frame_pil = self.init_image_pil
-        if not last_frame_pil:
-            last_frame_pil = self.img.decode_image()
-        self.last_frame_semantic = parse_prompt(
-            self.embedder,
-            f"stabilization:{self.semantic_stabilization_weight}",
-            last_frame_pil,
-        )
-        self.last_frame_semantic.set_enabled(self.init_image_pil is not None)
-        for scene in self.prompts:
-            scene.append(self.last_frame_semantic)
-
-    def configure_losses(self):
-        if self.init_image_pil is not None:
-            self.configure_init_image()
-        self.process_direct_image_prompts()
-        if self.semantic_stabilization_weight:
-            self.process_semantic_stabilization()
-        self.configure_stabilization_augs()
-        self.configure_optical_flows()
-        self.configure_aesthetic_losses()
-
-        return (
-            self.loss_augs,
-            self.init_augs,
-            self.stabilization_augs,
-            self.optical_flows,
-            self.semantic_init_prompt,
-            self.last_frame_semantic,
-            self.img,
-        )
-
-    def configure_init_image(self):
-
-        if not self.restore:
-            # move these logging statements into .encode_image()
-            logger.info("Encoding image...")
-            self.img.encode_image(self.init_image_pil)
-            logger.info("Encoded Image:")
-            # pretty sure this assumes we're in a notebook
-            display.display(self.img.decode_image())
-
-        ## wrap this for the flexibility that the loop is pretending to provide...
-        # set up init image prompt
-        if self.direct_init_weight:
-            init_aug = LossBuilder(
-                "direct_init_weight",
-                self.direct_init_weight,
-                f"init image ({self.init_image})",
-                self.img,
-                self.init_image_pil,
-            ).build_loss()
-            self.loss_augs.append(init_aug)
-            self.init_augs.append(init_aug)
-
-        ########
-        if self.semantic_init_weight:
-            self.semantic_init_prompt = parse_prompt(
-                self.embedder,
-                f"init image [{self.init_image}]:{self.semantic_init_weight}",
-                self.init_image_pil,
-            )
-            self.prompts[0].append(self.semantic_init_prompt)
-
-    # stabilization
-    def configure_stabilization_augs(self):
-        d_augs = {
-            "direct_stabilization_weight": self.direct_stabilization_weight,
-            "depth_stabilization_weight": self.depth_stabilization_weight,
-            "edge_stabilization_weight": self.edge_stabilization_weight,
-        }
-        stabilization_augs = [
-            LossBuilder(
-                k, v, "stabilization", self.img, self.init_image_pil
-            ).build_loss()
-            for k, v in d_augs.items()
-            if v
-        ]
-        self.stabilization_augs = stabilization_augs
-        self.loss_augs.extend(stabilization_augs)
-
-    def configure_optical_flows(self):
-        optical_flows = None
-
-        if self.animation_mode == "Video Source":
-            if self.flow_stabilization_weight == "":
-                self.flow_stabilization_weight = "0"
-            optical_flows = [
-                OpticalFlowLoss.TargetImage(
-                    f"optical flow stabilization (frame {-2**i}):{self.flow_stabilization_weight}",
-                    self.img.image_shape,
-                )
-                for i in range(self.flow_long_term_samples + 1)
-            ]
-
-        elif self.animation_mode == "3D" and self.flow_stabilization_weight:
-            optical_flows = [
-                TargetFlowLoss.TargetImage(
-                    f"optical flow stabilization:{self.flow_stabilization_weight}",
-                    self.img.image_shape,
-                )
-            ]
-
-        if optical_flows is not None:
-            for optical_flow in optical_flows:
-                optical_flow.set_enabled(False)
-            self.loss_augs.extend(optical_flows)
-
-    def configure_aesthetic_losses(self):
-        if self.smoothing_weight != 0:
-            self.loss_augs.append(TVLoss(weight=self.smoothing_weight))
diff --git a/src/pytti/LossAug/MSELossClass.py b/src/pytti/LossAug/MSELossClass.py
index ff1e5dc..8a1f33e 100644
--- a/src/pytti/LossAug/MSELossClass.py
+++ b/src/pytti/LossAug/MSELossClass.py
@@ -4,9 +4,9 @@
 from torch.nn import functional as F
 from pytti.LossAug.BaseLossClass import Loss
 
-# from pytti.Notebook import Rotoscoper
 from pytti.rotoscoper import Rotoscoper
-from pytti import fetch, parse, vram_usage_mode
+from pytti import fetch, vram_usage_mode
+from pytti.eval_tools import parse_subprompt
 import torch
 
 
@@ -30,37 +30,6 @@ def __init__(
         self.register_buffer("mask", torch.ones(1, 1, 1, 1, device=self.device))
         self.use_mask = False
 
-    @classmethod
-    @vram_usage_mode("Loss Augs")
-    @torch.no_grad()
-    def TargetImage(
-        cls, prompt_string, image_shape, pil_image=None, is_path=False, device=None
-    ):
-        # Why is this prompt parsing stuff here? Deprecate in favor of centralized
-        # parsing functions (if feasible)
-        text, weight, stop = parse(
-            prompt_string, r"(?<!^http)(?<!s):|:(?!/)", ["", "1", "-inf"]
-        )
-        weight, mask = parse(weight, r"_", ["1", ""])
-        text = text.strip()
-        mask = mask.strip()
-        if device is None:
-            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        if pil_image is None and text != "" and is_path:
-            pil_image = Image.open(fetch(text)).convert("RGB")
-            im = pil_image.resize(image_shape, Image.LANCZOS)
-            comp = cls.make_comp(im)
-        elif pil_image is None:
-            comp = torch.zeros(1, 1, 1, 1, device=device)
-        else:
-            im = pil_image.resize(image_shape, Image.LANCZOS)
-            comp = cls.make_comp(im)
-        if image_shape is None:
-            image_shape = pil_image.size
-        out = cls(comp, weight, stop, text + " (direct)", image_shape, device=device)
-        out.set_mask(mask)
-        return out
-
     @torch.no_grad()
     def set_mask(self, mask, inverted=False, device=None):
         if device is None:
@@ -89,6 +58,8 @@ def set_mask(self, mask, inverted=False, device=None):
     def convert_input(cls, input, img):
         return input
 
+    # Comp and mask should live on the image representation, not the loss class.
+    # comp for sure
     @classmethod
     def make_comp(cls, pil_image, device=None):
         if device is None:
diff --git a/src/pytti/LossAug/OpticalFlowLossClass.py b/src/pytti/LossAug/OpticalFlowLossClass.py
index 86e8998..0edc961 100644
--- a/src/pytti/LossAug/OpticalFlowLossClass.py
+++ b/src/pytti/LossAug/OpticalFlowLossClass.py
@@ -16,10 +16,8 @@
 import gma
 from gma.core.network import RAFTGMA
 
-# from gma.core.utils import flow_viz
 from gma.core.utils.utils import InputPadder
 
-# from pytti import fetch, to_pil, DEVICE, vram_usage_mode
 from pytti import fetch, vram_usage_mode
 from pytti.LossAug.MSELossClass import MSELoss
 from pytti.rotoscoper import Rotoscoper
@@ -65,7 +63,8 @@ def init_GMA(checkpoint_path=None, device=None):
         logger.debug(checkpoint_path)
     global GMA
     if device is None:
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
     if GMA is None:
         with vram_usage_mode("GMA"):
             # migrate this to a hydra initialize/compose operation
@@ -97,10 +96,21 @@ def init_GMA(checkpoint_path=None, device=None):
                 "--mixed_precision", action="store_true", help="use mixed precision"
             )
             args = parser.parse_args([])
-            GMA = torch.nn.DataParallel(RAFTGMA(args), device_ids=[device])
-            # GMA = RAFTGMA(args)
-            GMA.load_state_dict(torch.load(checkpoint_path))
-            GMA.to(device)
+
+            # create new OrderedDict that does not contain `module.` prefix
+            state_dict = torch.load(checkpoint_path, map_location=device)
+            from collections import OrderedDict
+
+            new_state_dict = OrderedDict()
+            for k, v in state_dict.items():
+                if k.startswith("module."):
+                    k = k[7:]  # remove `module.`
+                new_state_dict[k] = v
+
+            GMA = RAFTGMA(args)
+            GMA.load_state_dict(new_state_dict)
+            logger.debug("gma state_dict loaded")
+            GMA.to(device)  # redundant?
             GMA.eval()
 
 
@@ -187,7 +197,6 @@ def get_loss(self, input, img, device=None):
         if device is None:
             device = getattr(self, "device", self.device)
         init_GMA(
-            # "GMA/checkpoints/gma-sintel.pth"
             device=device,
         )  # update this to use model dir from config
         image1 = self.last_step
@@ -195,6 +204,9 @@ def get_loss(self, input, img, device=None):
         padder = InputPadder(image1.shape)
         image1, image2 = padder.pad(image1, image2)
         _, flow = GMA(image1, image2, iters=3, test_mode=True)
+        logger.debug(device)
+        logger.debug((flow.shape, flow.device))
+        logger.debug((self.comp.shape, self.comp.device))
         flow = flow.to(device, memory_format=torch.channels_last)
         return super().get_loss(TF.resize(flow, self.comp.shape[-2:]), img) / self.mag
 
@@ -205,9 +217,9 @@ class OpticalFlowLoss(MSELoss):
     def motion_edge_map(
         flow_forward,
         flow_backward,
-        img,  # is this even being used anywhere here?
-        border_mode="smear",
-        sampling_mode="bilinear",
+        img,  # unused
+        border_mode="smear",  # unused
+        sampling_mode="bilinear",  # unused
         device=None,
     ):
         """
@@ -298,7 +310,6 @@ def get_flow(image1, image2, device=None):
         """
         if device is None:
             device = "cuda" if torch.cuda.is_available() else "cpu"
-        # init_GMA("GMA/checkpoints/gma-sintel.pth")
         init_GMA(
             device=device,
         )
@@ -359,11 +370,9 @@ def set_flow(
             )
         logger.debug(device)
         if path is not None:
-            # img = img.clone()
             img = img.clone().to(device)
             if not isinstance(device, torch.device):
                 device = torch.device(device)
-            # logger.debug(device)
             state_dict = torch.load(path, map_location=device)
             img.load_state_dict(state_dict)
 
@@ -385,13 +394,9 @@ def set_flow(
         image1.add_(noise)
         image2.add_(noise)
 
-        # flow_forward = OpticalFlowLoss.get_flow(image1, image2)
-        # flow_backward = OpticalFlowLoss.get_flow(image2, image1)
-        # flow_forward = self.get_flow(image1, image2, device=device)
-        # flow_backward = self.get_flow(image2, image1, device=device)
         flow_forward = OpticalFlowLoss.get_flow(image1, image2, device=device)
         flow_backward = OpticalFlowLoss.get_flow(image2, image1, device=device)
-        unwarped_target_direct = img.decode_tensor()
+        unwarped_target_direct = img.decode_tensor()  # unused
         flow_target_direct = apply_flow(
             img, -flow_backward, border_mode=border_mode, sampling_mode=sampling_mode
         )
diff --git a/src/pytti/LossAug/__init__.py b/src/pytti/LossAug/__init__.py
index 51a6b98..3c185c0 100644
--- a/src/pytti/LossAug/__init__.py
+++ b/src/pytti/LossAug/__init__.py
@@ -8,10 +8,3 @@
 from pytti.LossAug.EdgeLossClass import EdgeLoss
 from pytti.LossAug.LatentLossClass import LatentLoss
 from pytti.LossAug.HSVLossClass import HSVLoss
-
-# from loguru import logger
-# logger.debug(dir(HSVLoss))
-# logger.debug(help(HSVLoss.TargetImage))
-
-# yeesh the ordering fragility in here...
-# TO DO: let's make this a class attribute on something
diff --git a/src/pytti/eval_tools.py b/src/pytti/eval_tools.py
index 944509a..4127076 100644
--- a/src/pytti/eval_tools.py
+++ b/src/pytti/eval_tools.py
@@ -86,3 +86,20 @@ def parse(string, split, defaults):
         tokens + defaults[len(tokens) :]
     )  # this is just a weird way to backfill defaults.
     return tokens
+
+
+from PIL import Image
+
+# cannibalized from TargetImage ... to do: make consistent with pytti.Prompt.parse_prompt()
+def parse_subprompt(prompt_string, is_path=False, pil_image=None):
+    text, weight, stop = parse(
+        prompt_string, r"(?<!^http)(?<!s):|:(?!/)", ["", "1", "-inf"]
+    )
+    weight, mask = parse(weight, r"_", ["1", ""])
+    text = text.strip()
+    mask = mask.strip()
+
+    if pil_image is None and text != "" and is_path:
+        pil_image = Image.open(fetch(text)).convert("RGB")
+
+    return text, weight, stop, mask, pil_image
diff --git a/src/pytti/image_models/pixel.py b/src/pytti/image_models/pixel.py
index 2816bd4..0beb892 100644
--- a/src/pytti/image_models/pixel.py
+++ b/src/pytti/image_models/pixel.py
@@ -1,9 +1,7 @@
-
 from pytti import DEVICE, named_rearrange, replace_grad, vram_usage_mode
 from pytti.image_models.differentiable_image import DifferentiableImage
 from pytti.LossAug.HSVLossClass import HSVLoss
 
-# from pytti.ImageGuide import DirectImageGuide
 import numpy as np
 import torch, math
 from torch import nn, optim
@@ -192,7 +190,6 @@ def __init__(
             .view(pallet_size, 1, 1)
             .repeat(1, n_pallets, 3)
         )
-        # pallet.set_(torch.rand_like(pallet)*self.pallet_inertia)
         self.pallet = nn.Parameter(pallet.to(self.device))
 
         self.pallet_size = pallet_size
@@ -430,7 +427,6 @@ def encode_image(self, pil_image, smart_encode=True, device=None):
         scale = self.scale
         color_ref = pil_image.resize((width // scale, height // scale), Image.LANCZOS)
         color_ref = TF.to_tensor(color_ref).to(device)
-        # value_ref = ImageOps.grayscale(color_ref)
         with torch.no_grad():
             # https://alienryderflex.com/hsp.html
             magic_color = self.pallet.new_tensor([[[0.299]], [[0.587]], [[0.114]]])
@@ -441,7 +437,13 @@ def encode_image(self, pil_image, smart_encode=True, device=None):
 
         # no embedder needed without any prompts
         if smart_encode:
-            mse = HSVLoss.TargetImage("HSV loss", self.image_shape, pil_image)
+            comp = HSVLoss.make_comp(pil_image)
+            mse = HSVLoss(
+                comp=comp,
+                name="HSV loss",
+                image_shape=self.image_shape,
+                device=device,
+            )
 
             if self.hdr_loss is not None:
                 before_weight = self.hdr_loss.weight.detach()
diff --git a/src/pytti/workhorse.py b/src/pytti/workhorse.py
index d579831..05c0763 100644
--- a/src/pytti/workhorse.py
+++ b/src/pytti/workhorse.py
@@ -42,6 +42,7 @@
 from pytti.ImageGuide import DirectImageGuide
 from pytti.Perceptor.Embedder import HDMultiClipEmbedder
 from pytti.Perceptor.Prompt import parse_prompt
+from pytti.eval_tools import parse_subprompt
 
 from pytti import (
     fetch,
@@ -51,7 +52,7 @@
     vram_profiling,
 )
 from pytti.LossAug.DepthLossClass import init_AdaBins
-from pytti.LossAug.LossOrchestratorClass import LossConfigurator
+
 
 logger.info("pytti loaded.")
 
@@ -67,7 +68,6 @@
 
 
 TB_LOGDIR = "logs"  # to do: make this more easily configurable
-# writer = SummaryWriter(TB_LOGDIR)
 OUTPATH = f"{os.getcwd()}/images_out/"
 
 #######################################################
@@ -78,24 +78,7 @@
     configure_optical_flows,
 )
 
-#######################################################
-
-# To do: ove remaining gunk into this...
-# class Renderer:
-#    """
-#    High-level orchestrator for pytti rendering procedure.
-#    """
-#
-#    def __init__(self, params):
-#        pass
-
-
-# this is the only place `parse_prompt` is invoked.
-# combine load_scenes, parse_prompt, and parse into a unified, generic parser.
-# generic here means the output of the parsing process shouldn't be bound to
-# modules yet, just a collection of settings.
-#
-# ...actually, parse_prompt is invoked in loss orchestration
+# move this with the other "prompt" functions...
 def parse_scenes(
     embedder,
     scenes,
@@ -173,8 +156,6 @@ def load_video_source(
     pre_animation_steps = max(steps_per_frame, pre_animation_steps)
     if init_image_pil is None:
         init_image_pil = Image.fromarray(video_frames.get_data(0)).convert("RGB")
-        # enhancer = ImageEnhance.Contrast(init_image_pil)
-        # init_image_pil = enhancer.enhance(2)
         init_size = init_image_pil.size
         if width == -1:
             width = int(height * init_size[0] / init_size[1])
@@ -185,7 +166,6 @@ def load_video_source(
 
 @hydra.main(config_path="config", config_name="default")
 def _main(cfg: DictConfig):
-    # params = OmegaConf.to_container(cfg, resolve=True)
     params = cfg
 
     if torch.cuda.is_available():
@@ -197,7 +177,7 @@ def _main(cfg: DictConfig):
         with open_dict(params) as p:
             p.device = _device
     logger.debug(f"Using device {_device}")
-    torch.cuda.set_device(_device)
+    # torch.cuda.set_device(_device)
 
     # literal "off" in yaml interpreted as False
     if params.animation_mode == False:
@@ -211,15 +191,12 @@ def _main(cfg: DictConfig):
     if params.use_tensorboard:
         writer = SummaryWriter(TB_LOGDIR)
 
-    batch_mode = False  # @param{type:"boolean"}
+    batch_mode = False
 
     ### Move these into default.yaml
-    # @markdown check `restore` to restore from a previous run
-    restore = params.get("restore") or False  # @param{type:"boolean"}
-    # @markdown check `reencode` if you are restoring with a modified image or modified image settings
-    reencode = False  # @param{type:"boolean"}
-    # @markdown which run to restore
-    restore_run = latest  # @param{type:"raw"}
+    restore = params.get("restore") or False
+    reencode = False
+    restore_run = latest  # which run to restore
 
     # NB: `backup/` dir probably not working at present
     if restore and restore_run == latest:
@@ -233,13 +210,10 @@ def do_run():
 
         # Phase 1 - reset state
         ########################
-        # clear_rotoscopers()  # what a silly name
         ROTOSCOPERS.clear_rotoscopers()
         vram_profiling(params.approximate_vram_usage)
         reset_vram_usage()
-        # global CLIP_MODEL_NAMES  # we don't do anything with this...
-        # @markdown which frame to restore from
-        restore_frame = latest  # @param{type:"raw"}
+        restore_frame = latest  # which frame to restore from
 
         # set up seed for deterministic RNG
         if params.seed is not None:
@@ -384,13 +358,32 @@ def do_run():
 
         # other image prompts
 
-        loss_augs.extend(
-            type(img)
-            .get_preferred_loss()
-            .TargetImage(p.strip(), img.image_shape, is_path=True)
-            for p in params.direct_image_prompts.split("|")
-            if p.strip()
-        )
+        # uh... I'm not sure I actually test direct_image_prompts anywhere. ah well. fuck it.
+        for p in params.direct_image_prompts.split("|"):
+            prompt_string = p.strip()
+            if prompt_string:
+                loss_factory = type(img).get_preferred_loss()
+                text, weight, stop, mask, pil_image = parse_subprompt(
+                    prompt_string,
+                    is_path=True,
+                    pil_image=init_image_pil,
+                )
+                image_shape = img.image_shape
+                if pil_image:
+                    im = pil_image.resize(image_shape, Image.LANCZOS)
+                    comp = loss_factory.make_comp(im)
+                else:
+                    comp = torch.zeros(1, 1, 1, 1, device=_device)
+
+                if image_shape is None:
+                    image_shape = pil_image.size
+                out = loss_factory(
+                    comp, weight, stop, text + " (direct)", image_shape, device=_device
+                )
+                out.set_mask(mask)
+                loss_augs.append(out)
+
+        ###############################
 
         # stabilization
         (
@@ -421,41 +414,6 @@ def do_run():
         # optical flow
         img, loss_augs, optical_flows = configure_optical_flows(img, params, loss_augs)
 
-        # # set up losses
-        # loss_orch = LossConfigurator(
-        #     init_image_pil=init_image_pil,
-        #     restore=restore,
-        #     img=img,
-        #     embedder=embedder,
-        #     prompts=prompts,
-        #     # params=params,
-        #     ########
-        #     # To do: group arguments into param groups
-        #     animation_mode=params.animation_mode,
-        #     init_image=params.init_image,
-        #     direct_image_prompts=params.direct_image_prompts,
-        #     semantic_init_weight=params.semantic_init_weight,
-        #     semantic_stabilization_weight=params.semantic_stabilization_weight,
-        #     flow_stabilization_weight=params.flow_stabilization_weight,
-        #     flow_long_term_samples=params.flow_long_term_samples,
-        #     smoothing_weight=params.smoothing_weight,
-        #     ###########
-        #     direct_init_weight=params.direct_init_weight,
-        #     direct_stabilization_weight=params.direct_stabilization_weight,
-        #     depth_stabilization_weight=params.depth_stabilization_weight,
-        #     edge_stabilization_weight=params.edge_stabilization_weight,
-        # )
-
-        # (
-        #     loss_augs,
-        #     init_augs,
-        #     stabilization_augs,
-        #     optical_flows,
-        #     semantic_init_prompt,
-        #     last_frame_semantic,
-        #     img,
-        # ) = loss_orch.configure_losses()
-
         # Phase 4 - setup outputs
         ##########################
 
diff --git a/tests/test_loss_refactoring.py b/tests/test_loss_refactoring.py
new file mode 100644
index 0000000..1709180
--- /dev/null
+++ b/tests/test_loss_refactoring.py
@@ -0,0 +1,124 @@
+import pytest
+
+from hydra import initialize, compose
+from loguru import logger
+from pytti.workhorse import _main as render_frames
+from omegaconf import OmegaConf, open_dict
+import torch
+from pathlib import Path
+
+CONFIG_BASE_PATH = "config"
+CONFIG_DEFAULTS = "default.yaml"
+
+TEST_DEVICE = "cuda:0"  # "cuda:1"
+
+
+video_fpath = str(next(Path(".").glob("**/assets/*.mp4")))
+img_fpath = str(next(Path(".").glob("**/src/pytti/assets/*.jpg")))
+
+
+def run_cfg(cfg_str):
+    with initialize(config_path=CONFIG_BASE_PATH):
+        cfg_base = compose(
+            config_name=CONFIG_DEFAULTS,
+            overrides=[f"conf=_empty"],
+        )
+        cfg_this = OmegaConf.create(cfg_str)
+
+        with open_dict(cfg_base) as cfg:
+            cfg = OmegaConf.merge(cfg_base, cfg_this)
+        render_frames(cfg)
+
+
+# @pytest.mark.skipif(torch.cuda.device_count() < 2, reason="requires multiple-GPUs")
+def test_direct_init_weight():
+    cfg_str = f"""# @package _global_
+scenes: a photograph of an apple
+direct_image_prompts: '{img_fpath}:-1:-.5'
+direct_init_weight: 1
+semantic_iniit_weight: 1
+device: '{TEST_DEVICE}'
+"""
+    run_cfg(cfg_str)
+
+
+def test_stabilization_weights():
+    cfg_str = f"""# @package _global_
+scenes: a photograph of an apple
+depth_stabilization_weight: 1
+edge_stabilization_weight: 1
+direct_stabilization_weight: 1
+semantic_stabilization_weight: 1
+flow_stabilization_weight: 1
+steps_per_frame: 10
+steps_per_scene: 150
+#flow_long_term_samples: 1
+device: '{TEST_DEVICE}'
+"""
+    run_cfg(cfg_str)
+
+
+def test_limited_palette_image_encode():
+    cfg_str = f"""# @package _global_
+scenes: a photograph of an apple
+direct_image_prompts: '{img_fpath}:-1:-.5'
+direct_init_weight: 1
+semantic_iniit_weight: 1
+image_model: Limited Palette
+device: '{TEST_DEVICE}'
+"""
+    run_cfg(cfg_str)
+
+
+def test_video_optical_flow():
+    cfg_str = f"""# @package _global_
+scenes: a photograph of an apple
+animation_mode: Video Source
+video_path: {video_fpath}
+flow_stabilization_weight: 1
+steps_per_frame: 10
+steps_per_scene: 150
+flow_long_term_samples: 3
+device: '{TEST_DEVICE}'
+height: 512
+width: 512
+pixel_size: 1
+"""
+    run_cfg(cfg_str)
+
+
+def test_3D_optical_flow():
+    cfg_str = f"""# @package _global_
+scenes: a photograph of an apple
+animation_mode: 3D
+video_path: {video_fpath}
+flow_stabilization_weight: 1
+steps_per_frame: 10
+steps_per_scene: 150
+device: '{TEST_DEVICE}'
+height: 512
+width: 512
+pixel_size: 1
+translate_z_3d: 10
+"""
+    run_cfg(cfg_str)
+
+
+# RuntimeError: CUDA error: device-side assert triggered
+@pytest.mark.xfail
+def test_3d_null_transform_bug():
+    cfg_str = f"""# @package _global_
+scenes: a photograph of an apple
+animation_mode: 3D
+video_path: {video_fpath}
+flow_stabilization_weight: 1
+steps_per_frame: 10
+steps_per_scene: 150
+device: '{TEST_DEVICE}'
+height: 512
+width: 512
+pixel_size: 1
+translate_z_3d: 0
+rotate_3d: [1,0,0,0]
+"""
+    run_cfg(cfg_str)