diff --git a/docs/tutorials/Nautilus_tutorial.ipynb b/docs/tutorials/Nautilus_tutorial.ipynb
new file mode 100644
index 00000000..8f95425f
--- /dev/null
+++ b/docs/tutorials/Nautilus_tutorial.ipynb
@@ -0,0 +1,434 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Nautilus Introduction #\n",
+    "\n",
+    "by Quinn Blackstone, Aniruddh Chalagulla, Eshel Dror and Niklas Naworal  (2026)\n",
+    "\n",
+    "This is a tutorial for using the [Nautilus](https://arxiv.org/abs/2306.16923) sampler in `orbitize`!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import orbitize\n",
+    "import numpy as np\n",
+    "import multiprocessing as mp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Basic Orbit Generating\n",
+    "\n",
+    "Before we get on with orbit generation, lets get some data ready. Already have a file? Lets convert it into a format the sampler can understand."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from orbitize.read_input import read_file\n",
+    "data_table = read_file('{}/GJ504.csv'.format(orbitize.DATADIR)) # path to data file, now we can input this data into the sampler"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Not done yet, you have to put everyting together."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from orbitize import system"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now put all the data and parameters together:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mySys = system.System(\n",
+    "        1, # number of bodies in your system (int)\n",
+    "        data_table, # the data you got previously (table)\n",
+    "        1.22, # mass of the system (float)\n",
+    "        56.95, # paralax (float)\n",
+    "        0, # mass err (int)\n",
+    "        0, # plx err (int) \n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is cool and all but if we run the sampler on this data, it's going to take time. I'm a tutorial we don't have time for that, instead lets generate some synthetic data with the `generate_synthetic_data()` function\n",
+    "\n",
+    "Cool thing about this function is that it calculates the semi major axis for you"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from orbitize.system import generate_synthetic_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "data_table, sma = generate_synthetic_data(\n",
+    "    95, # orbital fraction, how much of the orbit is covered (0-100%)\n",
+    "    1.2, # mass of the system\n",
+    "    60, # paralax\n",
+    "    0.1, # eccentricity (float)\n",
+    "    np.pi/6, # inclination (float)\n",
+    "    unc=2, # uncertainty (int)\n",
+    "    num_obs=30, # number of observations to be made (int)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "mySys = system.System(1, data_table, 1.2, 60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initialize the sampler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from orbitize import sampler"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "mysampler = sampler.NautilusSampler(mySys)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Nice, now it's time to run the sampler\n",
+    "\n",
+    "A bit more on the hyperparameters\n",
+    "\n",
+    "Sampler arguments-\n",
+    "n_networks: The number of neural networks trained to determine the iso-likelihood shells at each iteration. The likelihood scores prediceted by the neural networks are averaged to determine if a point is included in a shell. A higher value of n_networks leads to greater sampling efficiency at the cost of higher overhead per iteration. Neural network training is not parallelized.\n",
+    "n_batch: The number of orbits evaluated in each iteration, must be a multiple of num_threads. Each thread evaluates a set of n_batch/num_threads orbits. Higher n_batch takes advantage of the vectorized prior transform to improve computation speed, at the cost of some extra likelihood evaluations being performed in each shell (i.e. if n_update is 2500 samples and n_batch is 1000 then 3000 samples would be taken).\n",
+    "\n",
+    "Run arguments-\n",
+    "f_live: The maximum fraction of the evidence left in the live set before switching from the exploration to the sampling phase. This can be used to act as an ending point for the exploration phase (when shells are created), larger values lead to faster convergence but may not converge fully.\n",
+    "n_eff: The total effective size of the sample. Larger values produce higher quality posterior estimations but take longer to run. Acts as the ending point of the sampling phase.\n",
+    "\n",
+    "n_live: Number of live points used in the sampling process. Greater n_live yields better evidence estimation and shell accuracy but increased run time and computational cost.\n",
+    "num_threads: Number of threads used in parallel, greater number increases speed.\n",
+    "n_update: Number of additions to the live set before creating a new shell. If None defaults to n_live. Greater n_update leads to better shell accuracy but increased run time.\n",
+    "verbose: Lets you choose wether or not to display live updates of the sampler.\n",
+    "savefile: The name for a file that you want to save or resume nautilus progress to or from.\n",
+    "\n",
+    "See more on the possible hyperparameters in the [Nautilus docs](https://nautilus-sampler.readthedocs.io/en/latest/api_full.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting the nautilus sampler...\n",
+      "Please report issues at github.com/johannesulf/nautilus.\n",
+      "Status    | Bounds | Ellipses | Networks | Calls    | f_live | N_eff | log Z    \n",
+      "Finished  | 49     | 1        | 4        | 113100   | N/A    | 4503  | -166.17  \n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler_arg = {\n",
+    "    \"n_networks\": 4,\n",
+    "    \"n_batch\": None, #(int)  \n",
+    "    }\n",
+    "run_arg = {\"f_live\": 0.01, \"n_eff\": 1000} \n",
+    "samples = mysampler.run_sampler(\n",
+    "        n_live=500, #(int)\n",
+    "        num_threads=mp.cpu_count(), #(int)\n",
+    "        n_update=None, #(int)\n",
+    "        verbose=True, #(bool) \n",
+    "        savefile=None, #(str)\n",
+    "        sampler_kwargs=sampler_arg,\n",
+    "        run_kwargs=run_arg\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plotting and results ##\n",
+    "\n",
+    "For a more detailed guide on data visualization capabilities within orbitize, see the [Orbitize plotting tutorial](https://orbitize.readthedocs.io/en/latest/tutorials/Plotting_tutorial.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After generating the samples, the `run_sampler` method also creates a `Results` object that can be accessed\n",
+    "with `mysampler.results`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "myResults = mysampler.results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Weighted results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What is the difference between post and weighted post?\n",
+    "Weighted results are all the points that have been sampled by Nautilus weighted by shell sampling density and likelihood. The main benefit of weighted results is that they contain all points instead of equal-weighted results which are downsampled from it with no duplicates. plot_corner is able to make use of the weighted results for better accuracy but plot_orbits is not and therefore defaults to the unweighted results.\n",
+    "\n",
+    "myResults.weighted_post returns weighted posteriors if it exists, and unweighted if it does not, so you can still get the posterior from Nautilus without weights.\n",
+    "myResults.weighted_lnlike functions similarly for getting the log-likelihoods\n",
+    "\n",
+    "myResults.post is always unweighted. The same goes for myResults.lnlike.\n",
+    "Weight can be acquired from myResults.weight"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1954, 8)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "myResults.post.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(111635, 8)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "myResults.weighted_post.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In case you want more points than that of the unweighted results but fewer points than the weighted, you can use the downsample function. Note that if you do not allow duplicates, you will not obtain a completely true posterior (especially if your `amount` approaches the weighted posterior size); if you want a true equal-weighted posterior without duplicates use myResults.post."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((150000, 8), (150000,))"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Samples from the posterior a number of times. If the posterior is weighted, samples proportionally to weight to get an equal-weighted posterior.\n",
+    "post, lnlike = myResults.downsample(\n",
+    "                     150000, # amount\n",
+    "                     True # allow duplicates\n",
+    "                                    )\n",
+    "post.shape, lnlike.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You might be wondering what kind of cases you might want duplicates to be true, it would be when you want more points.\n",
+    "For example this would return an error:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downsampling error: Cannot take a larger sample than population when 'replace=False'\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    post, lnlike = myResults.downsample(250000, duplicates=False)\n",
+    "    print(post.shape, lnlike.shape)\n",
+    "\n",
+    "except ValueError as error:\n",
+    "    print(f\"Downsampling error: {error}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In addition to our `orbits` array, Orbitize also creates a `Results` class that contains built-in plotting capabilities for two types of plots: corner plots and orbit plots. These cornerplots can also take in weighted results, in addition to downsizing them.\n",
+    "\n",
+    "### Corner Plot ###"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now create a corner plot using the function `plot_corner` within the `Results` class. This function requires an input list of the parameters, in string format, that you wish to include in your corner plot. We can even plot all of the orbital parameters at once! You may wish to use the `downsample` keyword if you want a quick graph as the full weighted posteriors tend to take a while to plot. As shown below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 970x970 with 16 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "corner_figure = myResults.plot_corner(downsample=100000,param_list=['sma1', 'ecc1', 'inc1','tau1'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Find out more about generating orbits in ``orbitize!`` with tutorials [here](https://orbitize.readthedocs.io/en/latest/tutorials.html)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/orbitize/plot.py b/orbitize/plot.py
index 7f248695..77976e67 100644
--- a/orbitize/plot.py
+++ b/orbitize/plot.py
@@ -28,8 +28,7 @@
     cmap(np.linspace(0.0, 0.7, 1000)),
 )
 
