diff --git a/book/handling_multilang.rst b/book/handling_multilang.rst
new file mode 100644
index 00000000..93588a6e
--- /dev/null
+++ b/book/handling_multilang.rst
@@ -0,0 +1,350 @@
+.. index::
+    single: Multi Language; Book
+
+Handling Multi-Language Documents
+=================================
+
+The default storage layer of the CMF, PHPCR-ODM, can handle translations
+transparently.
+
+.. tip::
+
+   This chapter assumes you already have an idea how to interact with
+   PHPCR-ODM, which was introduced in the :doc:`Database chapter <database_layer>`.
+
+.. caution::
+
+    You also need the ``intl`` php extension installed and enabled (otherwise
+    composer will tell you it can't find ext-intl). If you get issues that some
+    locales can not be loaded, have a look at `this discussion about ICU`_.
+
+Initial Language Choice: Lunetics LocaleBundle
+----------------------------------------------
+
+The CMF recommends to rely on the `LuneticsLocaleBundle`_
+to handle requests to ``/`` on your website. This bundle provides the tools
+to select the best locale for the user based on various criteria.
+
+When you configure ``lunetics_locale``, it is recommended to use a parameter
+for the locales, as you need to configure the locales for other bundles
+(e.g. the CoreBundle) too.
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        lunetics_locale:
+            allowed_locales: "%locales%"
+
+    .. code-block:: xml
+
+        <?xml version="1.0" charset="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+
+            <config xmlns="http://example.org/schema/dic/lunetics_locale">
+                <allowed-locales>%locales%</allowed-locales>
+            </config>
+        </container>
+
+    .. code-block:: php
+
+        $container->loadFromExtension('lunetics_locale', array(
+            'allowed_locales' => '%locales%',
+        ));
+
+Configuring Available Locales
+-----------------------------
+
+The CoreBundle needs to be configure with the available locales. If it is
+not configured with locales, it registeres a listener that removes all
+translation mapping from PHPCR-ODM documents.
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        cmf_core:
+            multilang:
+                locales: "%locales%"
+
+    .. code-block:: xml
+
+        <?xml version="1.0" charset="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+
+            <config xmlns="http://cmf.symfony.com/schema/dic/core">
+                <multilang>%locales%</multilang>
+            </config>
+        </container>
+
+    .. code-block:: php
+
+        $container->loadFromExtension('cmf_core', array(
+            'multilang' => array(
+                'locales' => '%locales%',
+            ),
+        ));
+
+PHPCR-ODM multi-language Documents
+----------------------------------
+
+You can mark any properties as being translatable and have the document
+manager store and load the correct language for you. Note that translation
+always happens on a document level, not on the individual translatable fields.
+
+.. code-block:: php
+
+    <?php
+
+    // src/Acme/DemoBundle/Document/MyPersistentClass.php
+
+    use Doctrine\ODM\PHPCR\Mapping\Annotations as PHPCR;
+
+    /**
+     * @PHPCR\Document(translator="attribute")
+     */
+    class MyPersistentClass
+    {
+        /**
+         * Translated property
+         * @PHPCR\String(translated=true)
+         */
+        private $topic;
+
+        // ...
+    }
+
+.. seealso::
+
+    Read more about multi-language documents in the
+    `PHPCR-ODM documentation on multi-language`_ and see
+    :doc:`../bundles/phpcr_odm/multilang` for information how to configure
+    PHPCR-ODM correctly.
+
+The default documents provided by the CMF bundles are translated documents.
+The CoreBundle removes the translation mapping if ``multilang`` is not
+configured.
+
+The routes are handled differently, as you can read in the next section.
+
+Routing
+-------
+
+The ``DynamicRouter`` uses a route source to get routes that could match a
+request. The concept of the default PHPCR-ODM source is to map the request URL
+onto an id, which in PHPCR terms is the repository path to a node. This allows
+for a very efficient lookup without needing a full search over the repository.
+But a PHPCR node has exactly one path, therefore you need a separate route
+document per locale. The cool thing with this is that you can localize
+the URL for each language. Simply create one route document per locale.
+
+As all routes point to the same content, the route generator can handle
+picking the correct route for you when you generate the route from the
+content. See also
+":ref:`ContentAwareGenerator and Locales <component-route-generator-and-locales>`".
+
+.. _book_handling-multilang_sonata-admin:
+
+Sonata PHPCR-ODM Admin
+----------------------
+
+.. note::
+
+    Using sonata admin is one way to make your content editable. A book
+    chapter on sonata admin is planned. Meanwhile, read
+    :doc:`Sonata Admin <../cookbook/creating_a_cms/sonata-admin>` in the
+    "Creating a CMS" tutorial.
+
+The first step is to configure sonata admin. You should place the
+LuneticsLocaleBundle language switcher in the ``topnav`` bar.  To do this,
+configure the template for the ``user_block``:
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        # app/config/config.yml
+        sonata_admin:
+            # ...
+            templates:
+                    user_block: AcmeCoreBundle:Admin:admin_topnav.html.twig
+
+    .. code-block:: xml
+
+        <!-- app/config/config.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+            <config xmlns="http://sonata-project.org/schema/dic/admin">
+                <template user-block="AcmeCoreBundle:Admin:admin_topnav.html.twig"/>
+            </config>
+        </container>
+
+
+    .. code-block:: php
+
+        // app/config/config.php
+        $container->loadFromExtension('sonata_admin', array(
+            'templates' => array(
+                'user_block' => 'AcmeCoreBundle:Admin:admin_topnav.html.twig',
+            ),
+        ));
+
+And the template looks like this:
+
+.. code-block:: jinja
+
+    {# src/Acme/CoreBundle/Resources/views/Admin/admin_topnav.html.twig #}
+    {% extends 'SonataAdminBundle:Core:user_block.html.twig' %}
+
+    {% block user_block %}
+        {{ locale_switcher(null, null, 'AcmeCoreBundle:Admin:switcher_links.html.twig') }}
+        {{ parent() }}
+    {% endblock %}
+
+You need to tell the ``locale_switcher`` to use a custom template to display
+the links, which looks like this:
+
+.. code-block:: jinja
+
+    {# src/Acme/CoreBundle/Resources/views/Admin/switcher_links.html.twig #}
+    Switch to :
+    {% for locale in locales %}
+        {% if loop.index > 1 %} | {% endif %}<a href="{{ locale.link }}" title="{{ locale.locale_target_language }}">{{ locale.locale_target_language }}</a>
+    {% endfor %}
+
+Now what is left to do is to update the sonata routes to become locale aware:
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        # app/config/routing.yml
+
+        admin_dashboard:
+            pattern: /{_locale}/admin/
+            defaults:
+                _controller: FrameworkBundle:Redirect:redirect
+                route: sonata_admin_dashboard
+                permanent: true # this for 301
+
+        admin:
+            resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
+            prefix: /{_locale}/admin
+
+        sonata_admin:
+            resource: .
+            type: sonata_admin
+            prefix: /{_locale}/admin
+
+        # redirect routes for the non-locale routes
+        admin_without_locale:
+            pattern: /admin
+            defaults:
+                _controller: FrameworkBundle:Redirect:redirect
+                route: sonata_admin_dashboard
+                permanent: true # this for 301
+
+        admin_dashboard_without_locale:
+            pattern: /admin/dashboard
+            defaults:
+                _controller: FrameworkBundle:Redirect:redirect
+                route: sonata_admin_dashboard
+                permanent: true
+
+    .. code-block:: xml
+
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <routes xmlns="http://symfony.com/schema/dic/routing">
+
+            <route id="admin_dashboard" pattern="/{_locale}/admin/">
+                <default key="_controller">FrameworkBundle:Redirect:redirect</default>
+                <default key="route">sonata_admin_dashboard</default>
+                <default "permanent">true</default>
+            </route>
+
+            <import resource="@SonataAdminBundle/Resources/config/routing/sonata_admin.xml"
+                    prefix="/{_locale}/admin"
+            />
+
+            <import resource="." type="sonata_admin" prefix="/{_locale}/admin"/>
+
+            <!-- redirect routes for the non-locale routes -->
+            <route id="admin_without_locale" pattern="/admin">
+                <default key="_controller">FrameworkBundle:Redirect:redirect</default>
+                <default key="route">sonata_admin_dashboard</default>
+                <default "permanent">true</default>
+            </route>
+            <route id="admin_dashboard_without_locale" pattern="/admin/dashboard">
+                <default key="_controller">FrameworkBundle:Redirect:redirect</default>
+                <default key="route">sonata_admin_dashboard</default>
+                <default "permanent">true</default>
+            </route>
+        </routes>
+
+    .. code-block:: php
+
+        // app/config/routing.php
+
+        $collection = new RouteCollection();
+
+        $collection->add('admin_dashboard', new Route('/{_locale}/admin/', array(
+            '_controller' => 'FrameworkBundle:Redirect:redirect',
+            'route' => 'sonata_admin_dashboard',
+            'permanent' => true,
+        )));
+
+        $sonata = $loader->import('@SonataAdminBundle/Resources/config/routing/sonata_admin.xml');
+        $sonata->addPrefix('/{_locale}/admin');
+        $collection->addCollection($sonata);
+
+        $sonata = $loader->import('.', 'sonata_admin');
+        $sonata->addPrefix('/{_locale}/admin');
+        $collection->addCollection($sonata);
+
+        $collection->add('admin_without_locale', new Route('/admin', array(
+            '_controller' => 'FrameworkBundle:Redirect:redirect',
+            'route' => 'sonata_admin_dashboard',
+            'permanent' => true,
+        )));
+
+        $collection->add('admin_dashboard_without_locale', new Route('/admin/dashboard', array(
+            '_controller' => 'FrameworkBundle:Redirect:redirect',
+            'route' => 'sonata_admin_dashboard',
+            'permanent' => true,
+        )));
+
+        return $collection
+
+Now reload the admin dashboard. The URL should be prefixed with the
+default locale, for example ``/de/admin/dashboard``. When clicking on the
+language switcher, the page reloads and displays the correct content for the
+requested language.
+
+If your documents implement the TranslatableInterface, you can
+:ref:`configure the translatable admin extension <bundle-core-translatable-admin-extension>`
+to get a language choice field to let the administrator
+choose in which language to store the content.
+
+Frontend Editing and multi-language
+-----------------------------------
+
+When using the CreateBundle, you do not need to do anything at all to get
+multi-language support. PHPCR-ODM will deliver the document in the requested
+language, and the callback URL is generated in the request locale, leading to
+save the edited document in the same language as it was loaded.
+
+.. note::
+
+    If a translation is missing, language fallback kicks in, both when viewing
+    the page but also when saving the changes, so you always update the
+    current locale.
+
+    It would make sense to offer the user the choice whether they want to
+    create a new translation or update the existing one. There is this
+    `issue`_ in the CreateBundle issue tracker.
+
+.. _`LuneticsLocaleBundle`: https://github.com/lunetics/LocaleBundle/
+.. _`this discussion about ICU`: https://github.com/symfony/symfony/issues/5279#issuecomment-11710480
+.. _`cmf-sandbox config.yml file`: https://github.com/symfony-cmf/cmf-sandbox/blob/master/app/config/config.yml
+.. _`PHPCR-ODM documentation on multi-language`: http://docs.doctrine-project.org/projects/doctrine-phpcr-odm/en/latest/reference/multilang.html
+.. _`issue`: https://github.com/symfony-cmf/CreateBundle/issues/39
diff --git a/book/index.rst b/book/index.rst
index df905487..47d2c975 100644
--- a/book/index.rst
+++ b/book/index.rst
@@ -10,5 +10,6 @@ The Book
     simplecms
     static_content
     structuring_content
+    handling_multilang
 
 .. include:: map.rst.inc
diff --git a/book/installation.rst b/book/installation.rst
index cd903694..193d9233 100644
--- a/book/installation.rst
+++ b/book/installation.rst
@@ -214,7 +214,7 @@ Adding new pages
 
 Symfony CMF SE does not provide any admin tools to create new pages. If you
 are interested in adding an admin UI one solution can be found in
-:doc:`../cookbook/creating_cms_using_cmf_and_sonata`. However if all you want
+:doc:`../cookbook/creating_a_cms/sonata-admin`. However, if all you want
 is a simple way to add new pages that you can then edit via the inline
 editing, then you can use the SimpleCmsBundle ``page`` migrator. The Symfony
 CMF SE ships with an example YAML file stored in
diff --git a/book/routing.rst b/book/routing.rst
index 6f700bfa..aa940db2 100644
--- a/book/routing.rst
+++ b/book/routing.rst
@@ -502,7 +502,7 @@ For more information on the Routing component of Symfony CMF, please refer to:
 * :doc:`../components/routing/introduction` for most of the actual functionality implementation
 * :doc:`../bundles/routing/introduction` for Symfony2 integration bundle for Routing Bundle
 * Symfony2's `Routing`_ component page
-* :doc:`../cookbook/handling_multilang_documents` for some notes on multilingual routing
+* :doc:`../book/handling_multilang` for some notes on multilingual routing
 
 .. _`Doctrine ORM`: http://www.doctrine-project.org/projects/orm.html
 .. _`PHPCR-ODM`: http://www.doctrine-project.org/projects/phpcr-odm.html
diff --git a/book/static_content.rst b/book/static_content.rst
index 2c6ba3f5..e5b79f33 100644
--- a/book/static_content.rst
+++ b/book/static_content.rst
@@ -60,7 +60,7 @@ SonataDoctrinePHPCRAdminBundle_, a back office generation tool.
 In ContentBundle, the required administration panels are already declared in
 the ``Admin`` folder and configured in ``Resources/config/admin.xml``, and
 will automatically be loaded if you install the SonataDoctrinePHPCRAdminBundle
-(refer to :doc:`../cookbook/creating_cms_using_cmf_and_sonata` for
+(refer to :doc:`../cookbook/creating_a_cms/sonata-admin` for
 instructions on that).
 
 Configuration
diff --git a/book/structuring_content.rst b/book/structuring_content.rst
index d40eb597..f5d898f9 100644
--- a/book/structuring_content.rst
+++ b/book/structuring_content.rst
@@ -164,7 +164,7 @@ SonataDoctrinePHPCRAdminBundle_.
 
 The included administration panels are automatically available but need to
 be explicitly put on the dashboard if you want to use them. See
-:doc:`../cookbook/creating_cms_using_cmf_and_sonata` for instructions on how
+:doc:`../cookbook/creating_a_cms/sonata-admin` for instructions on how
 to install SonataDoctrinePHPCRAdminBundle.
 
 Configuration
diff --git a/bundles/routing/dynamic.rst b/bundles/routing/dynamic.rst
index 8b67a912..0ec31765 100644
--- a/bundles/routing/dynamic.rst
+++ b/bundles/routing/dynamic.rst
@@ -19,8 +19,9 @@ documents.
 Configuration
 -------------
 
-The minimum configuration required to load the dynamic router is
-to specify a route provider backend.
+The minimum configuration required to load the dynamic router is to specify a
+route provider backend and to register the dynamic router in the chain of
+routers.
 
 .. note::
 
@@ -34,6 +35,10 @@ to specify a route provider backend.
 
         # app/config/config.yml
         cmf_routing:
+            chain:
+                routers_by_id:
+                    router.default: 200
+                    cmf_routing.dynamic_router: 100
             dynamic:
                 persistence:
                     phpcr:
@@ -45,6 +50,10 @@ to specify a route provider backend.
         <?xml version="1.0" encoding="UTF-8" ?>
         <container xmlns="http://symfony.com/schema/dic/services">
             <config xmlns="http://cmf.symfony.com/schema/dic/routing">
+                <chain>
+                    <router-by-id id="router.default">200</router-by-id>
+                    <router-by-id id="cmf_routing.dynamic_router">100</router-by-id>
+                </chain>
                 <dynamic>
                     <persistence>
                         <phpcr enabled="true" />
@@ -57,6 +66,12 @@ to specify a route provider backend.
 
         // app/config/config.php
         $container->loadFromExtension('cmf_routing', array(
+            'chain' => array(
+                'routers_by_id' => array(
+                    'router.default' => 200,
+                    'cmf_routing.dynamic_router' => 100,
+                ),
+            ),
             'dynamic' => array(
                 'persistence' => array(
                     'phpcr' => array(
diff --git a/cookbook/_outdate-caution.rst.inc b/cookbook/_outdate-caution.rst.inc
deleted file mode 100644
index 629ab191..00000000
--- a/cookbook/_outdate-caution.rst.inc
+++ /dev/null
@@ -1,11 +0,0 @@
-.. caution::
-
-    The cookbook is in the process of being restructured. Some documentation is
-    outdated, notable configuration examples. If something does not work, please
-    have a look in the Reference section and send pull requests to fix things,
-    or just open an issue on github so that we know about the problem.
-
-    Refer to `the documentation issues`_ to help us bringing this article up to
-    date.
-
-.. _`the documentation issues`: https://github.com/symfony-cmf/symfony-cmf-docs/issues/
diff --git a/cookbook/create_new_project_phpcr_odm.rst b/cookbook/create_new_project_phpcr_odm.rst
deleted file mode 100644
index 961a2e88..00000000
--- a/cookbook/create_new_project_phpcr_odm.rst
+++ /dev/null
@@ -1,153 +0,0 @@
-.. index::
-    single: PHPCR-ODM, Creating a New Project
-
-Create a New Project with PHPCR-ODM
-===================================
-
-This article will show you how to create a new Symfony project from the
-`Symfony Standard Edition`_ using PHPCR-ODM instead of (or in addition to) the
-`Doctrine ORM`_.
-
-It is assumed that you have `installed composer`_.
-
-For more information on the PHPCR-ODM see the
-:doc:`../book/database_layer` article.
-
-General Instructions using Jackalope Doctrine DBAL
---------------------------------------------------
-
-The `Jackalope`_ Doctrine DBAL backend will use `Doctrine DBAL`_ to store the
-content repository.
-
-**Step 1**: Create a new Symfony project with composer based on the standard edition:
-
-.. code-block:: bash
-
-    $ php composer.phar create-project symfony/framework-standard-edition path/
-
-**Step 2**: Add the required packages to ``composer.json``:
-
-.. code-block:: javascript
-
-    {
-        ...
-        "require": {
-            ...
-            "doctrine/phpcr-bundle": "1.0.0",
-            "doctrine/phpcr-odm": "1.0.*",
-            "jackalope/jackalope-doctrine-dbal": "1.0.0"
-        }
-    }
-
-**Step 3**: (*optional*) Remove the Doctrine ORM:
-
- * Remove the ``doctrine\orm`` package from ``composer.json``;
- * Remove the ``orm`` section from ``app/config/config.yml``.
-
-**Step 4**: Add the DoctrinePHPCRBundle to the ``AppKernel``::
-
-    // app/AppKernel.php
-
-    // ...
-    class AppKernel extends Kernel
-    {
-        public function registerBundles()
-        {
-            $bundles = array(
-                // ...
-                new Doctrine\Bundle\PHPCRBundle\DoctrinePHPCRBundle(),
-            );
-
-            // ...
-        }
-    }
-
-**Step 5**: Modify ``parameters.yml.dist``, adding the required PHPCR-ODM settings:
-
-.. code-block:: yaml
-
-    # app/config/parameters.yml.dist
-    parameters:
-        # ...
-        phpcr_backend:
-            type: doctrinedbal
-            connection: default
-        phpcr_workspace: default
-        phpcr_user: admin
-        phpcr_pass: admin
-
-.. note::
-
-    You are modififying ``parameters.yml.dist`` and not ``paramaters.yml``.
-    This is because the Standard Edition will use this file as a template when
-    updating the configuration.
-
-**Step 6**: Add the Doctrine PHPCR configuration to the main application configuration:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # ...
-        doctrine_phpcr:
-           # configure the PHPCR session
-           session:
-               backend: "%phpcr_backend%"
-               workspace: "%phpcr_workspace%"
-               username: "%phpcr_user%"
-               password: "%phpcr_pass%"
-           # enable the ODM layer
-           odm:
-               auto_mapping: true
-               auto_generate_proxy_classes: "%kernel.debug%"
-
-    .. code-block:: xml
-
-        <?xml version="1.0" encoding="UTF-8" ?>
-        <container xmlns="http://symfony.com/schema/dic/services">
-            <config xmlns="http://doctrine-project.org/schema/symfony-dic/odm/phpcr">
-                <session backend="%phpcr_backend%"
-                    workspace="%phpcr_workspace%"
-                    username="%phpcr_user%"
-                    password="%phpcr_pass%"
-                />
-
-                <odm auto-mapping="true"
-                    auto-generate-proxy-classes="%kernel.debug%"
-                />
-            </config>
-        </container>
-
-    .. code-block:: php
-
-        $container->loadFromExtension('doctrine_phpcr', array(
-            'session' => array(
-                'backend' => '%phpcr_backend%',
-                'workspace' => '%phpcr_workspace%',
-                'username' => '%phpcr_username%',
-                'password' => '%phpcr_password%',
-            ),
-            'odm' => array(
-                'auto_mapping' => true,
-                'auto_generate_proxy_classes' => '%kernel.debug%',
-            ),
-        ));
-
-**Step 7**: Run ``composer update``:
-
-.. code-block:: bash
-
-    $ composer update
-
-After installing the packages composer will ask you to confirm or modify the
-default parameters defined in ``parameters.yml.dist`` and then generate the
-``parameters.yml`` file.
-
-Your should now be all set to start using PHPCR-ODM in your project!
-
-.. _`Symfony Standard Edition`: https://github.com/symfony/symfony-standard
-.. _`Doctrine ORM`: https://github.com/doctrine/doctrine2
-.. _`Apache Jackrabbit`: https://jackrabbit.apache.org
-.. _`Jackalope`: https://github.com/jackalope/jackalope
-.. _`Doctrine DBAL`: https://github.com/doctrine/dbal
-.. _`installed composer`: http://getcomposer.org/doc/00-intro.md#system-requirements
diff --git a/cookbook/creating_a_cms/content-to-controllers.rst b/cookbook/creating_a_cms/content-to-controllers.rst
index 108518b7..37a1deb3 100644
--- a/cookbook/creating_a_cms/content-to-controllers.rst
+++ b/cookbook/creating_a_cms/content-to-controllers.rst
@@ -3,7 +3,7 @@ Controllers and Templates
 
 Go to the URL http://localhost:8000/page/home in your browser - this should be
 your page, but it says that it cannot find a controller. In other words it has
-found the *page referencing route* for your page but Symfony does not know what
+found the *route referencing the page* for your page but Symfony does not know what
 to do with it.
 
 You can map a default controller for all instances of ``Page``:
@@ -83,7 +83,7 @@ object and all the ``Posts`` to the view::
 
 The ``Page`` object is passed automatically as ``$contentDocument``.
 
-Add a corresponding twig template (note that this works because you use the
+Add a corresponding Twig template (note that this works because you use the
 ``@Template`` annotation):
 
 .. configuration-block::
diff --git a/cookbook/creating_a_cms/getting-started.rst b/cookbook/creating_a_cms/getting-started.rst
index c2557c05..49bd11db 100644
--- a/cookbook/creating_a_cms/getting-started.rst
+++ b/cookbook/creating_a_cms/getting-started.rst
@@ -4,8 +4,8 @@ Getting Started
 Initializing the Project
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-First, follow the generic steps in :doc:`../create_new_project_phpcr_odm` to
-create a new project using the PHPCR-ODM.
+First, follow the generic steps in :doc:`../../bundles/phpcr_odm/introduction`
+to create a new project using the PHPCR-ODM.
 
 Install Additional Bundles
 ..........................
@@ -30,27 +30,20 @@ all of the required packages now.
         require: {
             ...
             "symfony-cmf/routing-auto-bundle": "1.0.*@alpha",
-            "symfony-cmf/menu-bundle": "1.0",
-            "sonata-project/doctrine-phpcr-admin-bundle": "dev-master",
-            "symfony-cmf/tree-browser-bundle": "@dev",
-            "doctrine/data-fixtures": "1.0.0",
-
-            "doctrine/phpcr-odm": "dev-master as 1.0.0",
-            "phpcr/phpcr-utils": "dev-master as 1.0.0",
-            "doctrine/phpcr-bundle": "dev-master as 1.0.0",
-            "symfony-cmf/routing-bundle": "dev-master as 1.1.0",
-            "symfony-cmf/routing": "dev-master as 1.2.0"
+            "symfony-cmf/menu-bundle": "1.1.*",
+            "sonata-project/doctrine-phpcr-admin-bundle": "1.1.*",
+            "symfony-cmf/tree-browser-bundle": "1.1.*",
+            "doctrine/data-fixtures": "1.0.*",
+
+            "doctrine/phpcr-odm": "1.1.*",
+            "phpcr/phpcr-utils": "1.1.*",
+            "doctrine/phpcr-bundle": "1.1.*",
+            "symfony-cmf/routing-bundle": "1.2.*",
+            "symfony-cmf/routing": "1.2.*"
         },
         ...
     }
 
-.. note::
-
-    This tutorial currently requires code only available in the lastest
-    unstable version of PHPCR-ODM, this is why you require the "dev-master as
-    1.0.0" constraints. When PHPCR-ODM 1.1 is released this will no longer be
-    necessary.
-
 Note that each time you modify your ``composer.json`` file you are required to
 run ``composer update``.
 
@@ -58,9 +51,9 @@ Initialize the Database
 .......................
 
 If you have followed the main instructions in
-:doc:`../create_new_project_phpcr_odm` then you are using the `Doctrine DBAL
-Jackalope`_ PHPCR backend with MySQL and you will need to create the MySQL
-database:
+:doc:`../../bundles/phpcr_odm/introduction` then you are using the
+`Doctrine DBAL Jackalope`_ PHPCR backend with MySQL and you will need to
+create the database:
 
 .. code-block:: bash
 
@@ -358,7 +351,7 @@ Ensure that you have the following package installed:
         ...
         require: {
             ...
-            "doctrine/data-fixtures": "1.0.0"
+            "doctrine/data-fixtures": "1.0.*"
         },
         ...
     }
diff --git a/cookbook/creating_a_cms/make-homepage.rst b/cookbook/creating_a_cms/make-homepage.rst
index 7682118c..ec72a079 100644
--- a/cookbook/creating_a_cms/make-homepage.rst
+++ b/cookbook/creating_a_cms/make-homepage.rst
@@ -5,8 +5,8 @@ All of your content should now be available at various URLs but your homepage
 (http://localhost:8000) still shows the default Symfony Standard Edition
 index page.
 
-In this section you will add a side menu to Sonata Admin which will make
-enable the user to make a specified page act as the homepage of your CMS.
+In this section you will add a side menu to Sonata Admin which
+allows the user to mark a ``Page`` to act as the homepage of your CMS.
 
 .. note::
 
@@ -56,8 +56,8 @@ Create the site document::
 Initializing the Site Document
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Where should this site document belong? Our document hierarchy currently looks
-like this:
+Where does the ``Site`` document belong? The document hierarchy currently
+looks like this:
 
 .. code-block:: text
 
@@ -68,10 +68,10 @@ like this:
            posts/
 
 There is one ``cms`` node, and this node contains all the children nodes of
-our site. This node is therefore the logical position of our ``Site``
+our site. This node is therefore the logical position of your ``Site``
 document.
 
-Earlier you used the ``GenericInitializer`` to initialize the base paths of
+Earlier, you used the ``GenericInitializer`` to initialize the base paths of
 our project, including the ``cms`` node. The nodes created by the
 ``GenericInitializer`` have no PHPCR-ODM mapping however.
 
@@ -110,24 +110,24 @@ node::
             $session = $registry->getConnection();
 
             // create the 'cms', 'pages', and 'posts' nodes
-            NodeHelper::createPath($session, '/cms/pages');
-            NodeHelper::createPath($session, '/cms/posts');
-            NodeHelper::createPath($session, '/cms/routes');
+            NodeHelper::createPath($session, $this->basePath . '/pages');
+            NodeHelper::createPath($session, $this->basePath . '/posts');
+            NodeHelper::createPath($session, $this->basePath . '/routes');
 
             $session->save();
         }
 
         public function getName()
         {
-            return 'My sites initializer';
+            return 'My site initializer';
         }
     }
 
 .. versionadded:: 1.1
-    Since version 1.1, the init method is passed the ``ManagerRegistry`` rather
-    than the PHPCR ``SessionInterface`` to allow the creation of documents in
-    initializers. With 1.0, you would need to manually set the ``phpcr:class``
-    property to the right value.
+    Since version 1.1, the ``init`` method receives the ``ManagerRegistry``
+    rather than the PHPCR ``SessionInterface``. This allows the creation of
+    documents in initializers. With 1.0, you would need to manually set the
+    ``phpcr:class`` property to the right value.
 
 Now modify the existing service configuration for ``GenericInitializer`` as
 follows:
@@ -178,13 +178,14 @@ follows:
             ->addTag('doctrine_phpcr.initializer', array('name' => 'doctrine_phpcr.initializer')
         ;
 
-Now reinitialize your repository:
+Now empty your repository and then reinitialize it:
 
 .. code-block:: bash
 
+    $ php app/console doctrine:phpcr:node:remove /cms
     $ php app/console doctrine:phpcr:repository:init
 
-and verify that the ``cms`` node has been updated by using the
+and verify that the ``cms`` node has been created correctly, using the
 ``doctrine:phpcr:node:dump`` command with the ``props`` flag:
 
 .. code-block:: bash
@@ -198,7 +199,7 @@ and verify that the ``cms`` node has been updated by using the
 
 .. note::
 
-    Why use an initializer instead of a data fixture? In this instance the
+    Why use an initializer instead of a data fixture? In this instance, the
     site object is a constant for your application. There is only one site
     object, new sites will not be created and the existing site document will
     not be removed. DataFixtures are intended to provide sample data, not
diff --git a/cookbook/creating_a_cms/sonata-admin.rst b/cookbook/creating_a_cms/sonata-admin.rst
index 0b2d87d9..dfb0c817 100644
--- a/cookbook/creating_a_cms/sonata-admin.rst
+++ b/cookbook/creating_a_cms/sonata-admin.rst
@@ -33,8 +33,8 @@ Enable the Sonata related bundles to your kernel::
                 new Sonata\CoreBundle\SonataCoreBundle(),
                 new Sonata\jQueryBundle\SonatajQueryBundle(),
                 new Sonata\BlockBundle\SonataBlockBundle(),
-                new Sonata\DoctrinePHPCRAdminBundle\SonataDoctrinePHPCRAdminBundle(),
                 new Sonata\AdminBundle\SonataAdminBundle(),
+                new Sonata\DoctrinePHPCRAdminBundle\SonataDoctrinePHPCRAdminBundle(),
             );
 
             // ...
@@ -159,7 +159,7 @@ No translations? Uncomment the translator in the configuration file:
         # ...
         framework:
             # ...
-            translator:      { fallback: %locale% }
+            translator:      { fallback: "%locale%" }
 
     .. code-block:: xml
 
@@ -187,10 +187,16 @@ No translations? Uncomment the translator in the configuration file:
             ),
         ));
 
-Notice that the adminstration class of the RoutingBundle has been automatically
-registered. However, this interface is not required in your application as the routes
-are managed by the RoutingAutoBundle and not the administrator. You can disable
-the RoutingBundle admin as follows:
+.. tip::
+
+    See :ref:`book_handling-multilang_sonata-admin` for more information
+    on Sonata Admin and multilanguage.
+
+When looking at the admin dashboard, you will notice that there is an entry
+to administrate Routes. The administration class of the RoutingBundle has
+been automatically registered. However, you do not need this in your
+application as the routes are managed by the RoutingAutoBundle and not the
+administrator. You can disable the RoutingBundle admin:
 
 .. configuration-block::
 
@@ -316,9 +322,9 @@ to avoid code duplication::
 
 .. note::
 
-    In the ``prePersist`` method of the ``PageAdmin`` you specify always a
-    fixed path, in the future you may want to modify this behavior to
-    enable pages to be structured (for example to have nested menus).
+    In the ``prePersist`` method of the ``PageAdmin`` you hardcode the
+    parent path. You may want to modify this behavior to enable pages
+    to be structured (for example to have nested menus).
 
 Now you just need to register these classes in the dependency injection
 container configuration:
@@ -436,11 +442,227 @@ container configuration:
 .. note::
 
     In the XML version of the above configuration you specify ``manager_type``
-    (with an underscore). This should be `manager-type` (with a hypen) and
-    will be fixed in Symfony version 2.4.
+    (with an underscore). This should be ``manager-type`` (with a hyphen) and
+    is fixed in Symfony version 2.4.
 
 Check it out at http://localhost:8000/admin/dashboard
 
 .. image:: ../../_images/cookbook/basic-cms-sonata-admin.png
 
+Configure the Admin Tree on the Dashboard
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sonata admin provides a useful tree view of your whole content. You can
+click items on the tree to edit them, right-click to delete them or add
+children and drag and drop to reorganize your content.
+
+Enable the CmfTreeBundle and the FOSJsRoutingBundle in your kernel::
+
+    // app/AppKernel.php
+    class AppKernel extends Kernel
+    {
+        // ...
+
+        public function registerBundles()
+        {
+            $bundles = array(
+                // ...
+                new FOS\JsRoutingBundle\FOSJsRoutingBundle(),
+                new Symfony\Cmf\Bundle\TreeBrowserBundle\CmfTreeBrowserBundle(),
+            );
+
+            // ...
+        }
+    }
+
+Routes used by the tree in the frontend are handled by the FOSJsRoutingBundle.
+The relevant routes are tagged with the ``expose`` flag, they are available
+automatically. However, you need to load the routes of the TreeBundle
+and the FOSJsRoutingBundle:
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        # app/config/routing.yml
+        cmf_tree:
+            resource: .
+            type: 'cmf_tree'
+
+        fos_js_routing:
+            resource: "@FOSJsRoutingBundle/Resources/config/routing/routing.xml"
+
+    .. code-block:: xml
+
+        <!-- app/config/routing.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <routes xmlns="http://symfony.com/schema/routing"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:schemaLocation="http://symfony.com/schema/routing
+                http://symfony.com/schema/routing/routing-1.0.xsd">
+
+            <import resource="." type="cmf_tree" />
+
+            <import resource="@FOSJsRoutingBundle/Resources/config/routing/routing.xml" />
+
+        </routes>
+
+    .. code-block:: php
+
+        // app/config/routing.php
+        use Symfony\Component\Routing\RouteCollection;
+
+        $collection = new RouteCollection();
+
+        $collection->addCollection($loader->import('.', 'cmf_tree'));
+
+        $collection->addCollection($loader->import(
+            "@FOSJsRoutingBundle/Resources/config/routing/routing.xml"
+        ));
+
+        return $collection;
+
+Add the tree block to the ``sonata_block`` configuration and tell sonata
+admin to display the block:
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        # app/config/config.yml
+
+        # ...
+        sonata_block:
+            blocks:
+                # ...
+                sonata_admin_doctrine_phpcr.tree_block:
+                    settings:
+                        id: '/cms'
+                    contexts: [admin]
+
+        sonata_admin:
+            dashboard:
+                blocks:
+                    - { position: left, type: sonata_admin_doctrine_phpcr.tree_block }
+                    - { position: right, type: sonata.admin.block.admin_list }
+
+    .. code-block:: xml
+
+        <!-- app/config/config.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <container xmlns="htp://symfony.com/schema/dic/services">
+
+            <config xmlns="http://sonata-project.org/schema/dic/block">
+                <! ... -->
+                <block id="sonata_admin_doctrine_phpcr.tree_block">
+                    <setting id="id">/cms</setting>
+                    <context>admin</context>
+                </block>
+            </config>
+
+            <config xmlns="http://sonata-project.org/schema/dic/admin">
+                <dashboard>
+                    <block position="left" type="sonata_admin_doctrine_phpcr.tree_block"/>
+                    <block position="right" type="sonata.admin.block.admin_list"/>
+                </dashboard>
+            </config>
+
+        </container>
+
+    .. code-block:: php
+
+        // app/config/config.php
+        $container->loadFromExtension('sonata_block', array(
+            'blocks' => array(
+                // ...
+                'sonata_admin_doctrine_phpcr.tree_block' => array(
+                    'settings' => array(
+                        'id' => '/cms',
+                    ),
+                    'contexts' => array('admin'),
+                ),
+            ),
+        ));
+
+        $container->loadFromExtension('sonata_admin', array(
+            'dashboard' => array(
+                'blocks' => array(
+                    array('position' => 'left', 'type' => 'sonata_admin_doctrine_phpcr.tree_block'),
+                    array('position' => 'right', 'type' => 'sonata.admin.block.admin_list'),
+                ),
+            ),
+        ));
+
+To see your documents on the tree in the admin dashboard tree, you need
+to tell sonata about them:
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        sonata_doctrine_phpcr_admin:
+            document_tree_defaults: [locale]
+            document_tree:
+                Doctrine\ODM\PHPCR\Document\Generic:
+                    valid_children:
+                        - all
+                Acme\BasicCmsBundle\Document\Page:
+                    valid_children:
+                        - Acme\BasicCmsBundle\Document\Post
+                Acme\BasicCmsBundle\Document\Post:
+                    valid_children: []
+                # ...
+
+    .. code-block:: xml
+
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+
+            <config xmlns="http://sonata-project.org/schema/dic/doctrine_phpcr_admin" />
+
+                <document-tree-default>locale</document-tree-default>
+
+                <document-tree class="Doctrine\ODM\PHPCR\Document\Generic">
+                    <valid-child>all</valid-child>
+                </document-tree>
+
+                <document-tree class="Acme\BasicCmsBundle\Document\Post">
+                    <valid-child>Acme\BasicCmsBundle\Document\Post</valid-child>
+                </document-tree>
+
+                <document-tree class="Acme\BasicCmsBundle\Document\Post" />
+
+                <!-- ... -->
+            </config>
+        </container>
+
+    .. code-block:: php
+
+        $container->loadFromExtension('sonata_doctrine_phpcr_admin', array(
+            'document_tree_defaults' => array('locale'),
+            'document_tree' => array(
+                'Doctrine\ODM\PHPCR\Document\Generic' => array(
+                    'valid_children' => array(
+                        'all',
+                    ),
+                ),
+                'Acme\BasicCmsBundle\Document\Post' => array(
+                    'valid_children' => array(
+                        'Acme\BasicCmsBundle\Document\Post',
+                    ),
+                ),
+                'Acme\BasicCmsBundle\Document\Post' => array(
+                    'valid_children' => array(),
+                ),
+                // ...
+        ));
+
+.. tip::
+
+    To have a document show up in the tree, it needs its own entry. You
+    can allow all document types underneath it by having the ``all`` child.
+    But if you explicitly list allowed children, the right click context
+    menu will propose only those documents. This makes it easier for your
+    users to not make mistakes.
+
 .. _SonataDoctrinePHPCRAdminBundle: http://sonata-project.org/bundles/doctrine-phpcr-admin/master/doc/index.html
diff --git a/cookbook/creating_a_cms/the-frontend.rst b/cookbook/creating_a_cms/the-frontend.rst
index 09752224..47ce8fe2 100644
--- a/cookbook/creating_a_cms/the-frontend.rst
+++ b/cookbook/creating_a_cms/the-frontend.rst
@@ -3,7 +3,7 @@ Creating a Menu
 
 In this section you will modify your application so that ``Page``
 documents act as menu nodes. The root page document can then be rendered
-using the twig helper of the `KnpMenuBundle`_.
+using the Twig helper of the `KnpMenuBundle`_.
 
 Installation
 ............
@@ -16,7 +16,7 @@ Ensure that the following package is installed:
         ...
         require: {
             ...
-            "symfony-cmf/menu-bundle": "1.0"
+            "symfony-cmf/menu-bundle": "1.1.*"
         },
         ...
     }
@@ -30,6 +30,7 @@ Add the CMF `MenuBundle`_ and its dependency, `CoreBundle`_, to your kernel::
         {
             $bundles = array(
                 // ...
+                new Knp\Bundle\MenuBundle\KnpMenuBundle(),
                 new Symfony\Cmf\Bundle\CoreBundle\CmfCoreBundle(),
                 new Symfony\Cmf\Bundle\MenuBundle\CmfMenuBundle(),
             );
@@ -41,8 +42,8 @@ Add the CMF `MenuBundle`_ and its dependency, `CoreBundle`_, to your kernel::
 Modify the Page Document
 ........................
 
-The menu document has to implement the ``NodeInterface`` provided by the
-KnpMenuBundle::
+The menu document has to implement the ``Knp\Menu\NodeInterface``
+provided by the KnpMenuBundle::
 
     // src/Acme/BasicCmsBundle/Document/Page.php
     namespace Acme\BasicCmsBundle\Document;
@@ -88,7 +89,11 @@ KnpMenuBundle::
 
 .. caution::
 
-    Don't forget to add the ``Knp\Menu\NodeInterface`` use statement!
+    In a typical CMF application, there are two ``NodeInterface`` which
+    have nothing to do with each other. The interface we use here is from
+    KnpMenuBundle and describes menu tree nodes. The other interface is
+    from the PHP content repository and describes content repository
+    tree nodes.
 
 Menus are hierarchical, PHPCR-ODM is also hierarchical and so lends itself
 well to this use case.
@@ -230,7 +235,7 @@ configuration:
             ->addTag('knp_menu.provider')
         ;
 
-and enable the twig rendering functionality of the KnpMenu bundle:
+and enable the Twig rendering functionality of the KnpMenu bundle:
 
 .. configuration-block::
 
diff --git a/cookbook/creating_cms_using_cmf_and_sonata.rst b/cookbook/creating_cms_using_cmf_and_sonata.rst
deleted file mode 100644
index 2c4d454c..00000000
--- a/cookbook/creating_cms_using_cmf_and_sonata.rst
+++ /dev/null
@@ -1,225 +0,0 @@
-.. index::
-    single: Creating a CMS
-
-Creating a CMS using CMF and Sonata
-===================================
-
-.. include:: _outdate-caution.rst.inc
-
-The goal of this tutorial is to create a simple content management system
-using the CMF as well as SonataDoctrinePHPCRAdminBundle_.
-
-.. index:: Sonata, SonataAdminBundle, SonataDoctrinePHPCRAdminBundle, SonatajQueryBundle, FOSJsRoutingBundle, TreeBundle, TreeBrowserBundle
-
-Preconditions
--------------
-
-* :doc:`editions/cmf_core`
-* `Symfony SecurityBundle`_ (required by the SonataAdminBundle default templates)
-
-.. caution::
-
-    Don't forget to add a configuration for the SecurityBundle or you will get an
-
-    ``The function "is_granted" does not exist in SonataAdminBundle``
-
-    error.
-
-Installation
-------------
-
-Download the Bundles
-~~~~~~~~~~~~~~~~~~~~
-
-Add the following to your ``composer.json`` file:
-
-.. code-block:: javascript
-
-    "require": {
-        ...
-        "sonata-project/doctrine-phpcr-admin-bundle": "1.0.*",
-        "sonata-project/core-bundle": "~2.2@dev"
-    }
-
-And then run:
-
-.. code-block:: bash
-
-    $ php composer.phar update
-
-Initialize Bundles
-~~~~~~~~~~~~~~~~~~
-
-Next, initialize the bundles in ``app/AppKernel.php`` by adding them to the
-``registerBundle`` method::
-
-    public function registerBundles()
-    {
-        $bundles = array(
-            // ...
-
-            // support for the admin
-            new Symfony\Cmf\Bundle\TreeBrowserBundle\CmfTreeBrowserBundle(),
-            new Sonata\CoreBundle\SonataCoreBundle(),
-            new Sonata\jQueryBundle\SonatajQueryBundle(),
-            new Sonata\BlockBundle\SonataBlockBundle(),
-            new Sonata\AdminBundle\SonataAdminBundle(),
-            new Sonata\CoreBundle\SonataCoreBundle(),
-            new Sonata\DoctrinePHPCRAdminBundle\SonataDoctrinePHPCRAdminBundle(),
-            new FOS\JsRoutingBundle\FOSJsRoutingBundle(),
-        );
-
-        // ...
-    }
-
-Configuration
--------------
-
-Add the sonata bundles to your application configuration:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        sonata_block:
-            default_contexts: [cms]
-            blocks:
-                sonata.admin.block.admin_list:
-                    contexts:   [admin]
-                sonata_admin_doctrine_phpcr.tree_block:
-                    settings:
-                        id: '/cms'
-                    contexts:   [admin]
-
-        sonata_admin:
-            templates:
-                # default global templates
-                ajax:    SonataAdminBundle::ajax_layout.html.twig
-            dashboard:
-                blocks:
-                    # display a dashboard block
-                    - { position: right, type: sonata.admin.block.admin_list }
-                    - { position: left, type: sonata_admin_doctrine_phpcr.tree_block }
-
-        sonata_doctrine_phpcr_admin:
-            document_tree:
-                Doctrine\ODM\PHPCR\Document\Generic:
-                    valid_children:
-                        - all
-                # if you are using the SimpleCmsBundle, enable the Page as well
-                # Symfony\Cmf\Bundle\SimpleCmsBundle\Doctrine\Phpcr\Page:
-                #     valid_children:
-                #         - all
-                Symfony\Cmf\Bundle\ContentBundle\Doctrine\Phpcr\StaticContent:
-                    valid_children:
-                        - all
-                Symfony\Cmf\Bundle\RoutingBundle\Doctrine\Phpcr\Route:
-                    valid_children:
-                        - Symfony\Cmf\Bundle\RoutingBundle\Doctrine\Phpcr\Route
-                        - Symfony\Cmf\Bundle\RoutingBundle\Doctrine\Phpcr\RedirectRoute
-                Symfony\Cmf\Bundle\RoutingBundle\Doctrine\Phpcr\RedirectRoute:
-                    valid_children: []
-                Symfony\Cmf\Bundle\MenuBundle\Doctrine\Phpcr\MenuNode:
-                    valid_children:
-                        - Symfony\Cmf\Bundle\MenuBundle\Doctrine\Phpcr\MenuNode
-
-This sets up a sonata dashboard with a document tree on the left side and all
-available admins on the right side.
-
-The ``document_tree`` configuration defines what kind of documents should be
-shown in the tree. It is also used by sonata widgets to know what can be added
-where. When you add your own classes, be sure to add them in the tree
-configuration.
-
-Add route in to your routing configuration:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/routing.yml
-        admin:
-            resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
-            prefix: /admin
-
-        sonata_admin:
-            resource: .
-            type: sonata_admin
-            prefix: /admin
-
-        fos_js_routing:
-            resource: "@FOSJsRoutingBundle/Resources/config/routing/routing.xml"
-
-        cmf_tree:
-            resource: .
-            type: 'cmf_tree'
-
-The FOSJsRoutingBundle is used to export sonata routes to javascript, to be
-used with the tree. All relevant routes have the ``expose`` option set. If you
-do custom routes that need to be used with the tree, you need to do that or
-configure the js routing bundle manually.
-
-Sonata Assets
--------------
-
-.. code-block:: bash
-
-    $ php app/console assets:install --symlink
-
-Defining own Admin Classes
---------------------------
-
-The CMF bundles come with predefined admin classes which will be activated
-automatically if Sonata PHPCR-ODM Admin is loaded. If you need to write
-different admins and do not want to load the defaults, you can deactivate the
-loading - see the documentation of the respective bundles.
-
-To load your own Admin service, you need to declare it as a service, tag with
-``sonata.admin`` with ``manager_type="doctrine_phpcr"``. For the admin to work
-properly, you need to add a call for method ``setRouteBuilder`` to set it to
-the service ``sonata.admin.route.path_info_slashes``, or your Admin will not
-work.
-
-The constructor expects three arguments, code, document class and controller
-name. You can pass an empty argument for the code, the document class must be
-the fully qualified class name of the document this admin is for and the third
-argument can be used to set a custom controller that does additional
-operations over the default sonata CRUD controller.
-
-.. configuration-block::
-
-    .. code-block:: xml
-
-        <service id="my_bundle.admin" class="%my_bundle.admin_class%">
-            <tag name="sonata.admin" manager_type="doctrine_phpcr" group="dashboard.group_content" label_catalogue="MyBundle" label="dashboard.label_my_admin" label_translator_strategy="sonata.admin.label.strategy.underscore" />
-            <argument/>
-            <argument>%my_bundle.document_class%</argument>
-            <argument>SonataAdminBundle:CRUD</argument>
-
-            <call method="setRouteBuilder">
-                <argument type="service" id="sonata.admin.route.path_info_slashes" />
-            </call>
-        </service>
-
-Finally
--------
-
-Now Sonata is configured to work with the PHPCR you can access the dashboard
-using via ``/admin/dashboard`` in your site.
-
-Tree Problems
--------------
-
-If you have not yet added anything to the content repository, the tree view
-will not load as it cannot find a root node. Create some content to get the
-tree working.
-
-Further Reading
----------------
-
-* :doc:`handling_multilang_documents`
-* SonataDoctrinePHPCRAdminBundle_
-
-.. _SonataDoctrinePHPCRAdminBundle: http://sonata-project.org/bundles/doctrine-phpcr-admin/master/doc/index.html
-.. _`Symfony SecurityBundle`: http://symfony.com/doc/master/book/security.html
diff --git a/cookbook/editions/cmf_core.rst b/cookbook/editions/cmf_core.rst
index 531b3c96..6afc18b3 100644
--- a/cookbook/editions/cmf_core.rst
+++ b/cookbook/editions/cmf_core.rst
@@ -4,8 +4,6 @@
 Installing and Configuring the CMF Core Bundles
 ===============================================
 
-.. include:: ../_outdate-caution.rst.inc
-
 The goal of this tutorial is to install the minimal CMF components ("core")
 with the minimum necessary configuration. From there, you can begin
 incorporating CMF functionality into your application as needed.
@@ -24,7 +22,7 @@ the Symfony CMF it would be a good idea to start with:
 Preconditions
 -------------
 
-* `Installation of Symfony2`_ (2.1.x)
+* `Installation of Symfony2`_
 * :doc:`../../bundles/phpcr_odm/introduction`
 
 Installation
@@ -37,10 +35,9 @@ Add the following to your ``composer.json`` file:
 
 .. code-block:: javascript
 
-    "minimum-stability": "dev",
     "require": {
         ...
-        "symfony-cmf/symfony-cmf": "1.0.*"
+        "symfony-cmf/symfony-cmf": "1.1.*"
     }
 
 And then run:
@@ -80,63 +77,86 @@ Next, initialize the bundles in ``AppKernel.php`` by adding them to the
         // ...
     }
 
-.. note::
-
-    This also enables the PHPCR-ODM and related dependencies; setup
-    instructions can be found in the dedicated documentation.
-
 Configuration
 -------------
 
-To get your application running, very little configuration is needed.
+To get your application running, very little configuration is needed. If
+you want to render menus from Twig, you need to enable this feature in the
+KnpMenuBundle:
 
-Minimum Configuration
-~~~~~~~~~~~~~~~~~~~~~
+.. configuration-block::
 
-These steps are needed to ensure your ``AppKernel`` still runs.
+    .. code-block:: yaml
 
-If you haven't done so already, make sure you have followed these steps from
-:doc:`../../bundles/phpcr_odm/introduction`:
+        # app/config/config.yml
+        knp_menu:
+            twig: true
 
-* Initialize ``DoctrinePHPCRBundle`` in ``app/AppKernel.php``
-* Ensure there is a ``doctrine_phpcr:`` section in ``app/config/config.yml``
+    .. code-block:: xml
 
-Configure the BlockBundle in your ``config.yml``:
+        <!-- app/config/config.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+            <config xmlns="http://knplabs.com/schema/dic/menu" twig="true"/>
+        </container>
 
-.. configuration-block::
+    .. code-block:: php
 
-    .. code-block:: yaml
+        // app/config/config.php
+        $container->loadFromExtension('knp_menu', array(
+            'twig' => true,
+        ));
 
-        # app/config/config.yml
-        sonata_block:
-            default_contexts: [cms]
+.. caution::
 
-Additional Configuration
-~~~~~~~~~~~~~~~~~~~~~~~~
+    While the CMF bundles work out of the box without configuration, you
+    will need to configure a storage layer. To use the default provided
+    model classes, you need PHPCR-ODM as well. Setup instructions are in
+    :doc:`../../bundles/phpcr_odm/introduction`.
 
-Because most CMF components use the DynamicRouter from the RoutingBundle,
-which by default is not loaded, you will need to enable it as follows:
+When using PHPCR-ODM, enable support globally for all CMF bundles with:
 
 .. configuration-block::
 
     .. code-block:: yaml
 
         # app/config/config.yml
-        cmf_routing:
-            chain:
-                routers_by_id:
-                    cmf_routing.dynamic_router: 200
-                    router.default: 100
-            dynamic:
-                enabled: true
-
-You might want to configure more on the dynamic router, i.e. to automatically
-choose controllers based on content.  See
-:doc:`../../bundles/routing/introduction` for details.
-
-For now this is the only configuration we need. Mastering the configuration of
-the different bundles will be handled in further articles. If you're looking
-for the configuration of a specific bundle take a look at the corresponding
-:doc:`bundles reference <../../reference/index>`.
-
-.. _`Installation of Symfony2`: http://symfony.com/doc/2.1/book/installation.html
+        cmf_core:
+            persistence:
+                phpcr:
+                    enabled: true
+
+    .. code-block:: xml
+
+        <!-- app/config/config.xml -->
+        <?xml version="1.0" encoding="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+            <config xmlns="http://cmf.symfony.com/schema/dic/core">
+                <persistence>
+                    <phpcr enabled="true"/>
+                </persistence>
+            </config>
+        </container>
+
+    .. code-block:: php
+
+        // app/config/config.php
+        $container->loadFromExtension('cmf_core', array(
+            'persistence' => array(
+                'phpcr' => array(
+                    'enabled' => true,
+                ),
+            ),
+        ));
+
+Next Steps
+----------
+
+If you want to support multiple languages, have a look at
+:doc:`../../book/handling_multilang`.
+
+Then have a look at the individual :doc:`bundles <../../bundles/index>` you are
+interested in, and find the details on the configuration in the
+:doc:`bundles configuration reference <../../reference/index>`.
+
+.. _`Installation of Symfony2`: http://symfony.com/doc/current/book/installation.html
diff --git a/cookbook/exposing_content_via_rest.rst b/cookbook/exposing_content_via_rest.rst
index 9670aee4..a67d6cf6 100644
--- a/cookbook/exposing_content_via_rest.rst
+++ b/cookbook/exposing_content_via_rest.rst
@@ -34,7 +34,7 @@ to generate the REST output. The best choice is the JMSSerializerBundle:
         ..
         "require": {
             ..
-            "friendsofsymfony/rest-bundle": "1.0.*",
+            "friendsofsymfony/rest-bundle": "1.*",
             "jms/serializer-bundle": "0.13.*",
         }
     }
@@ -153,8 +153,7 @@ However it might be necessary to add additional mapping to more tightly
 control what gets exposed. See the `documentation of the JMS serializer`_
 for details.
 
-.. note::
-
+.. versionadded:: 1.1
     The `default response format changed between 1.0 and 1.1 of the ContentBundle`_.
     In 1.0 the response is wrapped inside an array/tag. This is no longer the
     case in 1.1
diff --git a/cookbook/handling_multilang_documents.rst b/cookbook/handling_multilang_documents.rst
deleted file mode 100644
index b3292c47..00000000
--- a/cookbook/handling_multilang_documents.rst
+++ /dev/null
@@ -1,224 +0,0 @@
-.. index::
-    single: Multi Language Documents
-
-Handling Multi-Language Documents
-=================================
-
-.. include:: _outdate-caution.rst.inc
-
-The goal of the tutorial is to describe all the steps that are needed to be
-taken to use multi-language documents as clearly as possible.
-
-Please read this first
-----------------------
-
-You need to understand how to use PHPCR-ODM. You find an introduction in the
-:doc:`documentation on the PHPCR-ODM Doctrine bundle <../bundles/phpcr_odm/introduction>`
-
-Lunetics LocaleBundle
----------------------
-
-The CMF recommends to rely on the `LuneticsLocaleBundle`_
-to handle initial locale selection when a user first visits the site,
-and to provide a locale switcher.
-
-To install the bundle, require it in your project with:
-
-.. code-block:: bash
-
-    $ php composer.phar require lunetics/locale-bundle
-
-and then instantiate ``Lunetics\LocaleBundle\LuneticsLocaleBundle`` in your
-``AppKernel.php``.
-
-You also need the ``intl`` php extension installed and enabled. (Otherwise
-composer will tell you it can't find ext-intl.) If you get issues that some
-locales can not be loaded, have a look at `this discussion about ICU`_.
-
-Then configure it in the main application configuration file. As there are
-several CMF bundles wanting the list of allowed locales, we recommend putting
-them into a parameter ``%locales%``, see the `cmf-sandbox config.yml file`_
-for an example.
-
-PHPCR-ODM multi-language Documents
-----------------------------------
-
-You can mark any properties as being translatable and have the document
-manager store and load the correct language for you. Note that translation
-always happens on a document level, not on the individual translatable fields.
-
-.. code-block:: php
-
-    <?php
-
-    // src/Acme/DemoBundle/Document/MyPersistentClass.php
-
-    use Doctrine\ODM\PHPCR\Mapping\Annotations as PHPCR;
-
-    /**
-     * @PHPCR\Document(translator="attribute")
-     */
-    class MyPersistentClass
-    {
-        /**
-         * Translated property
-         * @PHPCR\String(translated=true)
-         */
-        private $topic;
-
-        // ...
-    }
-
-Read more about multi-language documents in the
-`PHPCR-ODM documentation on multi-language`_ and see
-:doc:`../bundles/phpcr_odm/multilang` for information how to configure
-PHPCR-ODM correctly.
-
-Most of the CMF bundles provide multi-language documents, for example
-``MultilangStaticContent``, ``MultilangMenuNode`` or ``MultilangSimpleBlock``.
-The routing is different, as explained in the next section.
-
-Routing
--------
-
-The ``DynamicRouter`` uses a route source to get routes that could match a
-request. The concept of the default PHPCR-ODM source is to map the request URL
-onto an id, which in PHPCR terms is the repository path to a node. This allows
-for a very efficient lookup without needing a full search over the repository.
-But a PHPCR node has exactly one path, therefore we need a separate route
-document for each locale. The cool thing with this is that we can localize
-the URL for each language. Simply create one route document per locale,
-and set a default value for ``_locale`` to point to the locale of that route.
-
-As all routes point to the same content, the route generator can handle
-picking the correct route for you when you generate the route from the
-content. See also
-":ref:`ContentAwareGeneator and Locales <component-route-generator-and-locales>`".
-
-Sonata PHPCR-ODM Admin
-----------------------
-
-This section explains how to make Sonata Admin handle multi-language
-documents. You should already have set up Sonata PHPCR-ODM Admin and
-understand how it works, see
-:doc:`Creating a CMS using the CMF and Sonata <creating_cms_using_cmf_and_sonata>`.
-
-.. note::
-
-    The following assumes that you installed the LuneticsLocaleBundle as
-    explained above. If you want to use something else or write your own
-    locale handling, first think if it would not make sense to give the
-    Lunetics bundle a try. If you are still convinced you will need to adapt
-    the following template examples to your way of building a locale switcher.
-
-The first step is to configure sonata admin. We are going to place the
-LuneticsLocaleBundle language switcher in the ``topnav`` bar.  To do this we
-need to configure the template for the ``user_block`` as shown below:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        sonata_admin:
-            # ...
-            templates:
-                    user_block: AcmeCoreBundle:Admin:admin_topnav.html.twig
-
-And the template looks like this:
-
-.. code-block:: jinja
-
-    {# src/Acme/CoreBundle/Resources/views/Admin/admin_topnav.html.twig #}
-    {% extends 'SonataAdminBundle:Core:user_block.html.twig' %}
-
-    {% block user_block %}
-        {{ locale_switcher(null, null, 'AcmeCoreBundle:Admin:switcher_links.html.twig') }}
-        {{ parent() }}
-    {% endblock %}
-
-You need to tell the ``locale_switcher`` to use a custom template to display
-the links, which looks like this:
-
-.. code-block:: jinja
-
-    {# src/Acme/CoreBundle/Resources/views/Admin/switcher_links.html.twig #}
-    Switch to :
-    {% for locale in locales %}
-        {% if loop.index > 1 %} | {% endif %}<a href="{{ locale.link }}" title="{{ locale.locale_target_language }}">{{ locale.locale_target_language }}</a>
-    {% endfor %}
-
-Now what is left to do is to update the sonata routes to become locale aware:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/routing.yml
-
-        admin_dashboard:
-            pattern: /{_locale}/admin/
-            defaults:
-                _controller: FrameworkBundle:Redirect:redirect
-                route: sonata_admin_dashboard
-                permanent: true # this for 301
-
-        admin:
-            resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
-            prefix: /{_locale}/admin
-
-        sonata_admin:
-            resource: .
-            type: sonata_admin
-            prefix: /{_locale}/admin
-
-        # redirect routes for the non-locale routes
-        admin_without_locale:
-            pattern: /admin
-            defaults:
-                _controller: FrameworkBundle:Redirect:redirect
-                route: sonata_admin_dashboard
-                permanent: true # this for 301
-
-        admin_dashboard_without_locale:
-            pattern: /admin/dashboard
-            defaults:
-                _controller: FrameworkBundle:Redirect:redirect
-                route: sonata_admin_dashboard
-                permanent: true # this for 301
-
-When we now reload the admin dashboard, the url should be prefixed with our
-default locale, for example ``/de/admin/dashboard``. When clicking on the
-language switcher the page reloads and displays the correct content for the
-requested language.
-
-The provided sonata admin classes map the locale field of the multi-language
-documents to the form. You need to do the same in your admins, in order to
-create new translations. Otherwise the language fallback of PHPCR-ODM will
-make you update the original language, even when you request a different
-locale.  With the mapped locale field, the editor can choose if they need to
-create a new language version or updates the loaded one.
-
-Frontend Editing and multi-language
------------------------------------
-
-When using the CreateBundle, you do not need to do anything at all to get
-multi-language support. PHPCR-ODM will deliver the document in the requested
-language, and the callback URL is generated in the request locale, leading to
-save the edited document in the same language as it was loaded.
-
-.. note::
-
-    If a translation is missing, language fallback kicks in, both when viewing
-    the page but also when saving the changes, so you always update the
-    current locale.
-
-    It would make sense to offer the user the choice whether they want to
-    create a new translation or update the existing one. There is this
-    `issue`_ in the CreateBundle issue tracker.
-
-.. _`LuneticsLocaleBundle`: https://github.com/lunetics/LocaleBundle/
-.. _`this discussion about ICU`: https://github.com/symfony/symfony/issues/5279#issuecomment-11710480
-.. _`cmf-sandbox config.yml file`: https://github.com/symfony-cmf/cmf-sandbox/blob/master/app/config/config.yml
-.. _`PHPCR-ODM documentation on multi-language`: http://docs.doctrine-project.org/projects/doctrine-phpcr-odm/en/latest/reference/multilang.html
-.. _`issue`: https://github.com/symfony-cmf/CreateBundle/issues/39
diff --git a/cookbook/index.rst b/cookbook/index.rst
index 37178b5d..56be9f7d 100644
--- a/cookbook/index.rst
+++ b/cookbook/index.rst
@@ -4,7 +4,6 @@ The Cookbook
 .. toctree::
     :hidden:
 
-    create_new_project_phpcr_odm
     creating_a_cms/index
     database/choosing_storage_layer
     database/choosing_phpcr_implementation
@@ -12,8 +11,6 @@ The Cookbook
     database/doctrine_cache
     editions/cmf_sandbox
     editions/cmf_core
-    creating_cms_using_cmf_and_sonata
-    handling_multilang_documents
     exposing_content_via_rest
 
 .. include:: map.rst.inc
diff --git a/cookbook/map.rst.inc b/cookbook/map.rst.inc
index 2254e6a1..9314d991 100644
--- a/cookbook/map.rst.inc
+++ b/cookbook/map.rst.inc
@@ -11,8 +11,5 @@
   * :doc:`editions/cmf_sandbox`
   * :doc:`editions/cmf_core`
 
-* :doc:`create_new_project_phpcr_odm`
 * :doc:`creating_a_cms/index`
-* :doc:`creating_cms_using_cmf_and_sonata`
-* :doc:`handling_multilang_documents`
 * :doc:`exposing_content_via_rest`
diff --git a/reference/configuration/core.rst b/reference/configuration/core.rst
index 35b8d196..e5c7ff89 100644
--- a/reference/configuration/core.rst
+++ b/reference/configuration/core.rst
@@ -232,8 +232,8 @@ bundles that use this configuration:
 
             <config xmlns="http://cmf.symfony.com/schema/dic/core">
                 <multilang>
-                    <locales>en</locales>
-                    <locales>fr</locales>
+                    <locale>en</locale>
+                    <locale>fr</locale>
                 </multilang>
             </config>
         </container>