sharing a namespace across multiple ipython notebooks

Unfortunately this no longer works, you get error message ipython.kernel replaced by ipython.parallel.

A less elegant way than above to alter this is to change IPython/frontend/html/notebook/kernelmanager.py around line 273 from

kernel_id = self.kernel_for_notebook(notebook_id)

to

kernel_id = None
for notebook_id in self._notebook_mapping:
    kernel_id = self._notebook_mapping[notebook_id]
    break

For Anaconda python, replace start_kernel in kernelmanager.py with

def start_kernel(self, kernel_id=None, path=None, **kwargs):
    global saved_kernel_id
    if saved_kernel_id:
        return saved_kernel_id
    if kernel_id is None:
        kwargs['extra_arguments'] = self.kernel_argv
        if path is not None:
            kwargs['cwd'] = self.cwd_for_path(path)
        kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs)
        self.log.info("Kernel started: %s" % kernel_id)
        self.log.debug("Kernel args: %r" % kwargs)
        self.add_restart_callback(kernel_id,
            lambda : self._handle_kernel_died(kernel_id),
            'dead',
        )
    else:
        self._check_kernel_id(kernel_id)
        self.log.info("Using existing kernel: %s" % kernel_id)
    saved_kernel_id = kernel_id
    return kernel_id

and add

    saved_kernel_id = None

above

    class MappingKernelManager(MultiKernelManager):

True IPython gurus, please supply the correct fix. A lot of people using notebooks want the ability to share the kernel, it's natural, because one notebook quickly grows too big to work with a single complex application, so it is easier to be able to break down the application into multiple notebooks.

Also, gurus, while you're listening, it would be nice to have a collapse-expand feature as in Mathematica so you can only view the part of the notebook you care about and you can zoom out the rest.

The IPython Notebook does not have the equivalent of --existing. Notebooks do not share kernels. It is not a limitation of the notebook itself, it is just a design decision made in the notebook server code. The server code can be modified, for instance, to have all notebooks share the same kernel. You can do this with a little monkeypatching in your IPython configuration. Start by creating a profile:

$ ipython profile create singlekernel
[ProfileCreate] Generating default config file: u'~/.ipython/profile_singlekernel/ipython_config.py'
[ProfileCreate] Generating default config file: u'~/.ipython/profile_singlekernel/ipython_qtconsole_config.py'
[ProfileCreate] Generating default config file: u'~/.ipython/profile_singlekernel/ipython_notebook_config.py'
[ProfileCreate] Generating default config file: u'~/.ipython/profile_singlekernel/ipython_nbconvert_config.py'

and edit $(ipython locate profile singlekernel)/ipython_notebook_config.py to contain:

# Configuration file for ipython-notebook.

c = get_config()

import os
import uuid
from IPython.kernel.multikernelmanager import MultiKernelManager

def start_kernel(self, **kwargs):
    """Minimal override of MKM.start_kernel that always returns the same kernel"""
    kernel_id = kwargs.pop('kernel_id', str(uuid.uuid4()))
    if self.km is None:
        self.km = self.kernel_manager_factory(connection_file=os.path.join(
                self.connection_dir, "kernel-%s.json" % kernel_id),
                parent=self, autorestart=True, log=self.log
    )
    if not self.km.is_alive():
        self.log.info("starting single kernel")
        self.km.start_kernel(**kwargs)
    else:
        self.log.info("reusing existing kernel")
    self._kernels[kernel_id] = self.km
    return kernel_id

MultiKernelManager.km = None
MultiKernelManager.start_kernel = start_kernel

This just overrides the kernel starting mechanism to start only one kernel and return it at every subsequent request, rather than starting a new one for each kernel ID.

Now whenever you start the notebook server with

ipython notebook --profile singlekernel

all of the notebooks in that session will share the same kernel.