-
-def plot_corner(results, param_list=None, **corner_kwargs):
+def plot_corner(results, param_list=None, downsample=None, **corner_kwargs):
     """
     Make a corner plot of posterior on orbit fit from any sampler
 
@@ -55,6 +54,9 @@ def plot_corner(results, param_list=None, **corner_kwargs):
                 sigma: rv jitter
                 mi: mass of individual body i, for i = 0, 1, 2, ... (only if fit_secondary_mass == True)
                 mtot: total mass (only if fit_secondary_mass == False)
+        
+        downsample (int):
+            amount of samples to randomly draw from the posterior using ``results.downsample``
 
         **corner_kwargs: any remaining keyword args are sent to ``corner.corner``.
                             See `here <https://corner.readthedocs.io/>`_.
@@ -125,8 +127,15 @@ def plot_corner(results, param_list=None, **corner_kwargs):
         else:
             fixed_indices.append(i)
 
+    if downsample is not None:
+        post, _ = results.downsample(downsample)
+        weights = None
+    else:
+        post = results.weighted_post
+        weights = results.weights
+
     samples = np.copy(
-        results.post[:, param_indices]
+        post[:, param_indices]
     )  # keep only chains for selected parameters
     samples[:, angle_indices] = np.degrees(
         samples[:, angle_indices]
@@ -161,7 +170,7 @@ def plot_corner(results, param_list=None, **corner_kwargs):
 
         corner_kwargs["labels"] = reduced_labels_list
 
-    figure = corner.corner(samples, **corner_kwargs)
+    figure = corner.corner(samples, weights=weights, **corner_kwargs)
     return figure
 
 
diff --git a/orbitize/results.py b/orbitize/results.py
index fea92e13..0d7533b1 100644
--- a/orbitize/results.py
+++ b/orbitize/results.py
@@ -9,7 +9,6 @@
 import orbitize.plot
 import orbitize.gaia, orbitize.hipparcos
 
-
 class Results(object):
     """
     A class to store accepted orbital configurations from the sampler
