diff --git a/CMakeLists.txt b/CMakeLists.txt
index 381f0cd7b..626aadae8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -336,7 +336,7 @@ set_target_properties(
 add_custom_command(TARGET libopenmc POST_BUILD
   COMMAND ${CMAKE_COMMAND} -E copy
   $<TARGET_FILE:libopenmc>
-  ${CMAKE_CURRENT_SOURCE_DIR}/openmc/capi/$<TARGET_FILE_NAME:libopenmc>
+  ${CMAKE_CURRENT_SOURCE_DIR}/openmc/lib/$<TARGET_FILE_NAME:libopenmc>
   COMMENT "Copying libopenmc to Python module directory")
 
 #===============================================================================
diff --git a/docs/source/capi/index.rst b/docs/source/capi/index.rst
index 90bef1909..0ce1c234d 100644
--- a/docs/source/capi/index.rst
+++ b/docs/source/capi/index.rst
@@ -1,17 +1,17 @@
 .. _capi:
 
-=====
-C API
-=====
+=========
+C/C++ API
+=========
 
 The libopenmc shared library that is built when installing OpenMC exports a
 number of C interoperable functions and global variables that can be used for
-in-memory coupling. While it is possible to directly use the C API as documented
-here for coupling, most advanced users will find it easier to work with the
-Python bindings in the :py:mod:`openmc.capi` module.
+in-memory coupling. While it is possible to directly use the C/C++ API as
+documented here for coupling, most advanced users will find it easier to work
+with the Python bindings in the :py:mod:`openmc.lib` module.
 
-.. warning:: The C API is still experimental and may undergo substantial changes
-             in future releases.
+.. warning:: The C/C++ API is still experimental and may undergo substantial
+             changes in future releases.
 
 ----------------
 Type Definitions
diff --git a/docs/source/pythonapi/capi.rst b/docs/source/pythonapi/capi.rst
index cacc5472e..44094ffd4 100644
--- a/docs/source/pythonapi/capi.rst
+++ b/docs/source/pythonapi/capi.rst
@@ -1,8 +1,8 @@
---------------------------------------------------
-:mod:`openmc.capi` -- Python bindings to the C API
---------------------------------------------------
+------------------------------------------------------
+:mod:`openmc.lib` -- Python bindings to the C/C++ API
+------------------------------------------------------
 
-.. automodule:: openmc.capi
+.. automodule:: openmc.lib
 
 Functions
 ---------
diff --git a/openmc/cmfd.py b/openmc/cmfd.py
index 742cdeabf..b215d2058 100644
--- a/openmc/cmfd.py
+++ b/openmc/cmfd.py
@@ -22,7 +22,7 @@ import numpy as np
 from scipy import sparse
 import h5py
 
-import openmc.capi
+import openmc.lib
 from openmc.checkvalue import (check_type, check_length, check_value,
                                check_greater_than, check_less_than)
 from openmc.exceptions import OpenMCError
@@ -701,7 +701,7 @@ class CMFDRun(object):
         ----------
         **kwargs
             All keyword arguments are passed to
-            :func:`openmc.capi.run_in_memory`.
+            :func:`openmc.lib.run_in_memory`.
 
         """
         with self.run_in_memory(**kwargs):
@@ -726,7 +726,7 @@ class CMFDRun(object):
         Parameters
         ----------
         **kwargs
-            All keyword arguments passed to :func:`openmc.capi.run_in_memory`.
+            All keyword arguments passed to :func:`openmc.lib.run_in_memory`.
 
         """
         # Store intracomm for part of CMFD routine where MPI reduce and
@@ -737,7 +737,7 @@ class CMFDRun(object):
             self._intracomm = MPI.COMM_WORLD
 
         # Run and pass arguments to C API run_in_memory function
-        with openmc.capi.run_in_memory(**kwargs):
+        with openmc.lib.run_in_memory(**kwargs):
             self.init()
             yield
             self.finalize()
@@ -759,7 +759,7 @@ class CMFDRun(object):
 
     def init(self):
         """ Initialize CMFDRun instance by setting up CMFD parameters and
-        calling :func:`openmc.capi.simulation_init`
+        calling :func:`openmc.lib.simulation_init`
 
         """
         # Configure CMFD parameters and tallies
@@ -780,10 +780,10 @@ class CMFDRun(object):
         self._initialize_linsolver()
 
         # Initialize simulation
-        openmc.capi.simulation_init()
+        openmc.lib.simulation_init()
 
         # Set cmfd_run variable to True through C API
-        openmc.capi.settings.cmfd_run = True
+        openmc.lib.settings.cmfd_run = True
 
     def next_batch(self):
         """ Run next batch for CMFDRun.
@@ -799,29 +799,29 @@ class CMFDRun(object):
         self._cmfd_init_batch()
 
         # Run next batch
-        status = openmc.capi.next_batch()
+        status = openmc.lib.next_batch()
 
         # Perform CMFD calculation if on
         if self._cmfd_on:
             self._execute_cmfd()
 
             # Write CMFD output if CMFD on for current batch
-            if openmc.capi.master():
+            if openmc.lib.master():
                 self._write_cmfd_output()
 
         # Write CMFD data to statepoint
-        if openmc.capi.is_statepoint_batch():
+        if openmc.lib.is_statepoint_batch():
             self.statepoint_write()
         return status
 
     def finalize(self):
         """ Finalize simulation by calling
-        :func:`openmc.capi.simulation_finalize` and print out CMFD timing
+        :func:`openmc.lib.simulation_finalize` and print out CMFD timing
         information.
 
         """
         # Finalize simuation
-        openmc.capi.simulation_finalize()
+        openmc.lib.simulation_finalize()
 
         # Print out CMFD timing statistics
         self._write_cmfd_timing_stats()
@@ -836,13 +836,13 @@ class CMFDRun(object):
 
         """
         if filename is None:
-            batch_str_len = len(str(openmc.capi.settings.batches))
-            batch_str = str(openmc.capi.current_batch()).zfill(batch_str_len)
+            batch_str_len = len(str(openmc.lib.settings.batches))
+            batch_str = str(openmc.lib.current_batch()).zfill(batch_str_len)
             filename = 'statepoint.{}.h5'.format(batch_str)
 
         # Call C API statepoint_write to save source distribution with CMFD
         # feedback
-        openmc.capi.statepoint_write(filename=filename)
+        openmc.lib.statepoint_write(filename=filename)
 
         # Append CMFD data to statepoint file using h5py
         self._write_cmfd_statepoint(filename)
@@ -856,10 +856,10 @@ class CMFDRun(object):
             Filename of statepoint
 
         """
-        if openmc.capi.master():
+        if openmc.lib.master():
             with h5py.File(filename, 'a') as f:
                 if 'cmfd' not in f:
-                    if openmc.capi.settings.verbosity >= 5:
+                    if openmc.lib.settings.verbosity >= 5:
                         print(' Writing CMFD data to {}...'.format(filename))
                         sys.stdout.flush()
                     cmfd_group = f.create_group("cmfd")
@@ -922,7 +922,7 @@ class CMFDRun(object):
         args = temp_loss.indptr, len(temp_loss.indptr), \
             temp_loss.indices, len(temp_loss.indices), n, \
             self._spectral, self._indices, coremap
-        return openmc.capi._dll.openmc_initialize_linsolver(*args)
+        return openmc.lib._dll.openmc_initialize_linsolver(*args)
 
     def _write_cmfd_output(self):
         """Write CMFD output to buffer at the end of each batch"""
@@ -948,7 +948,7 @@ class CMFDRun(object):
 
     def _write_cmfd_timing_stats(self):
         """Write CMFD timing stats to buffer after finalizing simulation"""
-        if openmc.capi.master():
+        if openmc.lib.master():
             outstr = ("=====================>     "
                       "CMFD TIMING STATISTICS     <====================\n\n"
                       "   Time in CMFD                    =  {:.5E} seconds\n"
@@ -961,7 +961,7 @@ class CMFDRun(object):
     def _configure_cmfd(self):
         """Initialize CMFD parameters and set CMFD input variables"""
         # Check if restarting simulation from statepoint file
-        if not openmc.capi.settings.restart_run:
+        if not openmc.lib.settings.restart_run:
             # Read in cmfd input defined in Python
             self._read_cmfd_input()
 
@@ -990,13 +990,13 @@ class CMFDRun(object):
 
         else:
             # Reset CMFD parameters from statepoint file
-            path_statepoint = openmc.capi.settings.path_statepoint
+            path_statepoint = openmc.lib.settings.path_statepoint
             self._reset_cmfd(path_statepoint)
 
     def _read_cmfd_input(self):
         """Sets values of additional instance variables based on user input"""
         # Print message to user and flush output to stdout
-        if openmc.capi.settings.verbosity >= 7 and openmc.capi.master():
+        if openmc.lib.settings.verbosity >= 7 and openmc.lib.master():
             print(' Configuring CMFD parameters for simulation')
             sys.stdout.flush()
 
@@ -1010,7 +1010,7 @@ class CMFDRun(object):
             self._indices[i] = n
 
         # Check if in continuous energy mode
-        if not openmc.capi.settings.run_CE:
+        if not openmc.lib.settings.run_CE:
             raise OpenMCError('CMFD must be run in continuous energy mode')
 
         # Set number of energy groups
@@ -1065,8 +1065,8 @@ class CMFDRun(object):
                                   'file {}'.format(filename))
             else:
                 # Overwrite CMFD values from statepoint
-                if (openmc.capi.master() and
-                        openmc.capi.settings.verbosity >= 5):
+                if (openmc.lib.master() and
+                        openmc.lib.settings.verbosity >= 5):
                     print(' Loading CMFD data from {}...'.format(filename))
                     sys.stdout.flush()
                 cmfd_group = f['cmfd']
@@ -1126,7 +1126,7 @@ class CMFDRun(object):
 
         # Allocate dimensions for each mesh cell
         self._hxyz = np.zeros((nx, ny, nz, 3))
-        self._hxyz[:] = openmc.capi.meshes[self._mesh_id].width
+        self._hxyz[:] = openmc.lib.meshes[self._mesh_id].width
 
         # Allocate flux, cross sections and diffusion coefficient
         self._flux = np.zeros((nx, ny, nz, ng))
@@ -1167,7 +1167,7 @@ class CMFDRun(object):
         """Handles CMFD options at the beginning of each batch"""
         # Get current batch through C API
         # Add 1 as next_batch has not been called yet
-        current_batch = openmc.capi.current_batch() + 1
+        current_batch = openmc.lib.current_batch() + 1
 
         # Check to activate CMFD diffusion and possible feedback
         # Check to activate CMFD tallies
@@ -1182,7 +1182,7 @@ class CMFDRun(object):
     def _execute_cmfd(self):
         """Runs CMFD calculation on master node"""
         # Run CMFD on single processor on master
-        if openmc.capi.master():
+        if openmc.lib.master():
             # Start CMFD timer
             time_start_cmfd = time.time()
 
@@ -1196,7 +1196,7 @@ class CMFDRun(object):
             self._k_cmfd.append(self._keff)
 
             # Check to perform adjoint on last batch
-            if (openmc.capi.current_batch() == openmc.capi.settings.batches
+            if (openmc.lib.current_batch() == openmc.lib.settings.batches
                     and self._run_adjoint):
                 self._cmfd_solver_execute(adjoint=True)
 
@@ -1207,20 +1207,20 @@ class CMFDRun(object):
         self._cmfd_reweight(True)
 
         # Stop CMFD timer
-        if openmc.capi.master():
+        if openmc.lib.master():
             time_stop_cmfd = time.time()
             self._time_cmfd += time_stop_cmfd - time_start_cmfd
 
     def _cmfd_tally_reset(self):
         """Resets all CMFD tallies in memory"""
         # Print message
-        if (openmc.capi.settings.verbosity >= 6 and openmc.capi.master() and
+        if (openmc.lib.settings.verbosity >= 6 and openmc.lib.master() and
                 not self._reset_every):
             print(' CMFD tallies reset')
             sys.stdout.flush()
 
         # Reset CMFD tallies
-        tallies = openmc.capi.tallies
+        tallies = openmc.lib.tallies
         for tally_id in self._tally_ids:
             tallies[tally_id].reset()
 
@@ -1407,7 +1407,7 @@ class CMFDRun(object):
         self._cmfd_src = cmfd_src / np.sum(cmfd_src)
 
         # Compute entropy
-        if openmc.capi.settings.entropy_on:
+        if openmc.lib.settings.entropy_on:
             # Compute source times log_2(source)
             source = self._cmfd_src[self._cmfd_src > 0] \
                 * np.log(self._cmfd_src[self._cmfd_src > 0])/np.log(2)
@@ -1441,12 +1441,12 @@ class CMFDRun(object):
             outside = self._count_bank_sites()
 
             # Check and raise error if source sites exist outside of CMFD mesh
-            if openmc.capi.master() and outside:
+            if openmc.lib.master() and outside:
                 raise OpenMCError('Source sites outside of the CMFD mesh')
 
             # Have master compute weight factors, ignore any zeros in
             # sourcecounts or cmfd_src
-            if openmc.capi.master():
+            if openmc.lib.master():
                 # Compute normalization factor
                 norm = np.sum(self._sourcecounts) / np.sum(self._cmfd_src)
 
@@ -1471,7 +1471,7 @@ class CMFDRun(object):
                                        dtype=np.float32))
 
             if (not self._feedback
-                    or openmc.capi.current_batch() < self._feedback_begin):
+                    or openmc.lib.current_batch() < self._feedback_begin):
                 return
 
             # Broadcast weight factors to all procs
@@ -1479,13 +1479,13 @@ class CMFDRun(object):
                 self._weightfactors = self._intracomm.bcast(
                                       self._weightfactors)
 
-            m = openmc.capi.meshes[self._mesh_id]
+            m = openmc.lib.meshes[self._mesh_id]
             energy = self._egrid
             ng = self._indices[3]
 
             # Get locations and energies of all particles in source bank
-            source_xyz = openmc.capi.source_bank()['r']
-            source_energies = openmc.capi.source_bank()['E']
+            source_xyz = openmc.lib.source_bank()['r']
+            source_energies = openmc.lib.source_bank()['E']
 
             # Convert xyz location to the CMFD mesh index
             mesh_ijk = np.floor((source_xyz-m.lower_left)/m.width).astype(int)
@@ -1503,13 +1503,13 @@ class CMFDRun(object):
 
             # Determine weight factor of each particle based on its mesh index
             # and energy bin and updates its weight
-            openmc.capi.source_bank()['wgt'] *= self._weightfactors[
+            openmc.lib.source_bank()['wgt'] *= self._weightfactors[
                     mesh_ijk[:,0], mesh_ijk[:,1], mesh_ijk[:,2], energy_bins]
 
-            if openmc.capi.master() and np.any(source_energies < energy[0]):
+            if openmc.lib.master() and np.any(source_energies < energy[0]):
                 print(' WARNING: Source pt below energy grid')
                 sys.stdout.flush()
-            if openmc.capi.master() and np.any(source_energies > energy[-1]):
+            if openmc.lib.master() and np.any(source_energies > energy[-1]):
                 print(' WARNING: Source pt above energy grid')
                 sys.stdout.flush()
 
@@ -1523,8 +1523,8 @@ class CMFDRun(object):
 
         """
         # Initialize variables
-        m = openmc.capi.meshes[self._mesh_id]
-        bank = openmc.capi.source_bank()
+        m = openmc.lib.meshes[self._mesh_id]
+        bank = openmc.lib.source_bank()
         energy = self._egrid
         sites_outside = np.zeros(1, dtype=bool)
         nxnynz = np.prod(self._indices[0:3])
@@ -1535,8 +1535,8 @@ class CMFDRun(object):
         count = np.zeros(self._sourcecounts.shape)
 
         # Get location and energy of each particle in source bank
-        source_xyz = openmc.capi.source_bank()['r']
-        source_energies = openmc.capi.source_bank()['E']
+        source_xyz = openmc.lib.source_bank()['r']
+        source_energies = openmc.lib.source_bank()['E']
 
         # Convert xyz location to mesh index and ravel index to scalar
         mesh_locations = np.floor((source_xyz - m.lower_left) / m.width)
@@ -1760,7 +1760,7 @@ class CMFDRun(object):
         s_o = np.zeros((n,))
 
         # Set initial guess
-        k_n = openmc.capi.keff()[0]
+        k_n = openmc.lib.keff()[0]
         k_o = k_n
         dw = self._w_shift
         k_s = k_o + dw
@@ -1791,7 +1791,7 @@ class CMFDRun(object):
             s_o /= k_lo
 
             # Compute new flux with C++ solver
-            innerits = openmc.capi._dll.openmc_run_linsolver(loss.data, s_o,
+            innerits = openmc.lib._dll.openmc_run_linsolver(loss.data, s_o,
                                                              phi_n, toli)
 
             # Compute new source vector
@@ -1863,7 +1863,7 @@ class CMFDRun(object):
         iconv = kerr < self._cmfd_ktol and serr < self._stol
 
         # Print out to user
-        if self._power_monitor and openmc.capi.master():
+        if self._power_monitor and openmc.lib.master():
             str1 = ' {:d}:'.format(iter)
             str2 = 'k-eff: {:0.8f}'.format(k_n)
             str3 = 'k-error:  {:.5E}'.format(kerr)
@@ -1904,7 +1904,7 @@ class CMFDRun(object):
 
         """
         # Update window size for expanding window if necessary
-        num_cmfd_batches = openmc.capi.current_batch() - self._tally_begin + 1
+        num_cmfd_batches = openmc.lib.current_batch() - self._tally_begin + 1
         if (self._window_type == 'expanding' and
                 num_cmfd_batches == self._window_size * 2):
             self._window_size *= 2
@@ -1925,7 +1925,7 @@ class CMFDRun(object):
         nx, ny, nz, ng = self._indices
 
         # Get tallies in-memory
-        tallies = openmc.capi.tallies
+        tallies = openmc.lib.tallies
 
         # Ravel coremap as 1d array similar to how tally data is arranged
         coremap = np.ravel(self._coremap.swapaxes(0, 2))
@@ -2181,7 +2181,7 @@ class CMFDRun(object):
         num_accel = self._mat_dim
 
         # Get openmc k-effective
-        keff = openmc.capi.keff()[0]
+        keff = openmc.lib.keff()[0]
 
         # Define leakage in each mesh cell and energy group
         leakage = (((self._current[:,:,:,_CURRENTS['out_right'],:] -
@@ -2973,7 +2973,7 @@ class CMFDRun(object):
     def _create_cmfd_tally(self):
         """Creates all tallies in-memory that are used to solve CMFD problem"""
         # Create Mesh object based on CMFDMesh, stored internally
-        cmfd_mesh = openmc.capi.RegularMesh()
+        cmfd_mesh = openmc.lib.RegularMesh()
         # Store id of mesh object
         self._mesh_id = cmfd_mesh.id
         # Set dimension and parameters of mesh object
@@ -2983,29 +2983,29 @@ class CMFDRun(object):
                                  width=self._mesh.width)
 
         # Create mesh Filter object, stored internally
-        mesh_filter = openmc.capi.MeshFilter()
+        mesh_filter = openmc.lib.MeshFilter()
         # Set mesh for Mesh Filter
         mesh_filter.mesh = cmfd_mesh
 
         # Set up energy filters, if applicable
         if self._energy_filters:
             # Create Energy Filter object, stored internally
-            energy_filter = openmc.capi.EnergyFilter()
+            energy_filter = openmc.lib.EnergyFilter()
             # Set bins for Energy Filter
             energy_filter.bins = self._egrid
 
             # Create Energy Out Filter object, stored internally
-            energyout_filter = openmc.capi.EnergyoutFilter()
+            energyout_filter = openmc.lib.EnergyoutFilter()
             # Set bins for Energy Filter
             energyout_filter.bins = self._egrid
 
         # Create Mesh Surface Filter object, stored internally
-        meshsurface_filter = openmc.capi.MeshSurfaceFilter()
+        meshsurface_filter = openmc.lib.MeshSurfaceFilter()
         # Set mesh for Mesh Surface Filter
         meshsurface_filter.mesh = cmfd_mesh
 
         # Create Legendre Filter object, stored internally
-        legendre_filter = openmc.capi.LegendreFilter()
+        legendre_filter = openmc.lib.LegendreFilter()
         # Set order for Legendre Filter
         legendre_filter.order = 1
 
@@ -3013,7 +3013,7 @@ class CMFDRun(object):
         n_tallies = 4
         self._tally_ids = []
         for i in range(n_tallies):
-            cmfd_tally = openmc.capi.Tally()
+            cmfd_tally = openmc.lib.Tally()
             # Set nuclide bins
             cmfd_tally.nuclides = ['total']
             self._tally_ids.append(cmfd_tally.id)
diff --git a/openmc/deplete/abc.py b/openmc/deplete/abc.py
index fb638e5c2..b1c854da6 100644
--- a/openmc/deplete/abc.py
+++ b/openmc/deplete/abc.py
@@ -17,7 +17,7 @@ from numpy import nonzero, empty, asarray
 from uncertainties import ufloat
 
 from openmc.data import DataLibrary, JOULE_PER_EV
-from openmc.capi import MaterialFilter, Tally
+from openmc.lib import MaterialFilter, Tally
 from openmc.checkvalue import check_type, check_greater_than
 from .results import Results
 from .chain import Chain
@@ -438,7 +438,7 @@ class FissionYieldHelper(ABC):
         Parameters
         ----------
         materials : iterable of C-API materials
-            Materials to be used in :class:`openmc.capi.MaterialFilter`
+            Materials to be used in :class:`openmc.lib.MaterialFilter`
         mat_indexes : iterable of int
             Indices of tallied materials that will have their fission
             yields computed by this helper. Necessary as the
@@ -520,8 +520,8 @@ class TalliedFissionYieldHelper(FissionYieldHelper):
 
         Parameters
         ----------
-        materials : iterable of :class:`openmc.capi.Material`
-            Materials to be used in :class:`openmc.capi.MaterialFilter`
+        materials : iterable of :class:`openmc.lib.Material`
+            Materials to be used in :class:`openmc.lib.MaterialFilter`
         mat_indexes : iterable of int
             Indices of tallied materials that will have their fission
             yields computed by this helper. Necessary as the
diff --git a/openmc/deplete/helpers.py b/openmc/deplete/helpers.py
index 56644a3bb..5d7133467 100644
--- a/openmc/deplete/helpers.py
+++ b/openmc/deplete/helpers.py
@@ -9,7 +9,7 @@ import bisect
 from numpy import dot, zeros, newaxis
 
 from openmc.checkvalue import check_type, check_greater_than
-from openmc.capi import (
+from openmc.lib import (
     Tally, MaterialFilter, EnergyFilter, EnergyFunctionFilter)
 from .abc import (
     ReactionRateHelper, EnergyHelper, FissionYieldHelper,
@@ -44,7 +44,7 @@ class DirectReactionRateHelper(ReactionRateHelper):
     def generate_tallies(self, materials, scores):
         """Produce one-group reaction rate tally
 
-        Uses the :mod:`openmc.capi` to generate a tally
+        Uses the :mod:`openmc.lib` to generate a tally
         of relevant reactions across all burnable materials.
 
         Parameters
@@ -362,13 +362,13 @@ class FissionYieldCutoffHelper(TalliedFissionYieldHelper):
     def generate_tallies(self, materials, mat_indexes):
         """Use C API to produce a fission rate tally in burnable materials
 
-        Include a :class:`openmc.capi.EnergyFilter` to tally fission rates
+        Include a :class:`openmc.lib.EnergyFilter` to tally fission rates
         above and below cutoff energy.
 
         Parameters
         ----------
-        materials : iterable of :class:`openmc.capi.Material`
-            Materials to be used in :class:`openmc.capi.MaterialFilter`
+        materials : iterable of :class:`openmc.lib.Material`
+            Materials to be used in :class:`openmc.lib.MaterialFilter`
         mat_indexes : iterable of int
             Indices of tallied materials that will have their fission
             yields computed by this helper. Necessary as the
@@ -490,8 +490,8 @@ class AveragedFissionYieldHelper(TalliedFissionYieldHelper):
 
         Parameters
         ----------
-        materials : iterable of :class:`openmc.capi.Material`
-            Materials to be used in :class:`openmc.capi.MaterialFilter`
+        materials : iterable of :class:`openmc.lib.Material`
+            Materials to be used in :class:`openmc.lib.MaterialFilter`
         mat_indexes : iterable of int
             Indices of tallied materials that will have their fission
             yields computed by this helper. Necessary as the
diff --git a/openmc/deplete/operator.py b/openmc/deplete/operator.py
index 01bf92dcc..86dbeb755 100644
--- a/openmc/deplete/operator.py
+++ b/openmc/deplete/operator.py
@@ -19,7 +19,7 @@ import numpy as np
 from uncertainties import ufloat
 
 import openmc
-import openmc.capi
+import openmc.lib
 from . import comm
 from .abc import TransportOperator, OperatorResult
 from .atom_number import AtomNumber
@@ -245,8 +245,8 @@ class Operator(TransportOperator):
         self._yield_helper.update_tally_nuclides(nuclides)
 
         # Run OpenMC
-        openmc.capi.reset()
-        openmc.capi.run()
+        openmc.lib.reset()
+        openmc.lib.run()
 
         time_openmc = time.time()
 
@@ -264,7 +264,7 @@ class Operator(TransportOperator):
         step : int
             Current depletion step including restarts
         """
-        openmc.capi.statepoint_write(
+        openmc.lib.statepoint_write(
             "openmc_simulation_n{}.h5".format(step),
             write_source=False)
 
@@ -438,10 +438,10 @@ class Operator(TransportOperator):
 
         # Initialize OpenMC library
         comm.barrier()
-        openmc.capi.init(intracomm=comm)
+        openmc.lib.init(intracomm=comm)
 
         # Generate tallies in memory
-        materials = [openmc.capi.materials[int(i)]
+        materials = [openmc.lib.materials[int(i)]
                      for i in self.burnable_mats]
         self._rate_helper.generate_tallies(materials, self.chain.reactions)
         self._energy_helper.prepare(
@@ -456,7 +456,7 @@ class Operator(TransportOperator):
 
     def finalize(self):
         """Finalize a depletion simulation and release resources."""
-        openmc.capi.finalize()
+        openmc.lib.finalize()
 
     def _update_materials(self):
         """Updates material compositions in OpenMC on all processes."""
@@ -491,7 +491,7 @@ class Operator(TransportOperator):
                             number_i[mat, nuc] = 0.0
 
                 # Update densities on C API side
-                mat_internal = openmc.capi.materials[int(mat)]
+                mat_internal = openmc.lib.materials[int(mat)]
                 mat_internal.set_densities(nuclides, densities)
 
                 #TODO Update densities on the Python side, otherwise the
@@ -581,7 +581,7 @@ class Operator(TransportOperator):
         rates.fill(0.0)
 
         # Get k and uncertainty
-        k_combined = ufloat(*openmc.capi.keff())
+        k_combined = ufloat(*openmc.lib.keff())
 
         # Extract tally bins
         nuclides = self._rate_helper.nuclides
diff --git a/openmc/capi/__init__.py b/openmc/lib/__init__.py
similarity index 69%
rename from openmc/capi/__init__.py
rename to openmc/lib/__init__.py
index 5ca867d67..92fd1730d 100644
--- a/openmc/capi/__init__.py
+++ b/openmc/lib/__init__.py
@@ -1,14 +1,14 @@
 """
-This module provides bindings to C functions defined by OpenMC shared library.
-When the :mod:`openmc` package is imported, the OpenMC shared library is
-automatically loaded. Calls to the OpenMC library can then be via functions or
-objects in the :mod:`openmc.capi` subpackage, for example:
+This module provides bindings to C/C++ functions defined by OpenMC shared
+library. When the :mod:`openmc.lib` package is imported, the OpenMC shared
+library is automatically loaded. Calls to the OpenMC library can then be via
+functions or objects in :mod:`openmc.lib`, for example:
 
 .. code-block:: python
 
-    openmc.capi.init()
-    openmc.capi.run()
-    openmc.capi.finalize()
+    openmc.lib.init()
+    openmc.lib.run()
+    openmc.lib.finalize()
 
 """
 
@@ -33,7 +33,7 @@ if os.environ.get('READTHEDOCS', None) != 'True':
 else:
     # For documentation builds, we don't actually have the shared library
     # available. Instead, we create a mock object so that when the modules
-    # within the openmc.capi package try to configure arguments and return
+    # within the openmc.lib package try to configure arguments and return
     # values for symbols, no errors occur
     from unittest.mock import Mock
     _dll = Mock()
diff --git a/openmc/capi/cell.py b/openmc/lib/cell.py
similarity index 99%
rename from openmc/capi/cell.py
rename to openmc/lib/cell.py
index 784ebd087..6ed4bca1e 100644
--- a/openmc/capi/cell.py
+++ b/openmc/lib/cell.py
@@ -63,7 +63,7 @@ class Cell(_FortranObjectWithID):
 
     This class exposes a cell that is stored internally in the OpenMC
     library. To obtain a view of a cell with a given ID, use the
-    :data:`openmc.capi.cells` mapping.
+    :data:`openmc.lib.cells` mapping.
 
     Parameters
     ----------
diff --git a/openmc/capi/core.py b/openmc/lib/core.py
similarity index 94%
rename from openmc/capi/core.py
rename to openmc/lib/core.py
index a470f0665..0bfdb457b 100644
--- a/openmc/capi/core.py
+++ b/openmc/lib/core.py
@@ -11,7 +11,7 @@ from numpy.ctypeslib import as_array
 from openmc.exceptions import AllocationError
 from . import _dll
 from .error import _error_handler
-import openmc.capi
+import openmc.lib
 
 
 class _Bank(Structure):
@@ -127,7 +127,7 @@ def find_cell(xyz):
 
     Returns
     -------
-    openmc.capi.Cell
+    openmc.lib.Cell
         Cell containing the point
     int
         If the cell at the given point is repeated in the geometry, this
@@ -137,7 +137,7 @@ def find_cell(xyz):
     index = c_int32()
     instance = c_int32()
     _dll.openmc_find_cell((c_double*3)(*xyz), index, instance)
-    return openmc.capi.Cell(index=index.value), instance.value
+    return openmc.lib.Cell(index=index.value), instance.value
 
 
 def find_material(xyz):
@@ -150,7 +150,7 @@ def find_material(xyz):
 
     Returns
     -------
-    openmc.capi.Material or None
+    openmc.lib.Material or None
         Material containing the point, or None is no material is found
 
     """
@@ -158,8 +158,8 @@ def find_material(xyz):
     instance = c_int32()
     _dll.openmc_find_cell((c_double*3)(*xyz), index, instance)
 
-    mats = openmc.capi.Cell(index=index.value).fill
-    if isinstance(mats, (openmc.capi.Material, type(None))):
+    mats = openmc.lib.Cell(index=index.value).fill
+    if isinstance(mats, (openmc.lib.Material, type(None))):
         return mats
     else:
         return mats[instance.value]
@@ -225,21 +225,21 @@ def iter_batches():
 
     This function returns a generator-iterator that allows Python code to be run
     between batches in an OpenMC simulation. It should be used in conjunction
-    with :func:`openmc.capi.simulation_init` and
-    :func:`openmc.capi.simulation_finalize`. For example:
+    with :func:`openmc.lib.simulation_init` and
+    :func:`openmc.lib.simulation_finalize`. For example:
 
     .. code-block:: Python
 
-        with openmc.capi.run_in_memory():
-            openmc.capi.simulation_init()
-            for _ in openmc.capi.iter_batches():
+        with openmc.lib.run_in_memory():
+            openmc.lib.simulation_init()
+            for _ in openmc.lib.iter_batches():
                 # Look at convergence of tallies, for example
                 ...
-            openmc.capi.simulation_finalize()
+            openmc.lib.simulation_finalize()
 
     See Also
     --------
-    openmc.capi.next_batch
+    openmc.lib.next_batch
 
     """
     while True:
@@ -365,11 +365,11 @@ def run_in_memory(**kwargs):
     block, all memory that was allocated during the block is freed. For
     example::
 
-        with openmc.capi.run_in_memory():
+        with openmc.lib.run_in_memory():
             for i in range(n_iters):
-                openmc.capi.reset()
+                openmc.lib.reset()
                 do_stuff()
-                openmc.capi.run()
+                openmc.lib.run()
 
     Parameters
     ----------
diff --git a/openmc/capi/error.py b/openmc/lib/error.py
similarity index 100%
rename from openmc/capi/error.py
rename to openmc/lib/error.py
diff --git a/openmc/capi/filter.py b/openmc/lib/filter.py
similarity index 100%
rename from openmc/capi/filter.py
rename to openmc/lib/filter.py
diff --git a/openmc/capi/material.py b/openmc/lib/material.py
similarity index 99%
rename from openmc/capi/material.py
rename to openmc/lib/material.py
index f0ecac761..0fbce7245 100644
--- a/openmc/capi/material.py
+++ b/openmc/lib/material.py
@@ -66,7 +66,7 @@ class Material(_FortranObjectWithID):
 
     This class exposes a material that is stored internally in the OpenMC
     library. To obtain a view of a material with a given ID, use the
-    :data:`openmc.capi.materials` mapping.
+    :data:`openmc.lib.materials` mapping.
 
     Parameters
     ----------
diff --git a/openmc/capi/math.py b/openmc/lib/math.py
similarity index 100%
rename from openmc/capi/math.py
rename to openmc/lib/math.py
diff --git a/openmc/capi/mesh.py b/openmc/lib/mesh.py
similarity index 99%
rename from openmc/capi/mesh.py
rename to openmc/lib/mesh.py
index a1161f48f..bf51bdfe9 100644
--- a/openmc/capi/mesh.py
+++ b/openmc/lib/mesh.py
@@ -50,7 +50,7 @@ class RegularMesh(_FortranObjectWithID):
 
     This class exposes a mesh that is stored internally in the OpenMC
     library. To obtain a view of a mesh with a given ID, use the
-    :data:`openmc.capi.meshes` mapping.
+    :data:`openmc.lib.meshes` mapping.
 
     Parameters
     ----------
diff --git a/openmc/capi/nuclide.py b/openmc/lib/nuclide.py
similarity index 98%
rename from openmc/capi/nuclide.py
rename to openmc/lib/nuclide.py
index 4a21a6d2b..81ef7e648 100644
--- a/openmc/capi/nuclide.py
+++ b/openmc/lib/nuclide.py
@@ -43,7 +43,7 @@ class Nuclide(_FortranObject):
 
     This class exposes a nuclide that is stored internally in the OpenMC
     solver. To obtain a view of a nuclide with a given name, use the
-    :data:`openmc.capi.nuclides` mapping.
+    :data:`openmc.lib.nuclides` mapping.
 
     Parameters
     ----------
diff --git a/openmc/capi/plot.py b/openmc/lib/plot.py
similarity index 97%
rename from openmc/capi/plot.py
rename to openmc/lib/plot.py
index c4bff4cb3..c51000e0d 100644
--- a/openmc/capi/plot.py
+++ b/openmc/lib/plot.py
@@ -52,9 +52,9 @@ class _PlotBase(Structure):
 
     C-Type Attributes
     -----------------
-    origin : openmc.capi.plot._Position
+    origin : openmc.lib.plot._Position
         A position defining the origin of the plot.
-    width_ : openmc.capi.plot._Position
+    width_ : openmc.lib.plot._Position
         The width of the plot along the x, y, and z axes, respectively
     basis_ : c_int
         The axes basis of the plot view.
@@ -222,7 +222,7 @@ def id_map(plot):
 
     Parameters
     ----------
-    plot : openmc.capi.plot._PlotBase
+    plot : openmc.lib.plot._PlotBase
         Object describing the slice of the model to be generated
 
     Returns
@@ -250,7 +250,7 @@ def property_map(plot):
 
     Parameters
     ----------
-    plot : openmc.capi.plot._PlotBase
+    plot : openmc.lib.plot._PlotBase
         Object describing the slice of the model to be generated
 
     Returns
diff --git a/openmc/capi/settings.py b/openmc/lib/settings.py
similarity index 100%
rename from openmc/capi/settings.py
rename to openmc/lib/settings.py
diff --git a/openmc/capi/tally.py b/openmc/lib/tally.py
similarity index 99%
rename from openmc/capi/tally.py
rename to openmc/lib/tally.py
index 88c14e449..0001b2c4b 100644
--- a/openmc/capi/tally.py
+++ b/openmc/lib/tally.py
@@ -143,7 +143,7 @@ class Tally(_FortranObjectWithID):
 
     This class exposes a tally that is stored internally in the OpenMC
     library. To obtain a view of a tally with a given ID, use the
-    :data:`openmc.capi.tallies` mapping.
+    :data:`openmc.lib.tallies` mapping.
 
     Parameters
     ----------
diff --git a/openmc/model/model.py b/openmc/model/model.py
index 2f515ca78..33a38ef22 100644
--- a/openmc/model/model.py
+++ b/openmc/model/model.py
@@ -147,7 +147,7 @@ class Model(object):
 
         """
         # Import the depletion module.  This is done here rather than the module
-        # header to delay importing openmc.capi (through openmc.deplete) which
+        # header to delay importing openmc.lib (through openmc.deplete) which
         # can be tough to install properly.
         import openmc.deplete as dep
 
diff --git a/openmc/polynomial.py b/openmc/polynomial.py
index ac1ad675d..abcfd8057 100644
--- a/openmc/polynomial.py
+++ b/openmc/polynomial.py
@@ -73,9 +73,9 @@ class ZernikeRadial(Polynomial):
         return self._order
 
     def __call__(self, r):
-        import openmc.capi as capi
+        import openmc.lib as lib
         if isinstance(r, Iterable):
-            return [np.sum(self._norm_coef * capi.calc_zn_rad(self.order, r_i))
+            return [np.sum(self._norm_coef * lib.calc_zn_rad(self.order, r_i))
                     for r_i in r]
         else:
-            return np.sum(self._norm_coef * capi.calc_zn_rad(self.order, r))
+            return np.sum(self._norm_coef * lib.calc_zn_rad(self.order, r))
diff --git a/setup.py b/setup.py
index 712244efb..aff7834d7 100755
--- a/setup.py
+++ b/setup.py
@@ -31,7 +31,7 @@ kwargs = {
 
     # Data files and librarries
     'package_data': {
-        'openmc.capi': ['libopenmc.{}'.format(suffix)],
+        'openmc.lib': ['libopenmc.{}'.format(suffix)],
         'openmc.data': ['mass16.txt', 'BREMX.DAT', '*.h5']
     },
 
diff --git a/tests/regression_tests/complex_cell/test.py b/tests/regression_tests/complex_cell/test.py
index b43ccd72f..77cbd6cb7 100755
--- a/tests/regression_tests/complex_cell/test.py
+++ b/tests/regression_tests/complex_cell/test.py
@@ -1,8 +1,5 @@
 from tests.testing_harness import TestHarness
 
-import sys
-
-import openmc.capi
 
 def test_complex_cell():
     harness = TestHarness('statepoint.10.h5')
diff --git a/tests/regression_tests/dagmc/legacy/test.py b/tests/regression_tests/dagmc/legacy/test.py
index db062d36e..963e73226 100644
--- a/tests/regression_tests/dagmc/legacy/test.py
+++ b/tests/regression_tests/dagmc/legacy/test.py
@@ -1,11 +1,11 @@
 import openmc
-import openmc.capi
+import openmc.lib
 
 import pytest
 from tests.testing_harness import PyAPITestHarness
 
 pytestmark = pytest.mark.skipif(
-    not openmc.capi._dagmc_enabled(),
+    not openmc.lib._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
 def test_dagmc():
diff --git a/tests/regression_tests/dagmc/refl/test.py b/tests/regression_tests/dagmc/refl/test.py
index 93104f1d0..c451b6125 100644
--- a/tests/regression_tests/dagmc/refl/test.py
+++ b/tests/regression_tests/dagmc/refl/test.py
@@ -1,12 +1,12 @@
 import openmc
-import openmc.capi
+import openmc.lib
 from openmc.stats import Box
 
 import pytest
 from tests.testing_harness import PyAPITestHarness
 
 pytestmark = pytest.mark.skipif(
-    not openmc.capi._dagmc_enabled(),
+    not openmc.lib._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
 class UWUWTest(PyAPITestHarness):
diff --git a/tests/regression_tests/dagmc/uwuw/test.py b/tests/regression_tests/dagmc/uwuw/test.py
index 885b83766..b4391d8e7 100644
--- a/tests/regression_tests/dagmc/uwuw/test.py
+++ b/tests/regression_tests/dagmc/uwuw/test.py
@@ -1,12 +1,12 @@
 import openmc
-import openmc.capi
+import openmc.lib
 from openmc.stats import Box
 
 import pytest
 from tests.testing_harness import PyAPITestHarness
 
 pytestmark = pytest.mark.skipif(
-    not openmc.capi._dagmc_enabled(),
+    not openmc.lib._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
 class UWUWTest(PyAPITestHarness):
diff --git a/tests/unit_tests/dagmc/test.py b/tests/unit_tests/dagmc/test.py
index bfe054dd8..f7b2844f6 100644
--- a/tests/unit_tests/dagmc/test.py
+++ b/tests/unit_tests/dagmc/test.py
@@ -4,12 +4,12 @@ import numpy as np
 import pytest
 
 import openmc
-import openmc.capi
+import openmc.lib
 
 from tests import cdtemp
 
 pytestmark = pytest.mark.skipif(
-    not openmc.capi._dagmc_enabled(),
+    not openmc.lib._dagmc_enabled(),
     reason="DAGMC CAD geometry is not enabled.")
 
 
@@ -60,15 +60,15 @@ def dagmc_model(request):
     with cdtemp():
         shutil.copyfile(dagmc_file, "./dagmc.h5m")
         model.export_to_xml()
-        openmc.capi.init()
+        openmc.lib.init()
         yield
 
-    openmc.capi.finalize()
+    openmc.lib.finalize()
 
 
 @pytest.mark.parametrize("cell_id,exp_temp", ((1, 320.0),   # assigned by material
                                               (2, 300.0),   # assigned in dagmc file
                                               (3, 293.6)))  # assigned by default
 def test_dagmc_temperatures(cell_id, exp_temp):
-    cell = openmc.capi.cells[cell_id]
+    cell = openmc.lib.cells[cell_id]
     assert np.isclose(cell.get_temperature(), exp_temp)
diff --git a/tests/unit_tests/test_capi.py b/tests/unit_tests/test_capi.py
index c8ad0907c..2f39f0b0d 100644
--- a/tests/unit_tests/test_capi.py
+++ b/tests/unit_tests/test_capi.py
@@ -5,7 +5,7 @@ import numpy as np
 import pytest
 import openmc
 import openmc.exceptions as exc
-import openmc.capi
+import openmc.lib
 
 from tests import cdtemp
 
@@ -51,42 +51,42 @@ def pincell_model():
 
 @pytest.fixture(scope='module')
 def capi_init(pincell_model, mpi_intracomm):
-    openmc.capi.init(intracomm=mpi_intracomm)
+    openmc.lib.init(intracomm=mpi_intracomm)
     yield
-    openmc.capi.finalize()
+    openmc.lib.finalize()
 
 
 @pytest.fixture(scope='module')
 def capi_simulation_init(capi_init):
-    openmc.capi.simulation_init()
+    openmc.lib.simulation_init()
     yield
 
 
 @pytest.fixture(scope='module')
 def capi_run(capi_simulation_init):
-    openmc.capi.run()
+    openmc.lib.run()
 
 
 def test_cell_mapping(capi_init):
-    cells = openmc.capi.cells
+    cells = openmc.lib.cells
     assert isinstance(cells, Mapping)
     assert len(cells) == 3
     for cell_id, cell in cells.items():
-        assert isinstance(cell, openmc.capi.Cell)
+        assert isinstance(cell, openmc.lib.Cell)
         assert cell_id == cell.id
 
 
 def test_cell(capi_init):
-    cell = openmc.capi.cells[1]
-    assert isinstance(cell.fill, openmc.capi.Material)
-    cell.fill = openmc.capi.materials[1]
+    cell = openmc.lib.cells[1]
+    assert isinstance(cell.fill, openmc.lib.Material)
+    cell.fill = openmc.lib.materials[1]
     assert str(cell) == 'Cell[0]'
     assert cell.name == "Fuel"
     cell.name = "Not fuel"
     assert cell.name == "Not fuel"
 
 def test_cell_temperature(capi_init):
-    cell = openmc.capi.cells[1]
+    cell = openmc.lib.cells[1]
     cell.set_temperature(100.0, 0)
     assert cell.get_temperature(0) == 100.0
     cell.set_temperature(200)
@@ -95,23 +95,23 @@ def test_cell_temperature(capi_init):
 
 def test_new_cell(capi_init):
     with pytest.raises(exc.AllocationError):
-        openmc.capi.Cell(1)
-    new_cell = openmc.capi.Cell()
-    new_cell_with_id = openmc.capi.Cell(10)
-    assert len(openmc.capi.cells) == 5
+        openmc.lib.Cell(1)
+    new_cell = openmc.lib.Cell()
+    new_cell_with_id = openmc.lib.Cell(10)
+    assert len(openmc.lib.cells) == 5
 
 
 def test_material_mapping(capi_init):
-    mats = openmc.capi.materials
+    mats = openmc.lib.materials
     assert isinstance(mats, Mapping)
     assert len(mats) == 3
     for mat_id, mat in mats.items():
-        assert isinstance(mat, openmc.capi.Material)
+        assert isinstance(mat, openmc.lib.Material)
         assert mat_id == mat.id
 
 
 def test_material(capi_init):
-    m = openmc.capi.materials[3]
+    m = openmc.lib.materials[3]
     assert m.nuclides == ['H1', 'O16', 'B10', 'B11']
 
     old_dens = m.densities
@@ -137,7 +137,7 @@ def test_material(capi_init):
     assert m.name == "Not hot borated water"
 
 def test_material_add_nuclide(capi_init):
-    m = openmc.capi.materials[3]
+    m = openmc.lib.materials[3]
     m.add_nuclide('Xe135', 1e-12)
     assert m.nuclides[-1] == 'Xe135'
     assert m.densities[-1] == 1e-12
@@ -145,23 +145,23 @@ def test_material_add_nuclide(capi_init):
 
 def test_new_material(capi_init):
     with pytest.raises(exc.AllocationError):
-        openmc.capi.Material(1)
-    new_mat = openmc.capi.Material()
-    new_mat_with_id = openmc.capi.Material(10)
-    assert len(openmc.capi.materials) == 5
+        openmc.lib.Material(1)
+    new_mat = openmc.lib.Material()
+    new_mat_with_id = openmc.lib.Material(10)
+    assert len(openmc.lib.materials) == 5
 
 
 def test_nuclide_mapping(capi_init):
-    nucs = openmc.capi.nuclides
+    nucs = openmc.lib.nuclides
     assert isinstance(nucs, Mapping)
     assert len(nucs) == 13
     for name, nuc in nucs.items():
-        assert isinstance(nuc, openmc.capi.Nuclide)
+        assert isinstance(nuc, openmc.lib.Nuclide)
         assert name == nuc.name
 
 
 def test_settings(capi_init):
-    settings = openmc.capi.settings
+    settings = openmc.lib.settings
     assert settings.batches == 10
     settings.batches = 10
     assert settings.inactive == 5
@@ -176,17 +176,17 @@ def test_settings(capi_init):
 
 
 def test_tally_mapping(capi_init):
-    tallies = openmc.capi.tallies
+    tallies = openmc.lib.tallies
     assert isinstance(tallies, Mapping)
     assert len(tallies) == 3
     for tally_id, tally in tallies.items():
-        assert isinstance(tally, openmc.capi.Tally)
+        assert isinstance(tally, openmc.lib.Tally)
         assert tally_id == tally.id
 
 
 def test_energy_function_filter(capi_init):
     """Test special __new__ and __init__ for EnergyFunctionFilter"""
-    efunc = openmc.capi.EnergyFunctionFilter([0.0, 1.0], [0.0, 2.0])
+    efunc = openmc.lib.EnergyFunctionFilter([0.0, 1.0], [0.0, 2.0])
     assert len(efunc.energy) == 2
     assert (efunc.energy == [0.0, 1.0]).all()
     assert len(efunc.y) == 2
@@ -194,17 +194,17 @@ def test_energy_function_filter(capi_init):
 
 
 def test_tally(capi_init):
-    t = openmc.capi.tallies[1]
+    t = openmc.lib.tallies[1]
     assert t.type == 'volume'
     assert len(t.filters) == 2
-    assert isinstance(t.filters[0], openmc.capi.MaterialFilter)
-    assert isinstance(t.filters[1], openmc.capi.EnergyFilter)
+    assert isinstance(t.filters[0], openmc.lib.MaterialFilter)
+    assert isinstance(t.filters[1], openmc.lib.EnergyFilter)
 
     # Create new filter and replace existing
     with pytest.raises(exc.AllocationError):
-        openmc.capi.MaterialFilter(uid=1)
-    mats = openmc.capi.materials
-    f = openmc.capi.MaterialFilter([mats[2], mats[1]])
+        openmc.lib.MaterialFilter(uid=1)
+    mats = openmc.lib.materials
+    f = openmc.lib.MaterialFilter([mats[2], mats[1]])
     assert f.bins[0] == mats[2]
     assert f.bins[1] == mats[1]
     t.filters = [f]
@@ -221,17 +221,17 @@ def test_tally(capi_init):
     t.scores = new_scores
     assert t.scores == new_scores
 
-    t2 = openmc.capi.tallies[2]
+    t2 = openmc.lib.tallies[2]
     assert len(t2.filters) == 2
-    assert isinstance(t2.filters[0], openmc.capi.ZernikeFilter)
-    assert isinstance(t2.filters[1], openmc.capi.CellFilter)
+    assert isinstance(t2.filters[0], openmc.lib.ZernikeFilter)
+    assert isinstance(t2.filters[1], openmc.lib.CellFilter)
     assert len(t2.filters[1].bins) == 3
     assert t2.filters[0].order == 5
 
-    t3 = openmc.capi.tallies[3]
+    t3 = openmc.lib.tallies[3]
     assert len(t3.filters) == 1
     t3_f = t3.filters[0]
-    assert isinstance(t3_f, openmc.capi.EnergyFunctionFilter)
+    assert isinstance(t3_f, openmc.lib.EnergyFunctionFilter)
     assert len(t3_f.energy) == 2
     assert len(t3_f.y) == 2
     t3_f.set_data([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
@@ -241,144 +241,144 @@ def test_tally(capi_init):
 
 def test_new_tally(capi_init):
     with pytest.raises(exc.AllocationError):
-        openmc.capi.Material(1)
-    new_tally = openmc.capi.Tally()
+        openmc.lib.Material(1)
+    new_tally = openmc.lib.Tally()
     new_tally.scores = ['flux']
-    new_tally_with_id = openmc.capi.Tally(10)
+    new_tally_with_id = openmc.lib.Tally(10)
     new_tally_with_id.scores = ['flux']
-    assert len(openmc.capi.tallies) == 5
+    assert len(openmc.lib.tallies) == 5
 
 
 def test_tally_activate(capi_simulation_init):
-    t = openmc.capi.tallies[1]
+    t = openmc.lib.tallies[1]
     assert not t.active
     t.active = True
     assert t.active
 
 
 def test_tally_results(capi_run):
-    t = openmc.capi.tallies[1]
+    t = openmc.lib.tallies[1]
     assert t.num_realizations == 10  # t was made active in test_tally
     assert np.all(t.mean >= 0)
     nonzero = (t.mean > 0.0)
     assert np.all(t.std_dev[nonzero] >= 0)
     assert np.all(t.ci_width()[nonzero] >= 1.95*t.std_dev[nonzero])
 
-    t2 = openmc.capi.tallies[2]
+    t2 = openmc.lib.tallies[2]
     n = 5
     assert t2.mean.size == (n + 1) * (n + 2) // 2 * 3 # Number of Zernike coeffs * 3 cells
 
 
 def test_global_tallies(capi_run):
-    assert openmc.capi.num_realizations() == 5
-    gt = openmc.capi.global_tallies()
+    assert openmc.lib.num_realizations() == 5
+    gt = openmc.lib.global_tallies()
     for mean, std_dev in gt:
         assert mean >= 0
 
 
 def test_statepoint(capi_run):
-    openmc.capi.statepoint_write('test_sp.h5')
+    openmc.lib.statepoint_write('test_sp.h5')
     assert os.path.exists('test_sp.h5')
 
 
 def test_source_bank(capi_run):
-    source = openmc.capi.source_bank()
+    source = openmc.lib.source_bank()
     assert np.all(source['E'] > 0.0)
     assert np.all(source['wgt'] == 1.0)
     assert np.allclose(np.linalg.norm(source['u'], axis=1), 1.0)
 
 
 def test_by_batch(capi_run):
-    openmc.capi.hard_reset()
+    openmc.lib.hard_reset()
 
     # Running next batch before simulation is initialized should raise an
     # exception
     with pytest.raises(exc.AllocationError):
-        openmc.capi.next_batch()
+        openmc.lib.next_batch()
 
-    openmc.capi.simulation_init()
+    openmc.lib.simulation_init()
     try:
-        for _ in openmc.capi.iter_batches():
+        for _ in openmc.lib.iter_batches():
             # Make sure we can get k-effective during inactive/active batches
-            mean, std_dev = openmc.capi.keff()
+            mean, std_dev = openmc.lib.keff()
             assert 0.0 < mean < 2.5
             assert std_dev > 0.0
-        assert openmc.capi.num_realizations() == 5
+        assert openmc.lib.num_realizations() == 5
 
         for i in range(3):
-            openmc.capi.next_batch()
-        assert openmc.capi.num_realizations() == 8
+            openmc.lib.next_batch()
+        assert openmc.lib.num_realizations() == 8
 
     finally:
-        openmc.capi.simulation_finalize()
+        openmc.lib.simulation_finalize()
 
 
 def test_reset(capi_run):
     # Init and run 10 batches.
-    openmc.capi.hard_reset()
-    openmc.capi.simulation_init()
+    openmc.lib.hard_reset()
+    openmc.lib.simulation_init()
     try:
         for i in range(10):
-            openmc.capi.next_batch()
+            openmc.lib.next_batch()
 
         # Make sure there are 5 realizations for the 5 active batches.
-        assert openmc.capi.num_realizations() == 5
-        assert openmc.capi.tallies[2].num_realizations == 5
-        _, keff_sd1 = openmc.capi.keff()
-        tally_sd1 = openmc.capi.tallies[2].std_dev[0]
+        assert openmc.lib.num_realizations() == 5
+        assert openmc.lib.tallies[2].num_realizations == 5
+        _, keff_sd1 = openmc.lib.keff()
+        tally_sd1 = openmc.lib.tallies[2].std_dev[0]
 
         # Reset and run 3 more batches.  Check the number of realizations.
-        openmc.capi.reset()
+        openmc.lib.reset()
         for i in range(3):
-            openmc.capi.next_batch()
-        assert openmc.capi.num_realizations() == 3
-        assert openmc.capi.tallies[2].num_realizations == 3
+            openmc.lib.next_batch()
+        assert openmc.lib.num_realizations() == 3
+        assert openmc.lib.tallies[2].num_realizations == 3
 
         # Check the tally std devs to make sure results were cleared.
-        _, keff_sd2 = openmc.capi.keff()
-        tally_sd2 = openmc.capi.tallies[2].std_dev[0]
+        _, keff_sd2 = openmc.lib.keff()
+        tally_sd2 = openmc.lib.tallies[2].std_dev[0]
         assert keff_sd2 > keff_sd1
         assert tally_sd2 > tally_sd1
 
     finally:
-        openmc.capi.simulation_finalize()
+        openmc.lib.simulation_finalize()
 
 
 def test_reproduce_keff(capi_init):
     # Get k-effective after run
-    openmc.capi.hard_reset()
-    openmc.capi.run()
-    keff0 = openmc.capi.keff()
+    openmc.lib.hard_reset()
+    openmc.lib.run()
+    keff0 = openmc.lib.keff()
 
     # Reset, run again, and get k-effective again. they should match
-    openmc.capi.hard_reset()
-    openmc.capi.run()
-    keff1 = openmc.capi.keff()
+    openmc.lib.hard_reset()
+    openmc.lib.run()
+    keff1 = openmc.lib.keff()
     assert keff0 == pytest.approx(keff1)
 
 
 def test_find_cell(capi_init):
-    cell, instance = openmc.capi.find_cell((0., 0., 0.))
-    assert cell is openmc.capi.cells[1]
-    cell, instance = openmc.capi.find_cell((0.4, 0., 0.))
-    assert cell is openmc.capi.cells[2]
+    cell, instance = openmc.lib.find_cell((0., 0., 0.))
+    assert cell is openmc.lib.cells[1]
+    cell, instance = openmc.lib.find_cell((0.4, 0., 0.))
+    assert cell is openmc.lib.cells[2]
     with pytest.raises(exc.GeometryError):
-        openmc.capi.find_cell((100., 100., 100.))
+        openmc.lib.find_cell((100., 100., 100.))
 
 
 def test_find_material(capi_init):
-    mat = openmc.capi.find_material((0., 0., 0.))
-    assert mat is openmc.capi.materials[1]
-    mat = openmc.capi.find_material((0.4, 0., 0.))
-    assert mat is openmc.capi.materials[2]
+    mat = openmc.lib.find_material((0., 0., 0.))
+    assert mat is openmc.lib.materials[1]
+    mat = openmc.lib.find_material((0.4, 0., 0.))
+    assert mat is openmc.lib.materials[2]
 
 
 def test_mesh(capi_init):
-    mesh = openmc.capi.RegularMesh()
+    mesh = openmc.lib.RegularMesh()
     mesh.dimension = (2, 3, 4)
     assert mesh.dimension == (2, 3, 4)
     with pytest.raises(exc.AllocationError):
-        mesh2 = openmc.capi.RegularMesh(mesh.id)
+        mesh2 = openmc.lib.RegularMesh(mesh.id)
 
     # Make sure each combination of parameters works
     ll = (0., 0., 0.)
@@ -394,47 +394,47 @@ def test_mesh(capi_init):
     assert mesh.upper_right == pytest.approx(ur)
     assert mesh.width == pytest.approx(width)
 
-    meshes = openmc.capi.meshes
+    meshes = openmc.lib.meshes
     assert isinstance(meshes, Mapping)
     assert len(meshes) == 1
     for mesh_id, mesh in meshes.items():
-        assert isinstance(mesh, openmc.capi.RegularMesh)
+        assert isinstance(mesh, openmc.lib.RegularMesh)
         assert mesh_id == mesh.id
 
-    mf = openmc.capi.MeshFilter(mesh)
+    mf = openmc.lib.MeshFilter(mesh)
     assert mf.mesh == mesh
 
-    msf = openmc.capi.MeshSurfaceFilter(mesh)
+    msf = openmc.lib.MeshSurfaceFilter(mesh)
     assert msf.mesh == mesh
 
 
 def test_restart(capi_init, mpi_intracomm):
     # Finalize and re-init to make internal state consistent with XML.
-    openmc.capi.hard_reset()
-    openmc.capi.finalize()
-    openmc.capi.init(intracomm=mpi_intracomm)
-    openmc.capi.simulation_init()
+    openmc.lib.hard_reset()
+    openmc.lib.finalize()
+    openmc.lib.init(intracomm=mpi_intracomm)
+    openmc.lib.simulation_init()
 
     # Run for 7 batches then write a statepoint.
     for i in range(7):
-        openmc.capi.next_batch()
-    openmc.capi.statepoint_write('restart_test.h5', True)
+        openmc.lib.next_batch()
+    openmc.lib.statepoint_write('restart_test.h5', True)
 
     # Run 3 more batches and copy the keff.
     for i in range(3):
-        openmc.capi.next_batch()
-    keff0 = openmc.capi.keff()
+        openmc.lib.next_batch()
+    keff0 = openmc.lib.keff()
 
     # Restart the simulation from the statepoint and the 3 remaining active batches.
-    openmc.capi.simulation_finalize()
-    openmc.capi.hard_reset()
-    openmc.capi.finalize()
-    openmc.capi.init(args=('-r', 'restart_test.h5'))
-    openmc.capi.simulation_init()
+    openmc.lib.simulation_finalize()
+    openmc.lib.hard_reset()
+    openmc.lib.finalize()
+    openmc.lib.init(args=('-r', 'restart_test.h5'))
+    openmc.lib.simulation_init()
     for i in range(3):
-        openmc.capi.next_batch()
-    keff1 = openmc.capi.keff()
-    openmc.capi.simulation_finalize()
+        openmc.lib.next_batch()
+    keff1 = openmc.lib.keff()
+    openmc.lib.simulation_finalize()
 
     # Compare the keff values.
     assert keff0 == pytest.approx(keff1)
@@ -442,13 +442,13 @@ def test_restart(capi_init, mpi_intracomm):
 
 def test_load_nuclide(capi_init):
     # load multiple nuclides
-    openmc.capi.load_nuclide('H3')
-    assert 'H3' in openmc.capi.nuclides
-    openmc.capi.load_nuclide('Pu239')
-    assert 'Pu239' in openmc.capi.nuclides
+    openmc.lib.load_nuclide('H3')
+    assert 'H3' in openmc.lib.nuclides
+    openmc.lib.load_nuclide('Pu239')
+    assert 'Pu239' in openmc.lib.nuclides
     # load non-existent nuclide
     with pytest.raises(exc.DataError):
-        openmc.capi.load_nuclide('Pu3')
+        openmc.lib.load_nuclide('Pu3')
 
 
 def test_id_map(capi_init):
@@ -457,7 +457,7 @@ def test_id_map(capi_init):
                              [(3, 3), (2, 2), (3, 3)]], dtype='int32')
 
     # create a plot object
-    s = openmc.capi.plot._PlotBase()
+    s = openmc.lib.plot._PlotBase()
     s.width = 1.26
     s.height = 1.26
     s.v_res = 3
@@ -466,7 +466,7 @@ def test_id_map(capi_init):
     s.basis = 'xy'
     s.level = -1
 
-    ids = openmc.capi.plot.id_map(s)
+    ids = openmc.lib.plot.id_map(s)
     assert np.array_equal(expected_ids, ids)
 
 def test_property_map(capi_init):
@@ -476,7 +476,7 @@ def test_property_map(capi_init):
          [(293.6, 0.740582), (293.6, 6.55), (293.6, 0.740582)]], dtype='float')
 
     # create a plot object
-    s = openmc.capi.plot._PlotBase()
+    s = openmc.lib.plot._PlotBase()
     s.width = 1.26
     s.height = 1.26
     s.v_res = 3
@@ -485,13 +485,13 @@ def test_property_map(capi_init):
     s.basis = 'xy'
     s.level = -1
 
-    properties = openmc.capi.plot.property_map(s)
+    properties = openmc.lib.plot.property_map(s)
     assert np.allclose(expected_properties, properties, atol=1e-04)
 
 
 def test_position(capi_init):
 
-    pos = openmc.capi.plot._Position(1.0, 2.0, 3.0)
+    pos = openmc.lib.plot._Position(1.0, 2.0, 3.0)
 
     assert tuple(pos) == (1.0, 2.0, 3.0)
 
@@ -506,7 +506,7 @@ def test_global_bounding_box(capi_init):
     expected_llc = (-0.63, -0.63, -np.inf)
     expected_urc = (0.63, 0.63, np.inf)
 
-    llc, urc = openmc.capi.global_bounding_box()
+    llc, urc = openmc.lib.global_bounding_box()
 
     assert tuple(llc) == expected_llc
     assert tuple(urc) == expected_urc
diff --git a/tests/unit_tests/test_complex_cell_capi.py b/tests/unit_tests/test_complex_cell_capi.py
index ee5e69925..39431684d 100644
--- a/tests/unit_tests/test_complex_cell_capi.py
+++ b/tests/unit_tests/test_complex_cell_capi.py
@@ -1,5 +1,5 @@
 import numpy as np
-import openmc.capi
+import openmc.lib
 import pytest
 
 @pytest.fixture(autouse=True)
@@ -73,12 +73,12 @@ def complex_cell(run_in_tmpdir, mpi_intracomm):
 
     model.export_to_xml()
 
-    openmc.capi.finalize()
-    openmc.capi.init(intracomm=mpi_intracomm)
+    openmc.lib.finalize()
+    openmc.lib.init(intracomm=mpi_intracomm)
 
     yield
 
-    openmc.capi.finalize()
+    openmc.lib.finalize()
 
 
 expected_results = ( (1, (( -4.,  -4., -np.inf),
@@ -93,6 +93,6 @@ expected_results = ( (1, (( -4.,  -4., -np.inf),
                           ( np.inf,  np.inf,  np.inf))) )
 @pytest.mark.parametrize("cell_id,expected_box", expected_results)
 def test_cell_box(cell_id, expected_box):
-    cell_box = openmc.capi.cells[cell_id].bounding_box
+    cell_box = openmc.lib.cells[cell_id].bounding_box
     assert tuple(cell_box[0]) == expected_box[0]
     assert tuple(cell_box[1]) == expected_box[1]
diff --git a/tests/unit_tests/test_deplete_fission_yields.py b/tests/unit_tests/test_deplete_fission_yields.py
index bedd702a9..854c530f9 100644
--- a/tests/unit_tests/test_deplete_fission_yields.py
+++ b/tests/unit_tests/test_deplete_fission_yields.py
@@ -8,7 +8,7 @@ import bisect
 import pytest
 import numpy as np
 import openmc
-from openmc import capi
+from openmc import lib
 from openmc.deplete.nuclide import Nuclide, FissionYieldDistribution
 from openmc.deplete.helpers import (
     FissionYieldCutoffHelper, ConstantFissionYieldHelper,
@@ -18,7 +18,7 @@ from openmc.deplete.helpers import (
 @pytest.fixture(scope="module")
 def materials(tmpdir_factory):
     """Use C API to construct realistic materials for testing tallies"""
-    tmpdir = tmpdir_factory.mktemp("capi")
+    tmpdir = tmpdir_factory.mktemp("lib")
     orig = tmpdir.chdir()
     # Create proxy problem to please openmc
     mfuel = openmc.Material(name="test_fuel")
@@ -40,8 +40,8 @@ def materials(tmpdir_factory):
     settings.export_to_xml()
 
     try:
-        with capi.run_in_memory():
-            yield [capi.Material(), capi.Material()]
+        with lib.run_in_memory():
+            yield [lib.Material(), lib.Material()]
     finally:
         # Convert to strings as os.remove in py 3.5 doesn't support Paths
         for file_path in ("settings.xml", "geometry.xml", "materials.xml",
@@ -64,7 +64,7 @@ def proxy_tally_data(tally, fill=None):
         if not hasattr(tfilter, "bins"):
             continue
         this_bins = len(tfilter.bins)
-        if isinstance(tfilter, capi.EnergyFilter):
+        if isinstance(tfilter, lib.EnergyFilter):
             this_bins -= 1
         n_bins *= max(this_bins, 1)
     data = np.empty((n_bins, n_nucs * n_scores, 3))
@@ -192,9 +192,9 @@ def test_cutoff_helper(materials, nuclide_bundle, therm_frac):
     assert fission_tally is not None
     filters = fission_tally.filters
     assert len(filters) == 2
-    assert isinstance(filters[0], capi.MaterialFilter)
+    assert isinstance(filters[0], lib.MaterialFilter)
     assert len(filters[0].bins) == len(materials)
-    assert isinstance(filters[1], capi.EnergyFilter)
+    assert isinstance(filters[1], lib.EnergyFilter)
     # lower, cutoff, and upper energy
     assert len(filters[1].bins) == 3
 
@@ -235,9 +235,9 @@ def test_averaged_helper(materials, nuclide_bundle, avg_energy):
     assert fission_tally is not None
     fission_filters = fission_tally.filters
     assert len(fission_filters) == 2
-    assert isinstance(fission_filters[0], capi.MaterialFilter)
+    assert isinstance(fission_filters[0], lib.MaterialFilter)
     assert len(fission_filters[0].bins) == len(materials)
-    assert isinstance(fission_filters[1], capi.EnergyFilter)
+    assert isinstance(fission_filters[1], lib.EnergyFilter)
     assert len(fission_filters[1].bins) == 2
     assert fission_tally.scores == ["fission"]
     assert fission_tally.nuclides == list(tallied_nucs)
@@ -246,9 +246,9 @@ def test_averaged_helper(materials, nuclide_bundle, avg_energy):
     assert weighted_tally is not None
     weighted_filters = weighted_tally.filters
     assert len(weighted_filters) == 2
-    assert isinstance(weighted_filters[0], capi.MaterialFilter)
+    assert isinstance(weighted_filters[0], lib.MaterialFilter)
     assert len(weighted_filters[0].bins) == len(materials)
-    assert isinstance(weighted_filters[1], capi.EnergyFunctionFilter)
+    assert isinstance(weighted_filters[1], lib.EnergyFunctionFilter)
     assert len(weighted_filters[1].energy) == 2
     assert len(weighted_filters[1].y) == 2
     assert weighted_tally.scores == ["fission"]
diff --git a/tests/unit_tests/test_math.py b/tests/unit_tests/test_math.py
index e6b2ddecd..7c0218fbd 100644
--- a/tests/unit_tests/test_math.py
+++ b/tests/unit_tests/test_math.py
@@ -2,7 +2,7 @@ import numpy as np
 import scipy as sp
 
 import openmc
-import openmc.capi
+import openmc.lib
 
 import pytest
 
@@ -15,10 +15,10 @@ def test_t_percentile():
     # The reference solutions come from Scipy
     ref_ts = [[sp.stats.t.ppf(p, df) for p in test_ps] for df in test_dfs]
 
-    test_ts = [[openmc.capi.math.t_percentile(p, df) for p in test_ps]
+    test_ts = [[openmc.lib.math.t_percentile(p, df) for p in test_ps]
                for df in test_dfs]
 
-    # The 5 DoF approximation in openmc.capi.math.t_percentile is off by up to
+    # The 5 DoF approximation in openmc.lib.math.t_percentile is off by up to
     # 8e-3 from the scipy solution, so test that one separately with looser
     # tolerance
     assert np.allclose(ref_ts[:-1], test_ts[:-1])
@@ -35,7 +35,7 @@ def test_calc_pn():
 
     test_vals = []
     for x in test_xs:
-        test_vals.append(openmc.capi.math.calc_pn(max_order, x).tolist())
+        test_vals.append(openmc.lib.math.calc_pn(max_order, x).tolist())
 
     test_vals = np.swapaxes(np.array(test_vals), 0, 1)
 
@@ -55,7 +55,7 @@ def test_evaluate_legendre():
     # evaluate legendre incorporates the (2l+1)/2 term on its own
     test_coeffs = [1. for l in range(max_order + 1)]
 
-    test_vals = np.array([openmc.capi.math.evaluate_legendre(test_coeffs, x)
+    test_vals = np.array([openmc.lib.math.evaluate_legendre(test_coeffs, x)
                           for x in test_xs])
 
     assert np.allclose(ref_vals, test_vals)
@@ -98,7 +98,7 @@ def test_calc_rn():
             ref_vals.append(ylm)
 
     test_vals = []
-    test_vals = openmc.capi.math.calc_rn(max_order, test_uvw)
+    test_vals = openmc.lib.math.calc_rn(max_order, test_uvw)
 
     assert np.allclose(ref_vals, test_vals)
 
@@ -133,7 +133,7 @@ def test_calc_zn():
         -8.98437500e-02, -1.08693628e-01, 1.78813094e-01,
         -1.98191857e-01, 1.65964201e-02, 2.77013853e-04])
 
-    test_vals = openmc.capi.math.calc_zn(n, rho, phi)
+    test_vals = openmc.lib.math.calc_zn(n, rho, phi)
 
     assert np.allclose(ref_vals, test_vals)
 
@@ -147,7 +147,7 @@ def test_calc_zn_rad():
         1.00000000e+00, -5.00000000e-01, -1.25000000e-01,
         4.37500000e-01, -2.89062500e-01,-8.98437500e-02])
 
-    test_vals = openmc.capi.math.calc_zn_rad(n, rho)
+    test_vals = openmc.lib.math.calc_zn_rad(n, rho)
 
     assert np.allclose(ref_vals, test_vals)
 
@@ -160,7 +160,7 @@ def test_rotate_angle():
     # reference: mu of 0 pulls the vector the bottom, so:
     ref_uvw = np.array([0., 0., -1.])
 
-    test_uvw = openmc.capi.math.rotate_angle(uvw0, mu, phi)
+    test_uvw = openmc.lib.math.rotate_angle(uvw0, mu, phi)
 
     assert np.array_equal(ref_uvw, test_uvw)
 
@@ -168,51 +168,51 @@ def test_rotate_angle():
     mu = 1.
     ref_uvw = np.array([1., 0., 0.])
 
-    test_uvw = openmc.capi.math.rotate_angle(uvw0, mu, phi)
+    test_uvw = openmc.lib.math.rotate_angle(uvw0, mu, phi)
 
     assert np.array_equal(ref_uvw, test_uvw)
 
     # Now to test phi is None
     mu = 0.9
-    settings = openmc.capi.settings
+    settings = openmc.lib.settings
     settings.seed = 1
 
     # When seed = 1, phi will be sampled as 1.9116495709698769
     # The resultant reference is from hand-calculations given the above
     ref_uvw = [0.9, 0.410813051297112, 0.1457142302040]
-    test_uvw = openmc.capi.math.rotate_angle(uvw0, mu)
+    test_uvw = openmc.lib.math.rotate_angle(uvw0, mu)
 
     assert np.allclose(ref_uvw, test_uvw)
 
 
 def test_maxwell_spectrum():
-    settings = openmc.capi.settings
+    settings = openmc.lib.settings
     settings.seed = 1
     T = 0.5
     ref_val = 0.6129982175261098
-    test_val = openmc.capi.math.maxwell_spectrum(T)
+    test_val = openmc.lib.math.maxwell_spectrum(T)
 
     assert ref_val == test_val
 
 
 def test_watt_spectrum():
-    settings = openmc.capi.settings
+    settings = openmc.lib.settings
     settings.seed = 1
     a = 0.5
     b = 0.75
     ref_val = 0.6247242713640233
-    test_val = openmc.capi.math.watt_spectrum(a, b)
+    test_val = openmc.lib.math.watt_spectrum(a, b)
 
     assert ref_val == test_val
 
 
 def test_normal_dist():
-    settings = openmc.capi.settings
+    settings = openmc.lib.settings
     settings.seed = 1
     a = 14.08
     b = 0.0
     ref_val = 14.08
-    test_val = openmc.capi.math.normal_variate(a, b)
+    test_val = openmc.lib.math.normal_variate(a, b)
 
     assert ref_val == pytest.approx(test_val)
 
@@ -220,7 +220,7 @@ def test_normal_dist():
     a = 14.08
     b = 1.0
     ref_val = 16.436645416691427
-    test_val = openmc.capi.math.normal_variate(a, b)
+    test_val = openmc.lib.math.normal_variate(a, b)
 
     assert ref_val == pytest.approx(test_val)
 
@@ -234,13 +234,13 @@ def test_broaden_wmp_polynomials():
     n = 6
 
     ref_val = [2., 1.41421356, 1.0001, 0.70731891, 0.50030001, 0.353907]
-    test_val = openmc.capi.math.broaden_wmp_polynomials(test_E, test_dopp, n)
+    test_val = openmc.lib.math.broaden_wmp_polynomials(test_E, test_dopp, n)
 
     assert np.allclose(ref_val, test_val)
 
     # now beta < 6
     test_dopp = 5.
     ref_val = [1.99999885, 1.41421356, 1.04, 0.79195959, 0.6224, 0.50346003]
-    test_val = openmc.capi.math.broaden_wmp_polynomials(test_E, test_dopp, n)
+    test_val = openmc.lib.math.broaden_wmp_polynomials(test_E, test_dopp, n)
 
     assert np.allclose(ref_val, test_val)