diff --git a/include/openmc/random_ray/flat_source_domain.h b/include/openmc/random_ray/flat_source_domain.h
index 0d4086966dd..33d62ce1035 100644
--- a/include/openmc/random_ray/flat_source_domain.h
+++ b/include/openmc/random_ray/flat_source_domain.h
@@ -40,9 +40,10 @@ class FlatSourceDomain {
   void random_ray_tally();
   virtual void accumulate_iteration_flux();
   void output_to_vtk() const;
-  void convert_external_sources();
+  void convert_external_sources(bool use_adjoint_sources);
   void count_external_source_regions();
-  void set_adjoint_sources();
+  void set_fw_adjoint_sources();
+  void set_local_adjoint_sources();
   void flux_swap();
   virtual double evaluate_flux_at_point(Position r, int64_t sr, int g) const;
   double compute_fixed_source_normalization_factor() const;
@@ -76,6 +77,7 @@ class FlatSourceDomain {
   // Static Data members
   static bool volume_normalized_flux_tallies_;
   static bool adjoint_; // If the user wants outputs based on the adjoint flux
+  static bool cadis_;
   static double
     diagonal_stabilization_rho_; // Adjusts strength of diagonal stabilization
                                  // for transport corrected MGXS data
@@ -84,6 +86,8 @@ class FlatSourceDomain {
   static std::unordered_map<int, vector<std::pair<Source::DomainType, int>>>
     mesh_domain_map_;
 
+  static std::vector<size_t> cadis_targets_;
+
   //----------------------------------------------------------------------------
   // Static data members
   static RandomRayVolumeEstimator volume_estimator_;
diff --git a/include/openmc/random_ray/random_ray_simulation.h b/include/openmc/random_ray/random_ray_simulation.h
index 3db6510697c..c783f8ce5f8 100644
--- a/include/openmc/random_ray/random_ray_simulation.h
+++ b/include/openmc/random_ray/random_ray_simulation.h
@@ -19,9 +19,10 @@ class RandomRaySimulation {
 
   //----------------------------------------------------------------------------
   // Methods
+  void compute_segment_correction_factors();
   void apply_fixed_sources_and_mesh_domains();
-  void prepare_fixed_sources_adjoint();
-  void prepare_adjoint_simulation();
+  void prepare_fw_fixed_sources_adjoint();
+  void prepare_local_fixed_sources_adjoint();
   void simulate();
   void output_simulation_results() const;
   void instability_check(
@@ -34,15 +35,9 @@ class RandomRaySimulation {
   // Accessors
   FlatSourceDomain* domain() const { return domain_.get(); }
 
-  //----------------------------------------------------------------------------
-  // Public data members
-
-  // Flag for adjoint simulation;
-  bool adjoint_needed_;
-
 private:
   //----------------------------------------------------------------------------
-  // Private data members
+  // Data members
 
   // Contains all flat source region data
   unique_ptr<FlatSourceDomain> domain_;
@@ -57,9 +52,6 @@ class RandomRaySimulation {
   // Number of energy groups
   int negroups_;
 
-  // Toggle for first simulation
-  bool is_first_simulation_;
-
 }; // class RandomRaySimulation
 
 //============================================================================
@@ -69,7 +61,6 @@ class RandomRaySimulation {
 void openmc_run_random_ray();
 void validate_random_ray_inputs();
 void openmc_reset_random_ray();
-void print_adjoint_header();
 
 } // namespace openmc
 
diff --git a/include/openmc/source.h b/include/openmc/source.h
index 36c821fc07c..c36d2464bd7 100644
--- a/include/openmc/source.h
+++ b/include/openmc/source.h
@@ -34,6 +34,7 @@ class Source;
 namespace model {
 
 extern vector<unique_ptr<Source>> external_sources;
+extern vector<unique_ptr<Source>> adjoint_sources;
 
 // Probability distribution for selecting external sources
 extern DiscreteIndex external_sources_probability;
diff --git a/include/openmc/weight_windows.h b/include/openmc/weight_windows.h
index 7638155228e..c21200440fd 100644
--- a/include/openmc/weight_windows.h
+++ b/include/openmc/weight_windows.h
@@ -17,7 +17,7 @@
 
 namespace openmc {
 
-enum class WeightWindowUpdateMethod { MAGIC, FW_CADIS };
+enum class WeightWindowUpdateMethod { MAGIC, FW_CADIS, CADIS };
 
 //==============================================================================
 // Constants
@@ -235,6 +235,9 @@ class WeightWindowsGenerator {
   double threshold_ {1.0}; //<! Relative error threshold for values used to
                            // update weight windows
   double ratio_ {5.0};     //<! ratio of lower to upper weight window bounds
+
+  // CADIS target tallies
+  std::vector<size_t> targets_;
 };
 
 //! Finalize variance reduction objects after all inputs have been read
diff --git a/openmc/model/model.py b/openmc/model/model.py
index 90b43f9f74f..0935cd73df6 100644
--- a/openmc/model/model.py
+++ b/openmc/model/model.py
@@ -265,6 +265,37 @@ def add_kinetics_parameters_tallies(self, num_groups: int | None = None):
             denom_tally = openmc.Tally(name='IFP denominator')
             denom_tally.scores = ['ifp-denominator']
             self.tallies.append(denom_tally)
+    
+    # TODO: This should also be incorporated into lower-level calls in 
+    # settings.py, but it requires information about the tallies currently
+    # on the active Model
+    def _assign_cadis_tally_IDs(self):
+        # Verify that all tallies assigned as targets on WeightWindowGenerators 
+        # exist within model.tallies. If this is the case, convert the .targets 
+        # attribute of each WeightWindowGenerator to a sequence of tally IDs.
+        if len(self.settings.weight_window_generators) == 0:
+            return
+        
+        for wwg in self.settings.weight_window_generators:
+            # Only proceeds if the "targets" attribute is an openmc.Tallies, 
+            # which means it hasn't been checked against model.tallies.
+            if isinstance(wwg.targets, openmc.Tallies):
+                id_vec = []
+                for tal in wwg.targets:
+                    # check against model tallies
+                    id_next = None
+                    for reference_tal in self.tallies:
+                        if tal == reference_tal:
+                            id_next = reference_tal.id
+                            break
+                    
+                    if id_next == None:
+                        raise RuntimeError(
+                            f'CADIS target tally {tal.id} not found on model.tallies!')
+                    else:
+                        id_vec.append(id_next)
+
+                wwg.targets = id_vec
 
     @classmethod
     def from_xml(
@@ -576,6 +607,7 @@ def export_to_xml(self, directory: PathLike = '.', remove_surfs: bool = False,
         if not d.is_dir():
             d.mkdir(parents=True, exist_ok=True)
 
+        self._assign_cadis_tally_IDs()
         self.settings.export_to_xml(d)
         self.geometry.export_to_xml(d, remove_surfs=remove_surfs)
 
@@ -634,6 +666,9 @@ def export_to_model_xml(self, path: PathLike = 'model.xml', remove_surfs: bool =
                           "set the Geometry.merge_surfaces attribute instead.")
             self.geometry.merge_surfaces = True
 
+        # Link CADIS WeightWindowGenerator target tallies, if present
+        self._assign_cadis_tally_IDs()
+
         # provide a memo to track which meshes have been written
         mesh_memo = set()
         settings_element = self.settings.to_xml_element(mesh_memo)
diff --git a/openmc/settings.py b/openmc/settings.py
index 3cf662e311e..74fd4ca5f1a 100644
--- a/openmc/settings.py
+++ b/openmc/settings.py
@@ -225,6 +225,9 @@ class Settings:
             stabilization, which may be desirable as stronger diagonal stabilization
             also tends to dampen the convergence rate of the solver, thus requiring
             more iterations to converge.
+        :adjoint_source:
+            Source object used to define localized adjoint source/detector response 
+            function.
 
         .. versionadded:: 0.15.0
     resonance_scattering : dict
@@ -1356,6 +1359,8 @@ def random_ray(self, random_ray: dict):
                 cv.check_type('diagonal stabilization rho', value, Real)
                 cv.check_greater_than('diagonal stabilization rho',
                                       value, 0.0, True)
+            elif key == 'adjoint_source':
+                cv.check_type('adjoint source', value, SourceBase)
             else:
                 raise ValueError(f'Unable to set random ray to "{key}" which is '
                                  'unsupported by OpenMC')
@@ -1887,11 +1892,12 @@ def _create_random_ray_subelement(self, root, mesh_memo=None):
             element = ET.SubElement(root, "random_ray")
             for key, value in self._random_ray.items():
                 if key == 'ray_source' and isinstance(value, SourceBase):
+                    subelement = ET.SubElement(element, 'ray_source')
                     source_element = value.to_xml_element()
                     if source_element.find('bias') is not None:
                         raise RuntimeError(
                             "Ray source distributions should not be biased.")
-                    element.append(source_element)
+                    subelement.append(source_element)
 
                 elif key == 'source_region_meshes':
                     subelement = ET.SubElement(element, 'source_region_meshes')
@@ -1909,8 +1915,12 @@ def _create_random_ray_subelement(self, root, mesh_memo=None):
                         path = f"./mesh[@id='{mesh.id}']"
                         if root.find(path) is None:
                             root.append(mesh.to_xml_element())
-                            if mesh_memo is not None:
+                            if mesh_memo is not None:    
                                 mesh_memo.add(mesh.id)
+                elif key == 'adjoint_source' and isinstance(value, SourceBase):
+                    subelement = ET.SubElement(element, 'adjoint_source')
+                    adj_source_element = value.to_xml_element()
+                    subelement.append(adj_source_element)
                 elif isinstance(value, bool):
                     subelement = ET.SubElement(element, key)
                     subelement.text = str(value).lower()
@@ -2337,8 +2347,9 @@ def _random_ray_from_xml_element(self, root, meshes=None):
             for child in elem:
                 if child.tag in ('distance_inactive', 'distance_active', 'diagonal_stabilization_rho'):
                     self.random_ray[child.tag] = float(child.text)
-                elif child.tag == 'source':
-                    source = SourceBase.from_xml_element(child)
+                elif child.tag == 'ray_source':
+                    source_element = child.find('source')
+                    source = SourceBase.from_xml_element(source_element)
                     if child.find('bias') is not None:
                         raise RuntimeError(
                             "Ray source distributions should not be biased.")
@@ -2355,6 +2366,11 @@ def _random_ray_from_xml_element(self, root, meshes=None):
                     self.random_ray['adjoint'] = (
                         child.text in ('true', '1')
                     )
+                elif child.tag == 'adjoint_source':
+                    for subelem in child.findall('source'):
+                        src = SourceBase.from_xml_element(subelem)
+                        # add newly constructed source object to the list
+                        self.random_ray['adjoint_source'].append(src)
                 elif child.tag == 'sample_method':
                     self.random_ray['sample_method'] = child.text
                 elif child.tag == 'source_region_meshes':
diff --git a/openmc/tallies.py b/openmc/tallies.py
index 74d4722af47..13ad1e57452 100644
--- a/openmc/tallies.py
+++ b/openmc/tallies.py
@@ -16,6 +16,23 @@
 
 import openmc
 import openmc.checkvalue as cv
+from openmc.filter import (
+    Filter, 
+    DistribcellFilter, 
+    EnergyFunctionFilter, 
+    DelayedGroupFilter, 
+    FilterMeta, 
+    MeshFilter,
+    MeshBornFilter,
+)
+from openmc.arithmetic import (
+    CrossFilter, 
+    AggregateFilter,
+    CrossScore,
+    AggregateScore,
+    CrossNuclide,
+    AggregateNuclide,
+)
 from ._sparse_compat import lil_array
 from ._xml import clean_indentation, get_elem_list, get_text
 from .mixin import IDManagerMixin
@@ -31,9 +48,9 @@
 
 # The following indicate acceptable types when setting Tally.scores,
 # Tally.nuclides, and Tally.filters
-_SCORE_CLASSES = (str, openmc.CrossScore, openmc.AggregateScore)
-_NUCLIDE_CLASSES = (str, openmc.CrossNuclide, openmc.AggregateNuclide)
-_FILTER_CLASSES = (openmc.Filter, openmc.CrossFilter, openmc.AggregateFilter)
+_SCORE_CLASSES = (str, CrossScore, AggregateScore)
+_NUCLIDE_CLASSES = (str, CrossNuclide, AggregateNuclide)
+_FILTER_CLASSES = (Filter, CrossFilter, AggregateFilter)
 
 # Valid types of estimators
 ESTIMATOR_TYPES = {'tracklength', 'collision', 'analog'}
@@ -394,7 +411,7 @@ def _read_results(self):
             self._num_realizations = int(group['n_realizations'][()])
 
             for filt in self.filters:
-                if isinstance(filt, openmc.DistribcellFilter):
+                if isinstance(filt, DistribcellFilter):
                     filter_group = f[f'tallies/filters/filter {filt.id}']
                     filt._num_bins = int(filter_group['n_bins'][()])
 
@@ -1062,8 +1079,8 @@ def _can_merge_filters(self, other):
             return False
 
         # Return False if only one tally has a delayed group filter
-        tally1_dg = self.contains_filter(openmc.DelayedGroupFilter)
-        tally2_dg = other.contains_filter(openmc.DelayedGroupFilter)
+        tally1_dg = self.contains_filter(DelayedGroupFilter)
+        tally2_dg = other.contains_filter(DelayedGroupFilter)
         if tally1_dg != tally2_dg:
             return False
 
@@ -1575,7 +1592,7 @@ def find_filter(self, filter_type):
 
             # Also check to see if the desired filter is wrapped up in an
             # aggregate
-            elif isinstance(test_filter, openmc.AggregateFilter):
+            elif isinstance(test_filter, AggregateFilter):
                 if isinstance(test_filter.aggregate_filter, filter_type):
                     return test_filter
 
@@ -1677,7 +1694,7 @@ def get_filter_indices(self, filters=[], filter_bins=[]):
 
         """
 
-        cv.check_type('filters', filters, Iterable, openmc.FilterMeta)
+        cv.check_type('filters', filters, Iterable, FilterMeta)
         cv.check_type('filter_bins', filter_bins, Iterable, tuple)
 
         # If user did not specify any specific Filters, use them all
@@ -1760,7 +1777,7 @@ def get_score_indices(self, scores):
         """
 
         for score in scores:
-            if not isinstance(score, (str, openmc.CrossScore)):
+            if not isinstance(score, (str, CrossScore)):
                 msg = f'Unable to get score indices for score "{score}" in ' \
                       f'ID="{self.id}" since it is not a string or CrossScore ' \
                       'Tally'
@@ -1957,9 +1974,9 @@ def get_pandas_dataframe(self, filters=True, nuclides=True, scores=True,
             column_name = 'score'
 
             for score in self.scores:
-                if isinstance(score, (str, openmc.CrossScore)):
+                if isinstance(score, (str, CrossScore)):
                     scores.append(str(score))
-                elif isinstance(score, openmc.AggregateScore):
+                elif isinstance(score, AggregateScore):
                     scores.append(score.name)
                     column_name = f'{score.aggregate_op}(score)'
 
@@ -2059,7 +2076,7 @@ def get_reshaped_data(self, value='mean', expand_dims=False):
         for i, f in enumerate(self.filters):
             if expand_dims:
                 # Mesh filter indices are backwards so we need to flip them
-                if type(f) in {openmc.MeshFilter, openmc.MeshBornFilter}:
+                if type(f) in {MeshFilter, MeshBornFilter}:
                     fshape = f.shape[::-1]
                     new_shape += fshape
                     idx0, idx1 = i, i + len(fshape) - 1
@@ -2246,7 +2263,7 @@ def hybrid_product(self, other, binary_op, filter_product=None,
         else:
             all_filters = [self_copy.filters, other_copy.filters]
             for self_filter, other_filter in product(*all_filters):
-                new_filter = openmc.CrossFilter(self_filter, other_filter,
+                new_filter = CrossFilter(self_filter, other_filter,
                                                 binary_op)
                 new_tally.filters.append(new_filter)
 
@@ -2257,7 +2274,7 @@ def hybrid_product(self, other, binary_op, filter_product=None,
         else:
             all_nuclides = [self_copy.nuclides, other_copy.nuclides]
             for self_nuclide, other_nuclide in product(*all_nuclides):
-                new_nuclide = openmc.CrossNuclide(self_nuclide, other_nuclide,
+                new_nuclide = CrossNuclide(self_nuclide, other_nuclide,
                                                   binary_op)
                 new_tally.nuclides.append(new_nuclide)
 
@@ -2268,9 +2285,9 @@ def cross_score(score1, score2, binary_op):
                 if score1 == score2:
                     return score1
                 else:
-                    return openmc.CrossScore(score1, score2, binary_op)
+                    return CrossScore(score1, score2, binary_op)
             else:
-                return openmc.CrossScore(score1, score2, binary_op)
+                return CrossScore(score1, score2, binary_op)
 
         # Add scores to the new tally
         if score_product == 'entrywise':
@@ -2479,16 +2496,16 @@ def _swap_filters(self, filter1, filter2):
 
         # Construct lists of tuples for the bins in each of the two filters
         filters = [type(filter1), type(filter2)]
-        if isinstance(filter1, openmc.DistribcellFilter):
+        if isinstance(filter1, DistribcellFilter):
             filter1_bins = [b for b in range(filter1.num_bins)]
-        elif isinstance(filter1, openmc.EnergyFunctionFilter):
+        elif isinstance(filter1, EnergyFunctionFilter):
             filter1_bins = [None]
         else:
             filter1_bins = filter1.bins
 
-        if isinstance(filter2, openmc.DistribcellFilter):
+        if isinstance(filter2, DistribcellFilter):
             filter2_bins = [b for b in range(filter2.num_bins)]
-        elif isinstance(filter2, openmc.EnergyFunctionFilter):
+        elif isinstance(filter2, EnergyFunctionFilter):
             filter2_bins = [None]
         else:
             filter2_bins = filter2.bins
@@ -2621,11 +2638,11 @@ def _swap_scores(self, score1, score2):
             raise ValueError(msg)
 
         # Check that the scores are valid
-        if not isinstance(score1, (str, openmc.CrossScore)):
+        if not isinstance(score1, (str, CrossScore)):
             msg = 'Unable to swap score1 "{}" in Tally ID="{}" since it is ' \
                   'not a string or CrossScore'.format(score1, self.id)
             raise ValueError(msg)
-        elif not isinstance(score2, (str, openmc.CrossScore)):
+        elif not isinstance(score2, (str, CrossScore)):
             msg = 'Unable to swap score2 "{}" in Tally ID="{}" since it is ' \
                   'not a string or CrossScore'.format(score2, self.id)
             raise ValueError(msg)
@@ -3269,7 +3286,7 @@ def get_slice(self, scores=[], filters=[], filter_bins=[], nuclides=[],
                 new_filter.bins = [f.bins[i] for i in bin_indices]
 
                 # Set number of bins manually for mesh/distribcell filters
-                if filter_type is openmc.DistribcellFilter:
+                if filter_type is DistribcellFilter:
                     new_filter._num_bins = f._num_bins
 
                 # Replace existing filter with new one
@@ -3335,16 +3352,16 @@ def summation(self, scores=[], filter_type=None,
         std_dev = self.get_reshaped_data(value='std_dev')
 
         # Sum across any filter bins specified by the user
-        if isinstance(filter_type, openmc.FilterMeta):
+        if isinstance(filter_type, FilterMeta):
             find_filter = self.find_filter(filter_type)
 
             # If user did not specify filter bins, sum across all bins
             if len(filter_bins) == 0:
                 bin_indices = np.arange(find_filter.num_bins)
 
-                if isinstance(find_filter, openmc.DistribcellFilter):
+                if isinstance(find_filter, DistribcellFilter):
                     filter_bins = np.arange(find_filter.num_bins)
-                elif isinstance(find_filter, openmc.EnergyFunctionFilter):
+                elif isinstance(find_filter, EnergyFunctionFilter):
                     filter_bins = [None]
                 else:
                     filter_bins = find_filter.bins
@@ -3373,7 +3390,7 @@ def summation(self, scores=[], filter_type=None,
 
                     # Add AggregateFilter to the tally sum
                     if not remove_filter:
-                        filter_sum = openmc.AggregateFilter(self_filter,
+                        filter_sum = AggregateFilter(self_filter,
                             [tuple(filter_bins)], 'sum')
                         tally_sum.filters.append(filter_sum)
 
@@ -3396,7 +3413,7 @@ def summation(self, scores=[], filter_type=None,
             std_dev = np.sqrt(std_dev)
 
             # Add AggregateNuclide to the tally sum
-            nuclide_sum = openmc.AggregateNuclide(nuclides, 'sum')
+            nuclide_sum = AggregateNuclide(nuclides, 'sum')
             tally_sum.nuclides.append(nuclide_sum)
 
         # Add a copy of this tally's nuclides to the tally sum
@@ -3414,7 +3431,7 @@ def summation(self, scores=[], filter_type=None,
             std_dev = np.sqrt(std_dev)
 
             # Add AggregateScore to the tally sum
-            score_sum = openmc.AggregateScore(scores, 'sum')
+            score_sum = AggregateScore(scores, 'sum')
             tally_sum.scores.append(score_sum)
 
         # Add a copy of this tally's scores to the tally sum
@@ -3487,16 +3504,16 @@ def average(self, scores=[], filter_type=None,
         std_dev = self.get_reshaped_data(value='std_dev')
 
         # Average across any filter bins specified by the user
-        if isinstance(filter_type, openmc.FilterMeta):
+        if isinstance(filter_type, FilterMeta):
             find_filter = self.find_filter(filter_type)
 
             # If user did not specify filter bins, average across all bins
             if len(filter_bins) == 0:
                 bin_indices = np.arange(find_filter.num_bins)
 
-                if isinstance(find_filter, openmc.DistribcellFilter):
+                if isinstance(find_filter, DistribcellFilter):
                     filter_bins = np.arange(find_filter.num_bins)
-                elif isinstance(find_filter, openmc.EnergyFunctionFilter):
+                elif isinstance(find_filter, EnergyFunctionFilter):
                     filter_bins = [None]
                 else:
                     filter_bins = find_filter.bins
@@ -3526,7 +3543,7 @@ def average(self, scores=[], filter_type=None,
 
                     # Add AggregateFilter to the tally avg
                     if not remove_filter:
-                        filter_sum = openmc.AggregateFilter(self_filter,
+                        filter_sum = AggregateFilter(self_filter,
                             [tuple(filter_bins)], 'avg')
                         tally_avg.filters.append(filter_sum)
 
@@ -3550,7 +3567,7 @@ def average(self, scores=[], filter_type=None,
             std_dev = np.sqrt(std_dev)
 
             # Add AggregateNuclide to the tally avg
-            nuclide_avg = openmc.AggregateNuclide(nuclides, 'avg')
+            nuclide_avg = AggregateNuclide(nuclides, 'avg')
             tally_avg.nuclides.append(nuclide_avg)
 
         # Add a copy of this tally's nuclides to the tally avg
@@ -3569,7 +3586,7 @@ def average(self, scores=[], filter_type=None,
             std_dev = np.sqrt(std_dev)
 
             # Add AggregateScore to the tally avg
-            score_sum = openmc.AggregateScore(scores, 'avg')
+            score_sum = AggregateScore(scores, 'avg')
             tally_avg.scores.append(score_sum)
 
         # Add a copy of this tally's scores to the tally avg
@@ -3759,7 +3776,7 @@ def _create_mesh_subelements(self, root_element, memo=None):
         already_written = memo if memo else set()
         for tally in self:
             for f in tally.filters:
-                if isinstance(f, openmc.MeshFilter):
+                if isinstance(f, MeshFilter):
                     if f.mesh.id in already_written:
                         continue
                     if len(f.mesh.name) > 0:
@@ -3854,7 +3871,7 @@ def from_xml_element(cls, elem, meshes=None):
         # Read filter elements
         filters = {}
         for e in elem.findall('filter'):
-            filter = openmc.Filter.from_xml_element(e, meshes=meshes)
+            filter = Filter.from_xml_element(e, meshes=meshes)
             filters[filter.id] = filter
 
         # Read derivative elements
diff --git a/openmc/weight_windows.py b/openmc/weight_windows.py
index 5d52a579a11..221fa718217 100644
--- a/openmc/weight_windows.py
+++ b/openmc/weight_windows.py
@@ -12,6 +12,7 @@
 import openmc
 from openmc.filter import _PARTICLES
 from openmc.mesh import MeshBase, RectilinearMesh, CylindricalMesh, SphericalMesh, UnstructuredMesh
+from openmc.tallies import Tallies
 import openmc.checkvalue as cv
 from openmc.checkvalue import PathLike
 from ._xml import get_elem_list, get_text, clean_indentation
@@ -496,8 +497,10 @@ class WeightWindowGenerator:
         maximum and minimum energy for the data available at runtime.
     particle_type : {'neutron', 'photon'}
         Particle type the weight windows apply to
-    method : {'magic', 'fw_cadis'}
+    method : {'magic', 'fw_cadis', 'cadis'}
         The weight window generation methodology applied during an update.
+    targets : :class:`openmc.Tallies`
+        Target tallies for local variance reduction via CADIS.
     max_realizations : int
         The upper limit for number of tally realizations when generating weight
         windows.
@@ -515,8 +518,10 @@ class WeightWindowGenerator:
         energies in [eV] for a single bin
     particle_type : {'neutron', 'photon'}
         Particle type the weight windows apply to
-    method : {'magic', 'fw_cadis'}
+    method : {'magic', 'fw_cadis', 'cadis'}
         The weight window generation methodology applied during an update.
+    targets : :class:`openmc.Tallies`
+        Target tallies for local variance reduction via CADIS.
     max_realizations : int
         The upper limit for number of tally realizations when generating weight
         windows.
@@ -528,7 +533,7 @@ class WeightWindowGenerator:
         Whether or not to apply weight windows on the fly.
     """
 
-    _MAGIC_PARAMS = {'value': str, 'threshold': float, 'ratio': float}
+    _WWG_PARAMS = {'value': str, 'threshold': float, 'ratio': float}
 
     def __init__(
         self,
@@ -536,6 +541,7 @@ def __init__(
         energy_bounds: Sequence[float] | None = None,
         particle_type: str = 'neutron',
         method: str = 'magic',
+        targets: openmc.Tallies | list[int] | None = None,
         max_realizations: int = 1,
         update_interval: int = 1,
         on_the_fly: bool = True
@@ -548,6 +554,7 @@ def __init__(
             self.energy_bounds = energy_bounds
         self.particle_type = particle_type
         self.method = method
+        self.targets = targets
         self.max_realizations = max_realizations
         self.update_interval = update_interval
         self.on_the_fly = on_the_fly
@@ -601,13 +608,33 @@ def method(self) -> str:
     @method.setter
     def method(self, m: str):
         cv.check_type('generation method', m, str)
-        cv.check_value('generation method', m, ('magic', 'fw_cadis'))
+        cv.check_value('generation method', m, ('magic', 'fw_cadis', 'cadis'))
         self._method = m
         if self._update_parameters is not None:
             try:
                 self._check_update_parameters()
             except (TypeError, KeyError):
                 warnings.warn(f'Update parameters are invalid for the "{m}" method.')
+    
+    @property
+    def targets(self) -> openmc.Tallies:
+        return self._targets
+
+    @targets.setter
+    def targets(self, t):
+        if t is None:
+            self._targets = t
+        else:
+            cv.check_type('CADIS target tallies', t, [openmc.Tallies, list])
+            cv.check_greater_than('CADIS target tallies', len(t), 0)
+            if isinstance(t, list):
+                for tally_id in t:
+                    if not isinstance(tally_id, int):
+                        raise TypeError(
+                            "Tally IDs passed to WeightWindowGenerator " \
+                            "must be of type int")
+                    
+            self._targets = t
 
     @property
     def max_realizations(self) -> int:
@@ -634,14 +661,14 @@ def update_parameters(self) -> dict:
         return self._update_parameters
 
     def _check_update_parameters(self, params: dict):
-        if self.method == 'magic' or self.method == 'fw_cadis':
-            check_params = self._MAGIC_PARAMS
+        if self.method == 'magic' or self.method == 'fw_cadis'  or self.method == 'cadis':
+            check_params = self._WWG_PARAMS
 
         for key, val in params.items():
             if key not in check_params:
                 raise ValueError(f'Invalid param "{key}" for {self.method} '
                                   'weight window generation')
-            cv.check_type(f'weight window generation param: "{key}"', val, self._MAGIC_PARAMS[key])
+            cv.check_type(f'weight window generation param: "{key}"', val, self._WWG_PARAMS[key])
 
     @update_parameters.setter
     def update_parameters(self, params: dict):
@@ -677,8 +704,8 @@ def _sanitize_update_parameters(cls, method: str, update_parameters: dict):
         update_parameters : dict
             The update parameters as-read from the XML node (keys: str, values: str)
         """
-        if method == 'magic' or method == 'fw_cadis':
-            check_params = cls._MAGIC_PARAMS
+        if method == 'magic' or method == 'fw_cadis'  or method == 'cadis':
+            check_params = cls._WWG_PARAMS
 
         for param, param_type in check_params.items():
             if param in update_parameters:
@@ -704,6 +731,20 @@ def to_xml_element(self):
         otf_elem.text = str(self.on_the_fly).lower()
         method_elem = ET.SubElement(element, 'method')
         method_elem.text = self.method
+        if self.targets is not None:
+            if self.method != 'cadis':
+                raise ValueError(
+                    "CADIS update method is required in order to use " \
+                    "target tallies for WeightWindowGenerator.")
+            elif isinstance(self.targets, openmc.Tallies):
+                raise RuntimeError(
+                    "CADIS target tallies must be checked to ensure they are" \
+                    "present on model.tallies. Use model.export_to_xml() or " \
+                    "model.export_to_model_xml() to link CADIS target tallies.")
+            else:
+                targets_elem = ET.SubElement(element, 'targets')
+                targets_elem.text = ' '.join(str(tally_id) for tally_id in self.targets)
+
         if self.update_parameters is not None:
             self._update_parameters_subelement(element)
 
@@ -731,7 +772,7 @@ def from_xml_element(cls, elem: ET.Element, meshes: dict) -> Self:
         mesh_id = int(get_text(elem, 'mesh'))
         mesh = meshes[mesh_id]
         
-        energy_bounds = get_elem_list(elem, "energy_bounds, float")
+        energy_bounds = get_elem_list(elem, "energy_bounds", float)
         particle_type = get_text(elem, 'particle_type')
 
         wwg = cls(mesh, energy_bounds, particle_type)
@@ -740,6 +781,14 @@ def from_xml_element(cls, elem: ET.Element, meshes: dict) -> Self:
         wwg.update_interval = int(get_text(elem, 'update_interval'))
         wwg.on_the_fly = bool(get_text(elem, 'on_the_fly'))
         wwg.method = get_text(elem, 'method')
+        targets_elem = elem.find('targets')
+        if targets_elem is not None:
+            if wwg.method != 'cadis':
+                raise ValueError(
+                    "CADIS update method is required in order to use " \
+                    "target tallies for WeightWindowGenerator.")
+            else:
+                wwg.targets = get_elem_list(elem, "targets")
 
         if elem.find('update_parameters') is not None:
             update_parameters = {}
diff --git a/src/random_ray/flat_source_domain.cpp b/src/random_ray/flat_source_domain.cpp
index c2effaa5d4a..ab109199791 100644
--- a/src/random_ray/flat_source_domain.cpp
+++ b/src/random_ray/flat_source_domain.cpp
@@ -30,9 +30,11 @@ RandomRayVolumeEstimator FlatSourceDomain::volume_estimator_ {
   RandomRayVolumeEstimator::HYBRID};
 bool FlatSourceDomain::volume_normalized_flux_tallies_ {false};
 bool FlatSourceDomain::adjoint_ {false};
+bool FlatSourceDomain::cadis_ {false};
 double FlatSourceDomain::diagonal_stabilization_rho_ {1.0};
 std::unordered_map<int, vector<std::pair<Source::DomainType, int>>>
   FlatSourceDomain::mesh_domain_map_;
+std::vector<size_t> FlatSourceDomain::cadis_targets_;
 
 FlatSourceDomain::FlatSourceDomain() : negroups_(data::mg.num_energy_groups_)
 {
@@ -1053,13 +1055,17 @@ void FlatSourceDomain::count_external_source_regions()
   }
 }
 
-void FlatSourceDomain::convert_external_sources()
+void FlatSourceDomain::convert_external_sources(bool use_adjoint_sources)
 {
+  // Determine whether forward or (local) adjoint sources are desired
+  const auto& sources = use_adjoint_sources ? 
+    model::adjoint_sources : model::external_sources;
+    
   // Loop over external sources
-  for (int es = 0; es < model::external_sources.size(); es++) {
+  for (int es = 0; es < sources.size(); es++) {
 
     // Extract source information
-    Source* s = model::external_sources[es].get();
+    Source* s = sources[es].get();
     IndependentSource* is = dynamic_cast<IndependentSource*>(s);
     Discrete* energy = dynamic_cast<Discrete*>(is->energy());
     const std::unordered_set<int32_t>& domain_ids = is->domain_ids();
@@ -1198,7 +1204,7 @@ void FlatSourceDomain::flatten_xs()
   }
 }
 
-void FlatSourceDomain::set_adjoint_sources()
+void FlatSourceDomain::set_fw_adjoint_sources()
 {
   // Set the adjoint external source to 1/forward_flux. If the forward flux is
   // negative, zero, or extremely close to zero, set the adjoint source to zero,
@@ -1227,6 +1233,10 @@ void FlatSourceDomain::set_adjoint_sources()
         source_regions_.external_source(sr, g) = 0.0;
       } else {
         source_regions_.external_source(sr, g) = 1.0 / flux;
+        if (!std::isfinite(source_regions_.external_source(sr, g))) {
+          // If the flux is NaN or Inf, set the adjoint source to zero
+          source_regions_.external_source(sr, g) = 0.0;
+        }
       }
       if (flux > 0.0) {
         source_regions_.external_source_present(sr) = 1;
@@ -1249,29 +1259,133 @@ void FlatSourceDomain::set_adjoint_sources()
   // set its adjoint source to zero. This adds negligible bias to the adjoint
   // flux solution, as the true total adjoint source contribution from small
   // regions is likely to be negligible.
+  if (!cadis_) {
 #pragma omp parallel for
-  for (int64_t sr = 0; sr < n_source_regions(); sr++) {
-    if (source_regions_.is_small(sr)) {
-      for (int g = 0; g < negroups_; g++) {
-        source_regions_.external_source(sr, g) = 0.0;
+    for (int64_t sr = 0; sr < n_source_regions(); sr++) {
+      if (source_regions_.is_small(sr)) {
+        for (int g = 0; g < negroups_; g++) {
+          source_regions_.external_source(sr, g) = 0.0;
+        }
+        source_regions_.external_source_present(sr) = 0;
       }
-      source_regions_.external_source_present(sr) = 0;
     }
-  }
-  // Divide the fixed source term by sigma t (to save time when applying each
-  // iteration)
+
+    // Divide the fixed source term by sigma t (to save time when applying each
+    // iteration)
 #pragma omp parallel for
-  for (int64_t sr = 0; sr < n_source_regions(); sr++) {
-    int material = source_regions_.material(sr);
-    if (material == MATERIAL_VOID) {
-      continue;
-    }
-    for (int g = 0; g < negroups_; g++) {
-      double sigma_t =
-        sigma_t_[material * negroups_ + g] * source_regions_.density_mult(sr);
-      source_regions_.external_source(sr, g) /= sigma_t;
+    for (int64_t sr = 0; sr < n_source_regions(); sr++) {
+      int material = source_regions_.material(sr);
+      if (material == MATERIAL_VOID) {
+        continue;
+      }
+      for (int g = 0; g < negroups_; g++) {
+        double sigma_t =
+          sigma_t_[material * negroups_ + g] * source_regions_.density_mult(sr);
+        source_regions_.external_source(sr, g) /= sigma_t;
+        if (!std::isfinite(source_regions_.external_source(sr, g))) {
+          // If the flux is NaN or Inf, set the adjoint source to zero
+          source_regions_.external_source(sr, g) = 0.0;
+        }
+      }
     }
   }
+
+  if (cadis_) {
+// Only external sources that have a non-mesh type tally task should remain
+// non-zero. Everything else gets zero'd out.
+#pragma omp parallel for
+    for (int64_t sr = 0; sr < n_source_regions(); sr++) {
+
+      // If there is already no external source, don't need to do anything
+      if (source_regions_.external_source_present(sr) == 0) {
+        continue;
+      }
+
+      // If there is an adjoint source term here, then we need to check it.
+
+      // We will track if ANY group has a valid CADIS source term
+      bool has_any_sources = false;
+
+      // Now, loop over groups
+      for (int g = 0; g < negroups_; g++) {
+
+        // If there are no tally tasks associated with this source element
+        // then it is not a CADIS source, so we continue to the next group
+        if (source_regions_.tally_task(sr, g).empty()) {
+          source_regions_.external_source(sr, g) = 0.0;
+          continue;
+        }
+
+        // If there are tally tasks, we can through them and check if
+        // any of them are CADIS targets and have a non-mesh filter type.
+
+        // We track if ANY of the tasks are CADIS target tallies
+        bool cadis_target_region = false;
+
+        // Now we loop through
+        for (const auto& task : source_regions_.tally_task(sr, g)) {
+          Tally& tally {*model::tallies[task.tally_idx]};
+          const auto t_id = tally.id();
+          
+          // Skip non-target tallies
+          if (std::find(cadis_targets_.begin(),
+                        cadis_targets_.end(),
+                        t_id) == cadis_targets_.end()) {
+            continue;
+          }
+          
+          auto filter_types = tally.filter_types();
+
+          // For each tally, we loop through the filter types array.
+          // If any of them have a CADIS-compatible filter type,
+          // then this source element is a valid CADIS source
+          for (const auto& filter_type : filter_types) {
+            if (filter_type == FilterType::CELL ||
+                filter_type == FilterType::CELL_INSTANCE ||
+                filter_type == FilterType::DISTRIBCELL ||
+                filter_type == FilterType::UNIVERSE ||
+                filter_type == FilterType::MATERIAL) {
+              cadis_target_region = true;
+              break;
+            }
+          }
+          // If a target tally doesn't have any compatible filters, error
+          if (!cadis_target_region) {
+            fatal_error("CADIS target tally with ID " + 
+                        std::to_string(t_id) + " does not have any "
+                        "CADIS-compatible filters.");
+          }
+        }
+
+        // If ANY of the tasks is a CADIS target,
+        // Then we keep the source term and set that this
+        // source region has a valid CADIS source term.
+        // Otherwise, we zero out the source term.
+        if (cadis_target_region) {
+          has_any_sources = true;
+          // print external source term
+          fmt::print("External source term for source region {} group {}: {}\n",
+            sr, g, source_regions_.external_source(sr, g));
+        } else {
+          source_regions_.external_source(sr, g) = 0.0;
+        }
+      } // End loop over groups
+
+      // If there were any valid CADIS source terms for any
+      // of the groups, then the SR as a whole counts as a source
+      if (has_any_sources) {
+        source_regions_.external_source_present(sr) = 1;
+      } else {
+        source_regions_.external_source_present(sr) = 0;
+      }
+    } // End loop over source regions
+  } // End CADIS logic
+}
+
+void FlatSourceDomain::set_local_adjoint_sources()
+{
+  // Set the external source to user-specified adjoint sources.
+  convert_external_sources(true);
 }
 
 void FlatSourceDomain::transpose_scattering_matrix()
diff --git a/src/random_ray/random_ray_simulation.cpp b/src/random_ray/random_ray_simulation.cpp
index 7bab3a9b1b6..f38e5e9065c 100644
--- a/src/random_ray/random_ray_simulation.cpp
+++ b/src/random_ray/random_ray_simulation.cpp
@@ -28,12 +28,25 @@ void openmc_run_random_ray()
   // Run forward simulation
   //////////////////////////////////////////////////////////
 
-  if (mpi::master) {
-    if (FlatSourceDomain::adjoint_) {
-      FlatSourceDomain::adjoint_ = false;
-      openmc::print_adjoint_header();
-      FlatSourceDomain::adjoint_ = true;
-    }
+  // Check if adjoint calculation is needed, and if local adjoint source(s) 
+  // are present. If an adjoint calculation is needed and no sources are 
+  // specified, we will run a forward calculation first to calculate adjoint 
+  // sources for global variance reduction, then perform an adjoint 
+  // calculation later.
+  bool adjoint_needed = FlatSourceDomain::adjoint_;
+  bool fw_adjoint = model::adjoint_sources.empty() && adjoint_needed;
+
+  // If we're going to do an adjoint simulation with forward-weighted adjoint
+  // sources afterwards, report that this is the initial forward flux solve.
+  if (!adjoint_needed || fw_adjoint) {
+    // Configure the domain for forward simulation
+    FlatSourceDomain::adjoint_ = false;
+
+    if (adjoint_needed && mpi::master) 
+      header("FORWARD FLUX SOLVE", 3);
+  } else {
+    // Configure domain for adjoint simulation (later)
+    FlatSourceDomain::adjoint_ = true;
   }
 
   // Initialize OpenMC general data structures
@@ -46,23 +59,86 @@ void openmc_run_random_ray()
   // Initialize Random Ray Simulation Object
   RandomRaySimulation sim;
 
-  // Initialize fixed sources, if present
-  sim.apply_fixed_sources_and_mesh_domains();
+  if (!adjoint_needed || fw_adjoint) {
+    // Initialize fixed sources, if present
+    sim.apply_fixed_sources_and_mesh_domains();
 
-  // Run initial random ray simulation
-  sim.simulate();
+    // Begin main simulation timer
+    simulation::time_total.start();
+
+    // Execute random ray simulation
+    sim.simulate();
+
+    // End main simulation timer
+    simulation::time_total.stop();
+
+    // Normalize and save the final forward flux
+    double source_normalization_factor =
+      sim.domain()->compute_fixed_source_normalization_factor() /
+      (settings::n_batches - settings::n_inactive);
+
+#pragma omp parallel for
+    for (uint64_t se = 0; se < sim.domain()->n_source_elements(); se++) {
+      sim.domain()->source_regions_.scalar_flux_final(se) *=
+        source_normalization_factor;
+    }
+
+    // Finalize OpenMC
+    openmc_simulation_finalize();
+
+    // Output all simulation results
+    sim.output_simulation_results();
+  }
 
   //////////////////////////////////////////////////////////
   // Run adjoint simulation (if enabled)
   //////////////////////////////////////////////////////////
 
-  if (sim.adjoint_needed_) {
-    // Setup for adjoint simulation
-    sim.prepare_adjoint_simulation();
+  if (!adjoint_needed) {
+    return;
+  }
 
-    // Run adjoint simulation
-    sim.simulate();
+  reset_timers();
+
+  if (mpi::master)
+    header("ADJOINT FLUX SOLVE", 3);
+
+  if (fw_adjoint) {
+    // Forward simulation has already been run;
+    // Configure the domain for adjoint simulation and
+    // re-initialize OpenMC general data structures
+    FlatSourceDomain::adjoint_ = true;
+
+    openmc_simulation_init();
+
+    sim.prepare_fw_fixed_sources_adjoint();
+  } else {
+    // Initialize adjoint fixed sources
+    sim.prepare_local_fixed_sources_adjoint();
   }
+
+  sim.domain()->k_eff_ = 1.0;
+
+  // Transpose scattering matrix
+  sim.domain()->transpose_scattering_matrix();
+
+  // Swap nu_sigma_f and chi
+  sim.domain()->nu_sigma_f_.swap(sim.domain()->chi_);
+
+  // Begin main simulation timer
+  simulation::time_total.start();
+
+  // Execute random ray simulation
+  sim.simulate();
+
+  // End main simulation timer
+  simulation::time_total.stop();
+
+  // Finalize OpenMC
+  openmc_simulation_finalize();
+  
+  // Output all simulation results
+  sim.output_simulation_results();
 }
 
 // Enforces restrictions on inputs in random ray mode.  While there are
@@ -83,12 +159,11 @@ void validate_random_ray_inputs()
       case SCORE_FISSION:
       case SCORE_NU_FISSION:
       case SCORE_EVENTS:
-      case SCORE_KAPPA_FISSION:
         break;
       default:
         fatal_error(
-          "Invalid score specified. Only flux, total, fission, nu-fission, "
-          "kappa-fission, and event scores are supported in random ray mode.");
+          "Invalid score specified. Only flux, total, fission, nu-fission, and "
+          "event scores are supported in random ray mode.");
       }
     }
 
@@ -278,8 +353,8 @@ void validate_random_ray_inputs()
     warning(
       "Linear sources may result in negative fluxes in small source regions "
       "generated by mesh subdivision. Negative sources may result in low "
-      "quality FW-CADIS weight windows. We recommend you use flat source mode "
-      "when generating weight windows with an overlaid mesh tally.");
+      "quality (FW-)CADIS weight windows. We recommend you use flat source "
+      "mode when generating weight windows with an overlaid mesh tally.");
   }
 }
 
@@ -294,17 +369,6 @@ void openmc_reset_random_ray()
   RandomRay::sample_method_ = RandomRaySampleMethod::PRNG;
 }
 
-void print_adjoint_header()
-{
-  if (!FlatSourceDomain::adjoint_)
-    // If we're going to do an adjoint simulation afterwards, report that this
-    // is the initial forward flux solve.
-    header("FORWARD FLUX SOLVE", 3);
-  else
-    // Otherwise report that we are doing the adjoint simulation
-    header("ADJOINT FLUX SOLVE", 3);
-}
-
 //==============================================================================
 // RandomRaySimulation implementation
 //==============================================================================
@@ -335,16 +399,6 @@ RandomRaySimulation::RandomRaySimulation()
   // Convert OpenMC native MGXS into a more efficient format
   // internal to the random ray solver
   domain_->flatten_xs();
-
-  // Check if adjoint calculation is needed. If it is, we will run the forward
-  // calculation first and then the adjoint calculation later.
-  adjoint_needed_ = FlatSourceDomain::adjoint_;
-
-  // Adjoint is always false for the forward calculation
-  FlatSourceDomain::adjoint_ = false;
-
-  // The first simulation is run after initialization
-  is_first_simulation_ = true;
 }
 
 void RandomRaySimulation::apply_fixed_sources_and_mesh_domains()
@@ -352,54 +406,29 @@ void RandomRaySimulation::apply_fixed_sources_and_mesh_domains()
   domain_->apply_meshes();
   if (settings::run_mode == RunMode::FIXED_SOURCE) {
     // Transfer external source user inputs onto random ray source regions
-    domain_->convert_external_sources();
+    domain_->convert_external_sources(false);
     domain_->count_external_source_regions();
   }
 }
 
-void RandomRaySimulation::prepare_fixed_sources_adjoint()
+void RandomRaySimulation::prepare_fw_fixed_sources_adjoint()
 {
+  // Prepare adjoint fixed sources using forward flux
   domain_->source_regions_.adjoint_reset();
   if (settings::run_mode == RunMode::FIXED_SOURCE) {
-    domain_->set_adjoint_sources();
+    domain_->set_fw_adjoint_sources();
   }
 }
 
-void RandomRaySimulation::prepare_adjoint_simulation()
+void RandomRaySimulation::prepare_local_fixed_sources_adjoint()
 {
-  // Configure the domain for adjoint simulation
-  FlatSourceDomain::adjoint_ = true;
-
-  // Reset k-eff
-  domain_->k_eff_ = 1.0;
-
-  // Initialize adjoint fixed sources, if present
-  prepare_fixed_sources_adjoint();
-
-  // Transpose scattering matrix
-  domain_->transpose_scattering_matrix();
-
-  // Swap nu_sigma_f and chi
-  domain_->nu_sigma_f_.swap(domain_->chi_);
+  if (settings::run_mode == RunMode::FIXED_SOURCE) {
+    domain_->set_local_adjoint_sources();
+  }
 }
 
 void RandomRaySimulation::simulate()
 {
-  if (!is_first_simulation_) {
-    if (mpi::master && adjoint_needed_)
-      openmc::print_adjoint_header();
-
-    // Reset the timers and reinitialize the general OpenMC datastructures if
-    // this is after the first simulation
-    reset_timers();
-
-    // Initialize OpenMC general data structures
-    openmc_simulation_init();
-  }
-
-  // Begin main simulation timer
-  simulation::time_total.start();
-
   // Random ray power iteration loop
   while (simulation::current_batch < settings::n_batches) {
     // Initialize the current batch
@@ -488,31 +517,6 @@ void RandomRaySimulation::simulate()
   } // End random ray power iteration loop
 
   domain_->count_external_source_regions();
-
-  // End main simulation timer
-  simulation::time_total.stop();
-
-  // Normalize and save the final flux
-  double source_normalization_factor =
-    domain_->compute_fixed_source_normalization_factor() /
-    (settings::n_batches - settings::n_inactive);
-
-#pragma omp parallel for
-  for (uint64_t se = 0; se < domain_->n_source_elements(); se++) {
-    domain_->source_regions_.scalar_flux_final(se) *=
-      source_normalization_factor;
-  }
-
-  // Finalize OpenMC
-  openmc_simulation_finalize();
-
-  // Output all simulation results
-  output_simulation_results();
-
-  // Toggle that the simulation object has been initialized after the first
-  // simulation
-  if (is_first_simulation_)
-    is_first_simulation_ = false;
 }
 
 void RandomRaySimulation::output_simulation_results() const
diff --git a/src/settings.cpp b/src/settings.cpp
index 5b472468fc4..d8fca66df81 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -276,8 +276,9 @@ void get_run_parameters(pugi::xml_node node_base)
     } else {
       fatal_error("Specify random ray inactive distance in settings XML");
     }
-    if (check_for_node(random_ray_node, "source")) {
-      xml_node source_node = random_ray_node.child("source");
+    if (check_for_node(random_ray_node, "ray_source")) {
+      xml_node ray_source_node = random_ray_node.child("ray_source");
+      xml_node source_node = ray_source_node.child("source");
       // Get point to list of <source> elements and make sure there is at least
       // one
       RandomRay::ray_source_ = Source::create(source_node);
@@ -363,6 +364,14 @@ void get_run_parameters(pugi::xml_node node_base)
                     "between 0 and 1");
       }
     }
+    if (check_for_node(random_ray_node, "adjoint_source")) {
+      for (pugi::xml_node adj_source_node : 
+        random_ray_node.children("adjoint_source")) {
+        // Find any local adjoint sources
+        xml_node source_node = adj_source_node.child("source");
+        model::adjoint_sources.push_back(Source::create(source_node));
+      }
+    }
   }
 }
 
@@ -1249,6 +1258,16 @@ void read_settings_xml(pugi::xml_node root)
         break;
       }
     }
+    // If any weight window generators have CADIS target tallies, user-defined
+    // adjoint sources cannot be used at the same time.
+    if (!model::adjoint_sources.empty()) {
+      for (const auto& wwg : variance_reduction::weight_windows_generators) {
+        if (!wwg->targets_.empty()) {
+          fatal_error("Cannot use both user-defined adjoint sources and CADIS "
+                      "target tallies at the same time.");
+        }
+      }
+    }
   }
 
   // Set up weight window checkpoints
diff --git a/src/source.cpp b/src/source.cpp
index b30b964d39c..566ac32d29b 100644
--- a/src/source.cpp
+++ b/src/source.cpp
@@ -45,6 +45,8 @@ namespace model {
 
 vector<unique_ptr<Source>> external_sources;
 
+vector<unique_ptr<Source>> adjoint_sources;
+
 DiscreteIndex external_sources_probability;
 
 } // namespace model
diff --git a/src/weight_windows.cpp b/src/weight_windows.cpp
index 4838e459152..f60de4c56d5 100644
--- a/src/weight_windows.cpp
+++ b/src/weight_windows.cpp
@@ -698,7 +698,7 @@ void WeightWindows::update_weights(const Tally* tally, const std::string& value,
       }
     }
   } else {
-    // For FW-CADIS, weight windows are inversely proportional to the adjoint
+    // For (FW-)CADIS, weight windows are inversely proportional to the adjoint
     // fluxes. We normalize the weight windows across all energy groups.
 #pragma omp parallel for collapse(2) schedule(static)
     for (int e = 0; e < e_bins; e++) {
@@ -876,6 +876,22 @@ WeightWindowsGenerator::WeightWindowsGenerator(pugi::xml_node node)
       fatal_error("FW-CADIS can only be run in random ray solver mode.");
     }
     FlatSourceDomain::adjoint_ = true;
+  } else if (method_string == "cadis") {
+    method_ = WeightWindowUpdateMethod::CADIS;
+    if (settings::solver_type != SolverType::RANDOM_RAY) {
+      fatal_error("CADIS can only be run in random ray solver mode.");
+    }
+    FlatSourceDomain::adjoint_ = true;
+    FlatSourceDomain::cadis_ = true;
+    if (check_for_node(node,"targets")) {
+      targets_ = get_node_array<size_t>(node, "targets");
+      FlatSourceDomain::cadis_targets_.insert(
+        std::end(FlatSourceDomain::cadis_targets_), std::begin(targets_), 
+        std::end(targets_));
+    } else {
+      fatal_error("CADIS method requires target tallies be specified to "
+                  "WeightWindowGenerator.");
+    }
   } else {
     fatal_error(fmt::format(
       "Unknown weight window update method '{}' specified", method_string));
diff --git a/tests/regression_tests/random_ray_adjoint_fixed_source/inputs_true.dat b/tests/regression_tests/random_ray_adjoint_fixed_source/inputs_true.dat
index 0adfc548848..94e2709768f 100644
--- a/tests/regression_tests/random_ray_adjoint_fixed_source/inputs_true.dat
+++ b/tests/regression_tests/random_ray_adjoint_fixed_source/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <adjoint>true</adjoint>
       <volume_estimator>naive</volume_estimator>
diff --git a/tests/regression_tests/random_ray_adjoint_k_eff/inputs_true.dat b/tests/regression_tests/random_ray_adjoint_k_eff/inputs_true.dat
index 073348c41e7..755afd6c439 100644
--- a/tests/regression_tests/random_ray_adjoint_k_eff/inputs_true.dat
+++ b/tests/regression_tests/random_ray_adjoint_k_eff/inputs_true.dat
@@ -80,11 +80,13 @@
     <random_ray>
       <distance_active>100.0</distance_active>
       <distance_inactive>20.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <adjoint>true</adjoint>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_adjoint_k_eff/results_true.dat b/tests/regression_tests/random_ray_adjoint_k_eff/results_true.dat
index dfef53cd2f9..429067b2212 100644
--- a/tests/regression_tests/random_ray_adjoint_k_eff/results_true.dat
+++ b/tests/regression_tests/random_ray_adjoint_k_eff/results_true.dat
@@ -79,7 +79,7 @@ tally 1:
 0.000000E+00
 0.000000E+00
 0.000000E+00
-9.248400E-01
+9.248399E-01
 1.710699E-01
 0.000000E+00
 0.000000E+00
@@ -148,7 +148,7 @@ tally 1:
 9.272977E-01
 1.721077E-01
 3.161443E-02
-2.000179E-04
+2.000180E-04
 2.002789E-07
 8.027290E-15
 8.778794E-01
diff --git a/tests/regression_tests/random_ray_auto_convert/infinite_medium/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert/infinite_medium/inputs_true.dat
index 464c89a5df9..86d5ec4abd5 100644
--- a/tests/regression_tests/random_ray_auto_convert/infinite_medium/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert/infinite_medium/inputs_true.dat
@@ -41,11 +41,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_auto_convert/material_wise/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert/material_wise/inputs_true.dat
index 464c89a5df9..86d5ec4abd5 100644
--- a/tests/regression_tests/random_ray_auto_convert/material_wise/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert/material_wise/inputs_true.dat
@@ -41,11 +41,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_auto_convert/stochastic_slab/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert/stochastic_slab/inputs_true.dat
index 464c89a5df9..86d5ec4abd5 100644
--- a/tests/regression_tests/random_ray_auto_convert/stochastic_slab/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert/stochastic_slab/inputs_true.dat
@@ -41,11 +41,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/model/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/model/inputs_true.dat
index 80a166c6786..15981f7fa5f 100644
--- a/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/model/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/model/inputs_true.dat
@@ -38,11 +38,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/user/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/user/inputs_true.dat
index 464c89a5df9..86d5ec4abd5 100644
--- a/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/user/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert_source_energy/infinite_medium/user/inputs_true.dat
@@ -41,11 +41,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/model/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/model/inputs_true.dat
index 80a166c6786..15981f7fa5f 100644
--- a/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/model/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/model/inputs_true.dat
@@ -38,11 +38,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/user/inputs_true.dat b/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/user/inputs_true.dat
index 464c89a5df9..2314266563c 100644
--- a/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/user/inputs_true.dat
+++ b/tests/regression_tests/random_ray_auto_convert_source_energy/stochastic_slab/user/inputs_true.dat
@@ -40,12 +40,14 @@
       </constraints>
     </source>
     <energy_mode>multi-group</energy_mode>
-    <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+    <random_ray>  
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_diagonal_stabilization/inputs_true.dat b/tests/regression_tests/random_ray_diagonal_stabilization/inputs_true.dat
index 47325ebd7d5..11100e88e12 100644
--- a/tests/regression_tests/random_ray_diagonal_stabilization/inputs_true.dat
+++ b/tests/regression_tests/random_ray_diagonal_stabilization/inputs_true.dat
@@ -41,11 +41,13 @@
     </source>
     <energy_mode>multi-group</energy_mode>
     <random_ray>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-0.63 -0.63 -1.0 0.63 0.63 1.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <distance_inactive>30.0</distance_inactive>
       <distance_active>150.0</distance_active>
       <source_region_meshes>
diff --git a/tests/regression_tests/random_ray_entropy/settings.xml b/tests/regression_tests/random_ray_entropy/settings.xml
index 81deaa7751d..0d830417b62 100644
--- a/tests/regression_tests/random_ray_entropy/settings.xml
+++ b/tests/regression_tests/random_ray_entropy/settings.xml
@@ -6,11 +6,13 @@
   <inactive>5</inactive>
   <energy_mode>multi-group</energy_mode>
   <random_ray>
-    <source particle="neutron" strength="1.0" type="independent">
-      <space type="box">
-        <parameters>0.0 0.0 0.0 100.0 100.0 100.0</parameters>
-      </space>
-    </source>
+    <ray_source>
+      <source particle="neutron" strength="1.0" type="independent">
+        <space type="box">
+          <parameters>0.0 0.0 0.0 100.0 100.0 100.0</parameters>
+        </space>
+      </source>
+    </ray_source>
     <distance_inactive>40.0</distance_inactive>
     <distance_active>400.0</distance_active>
   </random_ray>
diff --git a/tests/regression_tests/random_ray_fixed_source_domain/cell/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_domain/cell/inputs_true.dat
index 9f1987f3acc..d650bbaf95c 100644
--- a/tests/regression_tests/random_ray_fixed_source_domain/cell/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_domain/cell/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_fixed_source_domain/material/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_domain/material/inputs_true.dat
index b4f57dbfa8a..98a51add1f3 100644
--- a/tests/regression_tests/random_ray_fixed_source_domain/material/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_domain/material/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_fixed_source_domain/universe/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_domain/universe/inputs_true.dat
index ab91f74e50d..20deba664bd 100644
--- a/tests/regression_tests/random_ray_fixed_source_domain/universe/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_domain/universe/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_fixed_source_linear/linear/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_linear/linear/inputs_true.dat
index 220fa7db643..2268d82c391 100644
--- a/tests/regression_tests/random_ray_fixed_source_linear/linear/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_linear/linear/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_fixed_source_linear/linear_xy/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_linear/linear_xy/inputs_true.dat
index f8c4430852f..fe95baa7bb5 100644
--- a/tests/regression_tests/random_ray_fixed_source_linear/linear_xy/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_linear/linear_xy/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear_xy</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_fixed_source_mesh/flat/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_mesh/flat/inputs_true.dat
index c84e544fcc4..a5632ece960 100644
--- a/tests/regression_tests/random_ray_fixed_source_mesh/flat/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_mesh/flat/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_region_meshes>
         <mesh id="1">
diff --git a/tests/regression_tests/random_ray_fixed_source_mesh/linear/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_mesh/linear/inputs_true.dat
index 05c4846e6b4..9d22603c63c 100644
--- a/tests/regression_tests/random_ray_fixed_source_mesh/linear/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_mesh/linear/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_region_meshes>
         <mesh id="1">
diff --git a/tests/regression_tests/random_ray_fixed_source_normalization/False/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_normalization/False/inputs_true.dat
index 0c870e10067..de941f10fbb 100644
--- a/tests/regression_tests/random_ray_fixed_source_normalization/False/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_normalization/False/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>false</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_fixed_source_normalization/True/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_normalization/True/inputs_true.dat
index ab91f74e50d..20deba664bd 100644
--- a/tests/regression_tests/random_ray_fixed_source_normalization/True/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_normalization/True/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_fixed_source_subcritical/flat/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_subcritical/flat/inputs_true.dat
index 0c05a71df32..943468a1095 100644
--- a/tests/regression_tests/random_ray_fixed_source_subcritical/flat/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_subcritical/flat/inputs_true.dat
@@ -110,11 +110,13 @@
     <random_ray>
       <distance_active>40.0</distance_active>
       <distance_inactive>40.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>false</volume_normalized_flux_tallies>
       <source_shape>flat</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_fixed_source_subcritical/linear_xy/inputs_true.dat b/tests/regression_tests/random_ray_fixed_source_subcritical/linear_xy/inputs_true.dat
index a67495bf169..650953c4b06 100644
--- a/tests/regression_tests/random_ray_fixed_source_subcritical/linear_xy/inputs_true.dat
+++ b/tests/regression_tests/random_ray_fixed_source_subcritical/linear_xy/inputs_true.dat
@@ -110,11 +110,13 @@
     <random_ray>
       <distance_active>40.0</distance_active>
       <distance_inactive>40.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>false</volume_normalized_flux_tallies>
       <source_shape>linear_xy</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_halton_samples/inputs_true.dat b/tests/regression_tests/random_ray_halton_samples/inputs_true.dat
index 36d5f6f2276..1b86d2daeea 100644
--- a/tests/regression_tests/random_ray_halton_samples/inputs_true.dat
+++ b/tests/regression_tests/random_ray_halton_samples/inputs_true.dat
@@ -80,11 +80,13 @@
     <random_ray>
       <distance_active>100.0</distance_active>
       <distance_inactive>20.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <sample_method>halton</sample_method>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_halton_samples/results_true.dat b/tests/regression_tests/random_ray_halton_samples/results_true.dat
index 256f8a744a3..5f39ebaeb19 100644
--- a/tests/regression_tests/random_ray_halton_samples/results_true.dat
+++ b/tests/regression_tests/random_ray_halton_samples/results_true.dat
@@ -24,7 +24,7 @@ tally 1:
 1.707007E-02
 5.933921E-05
 4.154514E-02
-3.514889E-04
+3.514888E-04
 1.513147E+00
 4.652938E-01
 1.810962E-02
@@ -34,7 +34,7 @@ tally 1:
 4.347893E+00
 3.798064E+00
 6.851785E-03
-9.430195E-06
+9.430194E-06
 1.695426E-02
 5.773923E-05
 2.809071E+00
@@ -152,7 +152,7 @@ tally 1:
 4.036663E-02
 3.323832E-04
 1.516801E+00
-4.675245E-01
+4.675244E-01
 1.752096E-02
 6.241641E-05
 4.264304E-02
diff --git a/tests/regression_tests/random_ray_k_eff/inputs_true.dat b/tests/regression_tests/random_ray_k_eff/inputs_true.dat
index 545bd1d4578..72b783344fd 100644
--- a/tests/regression_tests/random_ray_k_eff/inputs_true.dat
+++ b/tests/regression_tests/random_ray_k_eff/inputs_true.dat
@@ -80,11 +80,13 @@
     <random_ray>
       <distance_active>100.0</distance_active>
       <distance_inactive>20.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_k_eff/results_true.dat b/tests/regression_tests/random_ray_k_eff/results_true.dat
index ace18df8cce..4e0c31988d7 100644
--- a/tests/regression_tests/random_ray_k_eff/results_true.dat
+++ b/tests/regression_tests/random_ray_k_eff/results_true.dat
@@ -1,5 +1,5 @@
 k-combined:
-8.400321E-01 8.023357E-03
+8.400321E-01 8.023358E-03
 tally 1:
 1.075769E+00
 2.317354E-01
@@ -28,7 +28,7 @@ tally 1:
 1.509054E+00
 4.629325E-01
 1.749679E-02
-6.226587E-05
+6.226588E-05
 4.258421E-02
 3.688336E-04
 4.322054E+00
@@ -131,7 +131,7 @@ tally 1:
 2.304093E-01
 4.053505E-01
 3.291277E-02
-9.865420E-01
+9.865421E-01
 1.949549E-01
 6.047420E-01
 7.327008E-02
diff --git a/tests/regression_tests/random_ray_k_eff_mesh/inputs_true.dat b/tests/regression_tests/random_ray_k_eff_mesh/inputs_true.dat
index 98badea18d8..f6e9c8e3e71 100644
--- a/tests/regression_tests/random_ray_k_eff_mesh/inputs_true.dat
+++ b/tests/regression_tests/random_ray_k_eff_mesh/inputs_true.dat
@@ -80,11 +80,13 @@
     <random_ray>
       <distance_active>100.0</distance_active>
       <distance_inactive>20.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_region_meshes>
         <mesh id="2">
diff --git a/tests/regression_tests/random_ray_k_eff_mesh/results_true.dat b/tests/regression_tests/random_ray_k_eff_mesh/results_true.dat
index 2ae8fad85fb..2976d169b63 100644
--- a/tests/regression_tests/random_ray_k_eff_mesh/results_true.dat
+++ b/tests/regression_tests/random_ray_k_eff_mesh/results_true.dat
@@ -1,5 +1,5 @@
 k-combined:
-8.379203E-01 8.057199E-03
+8.379203E-01 8.057198E-03
 tally 1:
 1.073897E+00
 2.309328E-01
diff --git a/tests/regression_tests/random_ray_linear/linear/inputs_true.dat b/tests/regression_tests/random_ray_linear/linear/inputs_true.dat
index a43a66e71c7..269d9892ebf 100644
--- a/tests/regression_tests/random_ray_linear/linear/inputs_true.dat
+++ b/tests/regression_tests/random_ray_linear/linear/inputs_true.dat
@@ -80,11 +80,13 @@
     <random_ray>
       <distance_active>100.0</distance_active>
       <distance_inactive>20.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_linear/linear_xy/inputs_true.dat b/tests/regression_tests/random_ray_linear/linear_xy/inputs_true.dat
index 7f76f2fd1c1..217e9551614 100644
--- a/tests/regression_tests/random_ray_linear/linear_xy/inputs_true.dat
+++ b/tests/regression_tests/random_ray_linear/linear_xy/inputs_true.dat
@@ -80,11 +80,13 @@
     <random_ray>
       <distance_active>100.0</distance_active>
       <distance_inactive>20.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>-1.26 -1.26 -1 1.26 1.26 1</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear_xy</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_linear/linear_xy/results_true.dat b/tests/regression_tests/random_ray_linear/linear_xy/results_true.dat
index 052608b4254..e00538f64c6 100644
--- a/tests/regression_tests/random_ray_linear/linear_xy/results_true.dat
+++ b/tests/regression_tests/random_ray_linear/linear_xy/results_true.dat
@@ -90,7 +90,7 @@ tally 1:
 1.746692E+00
 1.536860E-01
 4.251098E+00
-9.103405E-01
+9.103406E-01
 3.651202E+00
 6.682179E-01
 5.431675E-01
diff --git a/tests/regression_tests/random_ray_low_density/inputs_true.dat b/tests/regression_tests/random_ray_low_density/inputs_true.dat
index ab91f74e50d..20deba664bd 100644
--- a/tests/regression_tests/random_ray_low_density/inputs_true.dat
+++ b/tests/regression_tests/random_ray_low_density/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
     </random_ray>
   </settings>
diff --git a/tests/regression_tests/random_ray_point_source_locator/inputs_true.dat b/tests/regression_tests/random_ray_point_source_locator/inputs_true.dat
index 088f803bfa8..b4bd263f5ac 100644
--- a/tests/regression_tests/random_ray_point_source_locator/inputs_true.dat
+++ b/tests/regression_tests/random_ray_point_source_locator/inputs_true.dat
@@ -206,11 +206,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_region_meshes>
         <mesh id="1">
diff --git a/tests/regression_tests/random_ray_void/flat/inputs_true.dat b/tests/regression_tests/random_ray_void/flat/inputs_true.dat
index aa28e7b68bf..66390c76661 100644
--- a/tests/regression_tests/random_ray_void/flat/inputs_true.dat
+++ b/tests/regression_tests/random_ray_void/flat/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>flat</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_void/linear/inputs_true.dat b/tests/regression_tests/random_ray_void/linear/inputs_true.dat
index e4b2f22fa27..45228a03955 100644
--- a/tests/regression_tests/random_ray_void/linear/inputs_true.dat
+++ b/tests/regression_tests/random_ray_void/linear/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear</source_shape>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_volume_estimator/hybrid/inputs_true.dat b/tests/regression_tests/random_ray_volume_estimator/hybrid/inputs_true.dat
index 8e8a8ed9b81..4d1af46b121 100644
--- a/tests/regression_tests/random_ray_volume_estimator/hybrid/inputs_true.dat
+++ b/tests/regression_tests/random_ray_volume_estimator/hybrid/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <volume_estimator>hybrid</volume_estimator>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_volume_estimator/naive/inputs_true.dat b/tests/regression_tests/random_ray_volume_estimator/naive/inputs_true.dat
index 1e25b97da66..a268d55d04a 100644
--- a/tests/regression_tests/random_ray_volume_estimator/naive/inputs_true.dat
+++ b/tests/regression_tests/random_ray_volume_estimator/naive/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <volume_estimator>naive</volume_estimator>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_volume_estimator/simulation_averaged/inputs_true.dat b/tests/regression_tests/random_ray_volume_estimator/simulation_averaged/inputs_true.dat
index 78c16269763..777ccaea510 100644
--- a/tests/regression_tests/random_ray_volume_estimator/simulation_averaged/inputs_true.dat
+++ b/tests/regression_tests/random_ray_volume_estimator/simulation_averaged/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <volume_estimator>simulation_averaged</volume_estimator>
     </random_ray>
diff --git a/tests/regression_tests/random_ray_volume_estimator_linear/hybrid/inputs_true.dat b/tests/regression_tests/random_ray_volume_estimator_linear/hybrid/inputs_true.dat
index 47a8a718249..dd11567f69d 100644
--- a/tests/regression_tests/random_ray_volume_estimator_linear/hybrid/inputs_true.dat
+++ b/tests/regression_tests/random_ray_volume_estimator_linear/hybrid/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear</source_shape>
       <volume_estimator>hybrid</volume_estimator>
diff --git a/tests/regression_tests/random_ray_volume_estimator_linear/naive/inputs_true.dat b/tests/regression_tests/random_ray_volume_estimator_linear/naive/inputs_true.dat
index 80a9ada4d5b..6933fba435e 100644
--- a/tests/regression_tests/random_ray_volume_estimator_linear/naive/inputs_true.dat
+++ b/tests/regression_tests/random_ray_volume_estimator_linear/naive/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear</source_shape>
       <volume_estimator>naive</volume_estimator>
diff --git a/tests/regression_tests/random_ray_volume_estimator_linear/simulation_averaged/inputs_true.dat b/tests/regression_tests/random_ray_volume_estimator_linear/simulation_averaged/inputs_true.dat
index 4f032a62a82..3ccab1d21b7 100644
--- a/tests/regression_tests/random_ray_volume_estimator_linear/simulation_averaged/inputs_true.dat
+++ b/tests/regression_tests/random_ray_volume_estimator_linear/simulation_averaged/inputs_true.dat
@@ -207,11 +207,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_shape>linear</source_shape>
       <volume_estimator>simulation_averaged</volume_estimator>
diff --git a/tests/regression_tests/weightwindows_fw_cadis/inputs_true.dat b/tests/regression_tests/weightwindows_fw_cadis/inputs_true.dat
index 5fa6505ddf4..6bdabfbee31 100644
--- a/tests/regression_tests/weightwindows_fw_cadis/inputs_true.dat
+++ b/tests/regression_tests/weightwindows_fw_cadis/inputs_true.dat
@@ -222,11 +222,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <volume_estimator>naive</volume_estimator>
     </random_ray>
diff --git a/tests/regression_tests/weightwindows_fw_cadis_mesh/flat/inputs_true.dat b/tests/regression_tests/weightwindows_fw_cadis_mesh/flat/inputs_true.dat
index ceb89e6e34c..a0d84257a8d 100644
--- a/tests/regression_tests/weightwindows_fw_cadis_mesh/flat/inputs_true.dat
+++ b/tests/regression_tests/weightwindows_fw_cadis_mesh/flat/inputs_true.dat
@@ -222,11 +222,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_region_meshes>
         <mesh id="1">
diff --git a/tests/regression_tests/weightwindows_fw_cadis_mesh/linear/inputs_true.dat b/tests/regression_tests/weightwindows_fw_cadis_mesh/linear/inputs_true.dat
index c7691e950c4..62f8478586b 100644
--- a/tests/regression_tests/weightwindows_fw_cadis_mesh/linear/inputs_true.dat
+++ b/tests/regression_tests/weightwindows_fw_cadis_mesh/linear/inputs_true.dat
@@ -222,11 +222,13 @@
     <random_ray>
       <distance_active>500.0</distance_active>
       <distance_inactive>100.0</distance_inactive>
-      <source type="independent" strength="1.0" particle="neutron">
-        <space type="box">
-          <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
-        </space>
-      </source>
+      <ray_source>
+        <source type="independent" strength="1.0" particle="neutron">
+          <space type="box">
+            <parameters>0.0 0.0 0.0 30.0 30.0 30.0</parameters>
+          </space>
+        </source>
+      </ray_source>
       <volume_normalized_flux_tallies>true</volume_normalized_flux_tallies>
       <source_region_meshes>
         <mesh id="1">