@@ -64,9 +64,9 @@ def __getitem__(self, i):
 
 
 def test():
-    import time, __builtin__
+    import time, builtins
     #Just a quick sanity check
-    correct_result = __builtin__.range(5, 100, 3)
+    correct_result = builtins.range(5, 100, 3)
     oldrange_result = list(oldrange(5, 100, 3))
     genrange_result = list(genrange(5, 100, 3))
     if genrange_result != correct_result or oldrange_result != correct_result:
@@ -81,7 +81,7 @@ def test():
     for i in genrange(1000):
         pass
     t3 = time.time()
-    for i in __builtin__.range(1000):
+    for i in builtins.range(1000):
         pass
     t4 = time.time()
     print(t2-t1, 'sec (old-style class)')
 
@@ -7,7 +7,7 @@
 
 """
 
-import sys, imp, __builtin__
+import sys, imp, builtins
 
 
 # Replacement for __import__()
@@ -117,7 +117,7 @@ def reload(module):
 
 
 # Save the original hooks
-original_import = __builtin__.__import__
+original_import = builtins.__import__
 
 # Now install our hooks
-__builtin__.__import__ = import_hook
+builtins.__import__ = import_hook
@@ -3,7 +3,7 @@
 import sys
 import socket
 import pickle
-import __builtin__
+import builtins
 import os
 
 
@@ -90,8 +90,8 @@ def _recv(self, id):
         if exception is None:
             return value
         x = exception
-        if hasattr(__builtin__, exception):
-            x = getattr(__builtin__, exception)
+        if hasattr(builtins, exception):
+            x = getattr(builtins, exception)
         elif exception in ('posix.error', 'mac.error'):
             x = os.error
         if x == exception:
 
@@ -17,7 +17,7 @@ Initialization, Finalization, and Threads
       single: PyEval_AcquireLock()
       single: modules (in module sys)
       single: path (in module sys)
-      module: __builtin__
+      module: builtins
       module: __main__
       module: sys
       triple: module; search; path
@@ -29,7 +29,7 @@ Initialization, Finalization, and Threads
    exception of :cfunc:`Py_SetProgramName`, :cfunc:`PyEval_InitThreads`,
    :cfunc:`PyEval_ReleaseLock`, and :cfunc:`PyEval_AcquireLock`. This initializes
    the table of loaded modules (``sys.modules``), and creates the fundamental
-   modules :mod:`__builtin__`, :mod:`__main__` and :mod:`sys`.  It also initializes
+   modules :mod:`builtins`, :mod:`__main__` and :mod:`sys`.  It also initializes
    the module search path (``sys.path``). It does not set ``sys.argv``; use
    :cfunc:`PySys_SetArgv` for that.  This is a no-op when called for a second time
    (without calling :cfunc:`Py_Finalize` first).  There is no return value; it is a
@@ -83,7 +83,7 @@ Initialization, Finalization, and Threads
 .. cfunction:: PyThreadState* Py_NewInterpreter()
 
    .. index::
-      module: __builtin__
+      module: builtins
       module: __main__
       module: sys
       single: stdout (in module sys)
@@ -93,7 +93,7 @@ Initialization, Finalization, and Threads
    Create a new sub-interpreter.  This is an (almost) totally separate environment
    for the execution of Python code.  In particular, the new interpreter has
    separate, independent versions of all imported modules, including the
-   fundamental modules :mod:`__builtin__`, :mod:`__main__` and :mod:`sys`.  The
+   fundamental modules :mod:`builtins`, :mod:`__main__` and :mod:`sys`.  The
    table of loaded modules (``sys.modules``) and the module search path
    (``sys.path``) are also separate.  The new environment has no ``sys.argv``
    variable.  It has new standard I/O stream file objects ``sys.stdin``,
 
@@ -507,7 +507,7 @@ interpreter can only be used after the interpreter has been initialized.
 
 .. index::
    single: Py_Initialize()
-   module: __builtin__
+   module: builtins
    module: __main__
    module: sys
    module: exceptions
@@ -516,7 +516,7 @@ interpreter can only be used after the interpreter has been initialized.
 
 The basic initialization function is :cfunc:`Py_Initialize`. This initializes
 the table of loaded modules, and creates the fundamental modules
-:mod:`__builtin__`, :mod:`__main__`, :mod:`sys`, and :mod:`exceptions`.  It also
+:mod:`builtins`, :mod:`__main__`, :mod:`sys`, and :mod:`exceptions`.  It also
 initializes the module search path (``sys.path``).
 
 .. index:: single: PySys_SetArgv()
 
@@ -268,7 +268,7 @@ Glossary
       dictionaries.  There are the local, global and builtin namespaces as well
       as nested namespaces in objects (in methods).  Namespaces support
       modularity by preventing naming conflicts.  For instance, the functions
-      :func:`__builtin__.open` and :func:`os.open` are distinguished by their
+      :func:`builtins.open` and :func:`os.open` are distinguished by their
       namespaces.  Namespaces also aid readability and maintainability by making
       it clear which module implements a function.  For instance, writing
       :func:`random.seed` or :func:`itertools.izip` makes it clear that those
 
@@ -1,13 +1,13 @@
 
-:mod:`__builtin__` --- Built-in objects
-=======================================
+:mod:`builtins` --- Built-in objects
+====================================
 
-.. module:: __builtin__
+.. module:: builtins
    :synopsis: The module that provides the built-in namespace.
 
 
 This module provides direct access to all 'built-in' identifiers of Python; for
-example, ``__builtin__.open`` is the full name for the built-in function
+example, ``builtins.open`` is the full name for the built-in function
 :func:`open`.  See chapter :ref:`builtin`.
 
 This module is not normally accessed explicitly by most applications, but can be
@@ -16,10 +16,10 @@ but in which the built-in of that name is also needed.  For example, in a module
 that wants to implement an :func:`open` function that wraps the built-in
 :func:`open`, this module can be used directly::
 
-   import __builtin__
+   import builtins
 
    def open(path):
-       f = __builtin__.open(path, 'r')
+       f = builtins.open(path, 'r')
        return UpperCaser(f)
 
    class UpperCaser:
 
@@ -356,7 +356,7 @@ available.  They are listed here in alphabetical order.
    dictionaries as global and local namespace.  If the *globals* dictionary is
    present and lacks '__builtins__', the current globals are copied into *globals*
    before *expression* is parsed.  This means that *expression* normally has full
-   access to the standard :mod:`__builtin__` module and restricted environments are
+   access to the standard :mod:`builtins` module and restricted environments are
    propagated.  If the *locals* dictionary is omitted it defaults to the *globals*
    dictionary.  If both dictionaries are omitted, the expression is executed in the
    environment where :keyword:`eval` is called.  The return value is the result of
@@ -398,7 +398,7 @@ available.  They are listed here in alphabetical order.
 
    If the *globals* dictionary does not contain a value for the key
    ``__builtins__``, a reference to the dictionary of the built-in module
-   :mod:`__builtin__` is inserted under that key.  That way you can control what
+   :mod:`builtins` is inserted under that key.  That way you can control what
    builtins are available to the executed code by inserting your own
    ``__builtins__`` dictionary into *globals* before passing it to :func:`exec`.
 
 
@@ -108,7 +108,7 @@ This code is intended to be read, not executed.  However, it does work
 
 ::
 
-   import sys, imp, __builtin__
+   import sys, imp, builtins
 
    # Replacement for __import__()
    def import_hook(name, globals=None, locals=None, fromlist=None):
@@ -218,12 +218,12 @@ This code is intended to be read, not executed.  However, it does work
 
 
    # Save the original hooks
-   original_import = __builtin__.__import__
-   original_reload = __builtin__.reload
+   original_import = builtins.__import__
+   original_reload = builtins.reload
 
    # Now install our hooks
-   __builtin__.__import__ = import_hook
-   __builtin__.reload = reload_hook
+   builtins.__import__ = import_hook
+   builtins.reload = reload_hook
 
 .. index::
    module: knee
 
@@ -13,7 +13,7 @@ overview:
 .. toctree::
 
    sys.rst
-   __builtin__.rst
+   builtins.rst
    __main__.rst
    warnings.rst
    contextlib.rst