diff --git a/doc/ref_call.rst b/doc/ref_call.rst
index 4ba3246a2cd1dcf75bb89ce084d290d97852593c..60170a5f4a8a1cb579a2fc146abf2140f02b2e17 100644
--- a/doc/ref_call.rst
+++ b/doc/ref_call.rst
@@ -10,7 +10,7 @@ Function Interface
 Resolving and specialization
 ----------------------------
 
-In :mod:`loopy`, a :class:`loopy.Program` is a collection of callables
+In :mod:`loopy`, a :class:`loopy.TranslationUnit` is a collection of callables
 and entrypoints. Callable are of type
 :class`:loopy.kernel.function_interface.InKernelCallable`. Any expression node
 which has a callable corresponding to it appears as
@@ -18,7 +18,7 @@ which has a callable corresponding to it appears as
 a :class:`~loopy.kernel.function_interface.InKernelCallable` is referred to as resolving.
 
 
-During code-generation process for a :class:`~loopy.Program`, a callable
+During code-generation process for a :class:`~loopy.TranslationUnit`, a callable
 is *specialized* depending on the types and shapes of the arguments passed at a
 call site. For example, a call to ``sin(x)`` in :mod:`loopy` is type-generic to
 begin with, but it later specialized to either ``sinf``, ``sin`` or ``sinl``
@@ -31,7 +31,7 @@ or shape specialization is encoded via
 Registering callables
 ---------------------
 
-A user can *register* callables within a  :class:`~loopy.Program` to
+A user can *register* callables within a  :class:`~loopy.TranslationUnit` to
 allow loopy to resolve calls not pre-defined in :mod:`loopy`. In :mod:`loopy`,
 we typically aim to expose all the standard math functions defined for
 a :class:`~loopy.target.TargetBase`. Other foreign functions could be invoked by
diff --git a/doc/ref_program.rst b/doc/ref_program.rst
index 2e4d5b9bc64aa8f442203dfa4f41109c9e765743..e83530b625a177c993aebbf7d0de833f665b96d9 100644
--- a/doc/ref_program.rst
+++ b/doc/ref_program.rst
@@ -1,6 +1,6 @@
 .. currentmodule:: loopy
 
-Program
+TranslationUnit
 =======
 