@@ -28,6 +27,15 @@ class Results(object):
         data (astropy.table.Table): output from ``orbitize.read_input.read_file()``
         curr_pos (np.array of float): for MCMC only. A multi-D array of the 
             current walker positions that is used for restarting a MCMC sampler. 
+        weighted_post (np.array of float): RxN array of orbital parameters
+            (posterior output from weighted orbit-fitting process), where R is the
+            number of orbits generated, and N is the number of varying orbital
+            parameters in the fit (default: None).
+        weighted_lnlike (np.array of float): R array of log-likelihoods corresponding to
+            the orbits described in ``weighted_post`` (default: None).
+        lnweights (np.array of float): R array of log-weights corresponding to the orbits
+            and log-likelihoods described in ``weighted_post`` and ``weighted_lnlike`` (default: None)
+        
 
     Written: Henry Ngo, Sarah Blunt, 2018
 
@@ -36,7 +44,7 @@ class Results(object):
 
     def __init__(
         self, system=None, sampler_name=None, post=None, lnlike=None,
-        version_number=None, curr_pos=None
+        version_number=None, curr_pos=None, weighted_post=None, weighted_lnlike=None, lnweight=None
     ):
 
         self.system = system
@@ -45,6 +53,9 @@ def __init__(
         self.lnlike = lnlike
         self.curr_pos = curr_pos
         self.version_number = version_number
+        self._weighted_post = weighted_post
+        self._weighted_lnlike = weighted_lnlike
+        self.lnweight = lnweight
         self.ln_evidence = None
         self.ln_evidence_err = None
 
@@ -58,7 +69,60 @@ def __init__(
             self.param_idx = self.system.param_idx
             self.standard_param_idx = self.system.basis.standard_basis_idx
 
-    def add_samples(self, orbital_params, lnlikes, curr_pos=None): 
+    @property
+    def weighted_post(self):
+        """
+        Returns the weighted posterior if it exists,
+        otherwise returns the unweighted posterior.
+        """
+        if self._weighted_post is not None:
+            return self._weighted_post
+        return self.post
+    
+    @property
+    def weighted_lnlike(self):
+        """
+        Returns the weighted log-likelihoods if it exists,
+        otherwise returns the unweighted log-likelihoods.
+        """
+        if self._weighted_lnlike is not None:
+            return self._weighted_lnlike
+        return self.lnlike
+    
+    @property
+    def weights(self):
+        """
+        Returns the weights of ``weighted_post`` and ``weighted_lnlike``
+        if it exists, otherwise returns None.
+        """
+        if self.lnweight is None:
+            return None
+        return np.exp(self.lnweight)
+    
+    def downsample(self, amount, duplicates=True):
+        """
+        Samples from the posterior, or the weighted posterior if it exists.
+
+        Args:
+            amount (int): number of samples to draw from the posetrior
+            duplicates (bool): whether to replace sampled orbits from the posterior,
+                which may cause duplicate samples (default: True)
+        
+        Returns:
+            tuple:
+
+                numpy.array of float: orbital parameters of the samples (``amount``xN, where N is number of varying orbital parameters)
+
+                numpy.array of float: log-likelihoods of the samples (length ``amount``)
+
+        """
+
+        indexes = np.random.choice(len(self.weighted_post), amount, duplicates, self.weights)
+        if self.weighted_lnlike is None:
+            return self.weighted_post[indexes], None
+        return self.weighted_post[indexes], self.weighted_lnlike[indexes]
+        
+    def add_samples(self, orbital_params, lnlikes, curr_pos=None, weighted_post=None, weighted_lnlike=None, lnweight=None): 
         """
         Add accepted orbits, their likelihoods, and the orbitize version number 
         to the results
@@ -69,6 +133,12 @@ def add_samples(self, orbital_params, lnlikes, curr_pos=None):
             lnlike (np.array): add corresponding lnlike values to results
             curr_pos (np.array of float): for MCMC only. A multi-D array of the 
                 current walker positions
+            weighted_post (np.array): for Nautilus only. Sets of orbital params
+                associated with ``lnweight`` to add to results.
+            weighted_lnlike (np.array): for Nautilus only. Corresponding weighted lnlike
+                values for ``weighted_post`` to add to results.
+            weighted_post (np.array): for Nautilus only. Log of weights associated
+                with ``weighted_post`` and ``weighted_lnlike``.
 
         Written: Henry Ngo, 2018
 
@@ -88,6 +158,16 @@ def add_samples(self, orbital_params, lnlikes, curr_pos=None):
         else:
             self.post = np.vstack((self.post, orbital_params))
             self.lnlike = np.append(self.lnlike, lnlikes)
+        
+        if weighted_post is not None:
+            if self._weighted_post is None:
+                self._weighted_post = weighted_post
+                self._weighted_lnlike = weighted_lnlike
+                self.lnweight = lnweight
+            else:
+                self._weighted_post = np.vstack((self._weighted_post, weighted_post))
+                self._weighted_lnlike = np.append(self._weighted_lnlike, weighted_lnlike)
+                self.lnweight = np.append(self.lnweight, lnweight)
 
         if curr_pos is not None:
             self.curr_pos = curr_pos
@@ -132,6 +212,12 @@ def save_results(self, filename):
         if self.curr_pos is not None:
             hf.create_dataset("curr_pos", data=self.curr_pos)
 
+        if self._weighted_post is not None and self._weighted_lnlike is not None and self.lnweight is not None:
+            hf.create_dataset("weighted_post", data=self._weighted_post)
+            hf.create_dataset("weighted_lnlike", data=self._weighted_lnlike)
+            hf.create_dataset("lnweight", data=self.lnweight)
+
+
         self.system.save(hf)
 
         hf.close()  # Closes file object, which writes file to disk
@@ -160,12 +246,12 @@ def load_results(self, filename, append=False):
             version_number = str(hf.attrs['version_number'])
         else:
             version_number = "<= 1.13"
-        post = hf.get('post')
-        if post is not None:
-            post = np.array(post)
-        lnlike = hf.get('lnlike')
-        if lnlike is not None:
-            lnlike = np.array(lnlike)
+
+        post = array_not_none(hf.get('post'))
+        lnlike = array_not_none(hf.get('lnlike'))
+        weighted_post = array_not_none(hf.get('weighted_post'))
+        weighted_lnlike = array_not_none(hf.get('weighted_lnlike'))
+        lnweight = array_not_none(hf.get("lnweight"))
 
         if 'num_secondary_bodies' in hf.attrs:
             num_secondary_bodies = int(hf.attrs['num_secondary_bodies'])
@@ -287,10 +373,7 @@ def load_results(self, filename, append=False):
         if 'ln_evidence_err' in hf.attrs:
             self.ln_evidence_err = hf.attrs['ln_evidence_err']
 
-        try:
-            curr_pos = np.array(hf.get('curr_pos'))
-        except KeyError:
-            curr_pos = None
+        curr_pos = array_not_none(hf.get('curr_pos'))
 
         hf.close()  # Closes file object
 
@@ -316,14 +399,14 @@ def load_results(self, filename, append=False):
                     'Unable to append file {} to Results object. version_number of object and file do not match'.format(filename))
 
             # Now append post and lnlike
-            self.add_samples(post, lnlike)#, self.labels)
+            self.add_samples(post, lnlike, weighted_post=weighted_post, weighted_lnlike=weighted_lnlike, lnweight=lnweight)#, self.labels)
         else:
 
             # Only proceed if object is completely empty
-            if self.sampler_name is None and self.post is None and self.lnlike is None and self.version_number is None:# and self.tau_ref_epoch is None :
+            if self.sampler_name is None and self.post is None and self.lnlike is None and self.version_number is None and self._weighted_lnlike is None and self._weighted_post is None and self.lnweight is None:# and self.tau_ref_epoch is None :
                 self.sampler_name = sampler_name
                 self.version_number = version_number
-                self.add_samples(post, lnlike)#, self.labels)
+                self.add_samples(post, lnlike, weighted_post=weighted_post, weighted_lnlike=weighted_lnlike, lnweight=lnweight)#, self.labels)
 
             else:
                 raise Exception(
@@ -390,11 +473,11 @@ def print_results(self):
         self.results_str += '-------------------\n'
         print(self.results_str)
     
-    def plot_corner(self, param_list=None, **corner_kwargs):
+    def plot_corner(self, param_list=None, downsample=None, **corner_kwargs):
         """
         Wrapper for orbitize.plot.plot_corner
         """
-        return orbitize.plot.plot_corner(self, param_list, **corner_kwargs)
+        return orbitize.plot.plot_corner(self, param_list, downsample, **corner_kwargs)
 
     def plot_orbits(self, object_to_plot=1, start_mjd=51544.,
         num_orbits_to_plot=100, num_epochs_to_plot=100,
@@ -444,4 +527,12 @@ def plot_propermotion(self,
                         cmap=cmap,
                         cbar_param=cbar_param,
                         # fig=fig
-                        )
\ No newline at end of file
+                        )
+
+def array_not_none(raw):
+    """
+    Returns a numpy.array of the input if it is not None, else returns None
+    """
+    if raw is not None:
+        return np.array(raw)
+    return raw
diff --git a/orbitize/sampler.py b/orbitize/sampler.py
index dcf0765d..7be67596 100644
--- a/orbitize/sampler.py
+++ b/orbitize/sampler.py
@@ -8,6 +8,7 @@
 import dynesty
 import emcee
 import matplotlib.pyplot as plt
+import nautilus
 import numpy as np
 import ptemcee
 
@@ -18,6 +19,8 @@
 import orbitize.priors
 import orbitize.results
 
+import sys
+
 
 class Sampler(abc.ABC):
     """
@@ -1309,7 +1312,32 @@ def check_prior_support(self):
         return
 
 
-class NestedSampler(Sampler):
+class BaseNestedSampler(Sampler):
+    def ptform(self, u):
+        """
+        Prior transform function.
+
+        Args:
+            u (np.array of floats): RxM array of uniform
+                samples with values 0 < u < 1,
+                where R is the number of parameters
+                and M is the number of orbits
+
+        Returns:
+            numpy RxM array of floats: u samples transformed to
+                a chosen Prior Class distribution.
+        """
+        utform = np.zeros(u.shape)
+        for i in range(u.shape[0]):
+            if hasattr(self.system.sys_priors[i], 'transform_samples'):
+                utform[i] = self.system.sys_priors[i].transform_samples(u[i])
+            else:
+                # prior is a fixed number
+                utform[i] = self.system.sys_priors[i]
+        return utform
+
+
+class NestedSampler(BaseNestedSampler):
     """
     Implements nested sampling using the Dynesty package.
 
@@ -1352,26 +1380,6 @@ def __init__(self,
         self.start = time.time()
         self.dynesty_sampler = None
 
-    def ptform(self, u):
-        """
-        Prior transform function.
-
-        Args:
-            u (array of floats): list of samples with values 0 < u < 1.
-
-        Returns:
-            numpy array of floats: 1D u samples transformed to a chosen Prior
-                Class distribution.
-        """
-        utform = np.zeros(len(u))
-        for i in range(len(u)):
-            if hasattr(self.system.sys_priors[i], 'transform_samples'):
-                utform[i] = self.system.sys_priors[i].transform_samples(u[i])
-            else:
-                # prior is a fixed number
-                utform[i] = self.system.sys_priors[i]
-        return utform
-
     def run_sampler(
         self,
         nlive=500,
@@ -1675,3 +1683,133 @@ def _loglike_multinest(param_cube, n_dim, n_param):
             self.results.save_results(filename=hdf5_file)
 
         return post_samples[:, :-1]
+
+class NautilusSampler(BaseNestedSampler):
+    """
+    Implements nested sampling using the Nautilus-Sampler package.
+
+    Args:
+        system (system.System): system.System object
+        chi2_type (str, optional): either  "standard", or "log"
+        like (str): name of likelihood function in ``lnlike.py``
+        custom_lnlike (func): ability to include an addition custom likelihood
+            function in the fit. The function looks like
+            ``clnlikes = custon_lnlike(params)`` where ``params`` is a RxM array
+            of fitting parameters, where R is the number of orbital paramters
+            (can be passed in system.compute_model()), and M is the number of
+            orbits we need model predictions for. It returns ``clnlikes``
+            which is an array of length M, or it can be a single float if M = 1.
+
+    Eshel Dror, Quinton Blackston, Aniruddh Chalagulla, & Niklas Naworal 2026
+    """
+    def __init__(self,
+        system,
+        chi2_type="standard",
+        like="chi2_lnlike",
+        custom_lnlike=None,
+    ):
+        super(NautilusSampler, self).__init__(
+            system,
+            like=like,
+            chi2_type=chi2_type,
+            custom_lnlike=custom_lnlike,
+        )
+
+        # create an empty results object
+        self.results = orbitize.results.Results(
+            self.system,
+            sampler_name=self.__class__.__name__,
+            post=None,
+            lnlike=None,
+            version_number=orbitize.__version__,
+        )
+        self.start = time.time()
+    
+    def nautilus_ptform(self, u):
+        return self.ptform(u.T).T
+    
+    def nautilus_logl(self, u: np.ndarray):
+        return self._logl(u.T).T
+    
+    def run_sampler(
+        self,
+        n_live = 2000,
+        n_update = None,
+        verbose = False,
+        num_threads = 1,
+        savefile = None,
+        sampler_kwargs = {},
+        run_kwargs = {}
+    ):
+        """Runs the nested sampler from the Nautilus package.
+
+        Args:
+            n_live (int): Number of live points. A larger numbers results
+                in a more finely sampled posterior and a more accurate
+                evidence, but also a larger number of iterations is
+                required to converge (default: 2000).
+            n_update (int): Number of points added to the live set before
+                creating a new shell. When None defaults to `n_live` (default: None).
+            verbose (bool): Print progress when running sampler (default: False).
+            num_threads (int, tuple, pool): number of threads to use for parallelization.
+                If a tuple of two integers, the number of threads for
+                likelihood evaluations and sampler calculations respectively. If a thread
+                pool, the pool used for parallelization (default=1).
+            savefile (str): File used by Nautilus to save progress.
+                If file already exists, resumes from saved progress.
+            sampler_kwargs (dict): dictionary of keywords to be passed into nautilus.Sampler,
+                such as `periodic`
+            run_kwargs (dict): dictionary of keywords to be passed into nautilus.Sampler.run,
+                such as `n_eff`
+
+
+        Returns:
+            numpy.array of float: equal-weighted posterior samples
+        """
+        if sys.version_info < (3,9,0) and isinstance(num_threads, int) and num_threads > 1:
+            with mp.Pool(processes=num_threads) as pool:
+                self.naut_sampler = nautilus.Sampler(
+                    prior=self.nautilus_ptform,
+                    likelihood=self.nautilus_logl,
+                    n_dim=len(self.system.sys_priors),
+                    vectorized=True,
+                    n_live=n_live,
+                    n_update=n_update,
+                    pool=pool,
+                    filepath=savefile,
+                    **sampler_kwargs
+                    )
+
+                success = self.naut_sampler.run(
+                    verbose=verbose,
+                    **run_kwargs
+                )
+        else:
+            self.naut_sampler = nautilus.Sampler(
+                prior=self.nautilus_ptform,
+                likelihood=self.nautilus_logl,
+                n_dim=len(self.system.sys_priors),
+                vectorized=True,
+                n_live=n_live,
+                n_update=n_update,
+                pool=num_threads,
+                filepath=savefile,
+                **sampler_kwargs
+                )
+
+            success = self.naut_sampler.run(
+                verbose=verbose,
+                **run_kwargs
+            )
+        points, _, log_l = self.naut_sampler.posterior(equal_weight = True)
+        weighted_points, log_w, weighted_log_l = self.naut_sampler.posterior()
+
+        self.results.add_samples(
+            points,
+            log_l,
+            weighted_post=weighted_points,
+            weighted_lnlike=weighted_log_l,
+            lnweight=log_w
+        )
+
+        return points
diff --git a/pyproject.toml b/pyproject.toml
index 1e7ec9b6..2698bd55 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,7 +27,8 @@ dependencies = [
     "rebound",
     "dynesty",
     "pymultinest",
-    "tk"
+    "tk",
+    "nautilus-sampler"
 ]
 
 [tool.setuptools.dynamic]
diff --git a/requirements.txt b/requirements.txt
index 2c215d7e..fea4658c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -16,3 +16,4 @@ rebound
 dynesty
 pymultinest
 tk
+nautilus-sampler
diff --git a/tests/end-to-end-tests/GJ504_naut.py b/tests/end-to-end-tests/GJ504_naut.py
new file mode 100644
index 00000000..58948f9f
--- /dev/null
+++ b/tests/end-to-end-tests/GJ504_naut.py
@@ -0,0 +1,74 @@
+import matplotlib.pyplot as plt
+
+import orbitize
+
+# Based on driver.py
+
+import numpy as np
+from orbitize import read_input, system, sampler, priors
+import multiprocessing as mp
+import orbitize
+import time
+
+savedir = ""
+
+# System parameters
+datafile = "GJ504.csv"
+num_secondary_bodies = 1
+system_mass = 1.22  # Msol
+plx = 56.95  # mas
+mass_err = 0.08  # Msol
+plx_err = 0.26  # mas
+
+# Sampler parameters
+likelihood_func_name = "chi2_lnlike"
+n_threads = mp.cpu_count()
+n_live = 2000
+n_update = None
+sampler_args = {"n_networks": 4}
+run_args = {"f_live": 0.01, "n_eff": 10000}
+
+naut_file = f"{savedir}GJ504_naut.hdf5"
+
+results_file = f"{savedir}GJ504_results.hdf5"
+
+tau_ref_epoch = 50000
+
+
+# Read in data
+data_table = read_input.read_file(orbitize.DATADIR + datafile)
+
+# Initialize System object which stores data & sets priors
+my_system = system.System(
+    num_secondary_bodies,
+    data_table,
+    system_mass,
+    plx,
+    mass_err=mass_err,
+    plx_err=plx_err,
+    tau_ref_epoch=tau_ref_epoch,
+)
+
+my_sampler = sampler.NautilusSampler(my_system, like=likelihood_func_name)
+
+print(f"Running {datafile} sampler with {n_threads} {n_live} {n_update} {sampler_args} {run_args}")
+# Run the sampler to compute some orbits, yeah!
+my_sampler.run_sampler(n_live,
+                       n_update,
+                       verbose=False,
+                       num_threads=n_threads,
+                       savefile=naut_file,
+                       sampler_kwargs=sampler_args,
+                       run_kwargs=run_args)
+
+end = time.time()
+print(f"Processing time: {end} - {my_sampler.start} = {(end-my_sampler.start) / 60} minutes")
+
+
+my_sampler.results.save_results(results_file)
+
+# make corner plot
+fig = my_sampler.results.plot_corner(downsample=10000)
+plt.savefig(f"{savedir}GJ504_naut_corner.png", dpi=250)
+
+my_sampler.results.print_results()
\ No newline at end of file
diff --git a/tests/test_mcmc.py b/tests/test_mcmc.py
index 329434c2..3f85c3ed 100644
--- a/tests/test_mcmc.py
+++ b/tests/test_mcmc.py
@@ -96,6 +96,7 @@ def do_mcmc_runs(num_temps=0, num_threads=1, make_corner_plot=False):
     if make_corner_plot:
         assert myDriver.system.plx_err == 0 # (check that we're actually fixing at least one param: plx)
         plot_corner(new_sampler.results)
+        plot_corner(new_sampler.results, downsample=1000) # Test unweighted downsampling
 
     # clean up
     os.system(f'rm {output_filename} {output_filename_2}')
diff --git a/tests/test_nautilus.py b/tests/test_nautilus.py
new file mode 100644
index 00000000..0da3921a
--- /dev/null
+++ b/tests/test_nautilus.py
@@ -0,0 +1,56 @@
+import pytest
+from orbitize import sampler, system, results
+import numpy as np
+from orbitize.system import generate_synthetic_data
+import matplotlib.pyplot as plt
+""" This is pytest for Nautilus_Sampler, it assumes values for all the priors except 
+
+    eccentricity and trys to calculate the true eccentricity """
+
+def test_nautilus_general(make_plot=False):
+    # generate synthetic data
+    mtot = 1.2
+    plx = 60.0
+    orbit_frac = 95
+    ecc = 0.1
+    inc = np.pi/4
+    data_table, sma = generate_synthetic_data(
+        orbit_frac,
+        mtot,
+        plx,
+        num_obs=30,
+        ecc = ecc,
+        inc = inc
+    )
+
+    #initlialize the orbit
+
+    mySys = system.System(1, data_table, mtot, plx)
+    lab = mySys.param_idx
+
+    #set all paremeters except eccentricity
+
+    #mySys.sys_priors[lab["inc1"]] = np.pi / 4,
+    mySys.sys_priors[lab["sma1"]] = sma 
+    mySys.sys_priors[lab["aop1"]] = np.pi / 4
+    mySys.sys_priors[lab["pan1"]] = np.pi / 4
+    mySys.sys_priors[lab["tau1"]] = 0.8
+    mySys.sys_priors[lab["plx"]] = plx
+    mySys.sys_priors[lab["mtot"]] = mtot
+        
+    my_sampler = sampler.NautilusSampler(mySys)
+    my_sampler.run_sampler(n_live=800, n_update=None, verbose=False)
+    
+    nautilus_eccentricities = my_sampler.results.post[:, lab["ecc1"]]
+    assert np.mean(nautilus_eccentricities) == pytest.approx(0.1, abs=0.1)
+
+    nautilus_inclination = my_sampler.results.post[:, lab["inc1"]]
+    assert np.median(nautilus_inclination) == pytest.approx(inc, abs=0.1)
+
+    if make_plot:
+        myResults = my_sampler.results
+        myResults.plot_corner(param_list=["ecc1","inc1"]) # No downsampling
+        myResults.plot_corner(param_list=["ecc1","inc1"], downsample = 1000) # With downsampling
+
+if __name__ ==  "__main__":
+    test_nautilus_general(make_plot = True)
diff --git a/tests/test_results.py b/tests/test_results.py
index 0840a993..3f380f70 100644
--- a/tests/test_results.py
+++ b/tests/test_results.py
@@ -75,7 +75,7 @@ def simulate_orbit_sampling(n_sim_orbits):
     return sim_post
 
 
-def test_init_and_add_samples(radec_input=False):
+def test_init_and_add_samples(radec_input=False, weighted=False):
     """
     Tests object creation and add_samples() with some simulated posterior
     samples, and returns results.Results object
@@ -96,8 +96,18 @@ def test_init_and_add_samples(radec_input=False):
     n_orbit_draws1 = 1000
     sim_post = simulate_orbit_sampling(n_orbit_draws1)
     sim_lnlike = np.random.uniform(size=n_orbit_draws1)
-    # Test adding samples
-    results_obj.add_samples(sim_post, sim_lnlike)  # , labels=std_labels)
+    if weighted:
+        n_weighted_orbit_draws1 = 4000
+        sim_weighted_post = simulate_orbit_sampling(n_weighted_orbit_draws1)
+        sim_weighted_lnlike = np.random.uniform(size=n_weighted_orbit_draws1)
+        sim_weight = np.random.uniform(size=n_weighted_orbit_draws1)
+        sim_lnweight = np.log(sim_weight / np.sum(sim_weight)) # Normalize
+        # Test adding samples
+        results_obj.add_samples(sim_post, sim_lnlike, weighted_post=sim_weighted_post,
+                                weighted_lnlike=sim_weighted_lnlike, lnweight=sim_lnweight)
+    else:
+        # Test adding samples
+        results_obj.add_samples(sim_post, sim_lnlike)  # , labels=std_labels)
     # Simulate some more sample draws
     n_orbit_draws2 = 2000
     sim_post = simulate_orbit_sampling(n_orbit_draws2)
@@ -108,6 +118,12 @@ def test_init_and_add_samples(radec_input=False):
     expected_length = n_orbit_draws1 + n_orbit_draws2
     assert results_obj.post.shape == (expected_length, 8)
     assert results_obj.lnlike.shape == (expected_length,)
+    if weighted:
+        expected_length_weighted = n_weighted_orbit_draws1
+        assert results_obj.weighted_post.shape == (expected_length_weighted, 8)
+        assert results_obj.weighted_lnlike.shape == (expected_length_weighted,)
+        assert results_obj.weights.shape == (expected_length_weighted,)
+        
     assert results_obj.tau_ref_epoch == 58849
     assert results_obj.labels == std_labels
 
@@ -132,8 +148,15 @@ def results_to_test():
     n_orbit_draws2 = 2000
     sim_post = simulate_orbit_sampling(n_orbit_draws2)
     sim_lnlike = np.random.uniform(size=n_orbit_draws2)
-    # Test adding more samples
-    results_obj.add_samples(sim_post, sim_lnlike)
+    # Simulate some weighted draws
+    n_weighted_orbit_draws = 4000
+    sim_weighted_post = simulate_orbit_sampling(n_weighted_orbit_draws)
+    sim_weighted_lnlike = np.random.uniform(size=n_weighted_orbit_draws)
+    sim_weight = np.random.uniform(size=n_weighted_orbit_draws)
+    sim_lnweight = np.log(sim_weight / np.sum(sim_weight)) # Normalize
+    # Test adding weighted and more samples
+    results_obj.add_samples(sim_post, sim_lnlike, weighted_post=sim_weighted_post,
+                            weighted_lnlike=sim_weighted_lnlike, lnweight=sim_lnweight)
     # Return object for testing
     return results_obj
 
@@ -173,8 +196,11 @@ def test_save_and_load_results(results_to_test, has_lnlike=True):
     assert results_to_save.sampler_name == loaded_results.sampler_name
     assert results_to_save.version_number == loaded_results.version_number
     assert np.array_equal(results_to_save.post, loaded_results.post)
+    assert np.array_equal(results_to_save.weighted_post, loaded_results.weighted_post)
+    assert np.array_equal(results_to_save.lnweight, loaded_results.lnweight)
     if has_lnlike:
         assert np.array_equal(results_to_save.lnlike, loaded_results.lnlike)
+        assert np.array_equal(results_to_save.weighted_lnlike, loaded_results.weighted_lnlike)
     # Try to load the saved results again, this time appending
     loaded_results.load_results(save_filename, append=True)
     # Now check that the loaded results object has the expected size
@@ -200,7 +226,8 @@ def test_save_and_load_results(results_to_test, has_lnlike=True):
 def test_plot_corner(results_to_test):
     """
     Tests plot_corner() with plotting simulated posterior samples
-    for all 8 parameters and for just four selected parameters
+    for all 8 parameters, for just four selected parameters,
+    with fixed parameters, and downsampled
     """
 
     Figure1 = results_to_test.plot_corner()
@@ -213,10 +240,15 @@ def test_plot_corner(results_to_test):
     # test that fixing parameters doesn't crash corner plot code
     results_to_test.post[:, -1] = np.ones(len(results_to_test.post[:, -1]))
     Figure3 = results_to_test.plot_corner()
+    assert Figure3 is not None
 
     results_to_test.post[:, -1] = mass_vals
 
-    return Figure1, Figure2, Figure3
+    Figure4 = results_to_test.plot_corner(downsample=1000)
+    assert Figure4 is not None
+
+
+    return Figure1, Figure2, Figure3, Figure4
 
 
 def test_plot_orbits(results_to_test):
@@ -245,6 +277,25 @@ def test_plot_orbits(results_to_test):
     assert Figure5 is not None
     return (Figure1, Figure2, Figure3, Figure4, Figure5)
 
+def test_downsample(results_to_test):
+    """
+    Test downsample() with simulated posterior samples
+    """
+    size = results_to_test.weighted_post.shape[0]
+    post, lnlikes = results_to_test.downsample(size*2, duplicates=True)
+    assert post.shape[0] == size*2
+    assert lnlikes.shape[0] == size*2
+    post, lnlikes = results_to_test.downsample(size, duplicates=False)
+    assert post.shape[0] == size
+    assert lnlikes.shape[0] == size
+    try:
+        post, lnlikes = results_to_test.downsample(size+1, duplicates=False)
+    except ValueError:
+        pass # Expected error when taking too many samples without replacement
+    else:
+        assert False, "Expected ValueError for drawing more samples than possible without duplicates did not occur"
+
+
 
 def test_save_and_load_hipparcos_only():
     """
@@ -339,17 +390,20 @@ def test_save_and_load_gaia_and_hipparcos():
     test_save_and_load_hipparcos_only()
     test_save_and_load_gaia_and_hipparcos()
 
+    # Not weighted
     test_results = test_init_and_add_samples()
 
     test_results_printing(test_results)
     test_plot_long_periods(test_results)
+    test_downsample(test_results)
+    # TODO: Update failing test with radec_input=True
     test_results_radec = test_init_and_add_samples(radec_input=True)
 
     test_save_and_load_results(test_results, has_lnlike=True)
     test_save_and_load_results(test_results, has_lnlike=True)
     test_save_and_load_results(test_results, has_lnlike=False)
     test_save_and_load_results(test_results, has_lnlike=False)
-    test_corner_fig1, test_corner_fig2, test_corner_fig3 = test_plot_corner(
+    test_corner_fig1, test_corner_fig2, test_corner_fig3, test_corner_fig4 = test_plot_corner(
         test_results
     )
     test_orbit_figs = test_plot_orbits(test_results)
@@ -357,11 +411,29 @@ def test_save_and_load_gaia_and_hipparcos():
     test_corner_fig1.savefig("test_corner1.png")
     test_corner_fig2.savefig("test_corner2.png")
     test_corner_fig3.savefig("test_corner3.png")
+    test_corner_fig4.savefig("test_corner4.png")
     test_orbit_figs[0].savefig("test_orbit1.png")
     test_orbit_figs[1].savefig("test_orbit2.png")
     test_orbit_figs[2].savefig("test_orbit3.png")
     test_orbit_figs[3].savefig("test_orbit4.png")
     test_orbit_figs[4].savefig("test_orbit5.png")
 
+    # Weighted
+    test_results_weighted = test_init_and_add_samples(weighted=True)
+
+    test_results_printing(test_results_weighted)
+    test_downsample(test_results_weighted)
+
+    test_save_and_load_results(test_results_weighted, has_lnlike=True)
+    test_save_and_load_results(test_results_weighted, has_lnlike=True)
+    test_save_and_load_results(test_results_weighted, has_lnlike=False)
+    test_save_and_load_results(test_results_weighted, has_lnlike=False)
+    test_corner_fig5, test_corner_fig6, test_corner_fig7, test_corner_fig8 = test_plot_corner(
+        test_results_weighted
+    )
+    test_corner_fig5.savefig("test_corner5.png")
+    test_corner_fig6.savefig("test_corner6.png")
+    test_corner_fig7.savefig("test_corner7.png")
+    test_corner_fig8.savefig("test_corner8.png")
     # clean up
     os.system("rm test_*.png")