-.. autoclass:: Program
+.. autoclass:: TranslationUnit
diff --git a/loopy/__init__.py b/loopy/__init__.py
index 6cabbf614e0aa3ef938972a0e8af5c168467249a..602074305b53a561e982c27c4426dc30739bf775 100644
--- a/loopy/__init__.py
+++ b/loopy/__init__.py
@@ -47,7 +47,7 @@ from loopy.kernel.data import (
 from loopy.kernel.function_interface import (
         CallableKernel, ScalarCallable)
 from loopy.program import (
-        Program, make_program)
+        TranslationUnit, Program,  make_program)
 
 from loopy.kernel import LoopKernel, KernelState, kernel_state
 from loopy.kernel.tools import (
@@ -175,7 +175,7 @@ __all__ = [
 
         "ScalarCallable", "CallableKernel",
 
-        "Program", "make_program",
+        "TranslationUnit", "make_program", "Program",
 
         "KernelArgument",
         "ValueArg", "ArrayArg", "GlobalArg", "ConstantArg", "ImageArg",
@@ -461,7 +461,7 @@ class CacheMode:
 # {{{ make copy kernel
 
 def make_copy_kernel(new_dim_tags, old_dim_tags=None):
-    """Returns a :class:`loopy.Program` that changes the data layout
+    """Returns a :class:`loopy.TranslationUnit` that changes the data layout
     of a variable (called "input") to the new layout specified by
     *new_dim_tags* from the one specified by *old_dim_tags*.
     *old_dim_tags* defaults to an all-C layout of the same rank
diff --git a/loopy/cli.py b/loopy/cli.py
index a7d209ae87b2120f90a8d360c3ff9eb13bc925f5..787c3ee32aa412d1bae9b8da214067f58c703b31 100644
--- a/loopy/cli.py
+++ b/loopy/cli.py
@@ -184,10 +184,10 @@ def main():
         raise RuntimeError("unknown language: '%s'"
                 % args.lang)
 
-    if not isinstance(prg, lp.Program):
+    if not isinstance(prg, lp.TranslationUnit):
         # FIXME
         assert isinstance(prg, list)  # of kernels
-        raise NotImplementedError("convert list of kernels to Program")
+        raise NotImplementedError("convert list of kernels to TranslationUnit")
 
     if args.print_ir:
         print(prg, file=sys.stderr)
diff --git a/loopy/codegen/__init__.py b/loopy/codegen/__init__.py
index 68ee6c8080e48b3545092c7be80b891ec315fccb..ef244e23f9cedcb338f0cc7247972a685450ecf0 100644
--- a/loopy/codegen/__init__.py
+++ b/loopy/codegen/__init__.py
@@ -706,7 +706,7 @@ def generate_code_v2(program):
     """
     Returns an instance of :class:`CodeGenerationResult`.
 
-    :param program: An instance of :class:`loopy.Program`.
+    :param program: An instance of :class:`loopy.TranslationUnit`.
     """
 
     from loopy.kernel import LoopKernel
@@ -721,7 +721,7 @@ def generate_code_v2(program):
         input_program = prepare_for_caching(program)
         try:
             result = code_gen_cache[input_program]
-            logger.debug(f"Program with entrypoints {program.entrypoints}:"
+            logger.debug(f"TranslationUnit with entrypoints {program.entrypoints}:"
                          " code generation cache hit")
             return result
         except KeyError:
diff --git a/loopy/frontend/fortran/__init__.py b/loopy/frontend/fortran/__init__.py
index 4ad7cd21c48f7abd396afb977267e30cb9f2d501..d6311131f935a5b7dc8405e0cad039371131a079 100644
--- a/loopy/frontend/fortran/__init__.py
+++ b/loopy/frontend/fortran/__init__.py
@@ -157,7 +157,7 @@ def parse_transformed_fortran(source, free_form=True, strict=True,
     * ``FILENAME``: the file name of the code being processed
 
     The transform code must define ``RESULT``, conventionally a list of kernels
-    or a :class:`loopy.Program`, which is returned from this function
+    or a :class:`loopy.TranslationUnit`, which is returned from this function
     unmodified.
 
     An example of *source* may look as follows::
diff --git a/loopy/kernel/__init__.py b/loopy/kernel/__init__.py
index e6c05c8782b13c6b861843f20d785baba3d7937b..7fb779b639d2128d7bfe667aab1e81047a446074 100644
--- a/loopy/kernel/__init__.py
+++ b/loopy/kernel/__init__.py
@@ -1483,7 +1483,7 @@ class LoopKernel(ImmutableRecordWithoutPickling):
         """
         Execute the :class:`LoopKernel`.
         """
-        warn("Calling a LoopKernel is deprecated, call a Program "
+        warn("Calling a LoopKernel is deprecated, call a TranslationUnit "
                 "instead.", DeprecationWarning, stacklevel=2)
         from loopy.program import make_program
         program = make_program(self)
diff --git a/loopy/kernel/tools.py b/loopy/kernel/tools.py
index fa924467b9117c7c5b2332ee2702efdd120ecc30..6465965f9566ad2d73f1b9c84b9ad528ca7229a8 100644
--- a/loopy/kernel/tools.py
+++ b/loopy/kernel/tools.py
@@ -33,7 +33,7 @@ from islpy import dim_type
 from loopy.diagnostic import LoopyError, warn_with_kernel
 from pytools import memoize_on_first_arg, natsorted
 from loopy.kernel import LoopKernel
-from loopy.program import Program, iterate_over_kernels_if_given_program
+from loopy.program import TranslationUnit, iterate_over_kernels_if_given_program
 from loopy.kernel.function_interface import CallableKernel
 import logging
 logger = logging.getLogger(__name__)
@@ -47,13 +47,13 @@ def add_dtypes(prog_or_kernel, dtype_dict):
     :arg dtype_dict: a mapping from variable names to :class:`numpy.dtype`
         instances
     """
-    if isinstance(prog_or_kernel, Program):
+    if isinstance(prog_or_kernel, TranslationUnit):
         kernel_names = [clbl.subkernel.name for clbl in
                 prog_or_kernel.callables_table.values() if isinstance(clbl,
                     CallableKernel)]
         if len(kernel_names) != 1:
-            raise LoopyError("add_dtypes may not take a Program with more than"
-                    " one callable kernels. Please provide individual kernels"
+            raise LoopyError("add_dtypes may not take a TranslationUnit with more"
+                    " than one callable kernels. Please provide individual kernels"
                     " instead.")
 
         kernel_name, = kernel_names
@@ -124,7 +124,7 @@ def get_arguments_with_incomplete_dtype(kernel):
 
 def add_and_infer_dtypes(prog, dtype_dict, expect_completion=False,
         kernel_name=None):
-    assert isinstance(prog, Program)
+    assert isinstance(prog, TranslationUnit)
     if kernel_name is None:
         kernel_names = [clbl.subkernel.name for clbl in
                 prog.callables_table.values() if isinstance(clbl,
diff --git a/loopy/preprocess.py b/loopy/preprocess.py
index 90e527ae4a29715a81608079d4fdd88025cc0abf..cd6de2ab5a5fc0d5238f672a71b369c63c9c9c98 100644
--- a/loopy/preprocess.py
+++ b/loopy/preprocess.py
@@ -42,7 +42,7 @@ from loopy.symbolic import RuleAwareIdentityMapper, ReductionCallbackMapper
 from loopy.kernel.instruction import (MultiAssignmentBase, CInstruction,
         CallInstruction,  _DataObliviousInstruction)
 from loopy.kernel import LoopKernel
-from loopy.program import Program
+from loopy.program import TranslationUnit
 from loopy.kernel.function_interface import CallableKernel, ScalarCallable
 
 from pytools import ProcessLogger
@@ -87,7 +87,7 @@ def prepare_for_caching(program):
     if isinstance(program, LoopKernel):
         return prepare_for_caching_inner(program)
 
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
     tgt = program.target
 
     new_clbls = {}
@@ -2060,7 +2060,7 @@ def realize_reduction_for_single_kernel(kernel, callables_table,
 
 
 def realize_reduction(program, *args, **kwargs):
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
 
     callables_table = dict(program.callables_table)
     kernels_to_scan = [in_knl_callable.subkernel
diff --git a/loopy/program.py b/loopy/program.py
index 09b13ffd564e86a4c6e7c2051447241dddda8790..9143f3c88083141ef9e83afede1021eaa6e0d5ec 100644
--- a/loopy/program.py
+++ b/loopy/program.py
@@ -46,7 +46,7 @@ __doc__ = """
 
 .. currentmodule:: loopy
 
-.. autoclass:: Program
+.. autoclass:: TranslationUnit
 
 .. autofunction:: make_program
 
@@ -150,10 +150,14 @@ class CallableResolver(RuleAwareIdentityMapper):
 
 # {{{ program
 
-class Program(ImmutableRecord):
+class TranslationUnit(ImmutableRecord):
     """
     Records the information about all the callables in a :mod:`loopy` program.
 
+    An instance of :class:`TranslationUnit` is the object that gets lowered
+    for a :class:`loopy.target.TargetBase`.
+
+
     .. attribute:: entrypoints
 
         A :class:`frozenset` of the names of the kernels which
@@ -181,15 +185,18 @@ class Program(ImmutableRecord):
         TargetBase, function_indentifier: str)`` that would return an instance
         of :class:`loopy.kernel.function_interface.InKernelCallable` or *None*.
 
+    .. automethod:: __call__
     .. automethod:: copy
     .. automethod:: __getitem__
+    .. automethod:: with_kernel
 
     .. note::
 
-        - To create an instance of :class:`loopy.Program`, it is recommended to
-           go through :func:`loopy.make_kernel`.
+        - To create an instance of :class:`loopy.TranslationUnit`, it is
+          recommended to go through :func:`loopy.make_kernel`.
         - This data structure and its attributes should be considered
-          immutable, any modifications should be done through :meth:`~Program.copy`.
+          immutable, any modifications should be done through
+          :meth:`~TranslationUnit.copy`.
 
     """
     def __init__(self,
@@ -270,9 +277,9 @@ class Program(ImmutableRecord):
     @property
     def state(self):
         """ Returns an instance of :class:`loopy.kernel.KernelState`. """
-        return min(callable_knl.subkernel.state for callable_knl in
-                self.callables_table.values() if
-                isinstance(callable_knl, CallableKernel))
+        return min(callable_knl.subkernel.state
+                   for callable_knl in self.callables_table.values()
+                   if isinstance(callable_knl, CallableKernel))
 
     def with_kernel(self, kernel):
         """
@@ -314,10 +321,17 @@ class Program(ImmutableRecord):
             entrypoint, = self.entrypoints
             return self[entrypoint]
         else:
-            raise ValueError("Program has multiple possible entrypoints. The "
-                    "default entry point kernel is not uniquely determined.")
+            raise ValueError("TranslationUnit has multiple possible entrypoints."
+                             " The default entry point kernel is not uniquely"
+                             " determined.")
 
     def __call__(self, *args, **kwargs):
+        """
+        Builds and calls the *entrypoint* kernel, if
+        :attr:`TranslationUnit.target` is an executable target.
+
+        :arg entrypoint: The entrypoint which is to be called
+        """
         entrypoint = kwargs.get("entrypoint", None)
 
         if entrypoint is None:
@@ -325,7 +339,7 @@ class Program(ImmutableRecord):
             if len(self.entrypoints) == 1:
                 entrypoint, = self.entrypoints
             else:
-                raise TypeError("Program.__call__() missing 1 required"
+                raise TypeError("TranslationUnit.__call__() missing 1 required"
                         " keyword argument: 'entrypoint'. "
                         "(Multiple possible entrypoints are present in the "
                         "program.)")
@@ -370,6 +384,9 @@ class Program(ImmutableRecord):
         self.update_persistent_hash(key_hash, LoopyKeyBuilder())
         return hash(key_hash.digest())
 
+
+Program = TranslationUnit
+
 # }}}
 
 
@@ -689,11 +706,11 @@ class CallablesInferenceContext(ImmutableRecord):
 
 def make_program(kernel):
     """
-    Returns an instance of :class:`loopy.Program` with *kernel* as the only
+    Returns an instance of :class:`loopy.TranslationUnit` with *kernel* as the only
     callable kernel.
     """
 
-    program = Program(
+    program = TranslationUnit(
             callables_table={
                 kernel.name: CallableKernel(kernel)},
             target=kernel.target)
@@ -706,7 +723,7 @@ def iterate_over_kernels_if_given_program(transform_for_single_kernel):
     Function wrapper for transformations of the type ``transform(kernel:
     LoopKernel, *args, **kwargs): LoopKernel``. Returns a function with the
     ``transform`` being implemented on all of the callable kernels in a
-    :class:`loopy.Program`.
+    :class:`loopy.TranslationUnit`.
     """
     def _collective_transform(*args, **kwargs):
         if "program" in kwargs:
@@ -717,7 +734,7 @@ def iterate_over_kernels_if_given_program(transform_for_single_kernel):
             program_or_kernel = args[0]
             args = args[1:]
 
-        if isinstance(program_or_kernel, Program):
+        if isinstance(program_or_kernel, TranslationUnit):
             program = program_or_kernel
             new_callables = {}
             for func_id, in_knl_callable in program.callables_table.items():
@@ -763,7 +780,7 @@ def update_table(callables_table, clbl_id, clbl):
 
 def resolve_callables(program):
     """
-    Returns a :class:`Program` with known :class:`pymbolic.primitives.Call`
+    Returns a :class:`TranslationUnit` with known :class:`pymbolic.primitives.Call`
     expression nodes converted to :class:`loopy.symbolic.ResolvedFunction`.
     """
     from loopy.library.function import get_loopy_callables
diff --git a/loopy/statistics.py b/loopy/statistics.py
index 96d96e3a425dd543b85f77d424976eca373c61b5..3ae7836085adbb55456371c8958a28f99dd53635 100755
--- a/loopy/statistics.py
+++ b/loopy/statistics.py
@@ -35,7 +35,7 @@ from loopy.diagnostic import warn_with_kernel, LoopyError
 from loopy.symbolic import CoefficientCollector
 from pytools import ImmutableRecord, memoize_method
 from loopy.kernel.function_interface import CallableKernel
-from loopy.program import Program
+from loopy.program import TranslationUnit
 from functools import partial
 
 
@@ -1435,7 +1435,7 @@ def add_assumptions_guard(kernel, pwqpolynomial):
 
 
 def count(kernel, set, space=None):
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         kernel_names = [i for i, clbl in kernel.callables_table.items()
                 if isinstance(clbl, CallableKernel)]
         if len(kernel_names) > 1:
diff --git a/loopy/symbolic.py b/loopy/symbolic.py
index e810024e90dfce85bec551402d72e079ea0d901b..0c6a8d50f36867e16351ec5f51df55800f689e93 100644
--- a/loopy/symbolic.py
+++ b/loopy/symbolic.py
@@ -803,9 +803,9 @@ class RuleArgument(LoopyExpressionBase):
 class ResolvedFunction(LoopyExpressionBase):
     """
     A function invocation whose definition is known in a :mod:`loopy` program.
-    A function is said to be *known* in a :class:`~loopy.Program` if its
+    A function is said to be *known* in a :class:`~loopy.TranslationUnit` if its
     identifier maps to  an :class:`~loopy.kernel.function_interface.InKernelCallable`
-    in :attr:`loopy.Program.callables_table`. Refer to :ref:`func-interface`.
+    in :attr:`loopy.TranslationUnit.callables_table`. Refer to :ref:`func-interface`.
 
     .. attribute:: function
 
diff --git a/loopy/transform/buffer.py b/loopy/transform/buffer.py
index e8c4bc2e9bd687d782a4d9f71dbc5e3a54eb639b..92b3d63fb21e7b203635108421022447b27804ed 100644
--- a/loopy/transform/buffer.py
+++ b/loopy/transform/buffer.py
@@ -31,7 +31,7 @@ from loopy.tools import LoopyKeyBuilder, PymbolicExpressionHashWrapper
 from loopy.version import DATA_MODEL_VERSION
 from loopy.diagnostic import LoopyError
 from loopy.kernel import LoopKernel
-from loopy.program import Program
+from loopy.program import TranslationUnit
 from loopy.kernel.function_interface import CallableKernel, ScalarCallable
 
 from pymbolic import var
@@ -169,7 +169,7 @@ def buffer_array_for_single_kernel(kernel, callables_table, var_name,
         fetched.
     """
 
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         kernel_names = [i for i, clbl in
                 kernel.callables_table.items() if isinstance(clbl,
                     CallableKernel)]
@@ -554,7 +554,7 @@ def buffer_array_for_single_kernel(kernel, callables_table, var_name,
 
 
 def buffer_array(program, *args, **kwargs):
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
 
     new_callables = {}
 
diff --git a/loopy/transform/callable.py b/loopy/transform/callable.py
index 54a694775d2925fe4ea4c0769a6d7c6ecae6d0c4..5e5125c491566e963c13e8c876e21c0896d1b603 100644
--- a/loopy/transform/callable.py
+++ b/loopy/transform/callable.py
@@ -34,7 +34,7 @@ from loopy.symbolic import (
 from loopy.isl_helpers import simplify_via_aff
 from loopy.kernel.function_interface import (
         CallableKernel, ScalarCallable)
-from loopy.program import Program
+from loopy.program import TranslationUnit
 
 __doc__ = """
 .. currentmodule:: loopy
@@ -48,7 +48,7 @@ __doc__ = """
 def register_callable(translation_unit, function_identifier, callable_,
         redefining_not_ok=True):
     """
-    :param translation_unit: A :class:`loopy.Program`.
+    :param translation_unit: A :class:`loopy.TranslationUnit`.
     :param callable_: A :class:`loopy.InKernelCallable`.
     """
 
@@ -73,9 +73,9 @@ def register_callable(translation_unit, function_identifier, callable_,
 
 def merge(translation_units):
     """
-    :param translation_units: A list of :class:`loopy.Program`.
+    :param translation_units: A list of :class:`loopy.TranslationUnit`.
 
-    :returns: An instance of :class:`loopy.Program` which contains all the
+    :returns: An instance of :class:`loopy.TranslationUnit` which contains all the
         callables from each of the *translation_units.
     """
 
@@ -104,7 +104,7 @@ def merge(translation_units):
     for trans_unit in translation_units:
         callables_table.update(trans_unit.callables_table.copy())
 
-    return Program(
+    return TranslationUnit(
             entrypoints=frozenset().union(*(
                 t.entrypoints or frozenset() for t in translation_units)),
             callables_table=callables_table,
@@ -672,7 +672,7 @@ def _match_caller_callee_argument_dimension_(program, callee_function_name):
 
     # {{{  sanity checks
 
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
     assert isinstance(callee_function_name, str)
     assert callee_function_name not in program.entrypoints
     assert callee_function_name in program.callables_table
@@ -700,7 +700,7 @@ def _match_caller_callee_argument_dimension_(program, callee_function_name):
 
 def rename_callable(program, old_name, new_name=None, existing_ok=False):
     """
-    :arg program: An instance of :class:`loopy.Program`
+    :arg program: An instance of :class:`loopy.TranslationUnit`
     :arg old_name: The callable to be renamed
     :arg new_name: New name for the callable to be renamed
     :arg existing_ok: An instance of :class:`bool`
@@ -710,7 +710,7 @@ def rename_callable(program, old_name, new_name=None, existing_ok=False):
             SubstitutionRuleMappingContext)
     from pymbolic import var
 
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
     assert isinstance(old_name, str)
 
     if (new_name in program.callables_table) and not existing_ok:
diff --git a/loopy/transform/data.py b/loopy/transform/data.py
index 10344da0e465a360f89c99c8f0d7f0c4db24ad42..467f8bd5fa9fe6533bcbd58970fa8bb60a592b03 100644
--- a/loopy/transform/data.py
+++ b/loopy/transform/data.py
@@ -26,7 +26,7 @@ from islpy import dim_type
 from loopy.kernel.data import ImageArg
 
 from pytools import MovedFunctionDeprecationWrapper
-from loopy.program import Program, iterate_over_kernels_if_given_program
+from loopy.program import TranslationUnit, iterate_over_kernels_if_given_program
 from loopy.kernel import LoopKernel
 from loopy.kernel.function_interface import CallableKernel, ScalarCallable
 
@@ -369,7 +369,7 @@ def add_prefetch_for_single_kernel(kernel, callables_table, var_name,
 
 
 def add_prefetch(program, *args, **kwargs):
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
 
     new_callables = {}
     for func_id, in_knl_callable in program.callables_table.items():
diff --git a/loopy/transform/fusion.py b/loopy/transform/fusion.py
index 0880c22ae7d4ba5b2f579e4579de768c16046b9c..2698530247817143c5c4697676a6111d69b648a3 100644
--- a/loopy/transform/fusion.py
+++ b/loopy/transform/fusion.py
@@ -28,7 +28,7 @@ from loopy.diagnostic import LoopyError
 from pymbolic import var
 
 from loopy.kernel import LoopKernel
-from loopy.program import Program
+from loopy.program import TranslationUnit
 from loopy.kernel.function_interface import CallableKernel
 
 
@@ -333,7 +333,7 @@ def fuse_kernels(kernels, suffixes=None, data_flow=None):
     # namespace, otherwise the kernel names should be uniquified.
     # We should also somehow be able to know that callables like "sin"/"cos"
     # belong to the global namespace and need not be uniquified.
-    if all(isinstance(kernel, Program) for kernel in kernels):
+    if all(isinstance(kernel, TranslationUnit) for kernel in kernels):
         new_kernels = []
         for knl in kernels:
             kernel_names = [i for i, clbl in
diff --git a/loopy/transform/iname.py b/loopy/transform/iname.py
index 1686a87d934d6fb7efde4763610d8992472929e7..e99f10e7a71145c9ca67252e4fa0630705827224 100644
--- a/loopy/transform/iname.py
+++ b/loopy/transform/iname.py
@@ -29,7 +29,7 @@ from loopy.symbolic import (
         SubstitutionRuleMappingContext)
 from loopy.diagnostic import LoopyError
 
-from loopy.program import Program, iterate_over_kernels_if_given_program
+from loopy.program import TranslationUnit, iterate_over_kernels_if_given_program
 from loopy.kernel import LoopKernel
 from loopy.kernel.function_interface import CallableKernel
 
@@ -1038,7 +1038,7 @@ def get_iname_duplication_options(kernel, use_boostable_into=False):
     Use :func:`has_schedulable_iname_nesting` to decide whether an iname needs to be
     duplicated in a given kernel.
     """
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         if len([clbl for clbl in kernel.callables_table.values() if
                 isinstance(clbl, CallableKernel)]) == 1:
             kernel = kernel[list(kernel.entrypoints)[0]]
@@ -1092,7 +1092,7 @@ def has_schedulable_iname_nesting(kernel):
     :returns: a :class:`bool` indicating whether this kernel needs
         an iname duplication in order to be schedulable.
     """
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         if len([clbl for clbl in kernel.callables_table.values() if
                 isinstance(clbl, CallableKernel)]) == 1:
             kernel = kernel[list(kernel.entrypoints)[0]]
diff --git a/loopy/transform/instruction.py b/loopy/transform/instruction.py
index a48e8eda7472a73116a9cfcb2c567b23191ead93..3ec4b8d4214cf411850462eefd93b73ae7061d86 100644
--- a/loopy/transform/instruction.py
+++ b/loopy/transform/instruction.py
@@ -23,7 +23,7 @@ THE SOFTWARE.
 from loopy.diagnostic import LoopyError
 from loopy.kernel import LoopKernel
 from loopy.kernel.function_interface import (ScalarCallable, CallableKernel)
-from loopy.program import Program, iterate_over_kernels_if_given_program
+from loopy.program import TranslationUnit, iterate_over_kernels_if_given_program
 
 
 # {{{ find_instructions
@@ -39,7 +39,7 @@ def find_instructions(program, insn_match):
     if isinstance(program, LoopKernel):
         return find_instructions_in_single_kernel(program, insn_match)
 
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
     insns = []
     for in_knl_callable in program.callables_table.values():
         if isinstance(in_knl_callable, CallableKernel):
diff --git a/loopy/transform/pack_and_unpack_args.py b/loopy/transform/pack_and_unpack_args.py
index cf0730760417e9c439e05fcd9f19449cb98aba02..d6f2858cf74c40af6684f4b4b9ae983859c7ece0 100644
--- a/loopy/transform/pack_and_unpack_args.py
+++ b/loopy/transform/pack_and_unpack_args.py
@@ -22,7 +22,7 @@ THE SOFTWARE.
 
 from loopy.diagnostic import LoopyError
 from loopy.kernel.instruction import CallInstruction
-from loopy.program import Program
+from loopy.program import TranslationUnit
 from loopy.kernel import LoopKernel
 from loopy.kernel.function_interface import CallableKernel, ScalarCallable
 from loopy.symbolic import SubArrayRef
@@ -317,7 +317,7 @@ def pack_and_unpack_args_for_call_for_single_kernel(kernel,
 
 
 def pack_and_unpack_args_for_call(program, *args, **kwargs):
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
 
     new_callables = {}
     for func_id, in_knl_callable in program.callables_table.items():
diff --git a/loopy/transform/padding.py b/loopy/transform/padding.py
index 455ce31d03fa30476b9154ea2773a06b3db1b17d..f56588932ef1bd637dabcd90ee05924641ee59da 100644
--- a/loopy/transform/padding.py
+++ b/loopy/transform/padding.py
@@ -24,7 +24,7 @@ THE SOFTWARE.
 from pytools import MovedFunctionDeprecationWrapper
 from loopy.symbolic import RuleAwareIdentityMapper, SubstitutionRuleMappingContext
 
-from loopy.program import iterate_over_kernels_if_given_program, Program
+from loopy.program import iterate_over_kernels_if_given_program, TranslationUnit
 from loopy.kernel import LoopKernel
 from loopy.kernel.function_interface import CallableKernel
 from loopy.diagnostic import LoopyError
@@ -409,7 +409,7 @@ def split_array_axis(kernel, array_names, axis_nr, count,
 # {{{ find_padding_multiple
 
 def find_padding_multiple(kernel, variable, axis, align_bytes, allowed_waste=0.1):
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         kernel_names = [i for i, clbl in kernel.callables_table.items()
                 if isinstance(clbl, CallableKernel)]
         if len(kernel_names) > 1:
diff --git a/loopy/transform/precompute.py b/loopy/transform/precompute.py
index 438c07339b217f21d3e60c4f2f87050ea5b2d0d7..ac133ed591f0915db2a39e3c6563b576db5982aa 100644
--- a/loopy/transform/precompute.py
+++ b/loopy/transform/precompute.py
@@ -27,7 +27,7 @@ from loopy.symbolic import (get_dependencies,
         SubstitutionRuleMappingContext)
 from loopy.diagnostic import LoopyError
 from pymbolic.mapper.substitutor import make_subst_func
-from loopy.program import Program
+from loopy.program import TranslationUnit
 from loopy.kernel.function_interface import CallableKernel, ScalarCallable
 import numpy as np
 
@@ -354,7 +354,7 @@ def precompute_for_single_kernel(kernel, callables_table, subst_use,
     Trivial storage axes (i.e. axes of length 1 with respect to the sweep) are
     eliminated.
     """
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         kernel_names = [i for i, clbl in
                 kernel.callables_table.items() if isinstance(clbl,
                     CallableKernel)]
@@ -1057,7 +1057,7 @@ def precompute_for_single_kernel(kernel, callables_table, subst_use,
 
 
 def precompute(program, *args, **kwargs):
-    assert isinstance(program, Program)
+    assert isinstance(program, TranslationUnit)
     new_callables = {}
 
     for func_id, clbl in program.callables_table.items():
diff --git a/loopy/transform/subst.py b/loopy/transform/subst.py
index 066cf326cc4f7ea45e693ea1f48910dbe5747ad1..41ca677595767a04bbd0da9870c1ff823d994f44 100644
--- a/loopy/transform/subst.py
+++ b/loopy/transform/subst.py
@@ -28,7 +28,7 @@ from loopy.transform.iname import remove_any_newly_unused_inames
 from pytools import ImmutableRecord
 from pymbolic import var
 
-from loopy.program import iterate_over_kernels_if_given_program, Program
+from loopy.program import iterate_over_kernels_if_given_program, TranslationUnit
 from loopy.kernel.function_interface import CallableKernel, ScalarCallable
 
 import logging
@@ -53,7 +53,7 @@ def extract_subst(kernel, subst_name, template, parameters=()):
     unifications.
     """
 
-    if isinstance(kernel, Program):
+    if isinstance(kernel, TranslationUnit):
         kernel_names = [i for i, clbl in
                 kernel.callables_table.items() if isinstance(clbl,
                     CallableKernel)]